Jak zbudować monitor ruchu internetowego za pomocą Python, Flask, SQLite i Pusher

Jeśli masz aplikację internetową wybiegającą w Internecie, musisz wiedzieć, skąd pochodzą Twoi odwiedzający, systemy, których używają i inne takie rzeczy.

Chociaż możesz korzystać z usług takich jak Google Analytics, Monster Insights itp., Fajniej jest zbudować system monitorowania za pomocą Python, bazy danych SQL i popychacza dla aktualizacji danych w czasie rzeczywistym.

W dzisiejszym samouczku omówimy, jak stworzyć takie narzędzie za pomocą Pythona, Flask i Pusher. Samouczek to wysoce uporządkowany spin-off z samouczka opublikowanego na oficjalnej stronie Pushera.

Wymagania

W tej wersji będziesz musiał wiedzieć, jak pracować z językiem programowania Python, prostym tworzeniem stron internetowych i interfejsami API.

Instalowanie wymagań

Zacznij od zainstalowania Pythona w systemie. Będziesz także musiał zainstalować popychacz i kolbę, httpagentparser.

Tworzenie bazy danych

Pierwszym krokiem jest utworzenie bazy danych, w której dane są przechowywane. W przypadku Pythona SQLite3 jest domyślnie, a użycie go jest proste. Utwórz plik o nazwie baza danych.py i wprowadź poniższy kod:

import sqlite3
z błędu importu SQLite3
def create_connection (baza danych):
próbować:
conn = sqlite3.łączyć(
baza danych, izolacja_level = brak, check_same_thread = false)
Conn.Row_factory = Lambda C, R: DICT (
Zip ([col [0] dla col in c.Opis], r))
powrót Conn
z wyjątkiem błędu jako E:
Drukuj (e)
def create_table (c, sql):
C.Wykonaj (SQL)
def aktualizacja_or_create_page (c, dane):
sql = "wybierz * ze stron, w których nazwa =? i sesja =?"
C.Wykonaj (SQL, dane [:-1])
wynik = c.fetchone ()
Jeśli wynik == Brak:
create_pages (c, dane)
w przeciwnym razie:
Drukuj (wynik)
Update_Pages (C, wynik ['id'])
def create_pages (c, dane):
Drukuj (dane)
sql = "wstaw do stron (nazwa, sesja, First_visited)
Wartości (?,?,?) ”
C.Wykonaj (SQL, dane)
def aktualizacja_pages (c, pageID):
Drukuj (pageID)
sql = "aktualizuj strony
Ustaw wizyty = wizyty+1
Gdzie id = ?"
C.Wykonaj (SQL, [pageID])
def create_session (c, dane):
sql = "wstaw do sesji (IP, kontynent, kraj, miasto, system operacyjny, przeglądarka, sesja, creed_at)
Wartości (?,?,?,?,?,?,?,?) ”
C.Wykonaj (SQL, dane)
def Select_All_Sessions (c):
sql = "wybierz * z sesji"
C.Wykonaj (SQL)
Rząd = c.fetchall ()
zwróć wiersze
def Select_All_Pages (c):
sql = "wybierz * ze stron"
C.Wykonaj (SQL)
Rząd = c.fetchall ()
zwróć wiersze
def Select_All_User_visits (C, session_id):
sql = "wybierz * ze stron, w których sesja =?"
C.Wykonaj (SQL, [session_id])
Rząd = c.fetchall ()
zwróć wiersze
def main ():
baza danych = "./Pythonsqlite.db "
sql_create_pages = "" "
Utwórz tabelę, jeśli nie istnieje (
Id Id Integer Key podstawowy,
Nazwa varchar (225) nie null,
Sesja Varchar (255) nie null,
First_visited DateTime nie null,
Odwiedzi liczbę całkowitą, a nie zerowa domyślna 1
);
„” ”
sql_create_session = "" "
Utwórz tabelę, jeśli nie istnieje sesje (
Id Id Integer Key podstawowy,
ip varchar (225) nie null,
Kontynent Varchar (225) nie null,
Country Varchar (225) nie null,
City Varchar (225) nie null,
OS varchar (225) nie null,
przeglądarka varchar (225) nie null,
Sesja Varchar (225) nie null,
utworzony_at datetime nie null
);
„” ”
# Utwórz połączenie z bazą danych
conn = create_connection (baza danych)
Jeśli Conn nie jest żadnym:
# Utwórz tabele
create_table (conn, sql_create_pages)
create_table (conn, sql_create_session)
Drukuj (”ustalone połączenie!")
w przeciwnym razie:
Drukuj („Nie można ustalić połączenia”)
Jeśli __name__ == '__main__':
główny()

Zapisz plik i uruchom skrypt, aby utworzyć bazę danych z odpowiednimi danymi.

Baza danych Python.py
„Połączenie ustalone!"

Następnie przejdź do Pusher i utwórz konto. Następnie utwórz aplikację i śledź kreatora, aby skonfigurować aplikację. Po zakończeniu skopiuj klucze aplikacji i przechowuj je w słowniku Python, jak pokazano poniżej.

pusher = pusher (
app_id = "1079412",
key = "e5d266a24f3502d2b814",
Secret = "BAB634D2398EB5FCB0F8",
klaster = „US2”)

Na koniec utwórz aplikację do kolby i zbuduj backend, jak pokazano w poniższym kodzie:

z kolby kolbu importowego, render_template, żądanie, sesja, jsonify
importować urllib.wniosek
od popychacza popychacza
z datetime import datetime
Importuj httpagentparser
Importuj JSON
Import OS
Importuj hashlib
Z importu bazy danych 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.Urandom (24)
# Skonfiguruj obiekt popychacza
pusher = pusher (
app_id = "1079412",
key = "e5d266a24f3502d2b814",
Secret = "BAB634D2398EB5FCB0F8",
klaster = „US2”)
baza danych = "./Pythonsqlite.db "
conn = create_connection (baza danych)
c = conn.kursor()
useros = brak
Userip = Brak
Usercity = brak
UserBrowser = Brak
UserCountry = brak
UserConntint = Brak
sessionId = brak
def main ():
Global Conn, c
def Parsevisitor (dane):
aktualizacja_or_create_page (c, dane)
popychacz.wyzwalacz (u'pageview ', u'new',
u'page ': dane [0],
U'Session ': sessionID,
U'ip ': UseriP
)
popychacz.wyzwala (u'numbers ', u'update',
u'page ': dane [0],
U'Session ': sessionID,
U'ip ': UseriP
)
@App.Przed_request
def getAnalyticsData ():
Global UserOS, UserBrowser, UseriP, Userconntinent, Usercity, UserCountry, SessionID
userInfo = httpagentparser.wykryć (żądanie.nagłówki.get („użytkownik-agent”))
userOS = userInfo ['platforma'] ['nazwa']
UserBrowser = userInfo [„Browser”] [„Nazwa”]
userip = "196.207.130.148 "W razie prośby.remote_addr == '127.0.0.1 'żądanie inaczej.remote_addr
api = "https: // www.iplokat.IO/API/Lookup/" + Userip
próbować:
resp = urllib.wniosek.URLOPEN (API)
wynik = odpowiednio.Czytać()
wynik = JSON.ładunki (wynik.dekoduj („UTF-8”))
UserCountry = wynik [„kraj”]
UserConntinent = wynik [„kontynent”]
Usercity = wynik [„miasto”]
z wyjątkiem:
Drukuj („Nie można znaleźć:”, UseriP)
GETSession ()
def GetSession ():
Global SessionID
czas = dataTime.Teraz().Wymień (Microsekund = 0)
Jeśli „użytkownik” nie jest w sesji:
LINES = (STR (czas)+Userip).enkoduj („UTF-8”)
sesja [„użytkownik”] = hashlib.MD5 (linie).Hexdigest ()
sessionId = sesja [„użytkownik”]
popychacz.wyzwalacz (u'session ', u'new',
U'ip ': UseriP,
U'Continent ': Uscontinent,
U'Country ': UserCountry,
U'City ': Usercity,
u'os ': useros,
U'Browser ': UserBrowser,
U'Session ': sessionID,
U'Time ': str (czas),
)
data = [Userip, Userconntinent, UserCountry,
Usercity, UserOS, UserBrowser, SessionID, czas]
create_session (c, dane)
w przeciwnym razie:
sessionId = sesja [„użytkownik”]
@App.trasa('/')
DEF INDEX ():
data = ['home', session, str (dateTime.Teraz().Wymień (mikrosekund = 0))]
parsevisitor (dane)
zwróć dane F'user: data '
@App.trasa („/get-all-session”)
def get_all_sessions ():
data = []
dbrows = select_all_sessions (c)
dla wiersza w dbrows:
dane.dodać(
„ip”: wiersz ['ip'],
„Continent”: Row [„Continent”],
„kraj”: rząd [„kraj”],
„City”: Row [„City”],
„OS”: wiersz ['OS'],
„Przeglądarka”: wiersz [„przeglądarka”],
„Sesja”: wiersz [„sesja”],
„Time”: wiersz [„Created_AT”]
)
zwróć JSonify (dane)
Jeśli __name__ == '__main__':
główny()
App.RUN (debug = true)

Po zakończeniu uruchom aplikację za pomocą kolby poleceń uruchomienia i przejdź do 127.0.0.1: 5000/ To powinno zarejestrować użytkownika, informacje o sesji konkretnego adresu IP, w tym agenta (przeglądarka), kraj i takie.

Aby wyświetlić całą sesję zalogowaną, przejdź do 127.0.0.1: 5000/get-all-session.

[[[

„Przeglądarka”: „Chrome”,
„City”: „Nowy Jork”,
„Kontynent”: „Ameryka Północna”,
„Kraj”: „Stany Zjednoczone”,
„IP”: „192.148.18.103 ",
„OS”: „Linux”,
„Sesja”: „9A5D6A84D93AD62A599293ACB2E751A1”,
„Czas”: „2021-01-13 02:52:32”
,

„Przeglądarka”: „Mozilla”,
„City”: „Oregon”,
„Kontynent”: „Ameryka Północna”,
„Kraj”: „Stany Zjednoczone”,
„IP”: "66.115.149.229 ",
„OS”: „Windows”,
„Sesja”: „64D205C98C839E1D346C733FFD41B27F”,
„Czas”: „2021-01-13 02:54:12”
,

„Przeglądarka”: „Chrome”,
„City”: „Ogden”,
„Kontynent”: „Ameryka Północna”,
„Kraj”: „Stany Zjednoczone”,
„IP”: „172.231.59.124 ",
„OS”: „Windows”,
„Sesja”: „3FD564C16A32B5139A8DD0578E36ADED”,
„Czas”: „2021-01-13 02:54:37”
,

„Przeglądarka”: „Chrome”,
„City”: „Nowy Jork”,
„Kontynent”: „Ameryka Północna”,
„Kraj”: „Stany Zjednoczone”,
„IP”: „72.229.28.185 ",
„OS”: „Windows”,
„Sesja”: „27AD92271023888427da216de10a7cae”,
„Czas”: „2021-01-13 02:55:07”
,

„Przeglądarka”: „Chrome”,
„City”: „Nairobi”,
„Kontynent”: „Afryka”,
„Kraj”: „Kenia”,
„IP”: „196.207.130.148 ",
„OS”: „Linux”,
„Sesja”: „C92CDAB9EEFA2FE121D49264986E7345”,
„Czas”: „2021-01-13 02:56:43”
,

„Przeglądarka”: „Chrome”,
„City”: „Nairobi”,
„Kontynent”: „Afryka”,
„Kraj”: „Kenia”,
„IP”: „196.207.130.148 ",
„OS”: „Windows”,
„Sesja”: „31EE28EC6A655E0FA13BE4DBA8C13861”,
„Czas”: „2021-01-13 03:11:49”

]

Dzięki uruchomionej aplikacji możesz losowo zmienić adres IP i przeglądarki, aby zebrać wystarczającą ilość informacji dla swojej bazy danych. Korzystając z zebranych danych, możesz użyć narzędzi danych, takich jak stos Elk, aby je wizualizować i zobaczyć, które lokalizacje i przeglądarki odwiedzają aplikację więcej.

Poniżej znajduje się przykład wizualizacji zebranych danych z powyższej aplikacji.

Wniosek

W tym samouczku wykorzystaliśmy Python, SQLite i Pusher do zbierania informacji o użytkownikach odwiedzających witrynę, a następnie wykorzystali dane do tworzenia wizualizacji.

Aby uprościć, ograniczyłem wyjście aplikacji do konsoli i JSON, aby pomieścić tych, którzy nie pracowali z Flask Jinja Temppling.

Ta prosta aplikacja jest otwarta na rozszerzenie na pełnoprawne narzędzie do analizy internetowej. Rozważ poniższe zasoby, aby uzyskać dodatkową wiedzę:

• https: // popychacz.com/tutorials/Web-Traffic-Monitor-Python
• https: // kolba.PALLETSProjects.com/en/1.1.X/
• https: // dokumenty.pyton.org/3/biblioteka/sqlite3.html
• https: // popychacz.COM/DOC