Un Talos européen de qualité - Part VIII - Logs & Traces

part-08

Objectif 🎯

Nous avons vu la partie métrique précédemment, et il est temps de s’attaquer au logging et à la traçabilité. Nous allons commencer par installer les backends de stockage Loki pour les logs et Tempo pour les traces, tout 2 en mode distribué, puis nous verrons comment collecter efficacement ces données avec Alloy.

Voici le résultat attendu en terme d’architecture de la stack de télémétrie, en excluant la partie métrique déjà vue :

Schéma Télémétrie

Backends de stockage 🗄️

Logging 📇

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

4
  loki_s3_endpoint   = "https://${local.s3_endpoint}"
5
  loki_s3_region     = local.s3_region
6
  loki_s3_bucket     = local.cluster_name
7
  loki_s3_access_key = var.loki_s3_username
8
  loki_s3_secret_key = var.loki_s3_password
9
}

Explanation

Pour le stockage des logs long terme, Loki a besoin d’un stockage S3.

1
// ...
2

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

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

# ...

export TF_VAR_loki_s3_username=$(bw_field username loki_s3)
export TF_VAR_loki_s3_password=$(bw_field password loki_s3)

1
// ...
2

3
variable "loki_s3_endpoint" {
4
  description = "The endpoint of the S3 compatible storage"
5
  type        = string
6
}
7

8
variable "loki_s3_access_key" {
9
  description = "The access key for the S3 compatible storage"
10
  type        = string
11
}
12

13
variable "loki_s3_secret_key" {
14
  description = "The secret key for the S3 compatible storage"
15
  type        = string
16
  sensitive   = true
17
}
18

19
variable "loki_s3_region" {
20
  description = "The region of the S3 compatible storage"
21
  type        = string
22
}
23

24
variable "loki_s3_bucket" {
25
  description = "The bucket of the S3 compatible storage"
26
  type        = string
27
}
28

29
variable "loki_retention_period" {
30
  type    = string
31
  default = "744h"
32
}

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

10
resource "helm_release" "loki" {
11
  repository = "https://grafana.github.io/helm-charts"
12
  chart      = "loki"
13
  version    = "6.51.0"
14

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

19
  set = [
20
    {
21
      name  = "loki.storage.bucketNames.chunks"
22
      value = var.loki_s3_bucket
23
    },
24
    {
25
      name  = "loki.storage.bucketNames.ruler"
26
      value = var.loki_s3_bucket
27
    },
28
    {
29
      name  = "loki.storage.bucketNames.admin"
30
      value = var.loki_s3_bucket
31
    },
32
    {
33
      name  = "loki.storage.s3.endpoint"
34
      value = var.loki_s3_endpoint
35
    },
36
    {
37
      name  = "loki.storage.s3.region"
38
      value = var.loki_s3_region
39
    },
40
    {
41
      name  = "loki.storage.s3.accessKeyId"
42
      value = var.loki_s3_access_key
43
    },
44
    {
45
      name  = "chunksCache.allocatedMemory"
46
      value = 512
47
    },
48
    {
49
      name  = "resultsCache.allocatedMemory"
50
      value = 256
51
    },
52
    {
53
      name  = "lokiCanary.enabled"
54
      value = "false"
55
    },
56
    {
57
      name  = "test.enabled"
58
      value = "false"
59
    },
60
    {
61
      name  = "monitoring.dashboards.enabled"
62
      value = "true"
63
    },
64
    {
65
      name  = "monitoring.serviceMonitor.enabled"
66
      value = "true"
67
    },
68
    {
69
      name  = "read.replicas"
70
      value = "1"
71
    },
72
    {
73
      name  = "backend.replicas"
74
      value = "1"
75
    },
76
    {
77
      name  = "backend.persistence.storageClass"
78
      value = "longhorn-crypto"
79
    },
80
    {
81
      name  = "backend.persistence.size"
82
      value = "2Gi"
83
    },
84
    {
85
      name  = "write.replicas"
86
      value = "2"
87
    },
88
    {
89
      name  = "write.persistence.storageClass"
90
      value = "longhorn-crypto-local"
91
    },
92
    {
93
      name  = "write.persistence.size"
94
      value = "2Gi"
95
    },
96
    {
97
      name  = "write.tolerations[0].key"
98
      value = "node-role.kubernetes.io/storage"
99
    },
100
    {
101
      name  = "write.tolerations[0].operator"
102
      value = "Exists"
103
    },
104
    {
105
      name  = "write.nodeSelector.node\\.kubernetes\\.io/role"
106
      value = "storage"
107
    }
108
  ]
109

110
  set_sensitive = [
111
    {
112
      name  = "loki.storage.s3.secretAccessKey"
113
      value = var.loki_s3_secret_key
114
    }
115
  ]
116

117
  values = [
118
    yamlencode({
119
      loki = {
120
        structuredConfig = {
121
          auth_enabled = false
122
          limits_config = {
123
            retention_period = var.loki_retention_period
124
          }
125
          compactor = {
126
            retention_enabled    = true
127
            delete_request_store = "s3"
128
          }
129
          storage_config = {
130
            object_prefix = "loki"
131
          }
132
          ingester_client = {
133
            remote_timeout = "10s"
134
          }
135
          analytics = {
136
            reporting_enabled = false
137
          }
138
          schema_config = {
139
            configs = [
140
              {
141
                from         = "2024-01-01"
142
                store        = "tsdb"
143
                object_store = "s3"
144
                schema       = "v13"
145
                index = {
146
                  prefix = "index_"
147
                  period = "24h"
148
                }
149
              }
150
            ]
151
          }
152
        }
153
      }
154
    })
155
  ]
156
}
157

