Grafana Alloy: Pipeline de Telemetria Unificado para PME

Introdução

As pequenas e médias empresas (PME) enfrentam hoje um desafio crescente: observar sistemas distribuidos sem inflar custos nem complexidade. A pilha clássica de observabilidade — Prometheus para métricas, Promtail para registos, Jaeger para traces — exige múltiplas ferramentas, configurações separadas e binários distintos a consumir recursos em cada máquina monitorizada.

O Grafana Alloy é a resposta da Grafana Labs a este problema. Lançado como sucessor oficial dos Grafana Agents (Static e Flow), o Alloy unifica num único binário a recolha de métricas, registos e traces, com pipelines nativos para Prometheus, OpenTelemetry, Loki e Pyroscope. Para uma PME com 5 a 50 servidores, isto significa menos processos a manter, menos memória RAM ocupada e um único ficheiro de configuração para toda a telemetria.

Neste artigo, vamos explorar o que é o Grafana Alloy, como instalá-lo em Linux, e configurar passo a passo a recolha dos três pilares da observabilidade: métricas, registos e traces. Vamos também comparar o Alloy com a abordagem tradicional Promtail + Grafana Agent para perceber onde está a vantagem real.

O que é o Grafana Alloy

O Grafana Alloy é um colector de telemetria open source que combina as capacidades dos principais coletores da comunidade num só produto. Em vez de executar Promtail para enviar registos para Loki, o Grafana Agent para enviar métricas para Prometheus/Mimir, e o OpenTelemetry Collector para enviar traces para Tempo, o Alloy faz tudo num pipeline unificado.

O Alloy nasceu da evolução do Grafana Agent Flow, a versão declarativa do Grafana Agent. Com o lançamento do Alloy, a Grafana Labs unificou as duas variantes (Static e Flow) numa única ferramenta com configuração declarativa baseada em componentes. O Grafana Agent foi oficialmente descontinuado em favor do Alloy.

Principais características

O Alloy destaca-se por várias características que o tornam especialmente adequado para PME:

• Pipelines nativos para todos os sinais: métricas (Prometheus), registos (Loki), traces (OpenTelemetry) e perfis (Pyroscope) num só binário.
• Configuração declarativa com componentes: cada bloco do ficheiro de configuração descreve um componente (ex: prometheus.scrape, loki.write) que pode ser ligado a outros formando um pipeline.
• Compatibilidade com OpenTelemetry: suporta o protocolo OTLP nativamente, permitindo receber e exportar traces e métricas no padrão CNCF.
• Gestão de frotas (Fleet Management): permite gerir múltiplas instâncias do Alloy em cluster, com balanceamento de carga automático.
• Único binário: menos RAM, menos processos, menos superfície de ataque. Ideal para servidores com recursos limitados.

Instalação

O Alloy pode ser instalado em Linux (Debian/Ubuntu, RHEL/Fedora, SUSE/openSUSE), macOS, Windows, Docker e Kubernetes. Vamos cobrir a instalação em Debian/Ubuntu, a distribuição mais comum em servidores PME.

Debian/Ubuntu

Primeiro, importar a chave GPG e adicionar o repositório da Grafana:

sudo mkdir -p /etc/apt/keyrings
sudo wget -O /etc/apt/keyrings/grafana.asc https://apt.grafana.com/gpg-full.key
sudo chmod 644 /etc/apt/keyrings/grafana.asc
echo "deb [signed-by=/etc/apt/keyrings/grafana.asc] https://apt.grafana.com stable main" \
  | sudo tee /etc/apt/sources.list.d/grafana.list

Depois, actualizar os repositórios e instalar o Alloy:

sudo apt-get update
sudo apt-get install alloy

O Alloy é instalado como serviço systemd. Para verificar se está a correr:

sudo systemctl status alloy
sudo systemctl enable alloy

RHEL/Fedora

Para distribuições baseadas em RPM:

wget -q -O gpg.key https://rpm.grafana.com/gpg.key
sudo rpm --import gpg.key
echo -e '[grafana]\nname=grafana\nbaseurl=https://rpm.grafana.com\nrepo_gpgcheck=1\nenabled=1\ngpgcheck=1\ngpgkey=https://rpm.grafana.com/gpg.key\nsslverify=1\nsslcacert=/etc/pki/tls/certs/ca-bundle.crt' \
  | sudo tee /etc/yum.repos.d/grafana.repo
sudo dnf install alloy

Docker

Para ambientes contentorizados, o Alloy está disponível como imagem Docker oficial:

docker run -d --name alloy \
  -v /etc/alloy/config.alloy:/etc/alloy/config.alloy \
  -v /var/log:/var/log:ro \
  -p 12345:12345 \
  grafana/alloy:latest \
  run --server.http.listen-addr=0.0.0.0:12345 /etc/alloy/config.alloy

Configurar Recolha de Métricas

A recolha de métricas no Alloy usa componentes compatíveis com Prometheus. O componente prometheus.scrape recolhe métricas de endpoints no formato Prometheus, e o prometheus.remote_write envia-as para um backend compatível (Mimir, Prometheus, Cortex ou Grafana Cloud).

Exemplo de configuração para recolher métricas do próprio Alloy (auto-monitorização) e de um node_exporter:

prometheus.scrape "self" {
  targets = [
    {"__address__" = "127.0.0.1:12345", "job" = "alloy"},
  ]
  scrape_interval = "15s"
  forward_to = [prometheus.remote_write.default.receiver]
}

prometheus.scrape "node_exporter" {
  targets = [
    {"__address__" = "127.0.0.1:9100", "job" = "node"},
  ]
  scrape_interval = "15s"
  forward_to = [prometheus.remote_write.default.receiver]
}

