Deep Dive: Loki e Grafana Alloy – log ricercabili accanto alle metriche, e cosa ha trovato la prima ora

Come Loki salva i log per label invece di indicizzare ogni parola, come Grafana Alloy raccoglie log di journal, pod e audit, cosa gira esattamente sul blog – e le quattro cose che i nuovi alert sui log hanno trovato nella loro prima ora.

Illustrazione per la serie Deep Dive

🌐 Anche in: English · Deutsch · Français · Español · Português · Nederlands · Polski

Deep Dive della serie attorno all’Ansible Tour. Il tour spiega i ruoli, i deep dive la tecnologia sottostante: come funziona, perché qui viene usata in questo modo, e cosa è andato storto lungo la strada.

Le metriche ti dicono che qualcosa non va: la memoria è al 90 percento, un container si è riavviato tre volte, il disco si riempie. Raramente ti dicono perché. Il perché sta nei log – e su un host K3s i log sono sparsi tra il journal di systemd, una directory per pod sotto /var/log/pods, l’audit log e una manciata di file delle applicazioni. Finora trovare qualcosa significava SSH, journalctl, kubectl logs e grep, una sorgente alla volta. Questo post spiega come Loki e Grafana Alloy trasformano tutto questo in un unico posto ricercabile accanto alle dashboard, cosa gira esattamente sul blog dal 19 ottobre 2026 – e cosa hanno trovato i nuovi alert sui log entro la loro prima ora, prima che qualcuno lo cercasse.

Indice

🧭 Come funzionano Loki e Alloy

L’idea: indicizzare le label, non le parole

I sistemi di log classici come Elasticsearch costruiscono un indice full-text: ogni parola di ogni riga diventa ricercabile, e l’indice è spesso più grande dei log stessi. Loki fa il contrario. Indicizza solo un piccolo insieme di label per stream – per esempio job="journal", unit="sshd.service", namespace="wordpress" – e salva le righe stesse compresse in chunk. Una query prima seleziona gli stream per label (economico, tramite l’indice) e poi scansiona solo i chunk di quegli stream alla ricerca del testo (forza bruta, ma su una piccola quantità di dati). È lo stesso modello che Prometheus usa per le metriche, ed è per questo che i due si sposano così bene.

La conseguenza è una regola che decide se Loki resta veloce: le label devono avere pochi valori. Host, job, unit systemd, namespace, container – qualche decina di valori ciascuna – sono buone label. Un nome utente, un indirizzo IP, un request ID no: ogni nuovo valore crea un nuovo stream, e migliaia di stream minuscoli rendono l’indice grande e i chunk inutili. Questi valori restano nella riga e vengono filtrati al momento della query.

Stream, chunk, indice, compactor

  • Stream: tutte le righe con esattamente lo stesso insieme di label. {job="journal", unit="k3s.service", level="info"} è uno stream.
  • Chunk: un blocco compresso di righe di uno stream, scritto sul filesystem quando è pieno o abbastanza vecchio.
  • Indice (TSDB, schema v13): associa gli insiemi di label ai chunk, un file di indice al giorno.
  • Compactor: unisce i file di indice giornalieri e – importante – è il componente che cancella davvero i dati quando sono più vecchi del periodo di retention. Senza retention_enabled l’impostazione di retention nasconde soltanto i dati vecchi alle query.

LogQL in due passi

Una query LogQL inizia sempre con un selettore di stream tra graffe, seguito da filtri opzionali. Con un intervallo e una funzione attorno, la stessa query diventa una metrica – ed è quello che usano gli alert.

# all lines of the k3s unit that contain "error" (case-insensitive)
{job="journal", unit="k3s.service"} |~ "(?i)error"

# as a number: how many such lines in the last 15 minutes?
sum(count_over_time({job="journal", unit="k3s.service"} |~ "(?i)error" [15m]))

|= significa “contiene”, != “non contiene”, |~ e !~ sono le versioni regex. Parser come | json o | logfmt trasformano parti di una riga in label temporanee che esistono solo durante la query – il modo economico per filtrare per un valore che non deve mai diventare una vera label.

Grafana Alloy: il collettore

Alloy è l’agent di Grafana, il successore di Promtail e del Grafana Agent. La sua configurazione è una pipeline di componenti: le sorgenti leggono i log (journal, file), i processori li modificano (parsing, relabel, impostazione del timestamp, scarto), e i writer li inviano a Loki. Ogni componente dichiara dove va il suo output (forward_to), quindi la configurazione si legge come un diagramma di flusso dei dati. Alloy ricorda nella propria directory dati fin dove ha letto ogni file e il journal, quindi un riavvio non perde né ripete righe.