158
resource "kubernetes_config_map_v1" "grafana_datasource_loki" {
159
  metadata {
160
    name      = "grafana-datasource-loki"
161
    namespace = kubernetes_namespace_v1.logging.metadata[0].name
162
    labels = {
163
      grafana_datasource = "1"
164
    }
165
  }
166

167
  data = {
168
    "datasource.yaml" = yamlencode({
169
      apiVersion = 1
170
      datasources = [
171
        {
172
          name   = "Loki"
173
          type   = "loki"
174
          uid    = "loki"
175
          url    = "http://loki-gateway.logging"
176
          access = "proxy"
177
          jsonData = {
178
            derivedFields = [
179
              {
180
                name           = "TraceId"
181
                datasourceName = "Tempo"
182
                datasourceUid  = "tempo"
183
                matcherRegex   = "TraceId"
184
                matcherType    = "label"
185
                url            = "$$${__value.raw}"
186
              },
187
              {
188
                name           = "trace_id"
189
                datasourceName = "Tempo"
190
                datasourceUid  = "tempo"
191
                matcherRegex   = "trace_id"
192
                matcherType    = "label"
193
                url            = "$$${__value.raw}"
194
              }
195
            ]
196
          }
197
        }
198
      ]
199
    })
200
  }
201
}

Explanation

De la belle config helm bien velue qu’on aime bien…

Loki sera installé en mode distribué avec un composant write en 2 réplicas pour l’ingestion des logs en mode haute dispo, placés sur les nœuds de storage, un composant read en 1 réplica, et un composant backend en 1 replica pour la gestion des logs long-terme sur le s3.

Loki fourni également 2 composants de memcached pour le caching des chunks et des résultats de requêtes, que l’on configure à 512Mo et 256Mo respectivement. Ceci permet d’optimiser au mieux les performances de Loki en termes de gestion des flux de données.

Est inclus par ailleurs un composant canary pour le monitoring régulier de l’état de santé du cluster Loki. Je me permets de le désactiver, car il bourrine sévère.

La clé structuredConfig permet de passer une config Loki complète en YAML. On y active la rétention des logs, on désactive l’auth pour simplifier (à adapter à vos besoins), on configure le stockage S3.

Enfin, on configure le datasource Grafana pour Loki, pour une intégration automatique. La petite particularité supplémentaire est l’ajout de 2 derivedField pour permettre de faire le lien depuis les logs vers les futures traces dans Grafana. Le but est de récupérer la valeur du champ TraceId (traefik JSON) ou trace_id (logs OTLP) et de faire le lien vers la trace sur tempo.

