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 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çue | En réalité |
|---|---|
| Alloy stocke les données | Non : il les transmet à Mimir, Loki, Tempo, Pyroscope ou tout backend compatible |
| Alloy ne fonctionne qu’avec Grafana | Non : il envoie aussi en OTLP et en Prometheus remote write vers d’autres plateformes |
| Alloy est le Collector OpenTelemetry | Il 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.
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 classique | Alloy | |
|---|---|---|
| Configuration | Sections prévues à l’avance | Composants assemblés librement |
| Chemin des données | Fixé par l’outil | Décrit par vos références |
| Changement d’une cible | Souvent un rechargement global | Seuls les composants concernés sont réévalués |
| Réutilisation | Copier-coller | declare, 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 #
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) #

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| Erreur | Cause | Correction |
|---|---|---|
cycle detected | A envoie vers B, qui envoie vers A | Couper la boucle : le graphe doit rester acyclique |
already declared | Deux composants avec le même nom et la même étiquette | Changer l’étiquette |
does not exist or is out of scope | Référence à un composant absent | Vé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 runaccepte 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 ? #
| Environnement | Méthode | Pour |
|---|---|---|
| Serveurs Linux | Paquet deb ou rpm | Service systemd, mises à jour par le gestionnaire |
| Poste, CI, maquette | Docker | Essai rapide, sans toucher au système |
| Kubernetes | Chart Helm | DaemonSet ou cluster (voir le chapitre dédié) |
| Sans droits | Binaire de GitHub | Essai 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.alloyL'interface ne répond pas ? Par défaut, Alloy écoute sur127.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 -fLa 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.yamlLe 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ôle | Réponse attendue |
|---|---|
/-/ready | Alloy is ready. |
/-/healthy | All Alloy components are healthy. |
http://localhost:12345 | Interface et graphe des composants |
Bonne pratique : épinglez un tag précis de l'image (grafana/alloy:v1.21.3), et lancezalloy validatedans 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é).
