Hvordan bygge en netttrafikkmonitor med Python, kolbe, sqlite og pusher

Hvis du har en webapplikasjon som løper der ute på internett, må du vite hvor de besøkende kommer fra, systemene de bruker, og andre slike ting.

Selv om du kan bruke tjenester som Google Analytics, Monster Insights, etc., Det er morsommere å bygge et overvåkningssystem ved hjelp av Python, SQL-database og pusher for sanntids dataoppdateringer.

I dagens opplæring vil vi gå over hvordan du lager et slikt verktøy ved hjelp av Python, Flask og Pusher. Opplæringen er en sterkt tilpasset spin-off fra en tutorial publisert på Pusders offisielle side.

Krav

For denne bygningen må du vite hvordan du skal jobbe med Python -programmeringsspråket, enkel nettutvikling og API -er.

Installere krav

Begynn med å installere Python på systemet ditt. Du må også installere pusher og kolbe, httpagentparser.

Opprette databasen

Det første trinnet er å opprette en database der dataene er lagret. For Python kommer SQLite3 som standard, og bruk av det er enkelt. Opprett en fil som heter Database.PY og skriv inn koden nedenfor:

Importer SQLite3
Fra SQLite3 Importfeil
def create_connection (database):
prøve:
conn = sqlite3.koble(
Database, Isolation_leVel = ingen, check_same_thread = falsk)
Conn.row_factory = lambda c, r: dict (
Zip ([Col [0] for Col i C.beskrivelse], r))
Returner Conn
Bortsett fra feil som e:
trykk (e)
def create_table (c, sql):
c.Utfør (SQL)
def update_or_create_page (c, data):
sql = "velg * fra sider der navn =? og økt =?""
c.Utfør (SQL, Data [:-1])
Resultat = c.fetchone ()
Hvis resultat == ingen:
create_pages (c, data)
ellers:
trykk (resultat)
update_pages (c, resultat ['id'])
def create_pages (c, data):
Print (data)
sql = "sett inn i sider (navn, økt, første_visited)
Verdier (?,?,?) "
c.Utfør (SQL, data)
def update_pages (c, sideid):
trykk (sideid)
SQL = "Oppdater sider
Sett besøk = besøk+1
Hvor id = ?""
c.Utfør (SQL, [Pageid])
def create_session (c, data):
SQL = "Sett inn i økter (IP, kontinent, land, by, OS, nettleser, økt, opprettet_at)
Verdier (?,?,?,?,?,?,?,?) "
c.Utfør (SQL, data)
def select_all_sessions (c):
sql = "Velg * fra økter"
c.Utfør (SQL)
rader = c.Fetchall ()
returnerer rader
def select_all_pages (c):
sql = "velg * fra sider"
c.Utfør (SQL)
rader = c.Fetchall ()
returnerer rader
def select_all_user_visits (c, session_id):
sql = "velg * fra sider der økt =?""
c.Utfør (SQL, [Session_id])
rader = c.Fetchall ()
returnerer rader
def main ():
database = "./pythonsqlite.db "
sql_create_pages = "" "
Lag tabell hvis ikke eksisterer sider (
ID heltall primærnøkkel,
Navn varchar (225) Ikke null,
økt varchar (255) ikke null,
First_visited DateTime ikke null,
besøker heltall ikke null standard 1
);
"" "
SQL_CREATE_SESSION = "" "
Lag tabell hvis ikke eksisterer økter (
ID heltall primærnøkkel,
ip varchar (225) ikke null,
kontinent varchar (225) ikke null,
land varchar (225) ikke null,
City Varchar (225) Ikke null,
OS VARCHAR (225) Ikke null,
nettleser varchar (225) ikke null,
økt varchar (225) ikke null,
opprettet_at datetime ikke null
);
"" "
# Opprett en databaseforbindelse
conn = create_connection (database)
Hvis Conn ikke er ingen:
# Lag tabeller
create_table (conn, sql_create_pages)
create_table (conn, sql_create_session)
trykk ("Tilkobling etablert!")
ellers:
trykk ("Kunne ikke etablere forbindelse")
if __name__ == '__main__':
hoved()