Appliquer la config avec terraform apply. Vérifier que tout est bien déployé avec kgp -n logging.

Loki fourni son propre dashboard Grafana :

Dashboard Loki

Mais il sera vide en l’état actuel, car nous n’avons aucun outil de collecte de données pour le moment. On enchaîne tout de suite sur l’installation du backend Tempo.

Traces 🔍

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

4
  tempo_s3_endpoint   = local.s3_endpoint
5
  tempo_s3_region     = local.s3_region
6
  tempo_s3_bucket     = local.cluster_name
7
  tempo_s3_access_key = var.tempo_s3_username
8
  tempo_s3_secret_key = var.tempo_s3_password
9
}

Explanation

De même que pour Loki, nous allons utiliser le mode distribué adapté pour la production. De ce fait un stockage S3 est requis.

1
// ...
2

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

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

# ...

export TF_VAR_tempo_s3_username=$(bw_field username tempo_s3)
export TF_VAR_tempo_s3_password=$(bw_field password tempo_s3)

1
// ...
2

3
variable "tempo_s3_endpoint" {
4
  description = "The endpoint of the S3 compatible storage"
5
  type        = string
6
}
7

8
variable "tempo_s3_access_key" {
9
  description = "The access key for the S3 compatible storage"
10
  type        = string
11
}
12

13
variable "tempo_s3_secret_key" {
14
  description = "The secret key for the S3 compatible storage"
15
  type        = string
16
  sensitive   = true
17
}
18

19
variable "tempo_s3_region" {
20
  description = "The region of the S3 compatible storage"
21
  type        = string
22
}
23

24
variable "tempo_s3_bucket" {
25
  description = "The bucket of the S3 compatible storage"
26
  type        = string
27
}

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

10
resource "helm_release" "tempo" {
11
  repository = "https://grafana.github.io/helm-charts"
12
  chart      = "tempo-distributed"
13
  version    = "1.61.0"
14

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

19
  set = [
20
    {
21
      name  = "traces.otlp.http.enabled"
22
      value = "true"
23
    },
24
    {
25
      name  = "traces.otlp.grpc.enabled"
26
      value = "true"
27
    },
28
    {
29
      name  = "ingester.replicas"
30
      value = "2"
31
    },
32
    {
33
      name  = "ingester.persistence.enabled"
34
      value = "true"
35
    },
36
    {
37
      name  = "ingester.persistence.storageClass"
38
      value = "longhorn-crypto-local"
39
    },
40
    {
41
      name  = "ingester.persistence.size"
42
      value = "2Gi"
43
    },
44
    {
45
      name  = "ingester.tolerations[0].key"
46
      value = "node-role.kubernetes.io/storage"
47
    },
48
    {
49
      name  = "ingester.tolerations[0].operator"
50
      value = "Exists"
51
    },
52
    {
53
      name  = "ingester.nodeSelector.node\\.kubernetes\\.io/role"
54
      value = "storage"
55
    },
56
    {
57
      name  = "storage.trace.backend"
58
      value = "s3"
59
    },
60
    {
61
      name  = "storage.trace.s3.bucket"
62
      value = var.tempo_s3_bucket
63
    },
64
    {
65
      name  = "storage.trace.s3.prefix"
66
      value = "tempo"
67
    },
68
    {
69
      name  = "storage.trace.s3.endpoint"
70
      value = var.tempo_s3_endpoint
71
    },
72
    {
73
      name  = "storage.trace.s3.region"
74
      value = var.tempo_s3_region
75
    },
76
    {
77
      name  = "storage.trace.s3.access_key"
78
      value = var.tempo_s3_access_key
79
    },
80
    {
81
      name  = "metaMonitoring.serviceMonitor.enabled"
82
      value = "true"
83
    },
84
    {
85
      name  = "metricsGenerator.enabled"
86
      value = "true"
87
    },
88
    {
89
      name  = "metricsGenerator.config.storage.remote_write[0].url"
90
      value = "http://prometheus-operated.monitoring:9090/api/v1/write"
91
    }
92
  ]
93

94
  set_sensitive = [
95
    {
96
      name  = "storage.trace.s3.secret_key"
97
      value = var.tempo_s3_secret_key
98
    }
99
  ]
100

101
  set_list = [
102
    {
103
      name = "overrides.defaults.metrics_generator.processors"
104
      value = [
105
        "service-graphs",
106
        "span-metrics",
107
        "local-blocks"
108
      ]
109
    }
110
  ]
111
}
112

