RousselTMLEARNING

Observabilité

Grafana Alloy : Guide complet pour collecter métriques, logs et traces

Tutoriel complet sur Grafana Alloy. Découvrez comment installer, configurer et utiliser ce collecteur nouvelle génération avec ses pipelines programmables (syntaxe de configuration Alloy, ex-River).

1. Qu'est-ce que Grafana Alloy ? #

Comprendre le passage de l'Agent statique à Alloy.

L'évolution de l'agent Grafana #

Disponible dans : ✓ OSS ✓ Enterprise ✓ Cloud

Grafana Alloy, un collecteur unique pour tous les signaux

Grafana Alloy est le collecteur de télémétrie de Grafana Labs, sous licence Apache 2.0. Il reçoit, transforme et envoie les quatre signaux : métriques, logs, traces et profils. Il succède à Grafana Agent et à Promtail, tous deux en fin de vie (Grafana Agent le 1er novembre 2025, Promtail le 2 mars 2026) (voir la leçon Alloy, Grafana Agent et Promtail).

Il répond à un problème concret : sans lui, un serveur fait souvent tourner un node_exporter, un Promtail, un Collector OpenTelemetry et un agent de profilage, chacun avec sa configuration. Alloy remplace cet ensemble par un seul processus et un seul langage.

Ce qu'Alloy n'est pas #

Idée reçueEn réalité
Alloy stocke les donnéesNon : il les transmet à Mimir, Loki, Tempo, Pyroscope ou tout backend compatible
Alloy ne fonctionne qu’avec GrafanaNon : il envoie aussi en OTLP et en Prometheus remote write vers d’autres plateformes
Alloy est le Collector OpenTelemetryIl en embarque des composants (otelcol.*), mais a son propre langage et son moteur

2. Le concept de "Programmable Pipelines" #

Introduction à la syntaxe déclarative.

Pourquoi « programmable » ? #

Un agent classique se configure avec un gros fichier YAML : vous décrivez quoi collecter, et son fonctionnement interne reste figé. Alloy inverse la logique : vous assemblez des composants, comme des briques, et vous décidez du chemin des données.

Trois pipelines dans un même Alloy
Chaque signal suit sa propre chaîne, dans le même processus.

Un premier pipeline #

Deux composants suffisent. L'un collecte, l'autre envoie. Le lien entre les deux est une simple référence :

prometheus.scrape "app" {
  targets    = [{ "__address__" = "localhost:8080" }]
  forward_to = [prometheus.remote_write.mimir.receiver]
}

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

forward_to pointe vers receiver, une valeur publiée (exportée) par l'autre composant. C'est toute la mécanique du langage : une sortie est branchée sur une entrée. L'ordre des blocs dans le fichier n'a aucune importance, car Alloy déduit l'ordre d'exécution de ces références.

Ce que l'assemblage permet #

Envoyer vers plusieurs destinations. forward_to est une liste : les mêmes métriques partent vers deux backends sans dupliquer la collecte.

prometheus.relabel "filtre" {
  rule {
    source_labels = ["__name__"]
    regex         = "go_gc_.*"
    action        = "drop"
  }
  forward_to = [
    prometheus.remote_write.mimir.receiver,
    prometheus.remote_write.cloud.receiver,
  ]
}

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

prometheus.remote_write "cloud" {
  endpoint {
    url = sys.env("GRAFANA_CLOUD_URL")
  }
}

Décider selon le contenu. Ici, les logs de débogage sont écartés avant l'envoi. Dans nos essais, sur 4 lignes lues, 3 sont arrivées dans Loki.

loki.process "routage" {
  forward_to = [loki.write.long_terme.receiver]

  stage.json {
    expressions = { level = "" }
  }

  stage.drop {
    source = "level"
    value  = "debug"
  }
}

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

Réutiliser. Un même traitement se factorise avec declare et se partage avec import.git (voir la leçon Variables et fonctions).

Statique ou programmable #

Agent YAML classiqueAlloy
ConfigurationSections prévues à l’avanceComposants assemblés librement
Chemin des donnéesFixé par l’outilDécrit par vos références
Changement d’une cibleSouvent un rechargement globalSeuls les composants concernés sont réévalués
RéutilisationCopier-collerdeclare, import.*
À retenir : lisez une configuration Alloy en suivant les forward_to. Vous obtenez le chemin réel des données, et l'interface sur le port 12345 dessine ce même graphe.

3. Architecture interne #

Les composants, les services et le graphe de dépendances (DAG).

Le composant, brique de base #

Anatomie d'un composant Alloy

Tout repose sur le composant. Il reçoit des arguments (ce que vous écrivez), s'exécute en continu et publie des exports, que d'autres composants lisent. Il a aussi un état de santé, visible dans l'interface et par l'API.

Le graphe (DAG) #

Le graphe des composants dans l interface d Alloy

Au chargement, le contrôleur construit un graphe orienté acyclique (DAG) à partir des références. Il évalue d'abord les composants sans dépendance, puis remonte. Ensuite, quand un composant publie un nouvel export, seuls ses dépendants sont réévalués. Un nouveau pod découvert ne perturbe donc pas l'envoi des logs.

Le graphe impose des règles, contrôlées au chargement. Voici les messages réels d'Alloy 1.21 :

