Un Talos européen de qualité - Part VII - Métriques

part-07

Objectif 🎯

La mise en place des backups et base de données étant faite, il nous manque les derniers composants critiques d’un cluster de production, à savoir tout ce qui concerne l’observabilité à tous les niveaux, à savoir le triptyque métriques, logging, et traçabilité.

Networking

Cilium fourni déjà son propre outil d’observabilité réseau temps réel, que l’on a déjà installé à l’étape 3.

Pour Cilium il s’agit de Hubble, accessible sur https://hubble.dev.ohmytalos.io, son outil de visualisation eBPF, très utile pour visualiser les interactions réseau entre les composants. Exemple sur le namespace CrowdSec :

Cilium Hubble

Métriques 📊

Sur l’ensemble des charts helm préalablement installés, nous nous sommes assurés d’activer tous les ServiceMonitor afin que Prometheus puisse aller scraper les métriques exposées par tous les composants critiques du système sans que l’on ait à définir de configuration supplémentaire. Il nous reste plus qu’à installer un cluster Prometheus, de préférence sur nos nœuds de storage.

L’architecture de la stack Prometheus :

Schéma prometheus

1
module "kube_monitoring" {
2
  source = "../../modules/kube/monitoring"
3

4
  internal_domain = local.internal_domain
5
  control_planes_ips = [
6
    for s in data.hcloud_servers.control_planes.servers : tolist(s.network)[0].ip
7
  ]
8

9
  smtp_host = "smtp.tem.scaleway.com:465"
10

11
  alertmanager_smtp_username = var.alertmanager_smtp_username
12
  alertmanager_smtp_password = var.alertmanager_smtp_password
13
  alertmanager_from          = "prom.dev@ohmytalos.io"
14
  alertmanager_to            = "me@ohmytalos.io"
15
}

Explanation

Afin de scraper les métriques des composants centraux du kubernetes, notamment l’etcd, le scheduler ainsi que le controller manager, nous avons besoin d’envoyer au chart prometheus les IPs privées des nœuds de control plane. Nous utilisons donc la data source hcloud_servers déjà déclaré lors du chapitre sur l’ingress pour récupérer ces informations dynamiquement.

Nous configurons également les informations nécessaires pour qu’Alertmanager puisse envoyer des notifications par email via SMTP.

1
// ...
2

3
variable "internal_domain" {
4
  description = "The internal domain to use for the cluster"
5
  type        = string
6
}
7

8
variable "control_planes_ips" {
9
  description = "List of control plane IPs"
10
  type        = list(string)
11
}
12

13
variable "smtp_host" {
14
  description = "The SMTP host"
15
  type        = string
16
}
17

18
variable "alertmanager_smtp_username" {
19
  description = "The SMTP username for Alertmanager"
20
  type        = string
21
}
22

23
variable "alertmanager_smtp_password" {
24
  description = "The SMTP password for Alertmanager"
25
  type        = string
26
  sensitive   = true
27
}
28

29
variable "alertmanager_from" {
30
  description = "The email address to send Alertmanager notifications from"
31
  type        = string
32
}
33

34
variable "alertmanager_to" {
35
  description = "The email address to send Alertmanager notifications to"
36
  type        = string
37
}

1
// ...
2

3
variable "alertmanager_smtp_username" {
4
  type = string
5
}
6

7
variable "alertmanager_smtp_password" {
8
  type      = string
9
  sensitive = true
10
}

# ...

export TF_VAR_alertmanager_smtp_username=$(bw_field username alertmanager_smtp)
export TF_VAR_alertmanager_smtp_password=$(bw_field password alertmanager_smtp)

1
resource "kubernetes_namespace_v1" "monitoring" {
2
  metadata {
3
    name = "monitoring"
4
    labels = {
5
      "pod-security.kubernetes.io/enforce" = "privileged"
6
    }
7
  }
8
}
9

