Como construir um monitor de tráfego da web com python, frasco, sqlite e empurrador

Se você tem um aplicativo da web em execução na Internet, precisará saber de onde seus visitantes estão vindo, os sistemas que estão usando e outras coisas dessas coisas.

Embora você possa usar serviços como o Google Analytics, Monster Insights, etc., É mais divertido criar um sistema de monitoramento usando o Python, o banco de dados SQL e o empurrador para atualizações de dados em tempo real.

No tutorial de hoje, repassaremos como criar essa ferramenta usando Python, Flask e Pusher. O tutorial é um spin-off altamente personalizado de um tutorial publicado na página oficial de Pusher.

Requisitos

Para esta construção, você precisará saber como trabalhar com a linguagem de programação Python, o simples desenvolvimento da web e as APIs.

Instalação de requisitos

Comece instalando Python em seu sistema. Você também precisará instalar o empurrador e o frasco, httpagentparser.

Criando o banco de dados

O primeiro passo é criar um banco de dados onde os dados são armazenados. Para Python, o sqlite3 é como padrão, e usá -lo é simples. Crie um arquivo chamado banco de dados.py e insira o código abaixo:

Importar SQLite3
do erro de importação do SQLITE3
def create_connection (banco de dados):
tentar:
Conn = sqlite3.conectar(
banco de dados, isolation_level = nenhum, check_same_thread = false)
Conn.row_factory = lambda c, r: dict (
ZIP ([col [0] para col.descrição], r))
Retornar Conn
Exceto erro como e:
impressão (e)
def create_table (c, sql):
c.executar (SQL)
def update_or_create_page (c, dados):
sql = "selecione * nas páginas onde nome =? e sessão =?"
c.execute (SQL, dados [:-1])
resultado = c.FetchOne ()
Se resultado == Nenhum:
create_pages (c, dados)
outro:
Imprimir (resultado)
update_pages (c, resultado ['id'])
def create_pages (c, dados):
Impressão (dados)
sql = "Inserir em páginas (nome, sessão, primeiro_visited)
Valores (?,?,?) "
c.executar (SQL, dados)
def update_pages (C, PageId):
Imprimir (PageId)
sql = "Atualizar páginas
Set visitas = visitas+1
Onde id = ?"
c.Execute (SQL, [PageId])
def create_session (c, dados):
sql = "Inserir em sessões (IP, continente, país, cidade, sistema operacional, navegador, sessão, criado_at)
Valores (?,?,?,?,?,?,?,?) "
c.executar (SQL, dados)
def Select_all_Sessions (C):
SQL = "Selecione * das sessões"
c.executar (SQL)
linhas = c.Fetchall ()
Linhas de retorno
def select_all_pages (c):
sql = "Selecione * nas páginas"
c.executar (SQL)
linhas = c.Fetchall ()
Linhas de retorno
def Select_all_User_Visits (c, session_id):
sql = "selecione * nas páginas onde sessão =?"
c.execute (SQL, [session_id])
linhas = c.Fetchall ()
Linhas de retorno
def main ():
Database = "./pythonsqlite.dB "
sql_create_pages = "" "
Crie a tabela se não existe páginas (
Id Integer Primary Key,
nome Varchar (225) não nulo,
Sessão Varchar (255) Não NULL,
First_visited DateTime Not Null,
visitas inteiras não nulas padrão 1
);
"" "
sql_create_session = "" "
Crie a tabela, se não existe sessões (
Id Integer Primary Key,
IP Varchar (225) não nulo,
Continente Varchar (225) não nulo,
país varchar (225) não nulo,
City Varchar (225) não nulo,
OS Varchar (225) não nulo,
navegador Varchar (225) não nulo,
sessão Varchar (225) não nula,
criado_at datetime não nulo
);
"" "
# Crie uma conexão de banco de dados
Conn = create_connection (banco de dados)
Se Conn não é nenhum:
# Crie tabelas
create_table (Conn, sql_create_pages)
create_table (Conn, sql_create_session)
impressão ("conexão estabelecida!")
outro:
print ("Não foi possível estabelecer a conexão")
se __name__ == '__main__':
principal()

