So erstellen Sie einen Webverkehrsmonitor mit Python, Flask, SQLite und Pusher

Wenn Sie eine Webanwendung im Internet haben, müssen Sie wissen, woher Ihre Besucher stammen, die Systeme, die sie verwenden, und andere solche Dinge.

Obwohl Sie Dienste wie Google Analytics, Monster Insights usw. nutzen können., Es macht mehr Spaß, ein Überwachungssystem mithilfe von Python, SQL-Datenbank und Pusher für Echtzeitdatenaktualisierungen zu erstellen.

Im heutigen Tutorial werden wir mit Python, Flask und Pusher ein solches Tool erstellen. Das Tutorial ist eine hochkundenspezifische Ausgründung aus einem Tutorial, das auf Pushers offizieller Seite veröffentlicht wurde.

Anforderungen

Für diesen Build müssen Sie wissen, wie Sie mit der Python -Programmiersprache, der einfachen Webentwicklung und der APIs arbeiten können.

Anforderungen installieren

Beginnen Sie mit der Installation von Python auf Ihrem System. Sie müssen auch Pusher und Flask, httpagentParser, installieren.

Erstellen der Datenbank

Der erste Schritt besteht darin, eine Datenbank zu erstellen, in der die Daten gespeichert werden. Für Python ist SQLite3 standardmäßig und es ist einfach, es zu verwenden. Erstellen Sie eine Datei namens Datenbank.PY und geben Sie den folgenden Code ein:

Import SQLite3
Aus SQLite3 -Importfehler
Def create_connection (Datenbank):
versuchen:
conn = sqlite3.verbinden(
Datenbank, Isolation_Level = Keine, check_Same_thread = false)
Conn.row_factory = lambda c, r: dict (
ZIP ([col [0] für Col in C.Beschreibung], r))
Conn zurückgeben
Ausnahme von Fehler als E:
Druck (e)
Def create_table (c, sql):
C.ausführen (SQL)
DEF UPDATE_OR_CREATE_PAGE (C, Daten):
SQL = "SELECT * Aus Seiten, wobei Name =? und Sitzung =?"
C.ausführen (SQL, Daten [:-1])
Ergebnis = c.fetchone ()
Wenn Ergebnis == keine:
create_pages (c, Daten)
anders:
Druck (Ergebnis)
update_pages (c, result ['id'])
Def create_pages (c, Daten):
Druck (Daten)
SQL = "In Seiten einfügen (Name, Sitzung, First_visited)
WERTE (?,?,?) "
C.ausführen (SQL, Daten)
Def update_pages (c, pageid):
print (pageId)
sql = "Seiten aktualisieren
Setzen Sie Besuche = Besuche+1
Wo id = ?"
C.ausführen (SQL, [PageID])
Def create_session (c, Daten):
SQL = "In Sitzungen einfügen (IP, Kontinent, Land, Stadt, Betriebssystem, Browser, Sitzung, created_at)
WERTE (?,?,?,?,?,?,?,?) "
C.ausführen (SQL, Daten)
Def select_all_Sessions (c):
SQL = "Aus Sessions auswählen"
C.ausführen (SQL)
Zeilen = c.fetchall ()
Zeilen zurückgeben
Def select_all_pages (c):
SQL = "Ausgewählt * aus den Seiten"
C.ausführen (SQL)
Zeilen = c.fetchall ()
Zeilen zurückgeben
DEF SELECT_ALL_USER_VISITS (C, Session_ID):
SQL = "SELECT * Aus Seiten, wobei Sitzung =?"
C.ausführen (SQL, [Session_ID])
Zeilen = c.fetchall ()
Zeilen zurückgeben
Def Main ():
Database = "./pythonsqlite.DB "
sql_create_pages = "" ""
Erstellen Sie eine Tabelle, wenn nicht vorhanden ist (Seiten (
ID Ganzzahl Primärschlüssel,
Nennen Sie Varchar (225) nicht null,
Sitzungsvarchar (255) NICHT NULL,
First_viehed DateTime nicht null,
Besuche Ganzzahl nicht null Standard 1
);
"" "
SQL_Create_Session = "" ""
Erstellen Sie Tabelle, wenn nicht vorhanden ist (
ID Ganzzahl Primärschlüssel,
IP Varchar (225) nicht null,
Kontinent Varchar (225) nicht null,
Landvarchar (225) nicht null,
Stadtvarchar (225) nicht null,
OS Varchar (225) nicht null,
Browser Varchar (225) NICHT NULL,
Sitzungsvarchar (225) NICHT NULL,
erstellte_at datetime nicht null
);
"" "
# Erstellen Sie eine Datenbankverbindung
conn = create_connection (Datenbank)
Wenn Conn nicht ist:
# Tabellen erstellen
create_table (conn, sql_create_pages)
create_table (conn, sql_create_session)
drucken ("Verbindung hergestellt!"))
anders:
drucken ("konnte keine Verbindung herstellen")
Wenn __name__ == '__main__':
hauptsächlich()