113
resource "kubernetes_config_map_v1" "grafana_datasource_tempo" {
114
  metadata {
115
    name      = "grafana-datasource-tempo"
116
    namespace = kubernetes_namespace_v1.tracing.metadata[0].name
117
    labels = {
118
      grafana_datasource = "1"
119
    }
120
  }
121

122
  data = {
123
    "datasource.yaml" = yamlencode({
124
      apiVersion = 1
125
      datasources = [
126
        {
127
          name   = "Tempo"
128
          type   = "tempo"
129
          uid    = "tempo"
130
          url    = "http://tempo-query-frontend.tracing:3200"
131
          access = "proxy"
132
          jsonData = {
133
            tracesToLogsV2 = {
134
              datasourceUid      = "loki"
135
              filterByTraceID    = true
136
              filterBySpanID     = true
137
              spanEndTimeShift   = "5s"
138
              spanStartTimeShift = "-5s"
139
            }
140
            tracesToMetrics = {
141
              datasourceUid = "prometheus"
142
              queries = [
143
                {
144
                  "name" : "Request rate",
145
                  "query" : "sum by (client,server)(rate(traces_service_graph_request_total{$$__tags}[$$__rate_interval]))"
146
                },
147
                {
148
                  "name" : "Error rate",
149
                  "query" : "sum by (client,server)(rate(traces_service_graph_request_failed_total{$$__tags}[$$__rate_interval]))"
150
                }
151
              ],
152
              tags = [
153
                {
154
                  key   = "service.name",
155
                  value = "server"
156
                }
157
              ]
158
            }
159
            serviceMap = {
160
              datasourceUid = "prometheus"
161
            }
162
            nodeGraph = {
163
              enabled = true
164
            }
165
          }
166
        }
167
      ]
168
    })
169
  }
170
}

Explanation

Activer les ports de OpenTelemetry (OTLP) HTTP et gRPC pour la collecte des traces, puis paramétrer le stockage S3.

De même que pour les writers loki, on place les ingesters sur les nœuds de storage en 2 réplicas pour la haute dispo.

Nous activons metricsGenerator. C’est un composant spécifique indispensable pour permettre de faire le lien entre les traces et les métriques Prometheus. Nous le branchons sur le Prometheus déjà déployé dans le cluster grâce au write receiver déjà activé dans la section précédente. Nous activons les processors service-graphs, span-metrics et local-blocks. L’usage de ce dernier processor est nécessaire pour la visualisation des traces sous le menu menu Drilldown dans Grafana.

Enfin nous activons le datasource Grafana pour Tempo, avec la configuration des tracesToLogsV2 pour créer un lien depuis les traces vers les logs dans Grafana (le sens inverse de la datasource Loki). On précise une marge de 5 secondes avant et après le timestamp de chaque trace ou span pour avoir une vue plus complète des logs associés.

Le paramètre tracesToMetrics permet de créer un ou plusieurs liens, toujours depuis les traces vers des métriques Prometheus personnalisables. À adapter en fonction de vos besoins.

Enfin, nous activons le serviceGraph et nodeGraph pour avoir une vue graphique des flux de traces enrichies par les métriques. Cela nécessite l’activation de metricsGenerator pour générer les données de graphe dans prometheus.

Appliquer la config avec terraform apply. Vérifier que tout est bien déployé avec kgp -n tracing.

Collecte 📜

Bon cool, on a nos backends, mais aucun collector pour alimenter tout ça. C’est ici que Alloy entre en jeu.

Afin de distribuer au mieux la collecte des données, assez massives quand il s’agit de logs et traces, Alloy est devenu un composant de choix dans l’écosystème de l’observabilité. Il fournit une solution complète centralisée et flexible pour la collecte, le traitement et le routage des logs, métriques et traces.