10
resource "helm_release" "prometheus" {
11
  repository = "https://prometheus-community.github.io/helm-charts"
12
  chart      = "kube-prometheus-stack"
13
  version    = "81.2.2"
14

15
  name        = "prometheus"
16
  namespace   = kubernetes_namespace_v1.monitoring.metadata[0].name
17
  max_history = 2
18

19
  set = [
20
    {
21
      name  = "prometheus.prometheusSpec.serviceMonitorSelectorNilUsesHelmValues"
22
      value = "false"
23
    },
24
    {
25
      name  = "prometheus.prometheusSpec.podMonitorSelectorNilUsesHelmValues"
26
      value = "false"
27
    },
28
    {
29
      name  = "grafana.enabled"
30
      value = "false"
31
    },
32
    {
33
      name  = "grafana.forceDeployDatasources"
34
      value = "true"
35
    },
36
    {
37
      name  = "grafana.forceDeployDashboards"
38
      value = "true"
39
    },
40
    {
41
      name  = "kubeProxy.enabled"
42
      value = "false"
43
    },
44
    {
45
      name  = "crds.enabled"
46
      value = "false"
47
    },
48
    {
49
      name  = "prometheus.prometheusSpec.replicas"
50
      value = "2"
51
    },
52
    {
53
      name  = "prometheus.prometheusSpec.enableRemoteWriteReceiver"
54
      value = "true"
55
    },
56
    {
57
      name  = "prometheus.prometheusSpec.enableOTLPReceiver"
58
      value = "true"
59
    },
60
    {
61
      name  = "prometheus.prometheusSpec.remoteWriteDashboards"
62
      value = "true"
63
    },
64
    {
65
      name  = "prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.accessModes[0]"
66
      value = "ReadWriteOnce"
67
    },
68
    {
69
      name  = "prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.resources.requests.storage"
70
      value = "20Gi"
71
    },
72
    {
73
      name  = "prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.storageClassName"
74
      value = "longhorn-crypto-local"
75
    },
76
    {
77
      name  = "prometheus.prometheusSpec.tolerations[0].key"
78
      value = "node-role.kubernetes.io/storage"
79
    },
80
    {
81
      name  = "prometheus.prometheusSpec.tolerations[0].operator"
82
      value = "Exists"
83
    },
84
    {
85
      name  = "prometheus.prometheusSpec.nodeSelector.node\\.kubernetes\\.io/role"
86
      value = "storage"
87
    },
88
    {
89
      name  = "prometheus.prometheusSpec.externalUrl"
90
      value = "https://prom.${var.internal_domain}"
91
    },
92
    {
93
      name  = "alertmanager.alertmanagerSpec.replicas"
94
      value = "2"
95
    },
96
    {
97
      name  = "alertmanager.alertmanagerSpec.storage.volumeClaimTemplate.spec.accessModes[0]"
98
      value = "ReadWriteOnce"
99
    },
100
    {
101
      name  = "alertmanager.alertmanagerSpec.storage.volumeClaimTemplate.spec.resources.requests.storage"
102
      value = "2Gi"
103
    },
104
    {
105
      name  = "alertmanager.alertmanagerSpec.storage.volumeClaimTemplate.spec.storageClassName"
106
      value = "longhorn-crypto"
107
    },
108
    {
109
      name  = "alertmanager.alertmanagerSpec.externalUrl"
110
      value = "https://am.${var.internal_domain}"
111
    },
112
    {
113
      name  = "grafana.sidecar.datasources.exemplarTraceIdDestinations.datasourceUid"
114
      value = "tempo"
115
    },
116
    {
117
      name  = "grafana.sidecar.datasources.exemplarTraceIdDestinations.traceIdLabelName"
118
      value = "trace_id"
119
    },
120
    {
121
      name  = "grafana.sidecar.datasources.exemplarTraceIdDestinations.urlDisplayLabel"
122
      value = "View traces"
123
    }
124
  ]
125

126
  set_list = [
127
    {
128
      name  = "kubeControllerManager.endpoints"
129
      value = var.control_planes_ips
130
    },
131
    {
132
      name  = "kubeScheduler.endpoints"
133
      value = var.control_planes_ips
134
    },
135
    {
136
      name  = "kubeEtcd.endpoints"
137
      value = var.control_planes_ips
138
    },
139
    {
140
      name = "prometheus.prometheusSpec.otlp.promoteResourceAttributes"
141
      value = [
142
        "service.instance.id",
143
        "service.name",
144
      ]
145
    },
146
    {
147
      name = "prometheus.prometheusSpec.enableFeatures"
148
      value = [
149
        "exemplar-storage",
150
      ]
151
    }
152
  ]
153
}
154

