Comment construire un moniteur de trafic Web avec Python, Flask, Sqlite et Pusher

Si vous avez une application Web qui s'exécute sur Internet, vous devrez savoir d'où viennent vos visiteurs, les systèmes qu'ils utilisent et d'autres choses de ce type.

Bien que vous puissiez utiliser des services tels que Google Analytics, Monster Insights, etc., Il est plus amusant de créer un système de surveillance à l'aide de Python, de la base de données SQL et de Pusher pour les mises à jour de données en temps réel.

Dans le tutoriel d'aujourd'hui, nous allons contribuer à créer un tel outil à l'aide de Python, Flask et Pusher. Le tutoriel est un spin-off hautement personnalisé d'un tutoriel publié sur la page officielle de Pusher.

Exigences

Pour cette version, vous devrez savoir comment travailler avec le langage de programmation Python, le développement Web simple et les API.

Exigences d'installation

Commencez par installer Python sur votre système. Vous devrez également installer Pusher et Flask, HttpagentParser.

Création de la base de données

La première étape consiste à créer une base de données où les données sont stockées. Pour Python, SQLite3 est par défaut, et l'utiliser est simple. Créer un fichier appelé base de données.py et entrez le code ci-dessous:

importer sqlite3
à partir de l'erreur d'importation SQLite3
DEF CREATE_CONNECTION (base de données):
essayer:
Conn = Sqlite3.connecter(
base de données, isolement_level = aucun, check_same_thread = false)
Connecticut.row_factory = lambda c, r: dict (
zip ([col [0] pour col en c.Description], R))
Retourne Conn
sauf l'erreur comme e:
Imprimer (e)
DEF CREATE_TABLE (C, SQL):
c.exécuter (SQL)
def update_or_create_page (c, data):
sql = "select * à partir des pages où name =? et session =?"
c.exécuter (SQL, données [: - 1])
résultat = c.fetchone ()
Si résultat == Aucun:
create_pages (c, données)
autre:
Imprimer (résultat)
update_pages (c, résultat ['id'])
def create_pages (c, data):
Imprimer (données)
sql = "Insérer dans les pages (nom, session, premier_visité)
VALEURS (?,?,?) "
c.exécuter (SQL, données)
Def Update_Pages (C, Pageid):
Imprimer (Pageid)
SQL = "Pages de mise à jour
Définir les visites = visites + 1
Où id = ?"
c.exécuter (SQL, [PageID])
def Create_Session (C, Data):
sql = "Insérer dans les sessions (IP, continent, pays, ville, système d'exploitation, navigateur, session, créé_at)
VALEURS (?,?,?,?,?,?,?,?) "
c.exécuter (SQL, données)
def select_all_essions (c):
sql = "select * from Sessions"
c.exécuter (SQL)
lignes = c.fetchall ()
Retour des lignes
def select_all_pages (c):
SQL = "SELECT * FROM PAGES"
c.exécuter (SQL)
lignes = c.fetchall ()
Retour des lignes
DEF SELECT_ALL_USER_VIVESISS (C, Session_ID):
sql = "select * à partir des pages où session =?"
c.exécuter (SQL, [session_id])
lignes = c.fetchall ()
Retour des lignes
def main ():
base de données = "./ pythonsqlite.db "
sql_create_pages = "" "
Créer une table s'il n'existe pas de pages (
Clé primaire ID INTEGER,
nom varchar (225) pas null,
Session Varchar (255) pas nul,
premier_visité datetime pas nul,
Visites entier et non null par défaut 1
));
"" "
sql_create_session = "" "
Créer une table s'il n'existe pas de sessions (
Clé primaire ID INTEGER,
ip varchar (225) pas null,
continent varchar (225) pas nul,
pays varchar (225) pas nul,
City Varchar (225) pas nul,
OS Varchar (225) pas nul,
Browser varchar (225) pas null,
Session Varchar (225) pas nul,
Created_at datetime pas null
));
"" "
# Créer une connexion de base de données
Conn = create_connection (base de données)
Si Conn n'est pas nul:
# Créer des tables
Create_Table (CONN, SQL_CREATE_PAGES)
Create_Table (Conn, SQL_CREATE_SESSION)
Imprimer ("Connexion établie!")
autre:
imprimer ("ne pouvait pas établir la connexion")
Si __Name__ == '__MAIN__':
principal()

