Aller au contenu

Grafana Mimir

Presentation de la stack Grafana Mimir

Grafana Mimir c'est un peu LA stack de référence en terme de TSDB (Time Series Data Base) et la plus connue quand on parle d'observabilité pour les métriques. C'est un all-in-one. On va s'intérésser ici à la version distributed, c'est à dire la version hautement scalable et qui est composé que de micro-services.

Installation

Je te montre ici comment l'installer sous ArgoCD. On va y claquer le helm chart correspondant à mimir-distributed

Cela va être à toi de choisir ce que tu veux comme element qui tourne sur ta stack, mais le minimal va être d'avoir ces services ci :

  • distributor: C'est lui qui reçoit en premier les métriques et qui va les distribuer
  • ingester: Reçoit les séries du distributor. Il les garde en mémoire dans une TSDB locale, puis upload régulièrement des blocs TSDB (de 2h) vers ton storage long terme
  • compactor: il récupère les blocs uploadés par les ingesters, les fusionne et les déduplique en blocs plus gros. Cela permet d'avoir de meilleures perfs quand tu consultes d'anciennes données, et de limiter leur stockage à long terme
  • querier, query-frontend et store-gateway: le chemin de lecture, indispensable pour requêter tes métriques depuis Grafana (le store-gateway lit les blocs stockés sur S3)


Configuration du compactor

Comme dit précédemment, ce sont les ingesters qui reçoivent les données en premier lieu, en mémoire. Une fois un bloc TSDB complet, ils l'envoient vers le storage long terme, comme un bucket AWS S3.

Le compactor télécharge ensuite ces blocs depuis le bucket, les fusionne et les déduplique, puis renvoie les blocs compactés sur S3. Il ne touche pas à la mémoire des ingesters.

Le compactor pour réaliser ce job, va télécharger dans son coin les blocs afin de les optimiser, et cette opération peut vite échouer. Alors assure toi de lui laisser assez d'espace disque pour réaliser ses opération dans son coin :

1
2
3
4
5
6
compactor = {
    persistentVolume = {
        enabled = true
        size = "50Gi"
    }
}

Long term storage des données

AWS S3 Bucket

Il te faut un service pour stocker tes données si tu souhaites garder tes métriques afin de pouvoir les requêter depuis Grafana sur des mois et des mois. Ici je te propose simple en utilisant le service AWS S3. Configurons les values du helm chart afin de forcer Mimir à utiliser un storage de type s3 :

mimir = {
    structuredConfig = {
        blocks_storage = {
            backend = "s3" // sans ça, Mimir reste sur le stockage filesystem par défaut
            s3 = {
                region      = "<mon_aws_region>"
                bucket_name = "<mon_bucket_name>"
                endpoint    = "s3.<mon_aws_region>.amazonaws.com"
            }
        }
    }
}

// Le chart déploie un MinIO par défaut : inutile avec S3
minio = {
    enabled = false
}

Note

Si tu utilise d'autre services de Mimir, tel que alertManager ou le ruler, assure toi de bien les configurer vers ton long term storage aussi

Occupons nous de la création du bucket qui va être utilisé par Mimir :

1
2
3
resource "aws_s3_bucket" "mimir_bucket" {
  bucket = "mimir-bucket"
}

Permissions

On va devoir donner des permissions à notre Mimir afin qu'il communique entre notre cluster Kubernetes et notre service AWS précedemment crée. Ici on souhaite éviter les traditionnels access key et secret key pour deux choses :

  • La première est que on préfère utiliser des short term credentials, question de sécurité via sts pour récupérer des tokens via un webidentityOIDC
  • On n'écrit aucun secrets dans le code. Preferrez d'utiliser des iam role binder avec des iam policy et des trust relationship

On va donc vouloir que le service account de Mimir puisse assumer un rôle, qui lui donnera le pleins droits pour accéder au bucket.

On commence par terraformer l'iam role qui serra assumé par le sercice account de Mimir.

resource "aws_iam_role" "mimir_role" {
  name = "mimir_role"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect = "Allow",
        Principal = {
          Federated = "arn:aws:iam::<mon_compte_aws_id>:oidc-provider/<mon_oidc_prodiver_url>"
        },
        Action = "sts:AssumeRoleWithWebIdentity",
        Condition = {
          StringEquals = {
            "<mon_oidc_prodiver_url>:sub" : "system:serviceaccount:<namespace_ou_run_mimir>:<mimir_nom_du_service_account>"
            "<mon_oidc_prodiver_url>:aud": "sts.amazonaws.com"
          }
        }
      }
    ]
  })
}