155
resource "kubernetes_manifest" "traefik_ingress_route_prometheus" {
156
  manifest = {
157
    apiVersion = "traefik.io/v1alpha1"
158
    kind       = "IngressRoute"
159
    metadata = {
160
      name      = "prometheus"
161
      namespace = kubernetes_namespace_v1.monitoring.metadata[0].name
162
    }
163
    spec = {
164
      entryPoints = ["internal"]
165
      routes = [
166
        {
167
          match = "Host(`prom.${var.internal_domain}`)"
168
          kind  = "Rule"
169
          middlewares = [
170
            {
171
              name      = "internal-basic-auth"
172
              namespace = "traefik"
173
            }
174
          ]
175
          services = [
176
            {
177
              name = "prometheus-operated"
178
              port = "http-web"
179
            }
180
          ]
181
        }
182
      ]
183
    }
184
  }
185
}
186

187
resource "kubernetes_manifest" "traefik_ingress_route_alertmanager" {
188
  manifest = {
189
    apiVersion = "traefik.io/v1alpha1"
190
    kind       = "IngressRoute"
191
    metadata = {
192
      name      = "alertmanager"
193
      namespace = kubernetes_namespace_v1.monitoring.metadata[0].name
194
    }
195
    spec = {
196
      entryPoints = ["internal"]
197
      routes = [
198
        {
199
          match = "Host(`am.${var.internal_domain}`)"
200
          kind  = "Rule"
201
          middlewares = [
202
            {
203
              name      = "internal-basic-auth"
204
              namespace = "traefik"
205
            }
206
          ]
207
          services = [
208
            {
209
              name = "alertmanager-operated"
210
              port = "http-web"
211
            }
212
          ]
213
        }
214
      ]
215
    }
216
  }
217
}
218

219
resource "kubernetes_secret_v1" "alertmanager_smtp" {
220
  metadata {
221
    name      = "alertmanager-smtp"
222
    namespace = kubernetes_namespace_v1.monitoring.metadata[0].name
223
  }
224

225
  data = {
226
    password = var.alertmanager_smtp_password
227
  }
228
}
229

230
resource "kubernetes_manifest" "alertmanager_config_email" {
231
  manifest = {
232
    apiVersion = "monitoring.coreos.com/v1alpha1"
233
    kind       = "AlertmanagerConfig"
234
    metadata = {
235
      name      = "email"
236
      namespace = kubernetes_namespace_v1.monitoring.metadata[0].name
237
    }
238
    spec = {
239
      receivers = [
240
        {
241
          emailConfigs = [
242
            {
243
              authUsername = var.alertmanager_smtp_username
244
              authPassword = {
245
                key  = "password"
246
                name = kubernetes_secret_v1.alertmanager_smtp.metadata[0].name
247
              }
248
              smarthost    = var.smtp_host
249
              from         = var.alertmanager_from
250
              to           = var.alertmanager_to
251
              sendResolved = true
252
              requireTLS   = false
253
            }
254
          ]
255
          name = "email-notifications"
256
        }
257
      ]
258
      route = {
259
        matchers = [
260
          {
261
            matchType = "="
262
            name      = "severity"
263
            value     = "critical"
264
          }
265
        ]
266
        receiver = "email-notifications"
267
      }
268
    }
269
  }
270
}

Explanation

Nous configurons le chart helm pour qu’il utilise des ServiceMonitor et PodMonitor afin de scraper automatiquement les métriques exposées par les composants du cluster.

Le composant kubeProxy étant remplacé par cilium, penser à le désactiver. Le chart déploiera également un subchart node-exporter qui sera en charge de déployer des DaemonSets sur chaque nœud pour récupérer leurs métriques.

Ce chart étant suffisamment lourd comme ça, nous désactivons Grafana car je préfère l’installer séparément plus tard. Mais nous forçons le déploiement des dashboards pour kubernetes par défaut qui sont déjà très complets afin de les récupérer au moment de l’installation de Grafana.

On configure 2 replicas de prometheus que l’on dispatche sur les nœuds de stockage via des tolerations et nodeSelector. Nous configurons également le stockage persistant en localité stricte sur Longhorn.

Quant à Alertmanager, nous le déployons en mode cluster 2 réplicas, avec une persistence StorageClass longhorn-crypto uniquement. Pas besoin de haute perfo pour ça et cela permet de rester flexible sur l’emplacement des instances alertmanager.