L’utilisation de Prometheus Operator via les CRDs ServiceMonitor/PodMonitor (mode pull/scraping) exclu l’utilisation d’Alloy pour la collecte des métriques de l’infra, hors métriques OLTP (mode push) encore rarement utilisé. Il nous servira donc principalement pour les logs et traces. Pour la partie logs, il remplace pleinement Promtail, l’outil historique pour la collecte des logs.

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

10
resource "kubernetes_config_map_v1" "alloy" {
11
  metadata {
12
    name      = "alloy"
13
    namespace = kubernetes_namespace_v1.telemetry.metadata[0].name
14
  }
15

16
  data = {
17
    "config.alloy" = <<EOF
18
discovery.kubernetes "pod" {
19
  role = "pod"
20
}
21

22
discovery.relabel "pod" {
23
  targets = discovery.kubernetes.pod.targets
24

25
  rule {
26
    source_labels = ["__meta_kubernetes_namespace"]
27
    action = "replace"
28
    target_label = "namespace"
29
  }
30

31
  rule {
32
    source_labels = ["__meta_kubernetes_pod_name"]
33
    action = "replace"
34
    target_label = "pod"
35
  }
36

37
  rule {
38
    source_labels = ["__meta_kubernetes_pod_container_name"]
39
    action = "replace"
40
    target_label = "container"
41
  }
42

43
  rule {
44
    source_labels = ["__meta_kubernetes_pod_label_app_kubernetes_io_name"]
45
    action = "replace"
46
    target_label = "app"
47
  }
48

49
  rule {
50
    source_labels = ["__meta_kubernetes_namespace", "__meta_kubernetes_pod_container_name"]
51
    action = "replace"
52
    target_label = "job"
53
    separator = "/"
54
    replacement = "$1"
55
  }
56

57
  rule {
58
    source_labels = ["__meta_kubernetes_pod_uid", "__meta_kubernetes_pod_container_name"]
59
    action = "replace"
60
    target_label = "__path__"
61
    separator = "/"
62
    replacement = "/var/log/pods/*$1/*.log"
63
  }
64

65
  rule {
66
    source_labels = ["__meta_kubernetes_pod_container_id"]
67
    action = "replace"
68
    target_label = "container_runtime"
69
    regex = "^(\\S+):\\/\\/.+$"
70
    replacement = "$1"
71
  }
72
}
73

74
local.file_match "pod" {
75
  path_targets = discovery.relabel.pod.output
76
}
77

78
loki.source.file "pod" {
79
  targets = local.file_match.pod.targets
80
  forward_to = [loki.process.pod.receiver]
81
}
82

83
loki.process "pod" {
84
  stage.cri {}
85
  stage.static_labels {
86
    values = {
87
      cluster = "local",
88
    }
89
  }
90

91
  forward_to = [loki.write.endpoint.receiver]
92
}
93

94
loki.write "endpoint" {
95
  endpoint {
96
    url = "http://loki-gateway.logging/loki/api/v1/push"
97
  }
98
}
99

100
otelcol.receiver.otlp "default" {
101
  http {}
102
  grpc {}
103

104
  output {
105
    metrics = [otelcol.processor.batch.default.input]
106
    traces  = [otelcol.processor.batch.default.input]
107
    logs    = [otelcol.processor.batch.default.input]
108
  }
109
}
110

111
otelcol.processor.batch "default" {
112
  output {
113
    metrics = [otelcol.exporter.otlphttp.prometheus.input]
114
    logs    = [otelcol.exporter.otlphttp.loki.input]
115
    traces  = [otelcol.exporter.otlp.tempo.input]
116
  }
117
}
118

119
otelcol.exporter.otlphttp "prometheus" {
120
  client {
121
    endpoint = "http://prometheus-operated.monitoring:9090/api/v1/otlp"
122
  }
123
}
124

125
otelcol.exporter.otlphttp "loki" {
126
  client {
127
    endpoint = "http://loki-gateway.logging/otlp"
128
  }
129
}
130

131
otelcol.exporter.otlp "tempo" {
132
  client {
133
    endpoint = "tempo-distributor.tracing:4317"
134
    tls {
135
      insecure = true
136
    }
137
  }
138
}
139
EOF
140
  }
141
}
142