Salve o arquivo e execute o script para criar o banco de dados com os dados relevantes.

banco de dados Python.py
"Conexão estabelecida!”

Em seguida, vá até o Pusher e crie uma conta. Em seguida, crie um aplicativo e siga o assistente para configurar o aplicativo. Depois de concluído, copie as teclas do aplicativo e armazene -as em um dicionário Python, como mostrado abaixo.

pusher = pusher (
app_id = "1079412",
key = "e5d266a24f3502d2b814",
secret = "BAB634D2398EB5FCB0F8",
cluster = "US2")

Por fim, crie um aplicativo de frasco e construa o back -end, conforme mostrado no código abaixo:

do Flask Flask, render_template, solicitação, sessão, jsonify
importar urllib.solicitar
do empurrador empurrador empurrador
Do DateTime Import DateTime
importar httpagentparser
importar json
OS de importação
importar hashlib
Do banco de dados Import create_connection, create_session, update_or_create_page, select_all_sessions, select_all_user_visits, select_all_pages
App = Flask (__ nome__)
aplicativo.secret_key = os.Urandom (24)
# Configure objeto empurrador
pusher = pusher (
app_id = "1079412",
key = "e5d266a24f3502d2b814",
secret = "BAB634D2398EB5FCB0F8",
cluster = "US2")
Database = "./pythonsqlite.dB "
Conn = create_connection (banco de dados)
c = Conn.cursor()
useros = nenhum
Userip = Nenhum
UserCity = Nenhum
UserBrowser = Nenhum
UserCountry = Nenhum
UserContinent = Nenhum
sessionId = Nenhum
def main ():
Global Conn, C
def parsevisitor (dados):
update_or_create_page (c, dados)
empurrador.trigger (u'pageView ', u'new',
u'page ': dados [0],
U'Session ': SessionId,
u'ip ': userip
)
empurrador.gatilho (u'numbers ', u'update',
u'page ': dados [0],
U'Session ': SessionId,
u'ip ': userip
)
@aplicativo.antes_request
def GetAnalyticsData ():
Global Useros, UserBrowser, Userip, UserContinent, UserCity, UserCountry, SessionID
userInfo = httpagentParser.detectar (solicitação.cabeçalhos.Get ('User-Agent'))
useros = userInfo ['plataforma'] ['nome']
UserBrowser = UserInfo ['Browser'] ['Nome']
userip = "196.207.130.148 "se solicitar.remote_addr == '127.0.0.1 'mais solicitação.remote_addr
api = "https: // www.iplocate.IO/API/Lookup/" + Userip
tentar:
resp = urllib.solicitar.Urlopen (API)
resultado = resp.ler()
resultado = json.Cargas (resultado.Decode ("UTF-8"))
UserCountry = resultado ["país"]
UserContinent = resultado ["Continente"]
UserCity = Result ["City"]
exceto:
Print ("Não foi encontrado:", Usuário)
getSession ()
def getSession ():
Global SessionID
Time = DateTime.agora().Substitua (microssegundo = 0)
Se 'usuário' não está na sessão:
linhas = (str (tempo)+usuário).Encode ('UTF-8')
sessão ['usuário'] = hashlib.MD5 (linhas).hexdigest ()
sessionID = sessão ['usuário']
empurrador.gatilho (u'session ', 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 (tempo),
)
Data = [Usuário, UserContinent, UserCountry,
UserCity, Useros, UserBrowser, SessionId, Time]
create_session (c, dados)
outro:
sessionID = sessão ['usuário']
@aplicativo.rota('/')
Def Index ():
Dados = ['Home', SessionId, STR (DateTime.agora().Substitua (microssegundo = 0)]]
Parsevisitor (dados)
Retorne dados f'user: data '
@aplicativo.Rota ('/Get-All-Sessions')
def get_all_sessions ():
dados = []
dbrows = select_all_sessions (c)
para linha em dbrows:
dados.acrescentar(
'ip': linha ['ip'],
'Continente': Row ['Continente'],
'País': Row ['país'],
'Cidade': Row ['City'],
'OS': Row ['OS'],
'Navegador': linha ['navegador'],
'Sessão': Row ['Session'],
'Time': Row ['Created_at']
)
Retornar Jsonify (dados)
se __name__ == '__main__':
principal()
aplicativo.Run (Debug = True)