Nous activons les récepteurs enableRemoteWriteReceiver et enableOTLPReceiver qui nous servirons plus tard, particulièrement dans la corrélation avec les traces et logs. Autre détail du fait de l’utilisation de OTLP, on anticipe de préconfigurer exemplarTraceIdDestinations au niveau de la datasource prometheus Grafana, ceci nous permettra de lier les exemplars (sorte de références événementielles) aux futures traces générées par tempo. À ce titre, il est nécessaire d’activer la feature exemplar-storage pour stocker ce type de structure. Enfin configurer promoteResourceAttributes pour promouvoir quelques attributs de ressource OTLP en tant qu’étiquettes Prometheus.

Nous créons les routes d’ingress Traefik pour accéder à Prometheus et Alertmanager via des sous-domaines internes sécurisés par une authentification basique. Adapter les valeurs externalUrl dans le chart helm pour générer les bonnes URLs dans les alertes.

Enfin, nous créons une nouvelle ressource AlertmanagerConfig pour envoyer des notifications par email via SMTP. Ce sera l’alerte par défaut pour toutes les alertes de sévérité critical. Libre à vous de rajouter d’autres récepteurs et routes selon vos besoins.

Déployer tout ça et aller sur l’interface web de Prometheus via https://prom.dev.ohmytalos.io.

Prometheus Dashboard

Le plus intéressant dans l’immédiat est d’aller voir dans la section Targets pour vérifier que tous les endpoints sont bien scrappés, tout devrait déjà être à UP.

Prometheus Targets

Faites également un tour sur https://am.dev.ohmytalos.io (attention pas de dark mode !) et allez dans l’onglet Status pour vérifier que le mode cluster est bien actif et que l’alerte email est bien appliquée dans la partie configuration.

Testons le bon fonctionnement des alertes en créant une règle prometheus fake et lancer kaf test-alert.yaml pour l’appliquer :

1
apiVersion: monitoring.coreos.com/v1
2
kind: PrometheusRule
3
metadata:
4
  name: test-alert
5
  namespace: monitoring
6
  labels:
7
    app: kube-prometheus-stack
8
    release: prometheus
9
spec:
10
  groups:
11
    - name: test.rules
12
      rules:
13
        - alert: TestCriticalAlert
14
          expr: vector(1)
15
          for: 1m
16
          labels:
17
            namespace: monitoring
18
            severity: critical
19
          annotations:
20
            summary: "Test alert for email notification"

Après quelques instants, vous devriez voir l’alerte apparaître dans Prometheus, onglet Alerts, qui liste l’ensemble des règles Prometheus actives, avec un état Pending.

Prometheus Alerts Pending

C’est le mode intermédiaire avant que l’alerte ne soit déclenchée, ce qui se produit lorsque la condition de la règle est vraie pendant toute la durée spécifiée dans le champ for. Dans notre cas, la condition est toujours juste puisque l’expression vector(1) renvoie toujours 1, et la durée est fixée à 1 minute.

Passé ce délai, l’alerte passera à l’état Firing.

Prometheus Alerts Firing

Vous devriez la voir apparaître dans Alertmanager, groupé dans monitoring/email/email-notifications, confirmant que l’alerte est bien passé dans la bonne route et le bon receiver.

Alertmanager Alerts

Si votre SMTP est bien configuré, vous devriez recevoir un email d’alerte dans votre boîte de réception, avec les bonnes URLs configurées, grâce aux paramètres externalUrl.

Alertmanager Email

Supprimer l’alerte fake via kdel -f test-alert.yaml.

Dashboard 📈

Bien que Prometheus fournisse des fonctionnalités pour la visualisation des métriques, cela reste pour une utilisation avancée nécessitant des connaissances en PromQL. Pour une expérience plus riche et interactive, nous allons installer Grafana, l’outil dataviz de prédilection pour la visualisation de tous types de métriques.

Bien que Grafana soit inclus dans le chart kube-prometheus-stack (en tant que subchart), ce dernier est de base extrêmement lourd à installer et à configurer, et y inclure Grafana ne ferait que nous faire perdre notre temps. Je préfère donc le gérer séparément pour plus de flexibilité en termes de mise à jour.

