Deep Dive: Loki e Grafana Alloy – logs pesquisáveis ao lado das métricas, e o que a primeira hora encontrou
Como o Loki armazena logs por labels em vez de indexar cada palavra, como o Grafana Alloy coleta logs do journal, dos pods e de auditoria, o que exatamente roda no blog – e as quatro coisas que os novos alertas de log encontraram na primeira hora.

🌐 Também em: English · Deutsch · Français · Español · Italiano · Nederlands · Polski
Deep Dive da série em torno do Ansible Tour. O tour explica as roles, os deep dives explicam a tecnologia por baixo: como ela funciona, por que é usada assim aqui e o que deu errado no caminho.
Métricas dizem que algo está errado: a memória está em 90 por cento, um container reiniciou três vezes, o disco está enchendo. Elas raramente dizem por quê. O porquê está nos logs – e num host K3s os logs ficam espalhados pelo journal do systemd, um diretório por pod em /var/log/pods, o log de auditoria e um punhado de arquivos de aplicação. Até agora, encontrar alguma coisa significava SSH, journalctl, kubectl logs e grep, uma fonte de cada vez. Este post explica como o Loki e o Grafana Alloy transformam isso num único lugar pesquisável ao lado dos dashboards, o que exatamente roda no blog desde 19 de outubro de 2026 – e o que os novos alertas de log encontraram na primeira hora, antes que alguém tivesse procurado.
Índice
🧭 Como o Loki e o Alloy funcionam
A ideia: indexar os labels, não as palavras
Sistemas de log clássicos como o Elasticsearch constroem um índice de texto completo: cada palavra de cada linha fica pesquisável, e o índice muitas vezes é maior que os próprios logs. O Loki faz o contrário. Ele indexa só um pequeno conjunto de labels por stream – por exemplo job="journal", unit="sshd.service", namespace="wordpress" – e guarda as linhas em si comprimidas em chunks. Uma consulta primeiro seleciona streams por label (barato, via índice) e depois varre só os chunks desses streams em busca do texto (força bruta, mas sobre pouca quantidade de dados). É o mesmo modelo que o Prometheus usa para métricas, e por isso os dois se encaixam tão bem.
A consequência é uma regra que decide se o Loki continua rápido: labels precisam ter poucos valores. Host, job, unit do systemd, namespace, container – algumas dezenas de valores cada – são bons labels. Um nome de usuário, um endereço IP, um request ID não são: cada novo valor cria um novo stream, e milhares de streams minúsculos deixam o índice grande e os chunks inúteis. Esses valores ficam na linha e são filtrados na hora da consulta.
Streams, chunks, índice, compactor
- Stream: todas as linhas com exatamente o mesmo conjunto de labels.
{job="journal", unit="k3s.service", level="info"}é um stream. - Chunk: um bloco comprimido de linhas de um stream, gravado no sistema de arquivos quando está cheio ou velho o bastante.
- Índice (TSDB, schema v13): mapeia conjuntos de labels para chunks, um arquivo de índice por dia.
- Compactor: junta os arquivos de índice diários e – importante – é o componente que realmente apaga os dados quando ficam mais velhos que o período de retenção. Sem
retention_enabled, a configuração de retenção só esconde dados antigos das consultas.
LogQL em dois passos
Uma consulta LogQL sempre começa com um seletor de stream entre chaves, seguido de filtros opcionais. Com um intervalo e uma função em volta, a mesma consulta vira uma métrica – é isso que os alertas usam.
# 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 “contém”, != “não contém”, |~ e !~ são as versões com regex. Parsers como | json ou | logfmt transformam partes de uma linha em labels temporários que só existem durante a consulta – o jeito barato de filtrar por um valor que nunca deve virar um label de verdade.
Grafana Alloy: o coletor
O Alloy é o agente da Grafana, sucessor do Promtail e do Grafana Agent. A configuração dele é um pipeline de componentes: sources leem logs (journal, arquivos), processors os alteram (parse, relabel, definir o timestamp, descartar) e writers os enviam ao Loki. Cada componente declara para onde vai sua saída (forward_to), então a configuração se lê como um diagrama de fluxo de dados. O Alloy guarda no seu próprio diretório de dados até onde já leu cada arquivo e o journal, então um restart nem perde nem repete linhas.
🛡️ Por que ele está aqui
- Um lugar para todos os logs. Journal, cada pod, o log de auditoria e o fail2ban, pesquisáveis no Grafana ao lado das métricas, dos últimos 14 dias – inclusive de pods que já não existem e cujos logs o
kubectl logsnão consegue mais mostrar. - Alertas sobre coisas que métricas não veem. Uma negação do SELinux, um ban do fail2ban que falhou ou um OOM kill do kernel é uma linha de log, não um número. Antes, isso só era encontrado quando alguém por acaso olhava.
- Barato o bastante para um servidor pequeno. Loki e Alloy juntos precisam de cerca de meio gigabyte de RAM e alguns megabytes de disco por hora no blog – uma stack de texto completo precisaria de várias vezes isso.
🔧 O que este repositório faz
A role common_loki roda depois de common_grafana (cujo repositório de pacotes e API ela usa) e antes de common_monit (que depois vigia os dois serviços). Ela roda no blog desde 19 de outubro de 2026; os dois servidores Nextcloud vieram em 20 de outubro, depois de um dia de observação.
Loki: binário único, disco local, 14 dias
O pacote traz uma configuração de demonstração que guarda tudo em /tmp/loki – some a cada reboot – com logging de debug. A role a substitui por completo. As partes importantes:
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
O template é verificado antes de substituir o arquivo real: o validate do Ansible roda loki -verify-config no candidato. Um erro de digitação faz então o playbook falhar, em vez de deixar um serviço que não sobe mais.
Alloy: quatro fontes, um punhado de labels
- Journal com os labels
unit,leveletransport.transport="kernel"separa as mensagens do próprio kernel – é lá que o OOM killer escreve. - Logs dos pods de
/var/log/pods/<namespace>_<pod>_<uid>/<container>/N.log. Uma regra de relabel recorta namespace, pod e container do caminho;stage.criremove o prefixo do containerd (hora, stream, flag de parcial) e junta linhas quebradas. - audit.log. Negações do SELinux não estão no journal nesses hosts – o auditd é dono do socket de auditoria do kernel – então o Alloy lê o arquivo.
- fail2ban.log, porque um ban que falhou só é registrado ali.
Todos os streams recebem o label host; o label automático filename é descartado porque só duplicaria informação que já está nos outros labels.
Lendo os logs do root sem ser root
O pacote roda o Alloy como usuário alloy nos grupos adm e systemd-journal. Isso basta para o journal, mas não para audit.log (root, modo 0600), fail2ban.log e os logs dos pods (root, 0640). A solução preguiçosa seria rodar o Alloy como root. Em vez disso, a role dá a ele uma única capability do Linux, num drop-in do 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 contorna as verificações de permissão de leitura em arquivos e diretórios – e nada mais. O Alloy consegue ler qualquer log, mas não consegue escrever fora do próprio diretório de dados, não consegue mudar donos, não consegue carregar módulos. O Loki recebe um drop-in parecido, sem capability nenhuma. O systemd-analyze security avalia as duas units com 4.0 e 3.8 – “OK” na escala dele, onde um serviço sem hardening fica por volta de 9.
A lição: Um serviço que precisa ler todos os logs não precisa de root. Uma capability para leitura basta, e todo o resto fica trancado.
Grafana: datasource, alertas e um autoteste
A role cria a datasource “Loki” pela API do Grafana (verifica primeiro, só cria se faltar) e cinco regras de alerta na pasta que já guarda os alertas de métricas:
| Alerta | LogQL (janela de 15 minutos) | Por quê |
|---|---|---|
| SELinux bloqueou algo | {job="audit"} |= "type=AVC" |= "permissive=0" | Uma negação real. Linhas permissive=1 de domínios ainda em fase de aprendizado não contam. |
| fail2ban reporta erros | {job="fail2ban"} |= "]: ERROR" != "KeyError('/var/log/pods/" | Uma ação de ban ou um filtro está quebrado. O KeyError excluído é inofensivo (veja abaixo). |
| OOM killer do kernel | {job="journal", transport="kernel"} |~ "(?i)out of memory: killed process" | Cobre também processos do host, não só containers. |
| Nenhum log chegando | sum(count_over_time({job="journal"}[15m])) < 1 | O próprio pipeline está quebrado. “Sem dados” conta como alerta aqui. |
| Orçamento de erros estourado (desde 26 out 2026, janela de 1 hora) | linhas de erro e warning por unit ou container > 100, ruído conhecido excluído | Um serviço que escreve erros por horas sem que nenhuma métrica mostre – como dois exporters em outubro |
No final, a role testa a cadeia inteira: escreve um marcador único com logger no journal e consulta o Loki até o marcador aparecer. Se o Alloy ou o Loki estiver quebrado, o playbook falha bem ali.
🔍 A primeira hora: quatro achados que ninguém tinha procurado
Uma hora depois do primeiro rollout, os novos alertas já tinham mandado e-mails. Nenhum era ruído – cada um apontava para algo real, e dois deles para erros meus.
1. Linhas antigas, timestamps novos
Os dois primeiros alertas dispararam na hora: um AVC e um erro do fail2ban. A linha do fail2ban era das 11:13 daquela manhã. O que tinha acontecido: no primeiro start, o Alloy lê cada arquivo desde o começo e, sem mais instruções, carimba cada linha com a hora em que a leu. Todo o acúmulo de audit.log e fail2ban.log caiu no Loki como “agora” – e os alertas, que contam linhas nos últimos 15 minutos, viram horas de erros antigos de uma vez.
A correção é tirar o timestamp da própria linha. O log de auditoria traz o epoch em msg=audit(1792426019.999:37103), o fail2ban escreve hora local sem 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" }
}
...
}
O fuso horário não está fixo na role: ela lê o fuso do host com timedatectl e o passa para o template, então a mesma role acerta num host que roda em hora local.
A lição: Um coletor de logs que usa a hora da leitura em vez do timestamp da linha faz alertas dispararem por eventos antigos. Tire o timestamp da linha.
2. O primeiro AVC real: um instalador de pacote
O AVC em si era genuíno e novinho: durante a instalação do RPM do Alloy, useradd -m tentou criar .bash_logout no novo diretório home /var/lib/alloy. Esse diretório tem o tipo var_lib_t, e a policy não deixa useradd_t criar arquivos de usuário ali. Inofensivo – o Alloy não precisa de perfil de shell – mas exatamente o tipo de evento que antes sumia num log de auditoria de 6 MB.
A lição: Uma ferramenta nova traz negações novas junto. Um alerta sobre AVCs as encontrou na primeira ocorrência, não semanas depois.
3. Erros do fail2ban que estavam lá havia dias
Olhar os erros do fail2ban no Loki mostrou dois tipos. Um era inofensivo: KeyError('/var/log/pods/…'), o backend de polling perdendo o rastro de um log de pod que foi removido num restart do pod; a jail segue em frente. O outro não: em 13 e 14 de outubro, Failed to execute ban jail 'nginx-k3s-bad-paths' action 'nftables…' – bans que não aconteceram, nos dias em que o reload do firewall estava sendo refeito. Ninguém tinha visto. Agora o alerta exclui só o padrão inofensivo conhecido.
A lição: Erros que ninguém lê continuam existindo. Só quando os logs ficaram pesquisáveis apareceram erros que estavam lá havia dias.
4. Um AVC da próxima ferramenta nova
Uma hora depois, o Trivy foi instalado (o deep dive dele vem a seguir). A unit de scan dele tinha NoNewPrivileges=yes, e o script chama k3s kubectl. O binário k3s faz transição para o domínio container_runtime_t, e sob NoNewPrivileges o SELinux recusa essa transição a menos que a policy a permita explicitamente: avc: denied { nnp_transition }. O alerta do Loki disparou poucos minutos depois do primeiro scan. Não foi a primeira vez que esse mecanismo deu problema aqui – MariaDB e Grafana já tinham tropeçado nele antes – mas foi a primeira vez que uma máquina o encontrou, e não um serviço falhando.
Um erro meu de quebra: o Loki escrevia “error getting network interfaces … address family not supported” várias vezes por hora. O sandbox da unit permitia só sockets IPv4, IPv6 e Unix, mas o Loki consulta as interfaces de rede por um socket netlink. Desde 26 de outubro de 2026 AF_NETLINK é permitido; sem capabilities, o Loki só consegue ler por ele, não mudar nada.
Disco e memória
Depois das duas primeiras horas no blog: Loki com cerca de 240 MB de RSS, Alloy com cerca de 275 MB, juntos uns dois minutos de tempo de CPU, e 13 MB em /var/lib/loki – cerca de 150 MB por dia, então uns 2 GB com os 14 dias completos. Os servidores Nextcloud têm mais pods e mais tráfego; por isso a role ficou um dia só no blog e os números foram comparados antes de seguir adiante. Se um dia o disco crescer mais rápido que o esperado, a primeira pergunta é qual stream está grande – topk por unit ou namespace responde – e a segunda é se esse stream precisa ser guardado; o Alloy pode descartar linhas com stage.drop antes que cheguem ao Loki.
Coisas para saber
- Fuso horário no navegador. O Grafana mostra os horários no fuso do navegador, os servidores rodam em UTC. Uma linha “das 11:13” num arquivo aparece como 13:13 no Grafana no verão.
- Linhas antigas são rejeitadas.
reject_old_samples_max_age: 168h– um arquivo com linhas com mais de uma semana (por exemplo um backup restaurado) não será importado. É de propósito. - Restart é seguro. O Alloy guarda suas posições de leitura em
/var/lib/alloy/data. Apagar esse diretório faz com que ele leia tudo de novo – agora com timestamps corretos, mas como duplicatas.
🆘 Cola: sintoma → comando
A versão curta deste artigo para o momento em que algo está errado. Rode no host como root; <…> são placeholders.
| Sintoma | Comando |
|---|---|
| O Loki está pronto, o Alloy está pronto? | curl -s 127.0.0.1:3100/readycurl -s 127.0.0.1:12345/-/ready |
| Faltam logs de uma fonte | curl -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 |
| O que o SELinux negou? | {job="audit"} |= "type=AVC" |= "permissive=0" |
| Logs de um pod que já não existe | {namespace="<ns>", container="<container>"} |= "Fatal" |
| Kernel: OOM, segfaults, hardware | {job="journal", transport="kernel"} |
| O disco cresce mais rápido que o esperado | du -sh /var/lib/lokitopk(10, sum by (unit) (count_over_time({job="journal"}[1h]))) |
| Os horários no Grafana estão duas horas fora | # browser time zone vs. UTC on the servers - not a bug |
🎯 As lições
- Labels com poucos valores, conteúdo na linha: é isso que mantém o Loki pequeno e rápido.
- Tire o timestamp da linha de log, não da hora da ingestão.
- Ler todos os logs exige uma capability; root não é necessário.
- Teste um pipeline de logs de ponta a ponta: escreva um marcador e encontre-o de novo no Loki.
- Um alerta sobre linhas de log encontra o que nenhuma métrica mostra – inclusive os seus próprios erros.
⚖️ Alternativas – e por que o Loki
| Opção | Ponto forte | Por que não aqui |
|---|---|---|
| journald + grep | De graça, sempre disponível | Um host, uma fonte de cada vez, sem alertas, logs de pods somem com o pod. |
| ELK / OpenSearch | Busca de texto completo em tudo, muito poderoso | Java, vários GB de RAM para um único nó – mais do que a stack inteira do blog precisa. |
| Graylog | Boa UI, streams e alertas embutidos | Testado num lab antes: precisa de MongoDB mais OpenSearch – de novo pesado para um servidor pequeno. |
| Promtail + Loki | A combinação clássica | O Promtail está em modo de manutenção; o Alloy é o sucessor e também fala métricas e traces. |
| Loki + Alloy | Índice de labels como o Prometheus, pequeno, nativo no Grafana | Escolhido: encaixa no setup existente de Prometheus/Grafana e no orçamento de RAM. |
O ponto decisivo não foram as features, mas o encaixe. Prometheus e Grafana já estavam lá, os e-mails de alerta já funcionavam, e o modelo de labels é o mesmo que as métricas usam. O Loki acrescentou a metade que faltava – o porquê por trás dos números – por cerca de meio gigabyte de RAM.