Enregistrez le fichier et exécutez le script pour créer la base de données avec les données pertinentes.

base de données Python.py
"Connection établie!"

Ensuite, dirigez-vous vers Pusher et créez un compte. Ensuite, créez une application et suivez l'assistant pour configurer l'application. Une fois terminé, copiez les clés de l'application et stockez-les dans un dictionnaire Python comme indiqué ci-dessous.

Pusher = Pusher (
app_id = "1079412",
key = "e5d266a24f3502d2b814",
Secret = "BAB634D2398EB5FCB0F8",
cluster = "us2")

Enfin, créez une application Flask et créez le backend comme indiqué dans le code ci-dessous:

De Flask Import Flask, render_template, demande, session, jsonify
Importer Urllib.demande
à partir du poussoir d'importation de poussoir
à partir de Datetime Import Datetime
importer httpagentParser
Importer JSON
Importer un système d'exploitation
Importer un hashlib
à partir de la base de données importage_connection, create_session, update_or_create_page, select_all_essions, select_all_user_visits, select_all_pages
app = flacon (__ name__)
appliquer.Secret_Key = OS.urandom (24)
# Configurer l'objet Pusher
Pusher = Pusher (
app_id = "1079412",
key = "e5d266a24f3502d2b814",
Secret = "BAB634D2398EB5FCB0F8",
cluster = "us2")
base de données = "./ pythonsqlite.db "
Conn = create_connection (base de données)
C = Conn.le curseur()
userOs = aucun
userip = aucun
Usercité = aucun
UserBrowser = Aucun
usercountry = aucun
usercontinent = aucun
sessionId = aucun
def main ():
Global Conn, C
Def Parsevisitor (données):
Update_or_create_page (C, données)
poussoir.Trigger (u'PageView ', u'new',
u'page ': data [0],
U'Session ': SessionId,
u'ip ': userip
)
poussoir.Trigger (u'numbers ', u'update',
u'page ': data [0],
U'Session ': SessionId,
u'ip ': userip
)
@app.avant_Request
def getanalyticsdata ():
UserOS mondial, Userbrowser, Userip, Usercontinent, Usercity, Usercountry, SessionID
userInfo = httpagentArser.détecter (demande.têtes.get ('utilisateur-agent'))
userOs = userInfo ['plateforme'] ['name']
userBrowser = userInfo ['Browser'] ['name']
userip = "196.207.130.148 "Si demande.Remote_addr == '127.0.0.1 'ailleurs de demande.Remote_addr
api = "https: // www.iploration.IO / API / Lookup / "+ Userip
essayer:
resp = Urllib.demande.Urlopen (API)
résultat = resp.lire()
Résultat = JSON.charges (résultat.Decode ("UTF-8"))
usercountry = résultat ["pays"]
usercontinent = résultat ["continent"]
usercity = résultat ["ville"]
sauf:
imprimer ("Impossible de trouver:", userip)
getSession ()
def getSession ():
SessionID mondial
Time = DateTime.maintenant().remplacer (microseconde = 0)
Si «l'utilisateur» n'est pas en session:
lignes = (str (temps) + userip).Encode ('UTF-8')
session ['utilisateur'] = hashlib.MD5 (lignes).hexdigest ()
sessionId = session ['utilisateur']
poussoir.Trigger (u'Session ', u'new',
u'ip ': userip,
U'Continent ': usercontinent,
U'Country ': Usercountry,
u'city ': utilisabilité,
u'os ': useros,
U'Browser ': Userbrowser,
U'Session ': SessionId,
u'time ': str (temps),
)
data = [userip, usercontinent, usercountry,
usercity, userOs, userbrowser, sessionId, time]
create_session (c, données)
autre:
sessionId = session ['utilisateur']
@app.itinéraire('/')
def index ():
data = ['home', sessionid, str (datetime.maintenant().remplacer (microseconde = 0))]
PARSEVIVERSIGHT (DONNÉES)
return f'user data: data '
@app.itinéraire ('/ get-all-sessions')
def get_all_essions ():
data = []
dBrows = select_all_essions (c)
Pour la ligne dans DBrows:
données.ajouter(
'ip': row ['ip'],
«continent»: ligne [«continent»],
«Pays»: ligne [«pays»],
'City': Row ['City'],
'os': row ['os'],
'Browser': Row ['Browser'],
'session': row ['session'],
'Time': Row ['Created_at']
)
Renvoie Jsonify (données)
Si __name__ == '__MAIN__':
principal()
appliquer.courir (debug = true)