1
module "kube_monitoring" {
2
  // ...
3

4
  grafana_smtp_username = var.grafana_smtp_username
5
  grafana_smtp_password = var.grafana_smtp_password
6
  grafana_from          = "grafana.dev@ohmytalos.io"
7

8
  grafana_dashboards = {
9
    traefik = {
10
      gnetId   = 17347
11
      revision = 9
12
    },
13
    longhorn = {
14
      gnetId   = 16888
15
      revision = 9
16
    },
17
    crowdsec = {
18
      url        = "https://raw.githubusercontent.com/crowdsecurity/grafana-dashboards/master/dashboards_v5/Crowdsec%20Overview.json"
19
      datasource = "prometheus"
20
    }
21
  }
22
}

Explanation

Rien de bien particulier à part la configuration du SMTP pour l’envoi de notifications par email.

Nous rajoutons quelques dashboards additionnels pour Traefik, Longhorn, et Crowdsec. Libre à vous d’en ajouter d’autres selon vos besoins. Les ids et les révisions peuvent être récupérés sur le site de Grafana Labs.

1
// ...
2

3
variable "grafana_smtp_username" {
4
  type = string
5
}
6

7
variable "grafana_smtp_password" {
8
  type      = string
9
  sensitive = true
10
}

# ...

export TF_VAR_grafana_smtp_username=$(bw_field username grafana_smtp)
export TF_VAR_grafana_smtp_password=$(bw_field password grafana_smtp)

1
// ...
2

3
variable "grafana_smtp_username" {
4
  description = "The SMTP username for Grafana"
5
  type        = string
6
}
7

8
variable "grafana_smtp_password" {
9
  description = "The SMTP password for Grafana"
10
  type        = string
11
  sensitive   = true
12
}
13

14
variable "grafana_from" {
15
  description = "The email address to send Grafana notifications from"
16
  type        = string
17
}
18

19
variable "grafana_dashboards" {
20
  description = "Additional Grafana dashboards"
21
  type = map(object({
22
    gnetId     = optional(number)
23
    revision   = optional(number)
24
    url        = optional(string)
25
    datasource = optional(string)
26
  }))
27
  default = {}
28
}

1
resource "kubernetes_namespace_v1" "grafana" {
2
  metadata {
3
    name = "grafana"
4
  }
5
}
6

7
resource "kubernetes_secret_v1" "grafana_smtp" {
8
  metadata {
9
    name      = "grafana-smtp"
10
    namespace = kubernetes_namespace_v1.grafana.metadata[0].name
11
  }
12

13
  data = {
14
    user     = var.grafana_smtp_username
15
    password = var.grafana_smtp_password
16
  }
17
}
18

19
resource "helm_release" "grafana" {
20
  repository = "https://grafana.github.io/helm-charts"
21
  chart      = "grafana"
22
  version    = "10.5.12"
23

24
  name        = "grafana"
25
  namespace   = kubernetes_namespace_v1.grafana.metadata[0].name
26
  max_history = 2
27

28
  set = concat([
29
    {
30
      name  = "smtp.existingSecret"
31
      value = kubernetes_secret_v1.grafana_smtp.metadata[0].name
32
    },
33
    {
34
      name  = "grafana\\.ini.smtp.enabled"
35
      value = "true"
36
    },
37
    {
38
      name  = "grafana\\.ini.smtp.host"
39
      value = var.smtp_host
40
    },
41
    {
42
      name  = "grafana\\.ini.smtp.from_address"
43
      value = var.grafana_from
44
    },
45
    {
46
      name  = "grafana\\.ini.server.domain"
47
      value = "grafana.${var.internal_domain}"
48
    },
49
    {
50
      name  = "persistence.enabled"
51
      value = "true"
52
    },
53
    {
54
      name  = "persistence.storageClassName"
55
      value = "longhorn-crypto"
56
    },
57
    {
58
      name  = "persistence.size"
59
      value = "2Gi"
60
    },
61
    {
62
      name  = "sidecar.dashboards.searchNamespace"
63
      value = "ALL"
64
    },
65
    {
66
      name  = "sidecar.datasources.searchNamespace"
67
      value = "ALL"
68
    },
69
    {
70
      name  = "deploymentStrategy.type"
71
      value = "Recreate"
72
    },
73
    {
74
      name  = "serviceMonitor.enabled"
75
      value = "true"
76
    },
77
    {
78
      name  = "sidecar.alerts.enabled"
79
      value = "true"
80
    },
81
    {
82
      name  = "sidecar.dashboards.enabled"
83
      value = "true"
84
    },
85
    {
86
      name  = "sidecar.datasources.enabled"
87
      value = "true"
88
    },
89
    ], flatten([
90
      for service, attrs in var.grafana_dashboards : [
91
        for key, value in attrs : {
92
          name  = "dashboards.default.${service}.${key}"
93
          value = value
94
        }
95
      ]
96
  ]))
97

98
  values = [yamlencode({
99
    dashboardProviders = {
100
      "dashboardproviders.yaml" = {
101
        apiVersion = 1
102
        providers = [
103
          {
104
            name            = "default"
105
            orgId           = 1
106
            folder          = ""
107
            type            = "file"
108
            disableDeletion = false
109
            editable        = false
110
            options = {
111
              path = "/var/lib/grafana/dashboards/default"
112
            }
113
          }
114
        ]
115
      }
116
    }
117
  })]
118
}
119