Speichern Sie die Datei und führen Sie das Skript aus, um die Datenbank mit den entsprechenden Daten zu erstellen.

Python -Datenbank.py
"Verbindung hergestellt!”

Gehen Sie als nächstes zu Pusher und erstellen Sie ein Konto. Erstellen Sie als nächstes eine Anwendung und folgen Sie dem Assistenten, um die App einzurichten. Kopieren Sie nach Abschluss die Appschlüssel und speichern Sie sie in einem Python -Wörterbuch, wie unten gezeigt.

pusher = pusher (
app_id = "1079412",
KEY = "E5D266A24F3502D2B814",
Secret = "BAB634D2398EB5FCB0F8",
cluster = "us2")

Erstellen Sie schließlich eine Flask -Anwendung und erstellen Sie das Backend, wie im folgenden Code gezeigt:

Aus Flask -Importflächen, Render_Template, Anfrage, Sitzung, JSONIFY
UrlliB importieren.Anfrage
vom Pusher -Import -Pusher
Aus der DateTime -Importdatetime importieren
HttpagentParser importieren
JSON importieren
OS importieren
Hashlib importieren
Aus Datenbank importieren create_connection, create_Session, update_or_create_page, select_all_sessions, select_all_user_visits, select_all_pages
app = Flask (__ Name__)
App.secry_key = os.Urandom (24)
# Pusher -Objekt konfigurieren
pusher = pusher (
app_id = "1079412",
KEY = "E5D266A24F3502D2B814",
Secret = "BAB634D2398EB5FCB0F8",
cluster = "us2")
Database = "./pythonsqlite.DB "
conn = create_connection (Datenbank)
C = Conn.Mauszeiger()
useros = keine
userip = keine
Uscity = keine
userbrowser = Keine
UserCountry = Keine
usercontinent = keine
SessionID = keine
Def Main ():
Global Conn, C
Def Parsevisitor (Daten):
update_or_create_page (c, Daten)
Pusher.Trigger (u'pageView ', u'new',
u'page ': Daten [0],
u'Session ': sessionId,
u'ip ': userip
)
Pusher.Trigger (u'numbers ', u'update',
u'page ': Daten [0],
u'Session ': sessionId,
u'ip ': userip
)
@app.vor_request
Def getanalyticsData ():
Global Useros, Userbrowser, Userip, Usercontinent, Usercity, UserCountry, SessionID
userInfo = httpagentParser.erkennen (Anfrage.Header.get ('user-Agent'))
userOS = userInfo ['Plattform'] ['Name']
userBrowser = userInfo ['Browser'] ['Name']
userip = "196.207.130.148 "Auf Anfrage.Remote_addr == '127.0.0.1 'sonst Anfrage.Remote_Addr
api = "https: // www.IPLOCITE.IO/API/SOOKUP/" + Userip
versuchen:
resp = urllib.Anfrage.Urlopen (API)
Ergebnis = resp.lesen()
Ergebnis = JSON.Lasten (Ergebnis.decode ("utf-8"))
UserCountry = Ergebnis ["Land"]
UserContinent = Ergebnis ["Kontinent"]
Uscity = Ergebnis ["Stadt"]
außer:
print ("konnte nicht finden:", userip)
getSession ()
Def getSession ():
Globale Sitzung
Zeit = DateTime.Jetzt().ersetzen (Mikrosekunden = 0)
Wenn 'Benutzer' nicht in Sitzung:
line = (str (Zeit)+userip).codieren ('utf-8')
Sitzung ['Benutzer'] = Hashlib.MD5 (Zeilen).hexDigest ()
SessionID = Session ['Benutzer']
Pusher.Trigger (u'session ', u'new',
u'ip ': userip,
u'continent ': Usercontinent,
u'country ': UserCountry,
u'city ': Usercity,
u'os ': Useros,
u'browser ': userbrowser,
u'Session ': sessionId,
u'time ': str (Zeit),
)
Data = [Userip, Usercontinent, UserCountry,
Uscity, Useros, Userbrowser, SessionID, Zeit]
Create_Session (c, Daten)
anders:
SessionID = Session ['Benutzer']
@app.Route('/')
Def Index ():
Data = ['Home', SessionID, STR (DateTimezeit.Jetzt().ersetzen (Mikrosekunden = 0))]
Parsevisitor (Daten)
F'user Data zurückgeben: Daten '
@app.Route ('/Get-All-Session')
Def get_all_Sessions ():
Daten = []
dbrows = select_all_sessions (c)
Für Zeile in DBrows:
Daten.append (
'ip': row ['ip'],
'Kontinent': Row ['Kontinent'],
'Country': Row ['Land'],
'City': Row ['Stadt'],
'os': row ['os'],
'Browser': Row ['Browser'],
'Sitzung': Row ['Sitzung'],
'Zeit': row ['created_at']
)
Rückgabe jSonify (Daten)
Wenn __name__ == '__main__':
hauptsächlich()
App.run (debug = true)

