Phenquestions
Sebbene tu possa utilizzare servizi come Google Analytics, Monster Insights, ecc., è più divertente costruire un sistema di monitoraggio utilizzando Python, database SQL e Pusher per gli aggiornamenti dei dati in tempo reale.
Nel tutorial di oggi, esamineremo come creare uno strumento del genere utilizzando Python, Flask e Pusher. Il tutorial è uno spin-off altamente personalizzato da un tutorial pubblicato sulla pagina ufficiale di Pusher.
Requisiti
Per questa build, dovrai sapere come lavorare con il linguaggio di programmazione Python, lo sviluppo web semplice e le API.
Requisiti di installazione
Inizia installando Python sul tuo sistema. Dovrai anche installare Pusher e Flask, httpagentparser.
Creazione del database
Il primo passo è creare un database in cui sono archiviati i dati. Per Python, sqlite3 viene fornito di default e utilizzarlo è semplice. Crea un file chiamato database.py e inserisci il codice qui sotto:
import sqlite3da errore di importazione sqlite3
def create_connection(database):
provare:
conn = sqlite3.Collegare(
database, isolamento_level=Nessuno, check_same_thread=False)
connessione.row_factory = lambda c, r: dict(
zip([col[0] per col in c.descrizione], r))
ritorno conn
tranne Errore come e:
stampa(e)
def create_table(c, sql):
c.eseguire (sql)
def update_or_create_page(c, data):
sql = "SELECT * FROM pagine dove name=? e sessione=?"
c.esegui(sql, dati[:-1])
risultato = c.fetchone()
se risultato == Nessuno:
create_pages(c, dati)
altro:
stampa (risultato)
update_pages(c, risultato['id'])
def create_pages(c, data):
stampa (dati)
sql = "INSERT INTO pages(name,session,first_visited)
VALORI (?,?,?)"
c.eseguire (sql, dati)
def update_pages(c, pageId):
print(IDpagina)
sql = "AGGIORNA pagine
SET visite = visite+1
DOVE id = ?"
c.esegui (sql, [pageId])
def create_session(c, data):
sql = "INSERT INTO session (ip, continente, country, city, os, browser, session, created_at)
VALORI (?,?,?,?,?,?,?,?)"
c.eseguire (sql, dati)
def select_all_sessions(c):
sql = "SELEZIONA * DA sessioni"
c.eseguire (sql)
righe = c.recupera()
restituire righe row
def select_all_pages(c):
sql = "SELEZIONA * DA pagine"
c.eseguire (sql)
righe = c.recupera()
restituire righe
def select_all_user_visits(c, session_id):
sql = "SELECT * FROM pagine dove sessione =?"
c.eseguire (sql, [session_id])
righe = c.recupera()
restituire righe row
def principale():
banca dati = "./pythonsqlite.db"
sql_create_pages = """
CREA TABELLA SE NON ESISTE pagine (
ID intero CHIAVE PRIMARIA,
nome varchar(225) NOT NULL,
sessione varchar(255) NOT NULL,
first_visited datetime NOT NULL,
visite intero NOT NULL Predefinito 1
);
"""
sql_create_session = """
CREA TABELLA SE NON ESISTE sessioni (
ID intero CHIAVE PRIMARIA,
ip varchar(225) NOT NULL,
continente varchar(225) NOT NULL,
paese varchar(225) NOT NULL,
città varchar(225) NOT NULL,
os varchar(225) NOT NULL,
browser varchar(225) NOT NULL,
sessione varchar(225) NOT NULL,
create_at datetime NOT NULL
);
"""
# crea una connessione al database
conn = create_connection(database)
se conn non è Nessuno:
# crea tabelle
create_table(conn, sql_create_pages)
create_table(conn, sql_create_session)
print("Connessione stabilita!")
altro:
print("Impossibile stabilire la connessione")
if __name__ == '__main__':
principale()
Salva il file ed esegui lo script per creare il database con i dati rilevanti.
database pitone.pi"Connessione stabilita!"
Quindi, vai su pusher e crea un account. Quindi, crea un'applicazione e segui la procedura guidata per configurare l'app. Una volta completato, copia le chiavi dell'app e memorizzale in un dizionario Python come mostrato di seguito.
spintore = spintore(app_id = "1079412",
chiave = "e5d266a24f3502d2b814",
segreto = "bab634d2398eb5fcb0f8",
cluster = "us2")
Infine, crea un'applicazione flask e crea il backend come mostrato nel codice seguente:
from flask import Flask, render_template, request, session, jsonifyimport urllib.richiesta
da pusher import Pusher
da datetime import datetime
import httpagentparser
import json
importare il sistema operativo
importa hashlib
dal database import create_connection, create_session, update_or_create_page, select_all_sessions, select_all_user_visits, select_all_pages
app = Flask(__name__)
app.secret_key = os.casualità(24)
# configura l'oggetto pusher
spintore = spintore(
app_id = "1079412",
chiave = "e5d266a24f3502d2b814",
segreto = "bab634d2398eb5fcb0f8",
cluster = "us2")
banca dati = "./pythonsqlite.db"
conn = create_connection(database)
c = conn.cursore()
userOS = Nessuno
userIP = Nessuno
userCity = Nessuno
userBrowser = Nessuno
userCountry = Nessuno
userContinent = Nessuno
IDsessione = Nessuno
def principale():
connessione globale, c
def parseVisitor(data):
update_or_create_page(c, data)
spintore.trigger(u'pageview', u'new',
u'page': data[0],
u'session': IDsessione,
u'ip': userIP
)
spintore.trigger(u'numbers', u'update',
u'page': data[0],
u'session': IDsessione,
u'ip': userIP
)
@app.prima_richiesta
def getAnalyticsData():
userOS globale, userBrowser, userIP, userContinent, userCity, userCountry, sessionID
userInfo = httpagentparser.rilevare (richiesta).intestazioni.get('User-Agent'))
userOS = userInfo['platform']['name']
userBrowser = userInfo['browser']['name']
userIP = "196.207.130.148" su richiesta.remote_addr == '127.0.0.1' altra richiesta.ind_remoto
api = "https://www.iplocare.io/api/lookup/" + userIP
provare:
risp = urllib.richiesta.urlopen(api)
risultato = risp.leggere()
risultato = json.carichi (risultato.decodifica("utf-8"))
userPaese = risultato["paese"]
userContinent = risultato["continente"]
userCity = risultato["città"]
tranne:
print("Impossibile trovare: ", IPutente)
getSession()
def getSession():
ID sessione globale
ora = data e ora.adesso().sostituisci(microsecondo=0)
se 'utente' non è in sessione:
righe = (str(time)+userIP).codifica('utf-8')
session['user'] = hashlib.md5 (linee).esadecimale()
IDsessione = sessione['utente']
spintore.trigger(u'session', u'new',
u'ip': userIP,
u'continent': userContinent,
u'paese': userCountry,
u'city': userCity,
u'os': userOS,
u'browser': userBrowser,
u'session': IDsessione,
u'time': str(time),
)
data = [userIP, userContinent, userCountry,
userCity, userOS, userBrowser, ID sessione, ora]
create_session(c, dati)
altro:
IDsessione = sessione['utente']
@app.itinerario('/')
def indice():
data = ['home', IDsessione, str(datetime.adesso().sostituisci(microsecondo=0))]
parseVisitor (dati)
return f'Dati utente: data'
@app.route('/get-all-sessions')
def get_all_sessions():
dati = []
dbRows = select_all_sessions(c)
per riga in dbRows:
dati.aggiungere(
'ip': riga['ip'],
'continente': riga['continente'],
'paese': riga['paese'],
'città': riga['città'],
'os': riga['os'],
'browser': riga['browser'],
'sessione': riga['sessione'],
'ora': riga['creato_alle']
)
restituire jsonify (dati)
if __name__ == '__main__':
principale()
app.run(debug=True)
Una volta completato, esegui l'app utilizzando il comando flask run e vai a 127.0.0.1:5000/ Questo dovrebbe registrare l'utente, le informazioni sulla sessione dell'indirizzo IP specifico incluso Agente (browser), Paese e simili.
Per visualizzare tutta la sessione registrata, vai a 127.0.0.1:5000/ottieni tutte le sessioni.
["browser": "Chrome",
"città": "New York",
"continente": "Nord America",
"paese": "Stati Uniti",
"ip":"192.148.18.103",
"os": "Linux",
"sessione": "9a5d6a84d93ad62a599293acb2e751a1",
"tempo":"2021-01-13 02:52:32"
,
"browser": "Mozilla",
"città": "Oregon",
"continente": "Nord America",
"paese": "Stati Uniti",
"ip": "66.115.149.229",
"os": "Windows",
"sessione": "64d205c98c839e1d346c733ffd41b27f",
"tempo":"2021-01-13 02:54:12"
,
"browser": "Chrome",
"city": "Ogden",
"continente": "Nord America",
"paese": "Stati Uniti",
"ip": "172.231.59.124",
"os": "Windows",
"sessione": "3fd564c16a32b5139a8dd0578e36aded",
"tempo":"2021-01-13 02:54:37"
,
"browser": "Chrome",
"città": "New York",
"continente": "Nord America",
"paese": "Stati Uniti",
"ip": "72.229.28.185",
"os": "Windows",
"sessione": "27ad92271023888427da216de10a7cae",
"tempo":"2021-01-13 02:55:07"
,
"browser": "Chrome",
"città": "Nairobi",
"continente": "Africa",
"paese": "Kenia",
"ip": "196.207.130.148",
"os": "Linux",
"sessione": "c92cdab9eefa2fe121d49264986e7345",
"tempo":"2021-01-13 02:56:43"
,
"browser": "Chrome",
"città": "Nairobi",
"continente": "Africa",
"paese": "Kenia",
"ip": "196.207.130.148",
"os": "Windows",
"sessione": "31ee28ec6a655e0fa13be4dba8c13861",
"tempo":"2021-01-13 03:11:49"
]
Con l'app in esecuzione, puoi modificare casualmente il tuo indirizzo IP e i browser per raccogliere informazioni sufficienti per il tuo database. Utilizzando i dati raccolti, puoi utilizzare strumenti di dati come lo stack ELK per visualizzarlo e vedere quali posizioni e browser visitano l'applicazione di più.
Quello che segue è un esempio di visualizzazione dei dati raccolti dall'app sopra.
Conclusione
In questo tutorial, abbiamo utilizzato Python, SQLite e Pusher per raccogliere informazioni sugli utenti che visitano il sito Web e quindi abbiamo utilizzato i dati per creare visualizzazioni.
Per semplificare le cose, ho limitato l'output dell'app a console e JSON per accogliere coloro che non hanno lavorato con il modello jinja di Flask.
Questa semplice app è aperta all'espansione in uno strumento di analisi web completo. Considera le risorse di seguito per ulteriori conoscenze:
- https://pusher.com/tutorials/monitor-del-traffico-web-python
- https://flask.palletprogetti.com/it/1.1.X/
- https://docs.pitone.org/3/libreria/sqlite3.html
- https://pusher.com/docs
