Negli ultimi anni i Large Language Model (LLM) sono passati da curiosità accademiche a strumenti pratici per sviluppatori, analisti di sicurezza e amministratori di rete. Grazie a progetti open‑source come , è possibile eseguire questi modelli direttamente sul proprio computer, senza ricorrere a servizi cloud. Questo articolo fornisce una guida completa, passo‑passo, per analizzare log di rete con un LLM locale, dalla configurazione dell’ambiente fino alla scrittura di script Python che estraggono insight, identificano anomalie e generano report sintetici.

Perché analizzare i log di rete con un LLM locale

L’analisi tradizionale dei log si basa su pattern matching, espressioni regolari e regole statiche. Sebbene efficace per scenari semplici, questo approccio presenta limiti evidenti quando i dati diventano complessi, non strutturati o quando è necessario interpretare contesti semantici. Un LLM locale offre diversi vantaggi:

• Privacy totale: tutti i dati rimangono sul dispositivo, evitando la trasmissione a server esterni.
• Operatività offline: l’analisi può essere eseguita anche in ambienti senza connettività Internet.
• Personalizzazione: è possibile adattare il modello a terminologia di rete specifica, a log di firewall proprietari o a formati di syslog personalizzati.
• Efficienza dei costi: non si pagano canoni di utilizzo cloud; il costo è limitato all’hardware necessario.
• Scalabilità dinamica: grazie al supporto nativo di GPU Nvidia o Radeon, l’inferenza è rapida anche su modelli di dimensioni medio‑grandi.

Prerequisiti e ambiente di lavoro

Prima di iniziare è importante verificare di disporre di un ambiente adeguato. Di seguito una checklist sintetica:

Installazione di

è distribuito come binario pre‑compilato per le principali piattaforme. La procedura è identica su tutti i sistemi:

1. Scaricare il pacchetto dal sito ufficiale di (disponibile per Windows, macOS e Linux).
2. Eseguire l’installer o, su Linux, estrarre l’archivio e spostare l’eseguibile in /usr/local/bin.
3. Aggiungere il percorso di al PATH se necessario.
4. Verificare l’installazione con --version.

Una volta installato, può essere avviato con il comando serve. Il demone rimarrà in ascolto sulla porta predefinita 11434, pronto a ricevere richieste API da Python o da altri client.

Configurazione dell’ambiente Python

Con in esecuzione, è possibile interagire con i modelli tramite il pacchetto disponibile su PyPI:

python -m venv venv_ollamasource venv_ollama/bin/activate # su Windows: venv_ollama\Scripts\activatepip install --upgrade pippip install 

Il pacchetto fornisce una semplice interfaccia .chat che accetta il nome del modello e una lista di messaggi strutturati secondo lo schema {role, content}.

Scelta del modello LLM

supporta diversi modelli open source, tra cui , 2 e Gemma. La scelta dipende da:

• Dimensione del modello: modelli più grandi offrono capacità linguistiche superiori ma richiedono più VRAM.
• Tipo di licenza: tutti i modelli citati sono permissivi per uso commerciale.
• Specificità del dominio: alcuni modelli sono stati addestrati su dati tecnici più ampi.

Per l’analisi dei log di rete consigliamo di partire con , poiché combina una buona capacità di ragionamento con requisiti hardware contenuti.

Preparazione dei log di rete

I log di rete possono provenire da firewall, router, switch, IDS/IPS o server di autenticazione. Il formato più comune è il syslog, ma è frequente incontrare CSV, JSON o formati proprietari. Prima di inviare i dati al modello è necessario:

1. Normalizzare le linee (rimuovere timestamp ridondanti, convertire codifiche).
2. Segmentare il file in blocchi gestibili (tipicamente 1 KB‑4 KB per chiamata).
3. Rimuovere dati sensibili (indirizzi IP privati, credenziali) o anonimizzarli.

Esempio di log di firewall (formato syslog)