Führen Sie nach Abschluss die App mit dem Befehlsflaschenauslauf aus und navigieren Sie zu 127.0.0.1: 5000/ Dies sollte den Benutzer, die Sitzungsinformationen der spezifischen IP -Adresse einschließlich Agent (Browser), Land und solcher protokollieren.

Um alle protokollierten Sitzungen anzuzeigen, gehen Sie zu 127.0.0.1: 5000/Get-All-Session.

[

"Browser": "Chrome",
"Stadt": "New York",
"Kontinent": "Nordamerika",
"Land: Vereinigte Staaten",
"IP": "192.148.18.103 ",
"OS": "Linux",
"Session": "9A5D6A84D93AD62A599293ACB2E751A1",
"Zeit": "2021-01-13 02:52:32"
,

"Browser": "Mozilla",
"Stadt": "Oregon",
"Kontinent": "Nordamerika",
"Land: Vereinigte Staaten",
"IP": "66.115.149.229 ",
"OS": "Windows",
"Sitzung": "64d205c98c839e1d346c733ffd41b27f",
"Zeit": "2021-01-13 02:54:12"
,

"Browser": "Chrome",
"Stadt": "Ogden",
"Kontinent": "Nordamerika",
"Land: Vereinigte Staaten",
"IP": "172.231.59.124 ",
"OS": "Windows",
"Session": "3FD564C16A32B5139A8DD0578E36ADED",
"Zeit": "2021-01-13 02:54:37"
,

"Browser": "Chrome",
"Stadt": "New York",
"Kontinent": "Nordamerika",
"Land: Vereinigte Staaten",
"IP": "72.229.28.185 ",
"OS": "Windows",
"Session": "27AD92271023888427DA216DE10A7CAE",
"Zeit": "2021-01-13 02:55:07"
,

"Browser": "Chrome",
"Stadt": "Nairobi",
"Kontinent": "Afrika",
"Land": "Kenia",
"IP": "196.207.130.148 ",
"OS": "Linux",
"Session": "C92CDAB9EEFA2FE121D49264986E7345",
"Zeit": "2021-01-13 02:56:43"
,

"Browser": "Chrome",
"Stadt": "Nairobi",
"Kontinent": "Afrika",
"Land": "Kenia",
"IP": "196.207.130.148 ",
"OS": "Windows",
"Sitzung": "31ee28ec6a655e0fa13Be4DBA8C13861",
"Zeit": "2021-01-13 03:11:49"

]

Wenn die App ausgeführt wird, können Sie Ihre IP -Adresse und Browser zufällig ändern, um genügend Informationen für Ihre Datenbank zu sammeln. Mit den gesammelten Daten können Sie Datenwerkzeuge wie Elk Stack verwenden, um sie zu visualisieren und zu sehen, welche Standorte und Browser die Anwendung mehr besuchen.

Im Folgenden finden Sie eine Beispielvisualisierung gesammelter Daten aus der oben genannten App.

Abschluss

In diesem Tutorial haben wir Python, SQLite und Pusher verwendet, um Informationen über Benutzer zu sammeln, die die Website besuchen.

Um die Dinge einfach zu halten, habe ich die App -Output auf Console und JSON beschränkt, um diejenigen unterzubringen, die nicht mit Flask Jinja Templating gearbeitet haben.

Diese einfache App ist offen für eine Ausdehnung eines vollwertigen Webanalyse-Tools. Betrachten Sie die folgenden Ressourcen für zusätzliche Kenntnisse:

• https: // pusher.com/tutorials/webic-monitor-python
• https: // Flask.palletsProjects.com/en/1.1.X/
• https: // docs.Python.org/3/bibliothek/sqlite3.html
• https: // pusher.com/docs