143
resource "helm_release" "alloy" {
144
  repository = "https://grafana.github.io/helm-charts"
145
  chart      = "alloy"
146
  version    = "1.5.2"
147

148
  name        = "alloy"
149
  namespace   = kubernetes_namespace_v1.telemetry.metadata[0].name
150
  max_history = 2
151

152
  set = [
153
    {
154
      name  = "serviceMonitor.enabled"
155
      value = "true"
156
    },
157
    {
158
      name  = "alloy.configMap.create"
159
      value = "false"
160
    },
161
    {
162
      name  = "alloy.configMap.name"
163
      value = kubernetes_config_map_v1.alloy.metadata[0].name
164
    },
165
    {
166
      name  = "alloy.configMap.key"
167
      value = "config.alloy"
168
    },
169
    {
170
      name  = "alloy.extraPorts[0].name"
171
      value = "otlp-http"
172
    },
173
    {
174
      name  = "alloy.extraPorts[0].port"
175
      value = "4318"
176
    },
177
    {
178
      name  = "alloy.extraPorts[0].targetPort"
179
      value = "4318"
180
    },
181
    {
182
      name  = "alloy.extraPorts[1].name"
183
      value = "otlp-grpc"
184
    },
185
    {
186
      name  = "alloy.extraPorts[1].port"
187
      value = "4317"
188
    },
189
    {
190
      name  = "alloy.extraPorts[1].targetPort"
191
      value = "4317"
192
    },
193
    {
194
      name  = "alloy.mounts.varlog"
195
      value = "true"
196
    },
197
    {
198
      name  = "controller.tolerations[0].operator"
199
      value = "Exists"
200
    },
201
  ]
202
}
203

204
resource "kubernetes_manifest" "traefik_ingress_route_alloy" {
205
  manifest = {
206
    apiVersion = "traefik.io/v1alpha1"
207
    kind       = "IngressRoute"
208
    metadata = {
209
      name      = "alloy"
210
      namespace = kubernetes_namespace_v1.telemetry.metadata[0].name
211
    }
212
    spec = {
213
      entryPoints = ["internal"]
214
      routes = [
215
        {
216
          match = "Host(`alloy.${var.internal_domain}`)"
217
          kind  = "Rule"
218
          middlewares = [
219
            {
220
              name      = "internal-basic-auth"
221
              namespace = "traefik"
222
            }
223
          ]
224
          services = [
225
            {
226
              name = "alloy"
227
              port = "http-metrics"
228
            }
229
          ]
230
        }
231
      ]
232
    }
233
  }
234
}

Explanation

Par rapport à Promtail, il y a beaucoup plus de config à faire, prix de la flexibilité ?

Côté Helm on indique le ConfigMap à utiliser, et on expose les ports OTLP HTTP et gRPC pour activer la collecte des traces. Les applications supportant OpenTelemetry devront envoyer leurs données de spans/traces sur ces ports (ce qui est déjà le cas sur Traefik installé précédemment).

Quant aux logs, on utilise l’API Kubernetes pour aller chercher les pods et leurs containers sur lesquels Alloy devra collecter les logs, puis on applique une série de règles de relabellisation pour avoir des labels cohérents et exploitables dans Grafana.

L’exemple fourni par la doc officielle récupère le stream des logs via l’API Kubernetes. Cela a l’avantage de ne pas nécessiter de déploiement d’agent sur chaque nœud, ni d’élévation de privilège. Cependant, cela n’est pas du tout optimal en termes de charge sur l’API server ainsi que niveau réseau.

Je préfère personnellement rester sur l’approche Promtail traditionnelle de récupérer les logs directement à la source au niveau fichier brut. Dans ce mode, au niveau du chart helm, 2 éléments essentiels sont à considérer :