Mar 10 12:34:56 fw01 kernel: [UFW BLOCK] IN=eth0 OUT= MAC=00:1a:2b:3c:4d:5e:6f:70:80:90:aa:bb SRC=192.0.2.45 DST=203.0.113.10 PROTO=TCP SPT=54321 DPT=22Mar 10 12:35:01 fw01 kernel: [UFW ALLOW] IN=eth0 OUT= MAC=00:1a:2b:3c:4d:5e:6f:70:80:90:aa:bb SRC=10.0.0.5 DST=203.0.113.10 PROTO=UDP SPT=12345 DPT=53

Queste due righe mostrano un tentativo di connessione SSH bloccato e una richiesta DNS consentita. Un LLM può estrarre rapidamente le informazioni chiave (azione, protocollo, porte, IP) e fornire un riepilogo.

Interfaccia con da Python

Di seguito una funzione di utilità che incapsula la chiamata a .chat. La funzione gestisce il chunking, la conversione in JSON e il ritorno del contenuto testuale.

import jsonimport from pathlib import Path def ask_llm(model: str, prompt: str) -> str: """ Invia un prompt al modello specificato e restituisce la risposta testuale. """ response = .chat( model=model, messages=[ {"role": "system", "content": "Sei un esperto di sicurezza di rete."}, {"role": "user", "content": prompt} ] ) return response["message"]["content"]

Questa funzione può essere richiamata più volte per processare tutti i blocchi di un file di log.

Gestione della risposta e aggregazione

Le risposte dell’LLM sono tipicamente in formato testo libero. Per renderle più facili da analizzare, è consigliabile chiedere al modello di restituire JSON strutturato. Esempio di prompt:

prompt = ( "Analizza la seguente riga di log e restituisci un oggetto JSON con i campi: " "azione (ALLOW/BLOCK), protocollo, porta_sorgente, porta_destinazione, " "ip_sorgente, ip_destinazione. Se qualche informazione manca, usa null.\n\n" f"{log_line}")

Il risultato sarà qualcosa del tipo:

{"azione": "BLOCK", "protocollo": "TCP", "porta_sorgente": 54321, "porta_destinazione": 22, "ip_sorgente": "192.0.2.45", "ip_destinazione": "203.0.113.10"}

Prompt engineering per l'analisi dei log

Un prompt ben formulato è la chiave per ottenere risultati coerenti. Di seguito tre tipologie di prompt utili per la sicurezza di rete.

Prompt 1 – Estrarre eventi di blocco

prompt = ( "Sei un analista di sicurezza. Leggi le seguenti righe di log e " "elenca tutti gli eventi con azione BLOCK. Per ogni evento indica: " "timestamp, IP sorgente, IP destinazione, protocollo, porta di destinazione. " "Restituisci il risultato in una tabella markdown.")

Prompt 2 – Riepilogo attività per host

prompt = ( "Analizza i log forniti e genera un riepilogo per ogni indirizzo IP interno " "(es. 10.0.0.0/8). Per ogni host indica il numero totale di connessioni, " "quante sono state ALLOW e quante BLOCK, e le porte più frequentemente contattate. " "Restituisci il risultato in formato JSON.")

Prompt 3 – Rilevamento di anomalie

prompt = ( "Considera i seguenti log di rete. Identifica eventuali pattern anomali, " "come un numero insolitamente alto di tentativi di connessione su una porta " "non standard, o IP sorgente che tentano più di 10 connessioni in 1 minuto. " "Per ogni anomalia, descrivi il motivo sospetto e suggerisci una possibile azione di mitigazione.")

Caso pratico: Analisi di un file di log di firewall

Supponiamo di avere un file firewall.log contenente migliaia di righe. Lo script seguente:

1. Legge il file in blocchi da 2 KB.
2. Per ogni blocco invia un prompt di estrazione eventi BLOCK.
3. Aggrega le risposte in una lista di dizionari.
4. Salva il risultato finale in report_block.json.