Celui-ci devra demander un token pour bien être authentifié et donc autorisé à avoir les autorisation suivante.

On continu ici par créer une policy, qui va être attaché au rôle prédent. Cette policy va décrire les accès que l'on va donner à Mimir

resource "aws_iam_role_policy" "mimir_policy" {
  name = "mimir_policy"
  role = aws_iam_role.mimir_role.id

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        "Effect" : "Allow",
        "Action" : [
            "s3:AbortMultipartUpload",
            "s3:DeleteObject",
            "s3:GetObject",
            "s3:ListMultipartUploadParts",
            "s3:PutObject",
            "s3:ListBucket"
        ],
        "Resource" : [
          "${aws_s3_bucket.mimir_bucket.arn}",
          "${aws_s3_bucket.mimir_bucket.arn}/*"
        ]
      }
    ]
  })
}

Mais celle-ci va aller encore plus loin, via l'attribut ressource, permettant de définir ces accès là à seulement le bucket que je souhaite stocker les données.

Une fois le role créer, on va l'attribuer à notre service account de Mimir comme suit :

1
2
3
4
5
6
7
serviceAccount = {
    create = true
    name   = "mon_service_account_name"
    annotations = {
        "eks.amazonaws.com/role-arn" = "${aws_iam_role.mimir_role.arn}"
    }
}

Arrivé ici, on devrait avoir une stack Grafana Mimir qui tourne bien sur Kubernetes. Celle-ci peut dès à présent recevoir des données, qu'elle ira stocker sur notre S3 Bucket via le role et ses autorisations données.

Data pipeline

On souhaite maintenant avoir un outils qui tourne sur notre cluster k8s qui permet de scrapper des metrics et de les envoyer à Mimir afin d'y être traiter. Il existe une multitude d'outils pour faire ça, je t'en montre deux (détaillés dans Vector et Prometheus en mode Agent) :

  • Vector.dev: Racheté par datadog, c'est le plus complet. Il est très facile d'utilisation, extrement performant face à la concurence, et permet de manipuler simplement nos données. Il a une multitude de datasource pour y ingérer des données en input, et une multitude de sink en sortie pour envoyer les données. On l'utilisera en priorité selon le type de source, mais aussi pour les pods, service et container déployé en mode replicaset, deployment, ou statefulset.
  • Prometheus: Le collecteur de référence (projet CNCF), dont Mimir reçoit nativement le remote_write. Il est cependant très gourmand. C'est pour cela que on va l'utiliser pour scrapper des metrics de pods, service et container déploye en mode daemonset uniquement

Vector

Configuration general

Je vais pas trop perdre de temps à présenter comment le déployer via ArgoCD, mais on utilise comme d'habitude le helm chart associé. Je te donne un example de configuration Vector en mode Aggregator. Ce mode donne un seul replicat. Le mode agent s'apparente à le deployer en daemonset, non utile dans notre cas.

role = "Aggregator"

Configuration sources

Je te propose ici un example simple, on imagine que l'on a un Kube-state-metrics qui tourne dans notre cluster, et qui expose ses métriques façon prometheus sur le port 8080, endpoint /metrics. On utilisera la configuration suivante pour récupérer les données :

customConfig = {
    sources = {
        prometheus = {
            endpoints = [
                "http://kube-state-metrics.<namespace_ou_run_ksm>.svc.cluster.local:8080/metrics"
            ],
            type                 = "prometheus_scrape"
            scrape_interval_secs = 60
        }
    }
}

Note

Ici je te montre comment scrapper un endpoint d'un service, mais regarde la doc de Vector.dev il existe un nombre monumental d'inputs de services différents !!

Configuration transforms

On peux utiliser un tas de transformation provenant de Vector permettant de manipuler les données, de les supprimer, modifier, ajouter, d'y effectuer toute sorte d'opération mathématique, ou de renomage ou de fonction simple pour y ajouter de la logique.

On pense à bien prendre en inputs la data source précedement crée :

customConfig = {
    transforms = {
        filter_example = {
            type      = "filter"
            inputs    = ["prometheus"]
            condition = "starts_with(string!(.name), \"kube_\")" // ne garde que les métriques kube_*
        }
        remap_example = {
            type   = "remap"
            inputs = ["filter_example"]
            source = ".tags.cluster = \"mon-cluster\"" // ajoute un label à chaque métrique
        }
    }
}

Configuration sinks

Une fois que l'on a manipulé, et épuré nos données à notre souhait, c'est l'étape finale de l'envoyer à Mimir via un sink :

