Dashboards Grafana personnalisés via Kube-Prometheus-Stack

Avec cette approche, vos dashboards persistent lors d'un redéploiement de Grafana ou d'un déploiement vers un autre environnement ou cluster.

How-to-add-custom-Grafana-dashboards-in-code

Avec cette approche, vos dashboards persistent lors d'un redéploiement de Grafana ou d'un déploiement vers un autre environnement ou cluster

Prometheus s'est imposé comme l'outil de monitoring de référence : associé à Grafana et Alertmanager, il forme la stack complète d'observabilité et d'alerting de nombreuses organisations.

Gérer et déployer chacun de ces composants individuellement reste toutefois fastidieux et expose à des problèmes de synchronisation au fil de l'évolution de l'infrastructure. Grâce au chart Helm kube-prometheus-stack, maintenu par la prometheus-community, vous centralisez proprement la configuration de ces trois outils dans un seul fichier Helm values. Cet article détaille notre méthode pour ajouter des dashboards Grafana directement dans le chart Helm, afin que ceux-ci persistent même après un redéploiement de Grafana ou un déploiement vers un autre environnement ou cluster.

Prérequis

Première étape : cloner le dépôt contenant le chart Helm kube-prometheus-stack. Impossible en effet de stocker nos dashboards personnalisés en code si l'on récupère et applique le chart à distance ; cela n'est faisable qu'en appliquant le chart depuis une copie locale du code. Les outils suivants doivent également être installés sur nos postes de travail :

Git
Helm
Kubectl
L'IDE de votre choix

$ git clone https://github.com/prometheus-community/helm-charts.git
$ cd helm-charts/charts/kube-prometheus-stack

Une fois dans le dossier des charts, direction le dossier des dashboards Grafana, qui contient l'ensemble des dashboards livrés par défaut.

$ cd templates/grafana/dashboards-1.14/
$ ls
alertmanager-overview.yaml	   grafana-overview.yaml
k8s-resources-pod.yaml		   namespace-by-workload.yaml
pod-total.yaml			   statefulset.yaml
apiserver.yaml			   k8s-coredns.yaml
k8s-resources-workload.yaml	   node-cluster-rsrc-use.yaml

Comme vous pouvez le constater, l'installation de Grafana embarque de nombreux dashboards. Ils sont déployés depuis ce répertoire via les templates de configmaps qu'il contient.

Exporter notre dashboard personnalisé

Une fois le dashboard personnalisé créé et enregistré dans Grafana, il nous faut exporter le json à intégrer dans notre configmap à l'étape suivante. Cliquez sur la roue dentée des paramètres de votre dashboard, puis sélectionnez JSON Model dans le panneau de gauche. Il ne reste plus qu'à copier le json et le conserver pour la suite :

graphana-dashboards

Ajouter notre dashboard personnalisé

Nous pouvons à présent ajouter notre propre template Helm de configmap au dossier dashboards. Le plus simple consiste à dupliquer l'un des fichiers yaml existants, à le renommer d'après votre dashboard et à y intégrer le json. Dans mon exemple, ce sera time-series-graph.yaml, en référence à mon dashboard personnalisé ci-dessus. Place maintenant à la modification du template. Pour commencer, nous supprimons le commentaire en début de fichier — cette partie :

{{- /*
Generated from 'alertmanager-overview' from https://raw.githubusercontent.com/prometheus-operator/kube-prometheus/main/manifests/grafana-dashboardDefinitions.yaml
Do not change in-place! In order to change this file first read following link:
https://github.com/prometheus-community/Helm-charts/tree/main/charts/kube-prometheus-stack/hack
*/ -}}

Ensuite, nous mettons à jour le nom de notre ConfigMap à plusieurs endroits — d'abord ici :

apiVersion: v1
kind: ConfigMap
metadata:
  namespace: {{ template "kube-prometheus-stack-grafana.namespace" . }}
  name: {{ printf "%s-%s" (include "kube-prometheus-stack.fullname" $) "alertmanager-overview" | trunc 63 | trimSuffix "-" }}

Je vais remplacer alertmanager-overview, dont est issu le template d'origine, par time-series-graphs pour correspondre au nom de mon dashboard et de mon fichier yaml :