Une fois terminé, exécutez l'application à l'aide du Flask de commande Exécuter et accédez à 127.0.0.1: 5000 / Ceci devrait enregistrer l'utilisateur, les informations de session de l'adresse IP spécifique, y compris l'agent (navigateur), le pays, et tel.

Pour voir toute la session enregistrée, passez à 127.0.0.1: 5000 / Get-All-Sessions.

[

"Browser": "Chrome",
"City": "New York",
"Continent": "Amérique du Nord",
"pays": "États-Unis",
"IP": "192.148.18.103 ",
"OS": "Linux",
"Session": "9A5D6A84D93AD62A599293ACB2E751A1",
"Time": "2021-01-13 02:52:32"
,

"Browser": "Mozilla",
"ville": "Oregon",
"Continent": "Amérique du Nord",
"pays": "États-Unis",
"IP": "66.115.149.229 ",
"OS": "Windows",
"Session": "64d205c98c839e1d346c733ffd41b27f",
"Time": "2021-01-13 02:54:12"
,

"Browser": "Chrome",
"City": "Ogden",
"Continent": "Amérique du Nord",
"pays": "États-Unis",
"IP": "172.231.59.124 ",
"OS": "Windows",
"Session": "3FD564C16A32B5139A8DD0578E36ADED",
"Time": "2021-01-13 02:54:37"
,

"Browser": "Chrome",
"City": "New York",
"Continent": "Amérique du Nord",
"pays": "États-Unis",
"IP": "72.229.28.185 ",
"OS": "Windows",
"Session": "27Ad922710238888427DA216DE10A7CAE",
"Time": "2021-01-13 02:55:07"
,

"Browser": "Chrome",
"City": "Nairobi",
"Continent": "Afrique",
"pays": "Kenya",
"IP": "196.207.130.148 ",
"OS": "Linux",
"Session": "C92CDAB9EEFA2FE121D49264986E7345",
"Time": "2021-01-13 02:56:43"
,

"Browser": "Chrome",
"City": "Nairobi",
"Continent": "Afrique",
"pays": "Kenya",
"IP": "196.207.130.148 ",
"OS": "Windows",
"Session": "31EE28EC6A655E0FA13BE4DBA8C13861",
"Time": "2021-01-13 03:11:49"

]]

Avec l'application en cours d'exécution, vous pouvez modifier au hasard votre adresse IP et vos navigateurs pour collecter suffisamment d'informations pour votre base de données. À l'aide des données recueillies, vous pouvez utiliser des outils de données tels que Elk Stack pour les visualiser et voir quels emplacements et navigateurs visitent plus l'application.

Ce qui suit est un exemple de visualisation des données collectées de l'application ci-dessus.

Conclusion

Dans ce tutoriel, nous avons utilisé Python, SQLite et Pusher pour collecter des informations sur les utilisateurs visitant le site Web, puis utilisé les données pour créer des visualisations.

Pour garder les choses simples, j'ai limité la sortie de l'application à Console et JSON pour accueillir ceux qui n'ont pas travaillé avec des modèles Jinja Flask.

Cette application simple est ouverte à l'expansion dans un outil d'analyse Web à part entière. Considérez les ressources ci-dessous pour une connaissance supplémentaire:

• https: // pusteur.com / tutoriels / web-trafic-monitor-python
• https: // flacon.paletsprojects.com / en / 1.1.X/
• https: // docs.python.org / 3 / bibliothèque / sqlite3.html
• https: // pusteur.com / docs