120
resource "kubernetes_manifest" "traefik_ingress_route_grafana" {
121
  manifest = {
122
    apiVersion = "traefik.io/v1alpha1"
123
    kind       = "IngressRoute"
124
    metadata = {
125
      name      = "grafana"
126
      namespace = kubernetes_namespace_v1.grafana.metadata[0].name
127
    }
128
    spec = {
129
      entryPoints = ["internal"]
130
      routes = [
131
        {
132
          match = "Host(`grafana.${var.internal_domain}`)"
133
          kind  = "Rule"
134
          services = [
135
            {
136
              name = "grafana"
137
              port = "service"
138
            }
139
          ]
140
        }
141
      ]
142
    }
143
  }
144
}

Explanation

Niveau persistance rien de spécial, on reste sur un simple Deployment à replica unique, un simple longhorn-crypto suffit.

La configuration principale de Grafana passe par grafana.ini, que l’on utilise notamment pour la section SMTP.

La particularité de chaque Pod d’instance Grafana est d’inclure tout un tas de sidecars tous en charge de monter et fournir automatiquement dans Grafana divers types de ressources à partir de ConfigMap :

Un sidecar pour les dashboards.
Un sidecar pour les datasources, utilisés pour se connecter à divers backend tel que Prometheus, Loki, Tempo, etc.
Un sidecar pour les alertes. Pas de rapport avec Alertmanager, il s’agit d’alertes propres à Grafana, qui peuvent être complémentaires. Adapté pour des alertes secondaires avec une UI simple pour les créer. Pour les principales alertes infra, il vaut mieux privilégier Alertmanager, dédié pour cela et bien plus léger et résilient.

Nous activons tous les sidecars et configurons leur searchNamespace à ALL pour qu’ils puissent détecter les ConfigMap dans tous les namespaces.

Enfin le Pod du chart inclus un init conteneur download-dashboards qui permet de télécharger des dashboards depuis des référentiels distants avant démarrage du conteneur. Ceci nous évite de se trimballer avec des gros ConfigMap de json dashboards localement.

C’est ce conteneur qui téléchargera nos dashboards définis en amont. Ils seront inclus dans le fichier monté localement /var/lib/grafana/dashboards/default (selon la clé choisie). Il reste donc à définir dans dashboardProviders la source de ce fichier pour que l’import soit effectif.

Dans le ingress pas besoin de rajouter l’authentification, Grafana étant déjà protégé par son propre système d’authentification.

On déploie comme d’habitude et aller sur https://grafana.dev.ohmytalos.io et loguez-vous via le compte admin. Utiliser kgsec -n grafana -o yaml grafana | yq -r '.data."admin-password"' | base64 -d pour récupérer le mot de passe admin autogénéré. Allez dans la section dashboards :

Grafana Dashboards

Vous y trouverez plein de dashboards déjà inclus :

Ceux de Kubernetes, fournis par le chart kube-prometheus-stack.
Ceux de Cilium, qui inclus ses propres charts
Ceux de CloudNativePG
Ceux additionnels téléchargés via le sidecar download-dashboards.

Dashboards Kubernetes

etcd

Dashboards Ressources

Compute Cluster

Dashboards additionnels

Cilium

Conclusion

Nous voilà déjà avec tout plein de dashboards. La partie métrique et dataviz étant vue, il nous reste la collecte des logs et traces, des données assez massives à collecter. Suite dans la section suivante.