On s’assure via controller.tolerations que les pods alloy se déploient sur l’ensemble des noeuds. Cela est nécessaire pour la collecte des logs au niveau fichier, de la même manière que pour Promtail.
On monte le volume /var/log local de chaque noeud dans les pods alloy via alloy.mounts.varlog. Ceci nécessite des privilèges élevés indiqués dans le namespace.

Il s’agit ensuite de remplacer loki.source.kubernetes par le combo local.file_match et loki.source.file, qui permette respectivement de matcher les fichiers de logs grâce à __path__ et de parser les fichiers de logs.

1
local.file_match "pod" {
2
  path_targets = discovery.relabel.pod.output
3
}
4

5
loki.source.file "pod" {
6
  targets = local.file_match.pod.targets
7
  forward_to = [loki.process.pod.receiver]
8
}

En mode fichier, dans loki.process, il est important d’indiquer stage.cri afin de parser les logs au format CRI (le format standard utilisé par les runtimes de containers comme containerd ou Docker).

En résumé, côté config :

On récupère tous les pods actifs de l’API Kubernetes.
On applique toute une stratégie de labellisation pour avoir un truc propre à exploiter.
On matche les fichiers de logs via __path__ pour chaque container de chaque pod puis on parse les logs au format CRI.
On précise le point d’entrée loki-gateway.logging de Loki pour l’écriture des logs.
On configure un récepteur OTLP par défaut pour recevoir les données OpenTelemetry. Sur ce récepteur, nous utilisons trois processeurs batch distincts pour les métriques, les traces et les logs :
- Pour la partie metrics, on forwarde vers l’endpoint OTLP de prometheus préalablement configuré au chapitre précédent http://prometheus-operated.monitoring:9090/api/v1/otlp.
- Pour la partie logs, on forwarde vers l’URL loki http://loki-gateway.logging/otlp.
- Pour la partie traces, on forwarde vers le backend Tempo sur l’endpoint tempo-distributor.tracing:4317 (format gRPC).

L’intérêt principal d’OTLP est leur enrichissement mutuel entre métriques, logs et traces, permettant une corrélation parfaite. Ce format est en revanche spécifique par application les supportant, vu qu’il s’agit d’un nouveau protocole en mode push. Il nous servira notamment pour OpenTelemetry plus tard.

Plus qu’à terraform apply pour déployer Alloy. Vérifer avec kgp -n telemetry que tout est bien déployé. Puis allez faire un tour sur https://alloy.dev.ohmytalos.io pour vérifier l’état des composants de collecte.

Alloy Components

Alloy fourni également un graphe de flux des données collectées.

Alloy Graph

Et voilà les logs devraient commencer à arriver dans loki très rapidement. Traefik étant déjà configuré à la section des ingress pour envoyer les traces, vous devriez aussi voir les premières traces arriver dans Tempo.

Visualisation des logs

Pour visualiser tout ça, allez dans la section Drilldown de Grafana, section logs pour avoir un aperçu rapide des logs des principaux composants.

Drilldown logs

Naviguer dans les logs de Traefik :

Drilldown Traefik logs

Grâce au derivedField configuré dans le datasource Loki, vous pouvez cliquer sur le TraceId dans les logs pour accéder directement à la trace correspondante dans Tempo.

Drilldown logs to trace

En dépliant les spans, vous y retrouverez les fameux liens créés dans la datasource de tempo, via les paramètres tracesToLogsV2 et tracesToMetrics.

Corrélation des logs sur le span sélectionné :

Drilldown trace to logs

Corrélation des métriques personnalisées sur le span sélectionné :

Drilldown trace to metrics

Vous pouvez créer autant de métriques personalisées que vous souhaitez. Il vous suffira de les ajouter dans la section queries du paramètre tracesToMetrics du datasource Tempo.

Visualisation des traces

Grafana fourni également une vue complète des traces :

Drilldown traces

Une vue par graphe des flux de services est aussi disponible, enrichie par les métriques personnalisées issues des traces :

Explore Service Graph

Conclusion

On est bon pour la mise en place des collecteurs et agrégateurs de logs et traces. Nous verrons plus tard au travers d’une application réelle comment l’intégrer à travers ces outils. Il est temps d’installer fluxcd pour le déploiement automatique de nos applications, c’est parti.