Lagre filen og kjør skriptet for å opprette databasen med relevante data.

Python -database.py
"Forbindelse opprettet!”

Deretter kan du gå over til Pusher og opprette en konto. Neste, opprette et program og følg veiviseren for å konfigurere appen. Når den er fullført, kopier appnøklene og lagrer dem i en Python -ordbok som vist nedenfor.

Pusher = Pusher (
app_id = "1079412",
Key = "E5D266A24F3502D2B814",
Hemmelighet = "BAB634D2398EB5FCB0F8",
cluster = "US2")

Til slutt, lag en kolbeapplikasjon og bygg backend som vist i koden nedenfor:

Fra kolbeimportkolbe, render_template, forespørsel, økt, jsonify
Importer urllib.be om
Fra Pusher Import Pusher
fra DateTime Import DateTime
Importer httpagentparser
Importer JSON
Importer OS
Importer hashlib
Fra databaseimport create_connection, create_session, update_or_create_page, select_all_sessions, select_all_user_visits, select_all_pages
app = kolbe (__ name__)
app.SECREM_KEY = OS.Urandom (24)
# Konfigurer Pusher -objekt
Pusher = Pusher (
app_id = "1079412",
Key = "E5D266A24F3502D2B814",
Hemmelighet = "BAB634D2398EB5FCB0F8",
cluster = "US2")
database = "./pythonsqlite.db "
conn = create_connection (database)
c = conn.markør ()
userOs = ingen
userIp = ingen
UserCity = Ingen
userBrowser = Ingen
UserCountry = ingen
UserContinent = Ingen
SessionId = Ingen
def main ():
Global Conn, C
def ParseVisitor (data):
update_or_create_page (c, data)
Pusher.Trigger (u'PageView ', u'New',
u'page ': data [0],
U'Session ': SessionId,
u'ip ': userip
)
Pusher.trigger (u'numbers ', u'Update',
u'page ': data [0],
U'Session ': SessionId,
u'ip ': userip
)
@App.før_request
def getAnalyticsData ():
Global UserOS, UserBrowser, UserIp, UserContinent, UserCity, UserCountry, SessionId
userInfo = httpagentParser.oppdage (forespørsel.overskrifter.få ('bruker-agent'))
userOS = userInfo ['plattform'] ['navn']
userBrowser = userInfo ['nettleser'] ['navn']
userip = "196.207.130.148 "Hvis forespørsel.ekstern_addr == '127.0.0.1 'annet forespørsel.Remote_addr
api = "https: // www.iplocate.IO/API/Lookup/" + UserIp
prøve:
Resp = urllib.be om.Urlopen (API)
Resultat = resp.lese()
Resultat = JSON.belastninger (resultat.Dekode ("UTF-8"))
UserCountry = Resultat ["Land"]
UserContinent = Resultat ["Kontinent"]
UserCity = Resultat ["City"]
unntatt:
Print ("Finner ikke:", UserIp)
getession ()
def getession ():
Global SessionId
Tid = DateTime.nå().Erstatt (mikrosekund = 0)
Hvis 'bruker' ikke i økt:
linjer = (str (tid)+userip).kode ('UTF-8')
økt ['bruker'] = hashlib.MD5 (linjer).Hexdigest ()
SessionId = Session ['Bruker']
Pusher.trigger (u'essession ', 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 (tid),
)
Data = [UserIp, UserContinent, UserCountry,
UserCity, UserOS, UserBrowser, SessionId, Time]
create_session (c, data)
ellers:
SessionId = Session ['Bruker']
@App.rute('/')
def index ():
Data = ['Hjem', SessionId, STR (DateTime.nå().erstatte (mikrosekund = 0))]
ParseVisitor (data)
Returner F'User Data: Data '
@App.rute ('/get-all-sessions')
def get_all_sessions ():
data = []
Dbrows = Select_all_Sessions (C)
for rad i Dbrows:
data.vedlegg (
'ip': rad ['ip'],
'kontinent': rad ['kontinent'],
'land': rad ['land'],
'City': Row ['City'],
'OS': ROW ['OS'],
'nettleser': rad ['nettleser'],
'Session': Row ['Session'],
'Tid': ROW ['CATED_AT']
)
Returner jsonify (data)
if __name__ == '__main__':
hoved()
app.Kjør (Debug = True)