🛡️ Perché è qui

  • Un solo posto per tutti i log. Journal, ogni pod, l’audit log e fail2ban, ricercabili in Grafana accanto alle metriche, per gli ultimi 14 giorni – anche per pod che non esistono più, i cui log kubectl logs non può più mostrare.
  • Alert su cose che le metriche non vedono. Un denial di SELinux, un ban di fail2ban fallito o un OOM kill del kernel sono una riga di log, non un numero. Prima venivano trovati solo quando qualcuno per caso guardava.
  • Abbastanza economico per un server piccolo. Loki e Alloy insieme richiedono circa mezzo gigabyte di RAM e qualche megabyte di disco all’ora sul blog – uno stack full-text ne richiederebbe parecchie volte tanto.

🔧 Cosa fa questo repository

Il ruolo common_loki gira dopo common_grafana (di cui usa il repository dei pacchetti e l’API) e prima di common_monit (che poi sorveglia entrambi i servizi). Gira sul blog dal 19 ottobre 2026; i due server Nextcloud hanno seguito il 20 ottobre dopo un giorno di osservazione.

Loki: binario unico, disco locale, 14 giorni

Il pacchetto include una configurazione demo che salva tutto sotto /tmp/loki – sparito dopo ogni riavvio – con logging di debug. Il ruolo la sostituisce completamente. Le parti importanti:

server:
  http_listen_address: 127.0.0.1      # only Grafana on the same host reads
  grpc_listen_address: 127.0.0.1
common:
  path_prefix: /var/lib/loki
  replication_factor: 1
  ring:
    kvstore:
      store: inmemory                  # one process, no cluster
schema_config:
  configs:
    - from: 2026-10-01
      store: tsdb
      object_store: filesystem
      schema: v13
limits_config:
  retention_period: 336h               # 14 days
compactor:
  retention_enabled: true              # the part that really deletes
analytics:
  reporting_enabled: false

Il template viene controllato prima di sostituire il file vero: il validate di Ansible esegue loki -verify-config sul candidato. Un errore di battitura quindi fa fallire l’esecuzione del playbook invece di produrre un servizio che non parte più.

Alloy: quattro sorgenti, una manciata di label

  • Journal con le label unit, level e transport. transport="kernel" separa i messaggi del kernel stesso – è lì che scrive l’OOM killer.
  • Log dei pod da /var/log/pods/<namespace>_<pod>_<uid>/<container>/N.log. Una regola di relabel ritaglia namespace, pod e container dal percorso; stage.cri rimuove il prefisso di containerd (ora, stream, flag partial) e ricongiunge le righe spezzate.
  • audit.log. Su questi host i denial di SELinux non sono nel journal – auditd possiede il socket audit del kernel – quindi Alloy legge il file.
  • fail2ban.log, perché un ban fallito viene registrato solo lì.

Tutti gli stream ricevono la label host; la label automatica filename viene scartata perché duplicherebbe solo informazioni già presenti nelle altre label.

Leggere i log di root senza essere root

Il pacchetto esegue Alloy come utente alloy nei gruppi adm e systemd-journal. Basta per il journal, ma non per audit.log (root, modo 0600), fail2ban.log e i log dei pod (root, 0640). La soluzione pigra sarebbe eseguire Alloy come root. Il ruolo invece gli dà una sola capability Linux, in un drop-in di systemd:

[Service]
AmbientCapabilities=CAP_DAC_READ_SEARCH
CapabilityBoundingSet=CAP_DAC_READ_SEARCH
NoNewPrivileges=yes
ProtectSystem=strict
ReadWritePaths=/var/lib/alloy
ProtectHome=yes
PrivateTmp=yes
ProtectKernelTunables=yes
ProtectKernelModules=yes
...

CAP_DAC_READ_SEARCH aggira i controlli dei permessi di lettura su file e directory – e nient’altro. Alloy può leggere ogni log, ma non può scrivere fuori dalla propria directory dati, non può cambiare proprietario, non può caricare moduli. Loki riceve un drop-in simile senza alcuna capability. systemd-analyze security valuta le due unit 4,0 e 3,8 – “OK” sulla sua scala, dove un servizio non irrobustito sta intorno a 9.

Il succo: un servizio che deve leggere ogni log non ha bisogno di root. Basta una capability per la lettura, e tutto il resto resta chiuso.

Grafana: datasource, alert e un autotest

Il ruolo crea la datasource “Loki” tramite l’API di Grafana (prima controlla, crea solo se manca) e cinque regole di alert nella cartella che contiene già gli alert sulle metriche:

AlertLogQL (finestra di 15 minuti)Perché
SELinux ha bloccato qualcosa{job="audit"} |= "type=AVC" |= "permissive=0"Un vero denial. Le righe permissive=1 di domini ancora nella fase di apprendimento non contano.
fail2ban segnala errori{job="fail2ban"} |= "]: ERROR" != "KeyError('/var/log/pods/"Un’azione di ban o un filtro è rotto. Il KeyError escluso è innocuo (vedi sotto).
OOM killer del kernel{job="journal", transport="kernel"} |~ "(?i)out of memory: killed process"Copre anche i processi dell’host, non solo i container.
Non arrivano logsum(count_over_time({job="journal"}[15m])) < 1È rotta la pipeline stessa. Qui “nessun dato” conta come alert.
Error budget superato (dal 26 ott 2026, finestra di 1 ora)righe di errore e warning per unit o container > 100, rumore noto esclusoUn servizio che scrive errori per ore senza che alcuna metrica lo mostri – come due exporter a ottobre

Alla fine il ruolo testa l’intera catena: scrive con logger un marcatore univoco nel journal e interroga Loki finché il marcatore compare. Se Alloy o Loki sono rotti, l’esecuzione del playbook fallisce proprio lì.

🔍 La prima ora: quattro scoperte che nessuno aveva cercato

Entro un’ora dal primo rollout, i nuovi alert avevano inviato mail. Nessuna era rumore – ognuna indicava qualcosa di reale, e due di esse errori miei.

1. Righe vecchie, timestamp nuovi

I primi due alert sono scattati subito: un AVC e un errore di fail2ban. La riga di fail2ban era delle 11:13 di quella mattina. Cos’era successo: al primo avvio Alloy legge ogni file dall’inizio, e senza ulteriori istruzioni marca ogni riga con l’ora in cui l’ha letta. L’intero arretrato di audit.log e fail2ban.log è finito in Loki come “adesso” – e gli alert, che contano le righe degli ultimi 15 minuti, hanno visto in un colpo solo ore di errori vecchi.

La soluzione è prendere il timestamp dalla riga stessa. L’audit log riporta l’epoch in msg=audit(1792426019.999:37103), fail2ban scrive l’ora locale senza fuso:

loki.process "files" {
  stage.match {
    selector = "{job=\"audit\"}"
    stage.regex     { expression = "msg=audit\\((?P<ts>[0-9]+[.][0-9]+):" }
    stage.timestamp { source = "ts"  format = "Unix" }
  }
  stage.match {
    selector = "{job=\"fail2ban\"}"
    stage.regex     { expression = "^(?P<ts>[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9:]{8},[0-9]{3})" }
    stage.timestamp { source = "ts"  format = "2006-01-02 15:04:05,000"  location = "UTC" }
  }
  ...
}

Il fuso orario non è scritto fisso nel ruolo: legge il fuso dell’host con timedatectl e lo passa al template, così lo stesso ruolo è corretto anche su un host che gira in ora locale.

Il succo: un collettore di log che usa l’ora di lettura invece del timestamp della riga fa scattare gli alert su eventi vecchi. Prendi il timestamp dalla riga.

2. Il primo vero AVC: un installer di pacchetti

L’AVC in sé era autentico e nuovo di zecca: durante l’installazione dell’RPM di Alloy, useradd -m ha cercato di creare .bash_logout nella nuova home directory /var/lib/alloy. Quella directory ha il tipo var_lib_t, e la policy non permette a useradd_t di creare lì file utente. Innocuo – Alloy non ha bisogno di un profilo di shell – ma esattamente il tipo di evento che prima spariva in un audit log da 6 MB.

Il succo: un nuovo strumento porta con sé nuovi denial. Un alert sugli AVC li ha trovati alla prima occorrenza, non settimane dopo.

3. Errori di fail2ban che c’erano da giorni

Guardando gli errori di fail2ban in Loki ne sono emersi di due tipi. Uno era innocuo: KeyError('/var/log/pods/…'), il backend di polling che perde traccia di un log di pod rimosso a un riavvio del pod; la jail va avanti. L’altro no: il 13 e il 14 ottobre, Failed to execute ban jail 'nginx-k3s-bad-paths' action 'nftables…' – ban che non sono avvenuti, nei giorni in cui veniva rifatto il reload del firewall. Nessuno li aveva visti. Ora l’alert esclude solo lo schema innocuo noto.

Il succo: gli errori che nessuno legge esistono comunque. Solo quando i log sono diventati ricercabili sono comparsi errori che c’erano da giorni.

4. Un AVC dal prossimo nuovo strumento

Un’ora dopo è stato installato Trivy (seguirà il suo deep dive). La sua unit di scansione aveva NoNewPrivileges=yes, e lo script chiama k3s kubectl. Il binario k3s passa nel dominio container_runtime_t, e sotto NoNewPrivileges SELinux rifiuta una tale transizione a meno che la policy non la permetta esplicitamente: avc: denied { nnp_transition }. L’alert di Loki è scattato entro pochi minuti dalla prima scansione. Non era la prima volta che questo meccanismo causava problemi qui – MariaDB e Grafana ci erano già finiti dentro – ma la prima volta che l’ha trovato una macchina invece di un servizio che fallisce.