import jsonfrom pathlib import Path MODEL = ""LOG_PATH = Path("firewall.log")CHUNK_SIZE = 2048 # bytes def chunk_file(path: Path, size: int): with path.open("r", encoding="utf-8") as f: while True: data = f.read(size) if not data: break yield data def process_logs(): results = [] for chunk in chunk_file(LOG_PATH, CHUNK_SIZE): prompt = ( "Estrai tutti gli eventi con azione BLOCK dal seguente testo di log. " "Per ogni evento restituisci un oggetto JSON con i campi: " "timestamp, ip_sorgente, ip_destinazione, protocollo, porta_destinazione. " "Se un campo non è presente, usa null.\n\n" f"{chunk}" ) response = ask_llm(MODEL, prompt) try: # La risposta dovrebbe essere una lista JSON events = json.loads(response) results.extend(events) except json.JSONDecodeError: # In caso di risposta non valida, loggare e continuare print("Errore di parsing JSON per il chunk corrente") # Salvataggio del report with open("report_block.json", "w", encoding="utf-8") as out: json.dump(results, out, indent=2) if __name__ == "__main__": process_logs()

Il file report_block.json conterrà una struttura simile a:

[ {"timestamp": "Mar 10 12:34:56", "ip_sorgente": "192.0.2.45", "ip_destinazione": "203.0.113.10", "protocollo": "TCP", "porta_destinazione": 22}, {"timestamp": "Mar 10 13:02:11", "ip_sorgente": "198.51.100.23", "ip_destinazione": "203.0.113.10", "protocollo": "TCP", "porta_destinazione": 3389}]

Ottimizzazioni e best practice

Per ottenere le migliori prestazioni è utile tenere presente i seguenti accorgimenti:

• Chunk size ottimale: i modelli LLM hanno un contesto limitato (es. 8 k token). Un blocco di 2‑4 KB garantisce che il modello veda l’intera riga di log senza troncamenti.
• Cache dei risultati: se lo stesso file viene analizzato più volte, memorizzare le risposte in un database locale (SQLite) riduce le chiamate ripetute.
• Parallelismo controllato: è possibile lanciare più thread Python, ma è consigliato non superare il numero di GPU disponibili per evitare saturazione della VRAM.
• Prompt statici: definire i prompt in costanti e riutilizzarli evita variazioni di output dovute a formulazioni diverse.
• Gestione degli errori: includere try/except attorno a .chat per catturare timeout o errori di parsing.

Integrazione con sistemi di monitoraggio

Dopo aver generato i report JSON, è possibile integrarli con piattaforme di visualizzazione come Grafana o Kibana. Un semplice flusso di lavoro:

1. Salvare i risultati in un indice Elasticsearch.
2. Creare una visualizzazione “Eventi BLOCK per ora”.
3. Configurare un alert che si attivi quando il numero di blocchi supera una soglia predefinita (es. 100 blocchi in 5 minuti).

Il vantaggio è che l’LLM fornisce una prima analisi semantica, mentre gli strumenti di monitoraggio gestiscono la persistenza e la visualizzazione in tempo reale.

Sicurezza e privacy

Quando si trattano log contenenti dati sensibili, è fondamentale adottare misure di protezione:

• Anonimizzazione preventiva: prima di inviare i log al modello, sostituire gli indirizzi IP pubblici con placeholder (es. IP_SRC, IP_DST).
• Isolamento dell’ambiente: eseguire all’interno di un container Docker o di una VM dedicata, limitando l’accesso a rete e filesystem.
• Controllo degli accessi: impostare permessi di lettura/scrittura sui file di log e sui report generati.
• Audit logging: registrare ogni chiamata al modello (timestamp, dimensione del chunk, risultato) per eventuali verifiche di conformità.

Riepilogo operativo

Conclusioni

L’utilizzo di un LLM locale per l’analisi dei log di rete rappresenta una svolta significativa per chi deve gestire grandi volumi di dati in ambienti sensibili. Grazie a è possibile scaricare, avviare e interrogare modelli come con pochi comandi, senza dipendere da servizi cloud. Con una corretta pipeline di normalizzazione, prompt engineering e aggregazione dei risultati, è possibile trasformare log grezzi in insight azionabili: identificare rapidamente tentativi di intrusione, generare report di conformità e alimentare sistemi di monitoraggio in tempo reale.

Seguendo le linee guida illustrate in questo articolo, anche un professionista con competenze di base in Python potrà costruire una soluzione robusta, privata ed economicamente vantaggiosa per la sicurezza della propria rete.