Depois de concluído, execute o aplicativo usando o Flask Run e navegue para 127.0.0.1: 5000/ isso deve registrar o usuário, as informações da sessão do endereço IP específico, incluindo agente (navegador), país e tal.

Para ver toda a sessão registrada, vá para 127.0.0.1: 5000/Get-All-Sessions.

[[

"Navegador": "Chrome",
"City": "Nova York",
"Continente": "América do Norte",
"país": "Estados Unidos",
"IP": "192.148.18.103 ",
"OS": "Linux",
"Sessão": "9A5D6A84D93AD62A599293ACB2E751A1",
"Time": "2021-01-13 02:52:32"
,

"Navegador": "Mozilla",
"City": "Oregon",
"Continente": "América do Norte",
"país": "Estados Unidos",
"IP": "66.115.149.229 ",
"OS": "Windows",
"Sessão": "64D205C98C839E1D346C733FFD41B27F",
"Time": "2021-01-13 02:54:12"
,

"Navegador": "Chrome",
"City": "Ogden",
"Continente": "América do Norte",
"país": "Estados Unidos",
"IP": "172.231.59.124 ",
"OS": "Windows",
"Sessão": "3FD564C16A32B5139A8DD0578E36ADED",
"Time": "2021-01-13 02:54:37"
,

"Navegador": "Chrome",
"City": "Nova York",
"Continente": "América do Norte",
"país": "Estados Unidos",
"IP": "72.229.28.185 ",
"OS": "Windows",
"Sessão": "27Ad92271023888427DA216DE10A7CAE",
"Time": "2021-01-13 02:55:07"
,

"Navegador": "Chrome",
"City": "Nairobi",
"Continente": "África",
"Country": "Quênia",
"IP": "196.207.130.148 ",
"OS": "Linux",
"Sessão": "C92CDAB9EEFA2FE121D49264986E7345",
"Time": "2021-01-13 02:56:43"
,

"Navegador": "Chrome",
"City": "Nairobi",
"Continente": "África",
"Country": "Quênia",
"IP": "196.207.130.148 ",
"OS": "Windows",
"Sessão": "31EE28EC6A655E0FA13BE4DBA8C13861",
"Time": "2021-01-13 03:11:49"

]

Com o aplicativo em execução, você pode alterar aleatoriamente seu endereço IP e navegadores para coletar informações suficientes para o seu banco de dados. Usando os dados coletados, você pode usar ferramentas de dados como a pilha de alces para visualizá -las e ver quais locais e navegadores visitam o aplicativo mais.

A seguir, é apresentado um exemplo de visualização de dados coletados do aplicativo acima.

Conclusão

Neste tutorial, usamos Python, Sqlite e Pusher para coletar informações sobre usuários que visitam o site e depois usamos os dados para criar visualizações.

Para simplificar as coisas, limitei a saída do aplicativo ao console e ao JSON para acomodar aqueles que não trabalharam com o Flask Jinja.

Este aplicativo simples está aberto à expansão em uma ferramenta de análise da web completa. Considere os recursos abaixo para conhecimento adicional:

• https: // empurrador.com/tutoriais/web-trafic-monitor-python
• https: // Flask.PalletsProjects.com/en/1.1.x/
• https: // docs.Pitão.org/3/biblioteca/sqlite3.html
• https: // empurrador.com/docs