Un errore mio, di passaggio: Loki scriveva “error getting network interfaces … address family not supported” più volte all’ora. La sandbox della unit permetteva solo socket IPv4, IPv6 e Unix, ma Loki interroga le interfacce di rete tramite un socket netlink. Dal 26 ottobre 2026 AF_NETLINK è permesso; senza capability Loki può solo leggere attraverso di esso, non cambiare nulla.

Disco e memoria

Dopo le prime due ore sul blog: Loki circa 240 MB di RSS, Alloy circa 275 MB, insieme circa due minuti di tempo CPU, e 13 MB in /var/lib/loki – circa 150 MB al giorno, quindi più o meno 2 GB a pieni 14 giorni. I server Nextcloud hanno più pod e più traffico; per questo il ruolo è rimasto prima un giorno sul blog e i numeri sono stati confrontati prima di andare avanti. Se il disco dovesse crescere più in fretta del previsto, la prima domanda è quale stream sia grande – topk per unit o namespace risponde – e la seconda è se quello stream vada conservato affatto; Alloy può scartare righe con stage.drop prima che arrivino a Loki.

Cose da sapere

  • Fuso orario nel browser. Grafana mostra gli orari nel fuso del browser, i server girano in UTC. Una riga “delle 11:13” in un file in estate in Grafana è alle 13:13.
  • Le righe vecchie vengono rifiutate. reject_old_samples_max_age: 168h – un file con righe più vecchie di una settimana (per esempio un backup ripristinato) non verrà importato. È voluto.
  • Il riavvio è sicuro. Alloy tiene le sue posizioni di lettura in /var/lib/alloy/data. Cancellare quella directory gli fa rileggere tutto – ora con timestamp corretti, ma come duplicati.

🆘 Cheat sheet: sintomo → comando

La versione breve di questo articolo per il momento in cui qualcosa non va. Da eseguire sull’host come root; <…> sono segnaposto.

SintomoComando
Loki è pronto, Alloy è pronto?curl -s 127.0.0.1:3100/ready
curl -s 127.0.0.1:12345/-/ready
Mancano i log di una sorgentecurl -sG 127.0.0.1:3100/loki/api/v1/query \
--data-urlencode 'query=sum(count_over_time({job="<job>"}[10m]))'
journalctl -u alloy -p warning --since -1h
Cosa ha negato SELinux?{job="audit"} |= "type=AVC" |= "permissive=0"
Log di un pod che non esiste più{namespace="<ns>", container="<container>"} |= "Fatal"
Kernel: OOM, segfault, hardware{job="journal", transport="kernel"}
Il disco cresce più in fretta del previstodu -sh /var/lib/loki
topk(10, sum by (unit) (count_over_time({job="journal"}[1h])))
Gli orari in Grafana sono sfasati di due ore# browser time zone vs. UTC on the servers - not a bug

🎯 Le lezioni

  • Label con pochi valori, contenuto nella riga: così Loki resta piccolo e veloce.
  • Prendi il timestamp dalla riga di log, non dal momento dell’ingestione.
  • Leggere ogni log richiede una capability; root non è necessario.
  • Testa una pipeline di log da un capo all’altro: scrivi un marcatore, ritrovalo in Loki.
  • Un alert sulle righe di log trova ciò che nessuna metrica mostra – compresi i tuoi errori.

⚖️ Alternative – e perché Loki

OpzionePunto di forzaPerché non qui
journald + grepGratis, sempre presenteUn host, una sorgente alla volta, niente alert, i log dei pod spariscono con il pod.
ELK / OpenSearchRicerca full-text su tutto, molto potenteJava, diversi GB di RAM per un singolo nodo – più di quanto serva all’intero stack del blog.
GraylogBuona interfaccia, stream e alert integratiProvato prima in un laboratorio: richiede MongoDB più OpenSearch – di nuovo pesante per un piccolo server.
Promtail + LokiLa combinazione classicaPromtail è in modalità manutenzione; Alloy è il suo successore e parla anche metriche e trace.
Loki + AlloyIndice per label come Prometheus, piccolo, nativo in GrafanaScelto: si adatta al setup Prometheus/Grafana esistente e al budget di RAM.

Il punto decisivo non erano le funzionalità ma l’adattamento. Prometheus e Grafana c’erano già, le mail di alert funzionavano già, e il modello a label è lo stesso usato dalle metriche. Loki ha aggiunto la metà mancante – il perché dietro i numeri – per circa mezzo gigabyte di RAM.

Alcuni testi e immagini di questo sito sono creati con l’aiuto dell’IA o generati dall’IA. Dettagli