Alloy sur Kubernetes

2. Déploiement du Clustering Grafana Alloy #

Guide pratique pour déployer Grafana Alloy en mode clustering sur différentes plateformes, en mettant l'accent sur la haute disponibilité et la résilience.

Sur Kubernetes (Recommandé) #

Le déploiement de Grafana Alloy en mode clustering sur Kubernetes est la méthode la plus robuste et la plus courante, notamment grâce au Helm Chart officiel. Il permet de tirer parti des fonctionnalités natives de Kubernetes pour la gestion des pods, la persistance des données et la découverte de services.

• StatefulSet pour le Clustering : Pour un cluster Alloy, l'utilisation d'un StatefulSet est impérative. Contrairement à un Deployment, un StatefulSet garantit des identités réseau stables et un stockage persistant unique pour chaque réplique, ce qui est essentiel pour le protocole Gossip et la persistance du WAL (Write-Ahead Log).
• DaemonSet pour la Collecte Locale : Si l'objectif est de collecter des logs ou des métriques directement sur chaque nœud Kubernetes (par exemple, les logs de Docker/containerd, les métriques du nœud lui-même), un DaemonSet est plus approprié. Chaque pod Alloy du DaemonSet peut alors être configuré pour envoyer ses données à un cluster Alloy centralisé (déployé en StatefulSet) ou directement aux backends.

L'extrait de configuration Helm ci-dessous montre comment activer le mode clustering et configurer un StatefulSet avec un stockage persistant pour le WAL :

# Extrait de configuration Helm (values.yaml)
alloy:
  clustering:
    enabled: true
    name: "mon-cluster-alloy"
    # Initialisation des peers pour le protocole Gossip (peut être auto-découvert via Kubernetes DNS)
    # peers: ["alloy-0.alloy-headless.default.svc.cluster.local:7946", "alloy-1.alloy-headless.default.svc.cluster.local:7946"]
  controller:
    type: statefulset
    replicas: 3
    volumeClaimTemplates:
      - metadata:
          name: alloy-wal
        spec:
          accessModes: [ "ReadWriteOnce" ]
          resources:
            requests:
              storage: 10Gi
  # Configuration du port pour le protocole Gossip (par défaut 7946)
  extraArgs:
    - "--cluster.listen-address=0.0.0.0:7946"
    - "--cluster.advertise-address=$(POD_IP):7946"
  # Ajout de variables d'environnement pour la découverte de l'IP du Pod
  extraEnv:
    - name: POD_IP
      valueFrom:
        fieldRef:
          fieldPath: status.podIP

Le Helm Chart gère également la création des ConfigMaps pour les configurations River, facilitant les mises à jour et l'intégration GitOps.

Avec Docker Compose (pour environnements de test/développement) #

Déployer Grafana Alloy en mode clustering avec Docker Compose est une excellente solution pour les environnements de test ou de développement. Plutôt que de définir un service par instance, il est plus efficace de définir un seul service et d'utiliser la fonctionnalité de mise à l'échelle de Docker Compose.

Cette approche s'appuie sur le DNS interne de Docker pour que les instances se découvrent mutuellement. Chaque conteneur pourra résoudre le nom du service (par exemple `alloy`) et obtenir la liste des adresses IP de toutes les instances de ce service.

version: '3.8'

services:
  alloy:
    image: grafana/alloy:latest
    # Pas de container_name pour permettre le scaling
    volumes:
      # On utilise un seul fichier de configuration pour toutes les instances
      - ./config/alloy.river:/etc/alloy/config.river:ro
      # Le volume pour le WAL est anonyme et géré par Docker pour chaque conteneur
      - /var/lib/alloy/wal
    ports:
      # On expose le port de l'API sur le premier conteneur uniquement
      - "12345:12345"
    # Le port du Gossip n'a pas besoin d'être exposé sur l'hôte, 
    # la communication se fait via le réseau interne de Docker.
    command:
      - "run"
      - "--config.file=/etc/alloy/config.river"
      - "--cluster.enabled"
      - "--cluster.name=my-docker-cluster"
      # Chaque instance s'annonce avec son IP de conteneur sur le port Gossip
      - "--cluster.advertise-address=$$(HOSTNAME):7946"
      # On utilise la découverte DNS de Docker pour trouver les autres instances
      - "--cluster.discover-peers=tasks.alloy:7946"
    healthcheck:
      test: ["CMD", "wget", "-q", "-O", "-", "http://localhost:12345/metrics"]
      interval: 10s
      timeout: 5s
      retries: 3