cycle detected: prometheus.relabel.a, prometheus.relabel.b
block prometheus.remote_write.a already declared at du.alloy:1:1
component "prometheus.remote_write.absent.receiver" does not exist or is out of scope
ErreurCauseCorrection
cycle detectedA envoie vers B, qui envoie vers ACouper la boucle : le graphe doit rester acyclique
already declaredDeux composants avec le même nom et la même étiquetteChanger l’étiquette
does not exist or is out of scopeRéférence à un composant absentVérifier l’orthographe ou la portée d’un declare

Où sont les données ? #

Certains composants écrivent sur disque, dans le dossier --storage.path (par défaut data-alloy). Nous y avons trouvé par exemple le WAL de prometheus.remote_write et les positions de loki.source.file. Rendez ce dossier persistant : sans lui, un redémarrage relit les fichiers ou perd les métriques en attente.

Recharger sans s'interrompre #

Un POST /-/reload recharge la configuration. Nous avons vérifié deux cas :

  • Configuration valide : réponse config reloaded.
  • Configuration invalide : réponse 400, et les composants en cours continuent de tourner avec l'ancienne configuration.
Bonne pratique : alloy run accepte un dossier, et charge tous ses fichiers .alloy. Séparez par domaine : 10-collecte.alloy, 20-envoi.alloy. Nous l'avons testé : les références fonctionnent d'un fichier à l'autre.

4. Installation #

Déploiement sur Linux, Docker et Kubernetes.

Quelle méthode choisir ? #

EnvironnementMéthodePour
Serveurs LinuxPaquet deb ou rpmService systemd, mises à jour par le gestionnaire
Poste, CI, maquetteDockerEssai rapide, sans toucher au système
KubernetesChart HelmDaemonSet ou cluster (voir le chapitre dédié)
Sans droitsBinaire de GitHubEssai ponctuel

Avec Docker #

docker run --name alloy \
  -v "$PWD/config.alloy:/etc/alloy/config.alloy" \
  -p 12345:12345 \
  grafana/alloy:v1.21.3 \
  run --server.http.listen-addr=0.0.0.0:12345 \
      --storage.path=/var/lib/alloy/data \
      /etc/alloy/config.alloy
L'interface ne répond pas ? Par défaut, Alloy écoute sur 127.0.0.1:12345, donc uniquement dans le conteneur. D'où l'option --server.http.listen-addr=0.0.0.0:12345. Hors d'un conteneur, gardez la valeur par défaut, ou protégez ce port : l'interface expose la configuration.

Sur Debian ou Ubuntu #

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

sudo systemctl enable --now alloy
sudo systemctl status alloy
sudo journalctl -u alloy -f

La configuration se trouve dans /etc/alloy/config.alloy. Les options du service sont dans /etc/default/alloy (/etc/sysconfig/alloy sur RHEL) : CUSTOM_ARGS reçoit par exemple l'adresse d'écoute.

Sur Kubernetes #

helm repo add grafana https://grafana.github.io/helm-charts
helm repo update
helm install alloy grafana/alloy -n monitoring --create-namespace -f values.yaml

Le déploiement et ses modes sont détaillés dans le chapitre Déployer à grande échelle.

Vérifier l'installation #

alloy --version
alloy validate config.alloy
curl http://localhost:12345/-/ready     # Alloy is ready.
curl http://localhost:12345/-/healthy   # All Alloy components are healthy.
curl -X POST http://localhost:12345/-/reload   # config reloaded
Point de contrôleRéponse attendue
/-/readyAlloy is ready.
/-/healthyAll Alloy components are healthy.
http://localhost:12345Interface et graphe des composants
Bonne pratique : épinglez un tag précis de l'image (grafana/alloy:v1.21.3), et lancez alloy validate dans votre CI avant chaque déploiement.

5. Foire Aux Questions (FAQ) #

Questions courantes autour de Grafana Alloy.

Quelle est la différence entre Grafana Alloy et Grafana Agent ? #

Grafana Alloy est le successeur officiel de Grafana Agent. Là où l'Agent utilisait une configuration statique (souvent YAML complexe), Alloy introduit des pipelines programmables en langage de configuration Alloy (ex-River), offrant une flexibilité totale, un rechargement à chaud natif et une UI de débogage sous forme de graphe (DAG).

6. Allez plus loin : Formations et Maillage #

Passez de la théorie à la pratique.

Transformez l'essai #

Si ce tutoriel vous a aidé à comprendre les bases, notre Formation Grafana Alloy vous emmènera bien plus loin (Labs pratiques sur Kubernetes, transformations complexes, debug avancé).

Articles liés

Alloy et l'écosystème Grafana Labs : quel composant pour quel outil ?

La carte des intégrations d'Alloy avec Faro, Beyla, k6, Loki, Mimir, Tempo, Pyroscope, Database Observability…

Faro et Alloy : recevoir le RUM front-end avec faro.receiver

Configurer faro.receiver : CORS, clé d'API, limite de débit, source maps, puis envoyer erreurs, Web Vitals et…

Beyla et Alloy : métriques RED et traces sans code avec beyla.ebpf

Activer l'instrumentation eBPF de Beyla dans Alloy : découverte des services, métriques RED vers Mimir, trace…

Pour aller plus loin

Soutenir

♥ SOUTENIR

Soutenez RousselTM Learning

Les formations, articles, TP et attestations restent gratuits et sans publicité intrusive. Une contribution libre, du montant de votre choix, finance l’hébergement, les environnements de TP et l’écriture de nouveaux contenus.

Contribuer avec PayPal Montant libre · carte bancaire ou compte PayPalEn savoir plus
QR code PayPal
Ou scannez ce QR code avec votre téléphone

Merci, chaque contribution compte !