prometheus.remote_write "default" {
  endpoint {
    url = "http://mimir:9009/api/v1/push"
  }
}

Nesta configuração:

• prometheus.scrape "self" recolhe métricas internas do Alloy na porta 12345.
• prometheus.scrape "node_exporter" recolhe métricas do sistema (CPU, memória, disco) via node_exporter na porta 9100.
• prometheus.remote_write "default" envia as métricas para um backend Mimir (ou Prometheus, Grafana Cloud).
• O campo forward_to liga os componentes de scrape ao remote_write, formando o pipeline.

Para enviar métricas para o Grafana Cloud, substituir o endpoint pela URL fornecida na consola do Grafana Cloud e adicionar autenticação:

prometheus.remote_write "grafana_cloud" {
  endpoint {
    url = "https://prom-prod-xx.grafana.net/api/prom/push"
    basic_auth {
      username = "XXXXXX"
      password = "glc_YYYYYYYYY"
    }
  }
}

Recolha de Registos (registos)

A recolha de registos no Alloy substitui o Promtail. O componente loki.source.file lê ficheiros de log locais e envia-os para loki.write, que os persiste num backend Loki (ou Grafana Cloud Logs).

Exemplo para recolher registos do sistema (journald) e de ficheiros de aplicação:

loki.source.file "app_logs" {
  targets = [
    {__path__ = "/var/log/app/*.log", "job" = "app"},
  ]
  forward_to = [loki.write.default.receiver]
}

loki.source.api "journald" {
  targets = [
    {__path__ = "/var/log/journal", "job" = "systemd"},
  ]
  forward_to = [loki.write.default.receiver]
}

loki.write "default" {
  endpoint {
    url = "http://loki:3100/loki/api/v1/push"
  }
}

Para enriquecer os registos com labels (etiquetas) estáticas, usar o componente loki.process:

loki.process "add_labels" {
  forward_to = [loki.write.default.receiver]

  stage.static_labels {
    values = {
      environment = "producao",
      servidor    = "web-01",
    }
  }
}

loki.source.file "app_logs" {
  targets = [
    {__path__ = "/var/log/app/*.log", "job" = "app"},
  ]
  forward_to = [loki.process.add_labels.receiver]
}

Aqui o pipeline é: loki.source.file → loki.process (adiciona labels) → loki.write (envia para Loki). Esta cadeia declarativa é o coração do modelo de componentes do Alloy.

Recolha de Traces (OTel)

A recolha de traces é onde o Alloy mais brilha em relação aos agentes anteriores. O Alloy integra componentes OpenTelemetry nativos (prefixo otelcol.) que seguem a especificação OTel do CNCF. Isto significa que qualquer aplicação instrumentada com SDKs OpenTelemetry pode enviar traces directamente para o Alloy via OTLP.

Configuração para receber traces OTLP e enviá-los para Tempo:

otelcol.receiver.otlp "default" {
  grpc {
    endpoint = "0.0.0.0:4317"
  }
  http {
    endpoint = "0.0.0.0:4318"
  }
  output {
    traces = [otelcol.exporter.otlp.tempo.input]
  }
}

otelcol.exporter.otlp "tempo" {
  client {
    endpoint = "tempo:4317"
    tls {
      insecure = true
    }
  }
}

Nesta configuração:

• otelcol.receiver.otlp escuta nas portas 4317 (gRPC) e 4318 (HTTP), o padrão OTLP.
• otelcol.exporter.otlp envia os traces para um backend Tempo via gRPC.
• O campo output.traces liga o receiver ao exporter, definindo o fluxo dos dados.

Para ambientes com processamento intermédio (filtrar, transformar ou amostrar traces), o Alloy oferece componentes como otelcol.processor.tail_sampling (amostragem baseada em atributos) e otelcol.processor.attributes (adicionar/remover atributos). Exemplo com tail sampling:

otelcol.processor.tail_sampling "default" {
  policy {
    name = "errors-only"
    type = "status_code"
    status_code {
      status_codes = [ERROR]
    }
  }
  policy {
    name = "sample-10-percent"
    type = "probabilistic"
    probabilistic {
      sampling_percentage = 10
    }
  }
  output {
    traces = [otelcol.exporter.otlp.tempo.input]
  }
}

otelcol.receiver.otlp "default" {
  grpc {
    endpoint = "0.0.0.0:4317"
  }
  output {
    traces = [otelcol.processor.tail_sampling.default.input]
  }
}

Para uma PME, esta configuração permite recolher apenas traces com erro (100%) e uma amostra de 10% dos traces normais, reduzindo drasticamente o volume de dados enviado ao backend sem perder informação crítica para diagnóstico.

Comparação Alloy vs Promtail+Agent

A tabela seguinte resume as diferenças chave entre usar o Grafana Alloy único e a abordagem tradicional com Promtail + Grafana Agent + OpenTelemetry Collector separados:

Para uma PME, a vantagem é clara: menos binários significam menos actualizações de segurança para aplicar, menos processos para monitorizar e menos memória RAM consumida em cada servidor. Num cenário típico com 10 servidores, a diferença entre 3 processos (~300MB cada) e 1 processo (~100MB) traduz-se em cerca de 6GB de RAM poupada mensalmente across a frota.

Além disso, a configuração declarativa por componentes do Alloy permite visualizar o pipeline completo na interface web integrada (porta 12345), facilitando o diagnóstico de problemas de telemetria sem precisar de ferramentas externas. Para equipas pequenas sem um engenheiro de observabilidade dedicado, esta capacidade de auto-diagnóstico é inestimável.