Pour lancer ce cluster avec 3 instances, vous utiliserez la commande suivante :

docker compose up --scale alloy=3 -d

Points clés de cette nouvelle configuration :

• Service unique : Un seul service nommé alloy est défini, ce qui simplifie grandement le fichier.
• Découverte DNS : La magie opère grâce à l'argument --cluster.discover-peers=tasks.alloy:7946. Docker Compose fournit un DNS qui, lorsqu'on l'interroge sur tasks.alloy, retourne les adresses IP de tous les conteneurs du service `alloy`. Alloy peut ainsi découvrir dynamiquement ses pairs.
• Configuration partagée : Toutes les instances utilisent le même fichier de configuration alloy.river.
• Adresse dynamique : L'argument --cluster.advertise-address=$$(HOSTNAME):7946 utilise une variable d'environnement pour que chaque conteneur s'annonce avec son propre nom d'hôte (qui est unique pour chaque instance). Le double `$$` est nécessaire pour que la variable soit interprétée par le shell du conteneur et non par Docker Compose.
• Gestion des ports : Seul le port de l'API (12345) est exposé sur l'hôte pour le débogage. Le port Gossip (7946) n'a pas besoin d'être exposé, car la communication se fait sur le réseau interne créé par Docker Compose.
• Volumes WAL : En ne spécifiant pas de nom pour le volume du WAL, Docker gère automatiquement la création d'un volume anonyme unique pour chaque conteneur, assurant ainsi la persistance des données de manière isolée.

Sur VM ou Machine Physique #

Le déploiement de Grafana Alloy en mode clustering sur des machines virtuelles ou physiques suit une logique similaire à Docker Compose, mais nécessite une gestion manuelle des processus et de la configuration réseau.

Étapes clés :

1. Installation d'Alloy : Téléchargez et installez les binaires de Grafana Alloy sur chaque machine.
2. Configuration du Fichier River : Créez un fichier de configuration River (par exemple, /etc/alloy/config.river) sur chaque instance. Ce fichier doit inclure la section cluster :

   cluster {
     enabled = true
     name    = "my-physical-cluster"
     # Liste des adresses IP ou noms d'hôtes des autres membres du cluster
     # Assurez-vous que ces adresses sont accessibles entre les machines
     peers   = ["192.168.1.10:7946", "192.168.1.11:7946", "192.168.1.12:7946"]
   }
   
   # Exemple de configuration pour le scraping Prometheus
   prometheus.scrape "default" {
     targets = [
       {
         __address__ = "localhost:9100",
         instance    = "node-exporter"
       },
     ]
     forward_to = [prometheus.remote_write.default.receiver]
   }
   
   prometheus.remote_write "default" {
     endpoint = "http://your-prometheus-server:9090/api/v1/write"
   }

3. Configuration Réseau : Assurez-vous que le port utilisé par le protocole Gossip (par défaut 7946) est ouvert dans les pare-feu de toutes les machines et que les instances peuvent communiquer entre elles.
4. Persistance du WAL : Configurez un répertoire pour le WAL (par exemple, /var/lib/alloy/wal) et assurez-vous qu'il est persistant et a les bonnes permissions.
5. Gestion des Processus : Utilisez un gestionnaire de processus comme systemd pour démarrer et maintenir Alloy en fonctionnement. Créez un fichier de service systemd (par exemple, /etc/systemd/system/grafana-alloy.service) :

   [Unit]
   Description=Grafana Alloy Agent
   After=network.target
   
   [Service]
   ExecStart=/usr/local/bin/alloy run --config.file=/etc/alloy/config.river --cluster.enabled --cluster.name=my-physical-cluster --cluster.advertise-address=:7946
   Restart=on-failure
   User=alloy
   Group=alloy
   
   [Install]
   WantedBy=multi-user.target

   N'oubliez pas de remplacer <IP_DE_LA_MACHINE> par l'adresse IP réelle de chaque serveur.
6. Surveillance : Configurez Prometheus pour scraper les métriques de chaque instance Alloy (généralement sur le port 12345 par défaut) pour surveiller la santé du cluster.