Python

Hvordan lage en webtrafikkovervåker med Python, Flask, SQLite og Pusher

Hvordan lage en webtrafikkovervåker med Python, Flask, SQLite og Pusher
Hvis du har en webapplikasjon som kjører 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 osv., det er morsommere å bygge et overvåkingssystem ved hjelp av Python, SQL-database og Pusher for sanntidsdataoppdateringer.

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 veldig tilpasset spin-off fra en opplæring publisert på Pushers offisielle side.

Krav

For denne bygningen må du vite hvordan du kan arbeide med python-programmeringsspråk, enkel webutvikling og API-er.

Installasjonskrav

Start med å installere Python på systemet ditt. Du må også installere Pusher and Flask, httpagentparser.

Opprette databasen

Det første trinnet er å lage en database der dataene lagres. For Python kommer sqlite3 som standard, og det er enkelt å bruke det. Lag en fil som heter database.py og skriv inn koden nedenfor:

importere sqlite3
fra sqlite3 importfeil
def create_connection (database):
prøve:
conn = sqlite3.koble(
database, isolation_level = None, check_same_thread = False)
tilkobling.row_factory = lambda c, r: dict (
zip ([col [0] for col in c.beskrivelse], r))
retur tilkobling
unntatt feil som e:
skrive ut (e)
def create_table (c, sql):
c.utføre (sql)
def update_or_create_page (c, data):
sql = "VELG * FRA sider der navn =? og økt =?"
c.kjør (sql, data [: - 1])
resultat = c.fetchone ()
hvis resultat == Ingen:
create_pages (c, data)
ellers:
skriv ut (resultat)
update_pages (c, resultat ['id'])
def create_pages (c, data):
skriv ut (data)
sql = "INSERT INTO sides (name, session, first_visited)
VERDIER (?,?,?) "
c.kjør (sql, data)
def update_pages (c, pageId):
skriv ut (pageId)
sql = "OPPDATER sider
SET besøk = besøk + 1
HVOR id = ?"
c.kjør (sql, [pageId])
def create_session (c, data):
sql = "INSERT INTO sessions (ip, kontinent, land, by, os, nettleser, økt, opprettet_at)
VERDIER (?,?,?,?,?,?,?,?) "
c.kjør (sql, data)
def select_all_sessions (c):
sql = "VELG * FRA økter"
c.utføre (sql)
rader = c.fetchall ()
returnere rader
def select_all_pages (c):
sql = "VELG * FRA sider"
c.utføre (sql)
rader = c.fetchall ()
returnere rader
def select_all_user_visits (c, session_id):
sql = "VELG * FRA sider der økt =?"
c.kjør (sql, [session_id])
rader = c.fetchall ()
returnere rader
def main ():
database = "./ pythonsqlite.db "
sql_create_pages = "" "
OPPRETT TABELL HVIS IKKE eksisterer sider (
id heltall PRIMÆR NØKKEL,
navn varchar (225) IKKE NULL,
øktvarchar (255) IKKE NULL,
første besøkte datetid IKKE NULL,
besøker heltall IKKE NULL Standard 1
);
"" "
sql_create_session = "" "
OPPRETT TABELL HVIS IKKE FINNER økter (
id heltall PRIMÆR NØKKEL,
ip varchar (225) IKKE NULL,
continent varchar (225) IKKE NULL,
landvarchar (225) IKKE NULL,
city ​​varchar (225) IKKE NULL,
os varchar (225) IKKE NULL,
nettleser varchar (225) IKKE NULL,
øktvarchar (225) IKKE NULL,
created_at datetime NOT NULL
);
"" "
# opprett en databaseforbindelse
conn = create_connection (database)
hvis tilkobling ikke er Ingen:
# opprett tabeller
create_table (conn, sql_create_pages)
create_table (conn, sql_create_session)
print ("Tilkobling etablert!")
ellers:
skriv ut ("Kunne ikke opprette forbindelse")
hvis __name__ == '__main__':
hoved()

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

python-database.py
"Forbindelse opprettet!”

Deretter går du over til pusher og oppretter en konto. Deretter oppretter du et program og følger veiviseren for å sette opp appen. Når du er ferdig, kopierer du appnøklene og lagrer dem i en pythonordbok som vist nedenfor.

pusher = Pusher (
app_id = "1079412",
nøkkel = "e5d266a24f3502d2b814",
hemmelig = "bab634d2398eb5fcb0f8",
cluster = "us2")

Til slutt oppretter du en kolbeapplikasjon og bygger backend som vist i koden nedenfor:

fra kolbeimport Kolbe, render_template, forespørsel, økt, jsonify
importer urllib.be om
fra pusher import Pusher
fra datetime importer datetime
importer httpagentparser
importere 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 (__ navn__)
app.secret_key = os.urandom (24)
# konfigurer skyveobjekt
pusher = Pusher (
app_id = "1079412",
nøkkel = "e5d266a24f3502d2b814",
hemmelig = "bab634d2398eb5fcb0f8",
cluster = "us2")
database = "./ pythonsqlite.db "
conn = create_connection (database)
c = tilkobling.markør ()
userOS = Ingen
userIP = Ingen
userCity = Ingen
userBrowser = Ingen
userCountry = Ingen
userContinent = Ingen
sessionID = Ingen
def main ():
global forbindelse, c
def parseVisitor (data):
update_or_create_page (c, data)
skyver.trigger (u'pageview ', u'new',
u'side ': data [0],
u'session ': sessionID,
u'ip ': brukerIP
)
skyver.trigger (u'numbers ', u'update',
u'side ': data [0],
u'session ': sessionID,
u'ip ': brukerIP
)
@app.før_forespørsel
def getAnalyticsData ():
global userOS, userBrowser, userIP, userContinent, userCity, userCountry, sessionID
userInfo = httpagentparser.oppdage (forespørsel.topptekster.get ('User-Agent'))
userOS = userInfo ['platform'] ['name']
userBrowser = userInfo ['browser'] ['name']
userIP = "196.207.130.148 "hvis forespørsel.ekstern_addr == '127.0.0.1 'annen forespørsel.ekstern_adr
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 ["by"]
unntatt:
print ("Kunne ikke finne:", userIP)
getSession ()
def getSession ():
global økt-ID
tid = datetime.nå().erstatt (mikrosekund = 0)
hvis 'bruker' ikke er i økt:
linjer = (str (tid) + brukerIP).kode ('utf-8')
økt ['bruker'] = hashlib.md5 (linjer).hexdigest ()
sessionID = økt ['bruker']
skyver.trigger (u'session ', u'new',
u'ip ': brukerIP,
u'continent ': userContinent,
u'country ': userCountry,
u'city ': userCity,
u'os ': brukerOS,
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 = økt ['bruker']
@app.rute('/')
def indeks ():
data = ['home', sessionID, str (datetime.nå().erstatt (mikrosekund = 0))]
parseVisitor (data)
returner f'Brukerdata: data '
@app.rute ('/ get-all-sessions')
def get_all_sessions ():
data = []
dbRows = select_all_sessions (c)
for rad i dbRader:
data.legg til (
'ip': rad ['ip'],
'kontinent': rad ['kontinent'],
'land': rad ['land'],
'by': rad ['by'],
'os': rad ['os'],
'browser': rad ['browser'],
'økt': rad ['økt'],
'tid': rad ['created_at']
)
returner jsonify (data)
hvis __name__ == '__main__':
hoved()
app.kjør (feilsøk = sann)

Når du er ferdig, kjører du appen ved å bruke kommandokolben og naviger til 127.0.0.1: 5000 / Dette skal logge brukeren, øktinformasjonen til den spesifikke IP-adressen inkludert agent (nettleser), land og lignende.

For å se hele den loggede økten, gå til 127.0.0.1: 5000 / få alle økter.

[

"browser": "Chrome",
"city": "New York",
"continent": "Nord-Amerika",
"country": "United States",
"ip": "192.148.18.103 ",
"os": "Linux",
"økt": "9a5d6a84d93ad62a599293acb2e751a1",
"tid": "2021-01-13 02:52:32"
,

"browser": "Mozilla",
"city": "Oregon",
"continent": "Nord-Amerika",
"country": "United States",
"ip": "66.115.149.229 ",
"os": "Windows",
"økt": "64d205c98c839e1d346c733ffd41b27f",
"tid": "2021-01-13 02:54:12"
,

"browser": "Chrome",
"city": "Ogden",
"continent": "Nord-Amerika",
"country": "United States",
"ip": "172.231.59.124 ",
"os": "Windows",
"økt": "3fd564c16a32b5139a8dd0578e36aded",
"tid": "2021-01-13 02:54:37"
,

"browser": "Chrome",
"city": "New York",
"continent": "Nord-Amerika",
"country": "United States",
"ip": "72.229.28.185 ",
"os": "Windows",
"session": "27ad92271023888427da216de10a7cae",
"tid": "2021-01-13 02:55:07"
,

"browser": "Chrome",
"city": "Nairobi",
"continent": "Africa",
"country": "Kenya",
"ip": "196.207.130.148 ",
"os": "Linux",
"økt": "c92cdab9eefa2fe121d49264986e7345",
"tid": "2021-01-13 02:56:43"
,

"browser": "Chrome",
"city": "Nairobi",
"continent": "Africa",
"country": "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-adresse og nettlesere for å samle nok informasjon til databasen din. Ved å bruke dataene som er samlet, kan du bruke dataverktøy som ELK stack for å visualisere det og se hvilke steder og nettlesere som besøker applikasjonen mer.

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

Konklusjon

I denne veiledningen brukte vi Python, SQLite og Pusher til å samle informasjon om brukere som besøkte nettstedet, og brukte deretter dataene til å lage visualiseringer.

For å holde ting enkelt, begrenset jeg apputgangen til konsoll og JSON for å imøtekomme de som ikke har jobbet med Flask jinja mal.

Denne enkle appen er åpen for utvidelse til et fullverdig verktøy for nettanalyse. Vurder ressursene nedenfor for ytterligere kunnskap:

Spill Kjemp om Wesnoth-opplæringen
Kjemp om Wesnoth-opplæringen
Kampen om Wesnoth er et av de mest populære open source-strategispillene du kan spille på dette tidspunktet. Ikke bare har dette spillet vært i utvikl...
Spill 0 A.D. Opplæringen
0 A.D. Opplæringen
Ut av de mange strategispillene der ute, 0 A.D. klarer å skille seg ut som en omfattende tittel og et veldig dypt, taktisk spill til tross for å være ...
Spill Unity3D opplæring
Unity3D opplæring
Introduksjon til Unity 3D Unity 3D er en kraftig spillutviklingsmotor. Det er kryssplattform, det er det lar deg lage spill for mobil, web, stasjonær ...