Når den er fullført, kjør appen ved å bruke kommandokolbe -kjøringen og navigere til 127.0.0.1: 5000/ Dette skal logge brukeren, sesjonsinformasjonen til den spesifikke IP -adressen inkludert agent (nettleser), land og slikt.

For å se hele den loggede økten, gå til 127.0.0.1: 5000/Get-all-Sessions.

[

"nettleser": "krom",
"City": "New York",
"Kontinent": "Nord -Amerika",
"Land": "USA",
"IP": "192.148.18.103 ",
"OS": "Linux",
"Session": "9A5D6A84D93AD62A599293ACB2E751A1",
"Tid": "2021-01-13 02:52:32"
,

"nettleser": "Mozilla",
"City": "Oregon",
"Kontinent": "Nord -Amerika",
"Land": "USA",
"IP": "66.115.149.229 ",
"OS": "Windows",
"Session": "64d205c98c839e1d346c733ffd41b27f",
"Tid": "2021-01-13 02:54:12"
,

"nettleser": "krom",
"City": "Ogden",
"Kontinent": "Nord -Amerika",
"Land": "USA",
"IP": "172.231.59.124 ",
"OS": "Windows",
"Session": "3FD564C16A32B5139A8DD0578E36ADED",
"Tid": "2021-01-13 02:54:37"
,

"nettleser": "krom",
"City": "New York",
"Kontinent": "Nord -Amerika",
"Land": "USA",
"IP": "72.229.28.185 ",
"OS": "Windows",
"Session": "27AD92271023888427DA216DE10A7CAE",
"Tid": "2021-01-13 02:55:07"
,

"nettleser": "krom",
"City": "Nairobi",
"Kontinent": "Afrika",
"Land": "Kenya",
"IP": "196.207.130.148 ",
"OS": "Linux",
"Session": "C92CDAB9EEFA2FE121D49264986E7345",
"Tid": "2021-01-13 02:56:43"
,

"nettleser": "krom",
"City": "Nairobi",
"Kontinent": "Afrika",
"Land": "Kenya",
"IP": "196.207.130.148 ",
"OS": "Windows",
"Session": "31ee28ec6a655e0fa13be4dba8c13861",
"Tid": "2021-01-13 03:11:49"

]

Når appen kjører, kan du tilfeldig endre IP -adressen og nettleserne for å samle inn nok informasjon til databasen din. Ved å bruke dataene som er samlet, kan du bruke dataverktøy som Elk Stack for å visualisere dem og se hvilke steder og nettlesere besøker applikasjonen mer.

Følgende er et eksempel visualisering av innsamlede data fra appen ovenfor.

Konklusjon

I denne opplæringen brukte vi Python, Sqlite og Pusher for å samle informasjon om brukere som besøker nettstedet og brukte deretter dataene til å lage visualiseringer.

For å holde ting enkelt, begrenset jeg apputgangen til å konsoll.

Denne enkle appen er åpen for utvidelse til et fullverdig webanalyseverktøy. Tenk på ressursene nedenfor for ytterligere kunnskap:

• https: // skyver.com/tutorials/web-trafikk-monitor-python
• https: // kolbe.pallprosjekter.com/en/1.1.x/
• https: // dokumenter.Python.org/3/bibliotek/sqlite3.html
• https: // skyver.com/dokumenter