Alloy

Alloy est un agent unifié développé par Grafana Labs, conçu pour collecter des logs, des métriques et des traces dans les environnements cloud natifs.
Il remplace Promtail, Agent, et d'autres outils en les unifiant dans une configuration centralisée, déclarative, et extensible.

Architecture

Dans notre infrastructure, Alloy est utilisé à deux niveaux :

En tant qu’agent DaemonSet dans Kubernetes pour collecter les logs des pods.
En tant que service systemd sur les machines NixOS pour collecter les logs journald.

Les logs sont ensuite envoyés vers notre instance Loki centralisée pour archivage et analyse via Grafana.

Déploiement dans Kubernetes

Alloy est déployé dans le namespace supervision via FluxCD et Helm.
Le chart utilisé provient du dépôt Helm officiel de Grafana.

apiVersion: helm.toolkit.fluxcd.io/v2
kind: HelmRelease
metadata:
  name: grafana-alloy
  namespace: supervision
spec:
  interval: 5m
  chart:
    spec:
      chart: alloy
      sourceRef:
        kind: HelmRepository
        name: grafana
        namespace: supervision
      version: "1.2.0"
  values:
    alloy:
      configMap:
        content: |
          logging {
            level = "info"
            format = "logfmt"
          }
          discovery.kubernetes "pods" {
            role = "pod"
          }
          discovery.relabel "pods" {
            targets = discovery.kubernetes.pods.targets

            rule {
              source_labels = ["__meta_kubernetes_namespace"]
              target_label = "namespace"
              action = "replace"
            }

            rule {
              source_labels = ["__meta_kubernetes_pod_label_app_kubernetes_io_name"]
              target_label = "app"
              action = "replace"
            }

            rule {
              source_labels = ["__meta_kubernetes_pod_container_name"]
              target_label = "container"
              action = "replace"
            }

            rule {
              source_labels = ["__meta_kubernetes_pod_name"]
              target_label = "pod"
              action = "replace"
            }
          }
          loki.source.kubernetes "pods" {
            targets    = discovery.relabel.pods.output
            forward_to = [loki.process.process.receiver]
          }
          loki.process "process" {
            forward_to = [loki.write.loki.receiver]

            stage.drop {
              older_than          = "1h"
              drop_counter_reason = "too old"
            }
            stage.match { 
              selector = "{instance=~\".*\"}"
              stage.json {
                expressions = {
                  level = "\"level\"",
                }
              }
              stage.labels {
                values = { 
                  level = "level",
                }
              }
            }
            stage.label_drop {
              values = [ "service_name" ]
            }
          }
          loki.write "loki" {
            endpoint {
              url = "http://loki-gateway/loki/api/v1/push"
            }
          }
      mounts:
        varlog: true
        dockercontainers: true
      resources:
        limits:
          cpu: 200m
          memory: 128Mi
        requests:
          cpu: 100m
          memory: 128Mi

Configuration de l’agent Kubernetes

L’agent Alloy utilise une configuration HCL (style Terraform) fournie via une ConfigMap.

Cette configuration permet :

La découverte des pods via l’API Kubernetes
Le relabelling des métadonnées (namespace, pod, container, etc.)
L’envoi des logs à Loki
Le parsing JSON des logs avec enrichissement de labels
Le nettoyage automatique des logs trop anciens (>1h)
L' envoi vers Loki via l’URL interne du cluster (loki-gateway)

Extrait de configuration :

discovery.kubernetes "pods" {
  role = "pod"
}

discovery.relabel "pods" {
  targets = discovery.kubernetes.pods.targets

  rule {
    source_labels = ["__meta_kubernetes_namespace"]
    target_label = "namespace"
    action = "replace"
  }
  ...
}

loki.source.kubernetes "pods" {
  targets    = discovery.relabel.pods.output
  forward_to = [loki.process.process.receiver]
}

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

  stage.drop {
    older_than = "1h"
  }
  stage.match { ... }
  stage.label_drop { ... }
}

loki.write "loki" {
  endpoint {
    url = "http://loki-gateway/loki/api/v1/push"
  }
}

Le chart active aussi la collecte de logs Docker et /var/log via les montages suivants :

mounts:
  varlog: true
  dockercontainers: true

Visualisation du flow Alloy

Voici une visualisation du pipeline (de la source à l’output):

Déploiement sur les machines NixOS

Chaque machine NixOS déploie Alloy comme un service systemd, avec une configuration personnalisée stockée dans /etc/alloy/config.alloy.

Configuration NixOS typique

services.alloy = {
  enable = true;
  configPath = "/etc/alloy";
};

systemd.services.alloy.serviceConfig = {
  SupplementaryGroups = ["systemd-journal"];
};

La configuration est injectée via Nix :

environment.etc."alloy/config.alloy".text = ''
  loki.relabel "journal" {
    forward_to = []

    rule {
      source_labels = ["__journal__systemd_unit"]
      target_label  = "unit"
    }
  }

  loki.source.journal "read" {
    forward_to    = [loki.write.endpoint.receiver]
    relabel_rules = loki.relabel.journal.rules
    labels = {
      component = "loki.source.journal",
      host      = "${hostname}",
    }
  }

  loki.write "endpoint" {
    endpoint {
      url = "${cfg.loki.url}"
    }
  }
'';

Les logs du journal systemd sont ainsi labellisés, traités et envoyés vers Loki.

Spécification de l’URL Loki

L’URL d’envoi des logs est définie via une option NixOS partagée :

{
  monitoring.loki.url = "https://loki.innovalia.cc/loki/api/v1/push";
}

Accès et supervision

Tous les logs collectés sont disponibles dans Grafana, via la datasource Loki.
Cela inclut :

Les logs des pods Kubernetes
Les logs système des machines NixOS

Cette solution centralisée nous permet d’avoir une visibilité complète sur nos workloads et nos hôtes.

Last modified: 22 July 2025