apiVersion: v1
kind: ConfigMap
metadata:
  namespace: {{ template "kube-prometheus-stack-grafana.namespace" . }}
  name: {{ printf "%s-%s" (include "kube-prometheus-stack.fullname" $) "time-series-graph" | trunc 63 | trimSuffix "-" }}

Puis nous modifions le nom de la section data du template configmap comme ci-dessous :

data:
  alertmanager-overview.json: |-

devient

data:
  time-series-graph.json: |-

Nous remplaçons enfin le JSON du dashboard existant par celui copié depuis les paramètres du dashboard Grafana, directement sous cette ligne, comme ci-dessous, en veillant à indenter l'intégralité du json d'au moins une tabulation :

data:
  time-series-graphs.json: |-
    {
        "__inputs": [\
\
        ],
        "__requires": [\
\
        ],
        "annotations": {
            "list": [\
\
            ]
        },
        "editable": false,
        "gnetId": null,
        "graphTooltip": 1,
        "hideControls": false,
        "id": null,
        "links": [\
\
        ],
        "refresh": "30s",
        "rows": [\
...\
```\
\

Générer les templates Helm rendus\

Maintenant que le fichier yaml du template Helm de configmap du dashboard est en place, vérifions quels manifestes yaml sont générés à partir du chart Helm pour confirmer que la ConfigMap de notre dashboard a bien été produite :
\

# Ajouter à Helm les dépôts des charts dont nous avons besoin\
$ Helm repo add grafana https://grafana.github.io/Helm-charts\
\
$ Helm repo add prometheus-community https://prometheus-community.github.io/Helm-charts\
\
# Récupérer toutes les dépendances des charts et mettre à jour\
$ Helm dependency build\
\
$ Helm repo update\
```\
\
Nous pouvons à présent exécuter la commande Helm template pour générer les manifestes yaml à partir de nos templates Helm et les enregistrer dans un fichier en vue d'une vérification ultérieure. Le flag —validate sert à confirmer que nos manifestes Kubernetes yaml sont valides au regard du contexte actuel du cluster Kubernetes :\
\
```\
$ Helm template kube-prometheus-stack . --validate > rendered-template.yaml\
```\
\
Nous inspectons ensuite le fichier rendered-template.yaml pour vérifier que notre ConfigMap a bien été créée et qu'elle sera appliquée lors de l'exécution de la commande Helm install à l'étape suivante :\
\
```\
$ cat rendered-template.yaml\
…\
---\
# Source: kube-prometheus-stack/templates/grafana/dashboards-1.14/time-series-graphs.yaml\
apiVersion: v1\
kind: ConfigMap\
metadata:\
  namespace: default\
  name: kube-prometheus-stack-time-series-graphs\
  annotations:\
    {}\
  labels:\
    grafana_dashboard: "1"\
    app: kube-prometheus-stack-grafana\
    app.kubernetes.io/managed-by: Helm\
    app.kubernetes.io/instance: kube-prometheus-stack\
    app.kubernetes.io/version: "32.2.1"\
    app.kubernetes.io/part-of: kube-prometheus-stack\
    chart: kube-prometheus-stack-32.2.1\
    release: "kube-prometheus-stack"\
    heritage: "Helm"\
data:\
  time-series-graphs.json: |-\
    {\
      "annotations": {\
        "enable": false,\
        "list": [\
          {\
            "builtIn": 1,\
            "datasource": "-- Grafana --",\
            "enable": true,\
            "hide": true,\
            "iconColor": "rgba(0, 211, 255, 1)",\
            "name": "Annotations & Alerts",\
```\
\
Une recherche rapide de *time-series* dans le fichier confirme que la ConfigMap a bien été créée et que la section data contient le json du dashboard ajouté précédemment.\
\
Il ne reste qu'à appliquer le chart Helm à notre cluster Kubernetes ; une fois Grafana opérationnel, nous pouvons vérifier que le dashboard est bien présent :\
\
```\
$ Helm install kube-prometheus-stack .\
```\
\
![graphana-dashboards](https://media.doit.com/imports/wordpress/2022/04/f4aa0c1fd59e-graphana-dashboards.jpg)\
\