customConfig = {
    sinks = {
        output_to_mimir = {
            type = "prometheus_remote_write"
            inputs = [
                "prometheus",
                //"filter_example",
                //"remap_example"
            ]
            endpoint = "http://mimir-distributed-nginx.<namespace_ou_run_ksm>.svc.cluster.local/api/v1/push"
            healthcheck = {
                enabled = false
            }
        }
    }
}

Warning

Pensez à bien désactiver le healthcheck, sinon ça ne marchera pas

Et voilà, nos données partent désormais bien vers Grafana Mimir d'un façon simple et surtout cost effective.

Prometheus

Dans cette example on va partir sur kube-prometheus-stack, qui comprends un opérateur pour installer et maintenir Prometheus.

On commence par quelques paramètres, notemment ici on ne souhaite pas self monitorer l'operateur

1
2
3
4
5
6
7
8
9
defaultRules = {
    create = false
}

prometheusOperator = {
    serviceMonitor = {
        selfMonitor = false
    }
}

Ce chart self monitor pas mal de services de base. Faisons simple et ne gardons que l'essentiel, je vais en desactiver quelques-uns :

kubernetesServiceMonitors = {
    enabled = true
}

alertmanager = {
    enabled = false
}

grafana = {
    enabled = false
}

kubeStateMetrics = {
    enabled = false
}

kubeApiServer = {
    enabled = false
}

kubeEtcd = {
    enabled = false
}

kubeScheduler = {
    enabled = false
}

nodeExporter = {
    enabled = false
}

kubeControllerManager = {
    enabled = false
}

coreDns = {
    enabled = false
}

kubeDns = {
    enabled = false
}

kubeProxy = {
    enabled = false
}

Petite astuces ici optionnel, pour ceux qui souhaitent avoir les metrics de cAdvisor, pas besoin d'installer le chart correspondant. En effet, une version tourne déjà sur les nodes via le kubelet. On peut le scrap comme ceci :

kubelet = {
    enabled = true
    serviceMonitor = {
        cAdvisor     = true
        probes       = false
        resource     = false
        resourcePath = "/metrics/resource"

        cAdvisorMetricRelabelings = [
            {
                sourceLabels = ["__name__"],
                regex        = "(metrics_1|metrics2|...)",
                action       = "keep"
            },
            {
                regex  = "(label_to_drop_1|label_to_drop_2|...)"
                action = "labeldrop"
            }
        ],
        metricRelabelings = [
            {
                sourceLabels = ["__metrics_path__"]
                regex        = "/metrics/cadvisor"
                action       = "keep"
            }
        ]
    }
}

Ici on ne garde que les metrics de cAdvisor, mais vous pouvez récuperer celles provenant des probes ou des ressources.

cAdvisorMetricRelabelings permet de manipuler les metrics. Ici j'y ais ajouté une rule permettant d'utiliser une regex pour n'en garder que quelques une, ou encore une autre regex me permettant de modifier certains label. metricRelabelings permet quand à lui de faire un second filtre, car ici on scrappe d'autres metrics de base en plus de celles de cAvisor. j'y ajoute une rule me permettant de ne garder que celle de cAdvisor.

Maintenant finissons par nous attaquer au plus important, à savoir envoyer nos données vers Grafana Mimir :

prometheus = {
    serviceMonitor = {
        selfMonitor = false
    }
    agentMode = true
    prometheusSpec = {
        replicaExternalLabelNameClear    = true
        prometheusExternalLabelNameClear = true
        scrapeInterval                   = "60s"
        remoteWrite = [
            {
                url = "http://mimir-distributed-nginx.<namespace>.svc.cluster.local/api/v1/push"
            }
        ]
    }
}

Tip

Le mode agent de prometheus est une optimisation à ne surtout pas louper. En effet cela permet de configurer et d'utiliser Prometheus en simple scrapper, permettant d'éviter d'avoir une database d'instancier pour stocker les métriques sur notre cluster, et donc une consomation de ressources plus conséquente et non utile dans notre cas. On l'utilise ici en tant que simple scrapper et forwarder de métriques.

Mais quid de si je veux envoyer mes données non pas directement vers Mimir, mais vouloir les envoyer dans un vector aggregator afin d'y effectuer des transformations plus poussées que celle effectués précédemment ? Change juste ton remoteWrite :

1
2
3
4
5
remoteWrite = [
    {
        url = "http://vector-aggregator-headless.<namespace>:9090"
    }
]

Et on récupère ces données depuis une data source dans Vector. Voici un example de configuration :

1
2
3
4
5
6
sources = {
    prometheus = {
        type = "prometheus_remote_write"
        address = "0.0.0.0:9090"
    }
}

Pour aller plus loin