TL; DR;

自宅サーバーのObservability基盤としてOpenTelemetryパイプラインを構築しました
複数の役割を持つコレクタにより実システムにも適用可能なスケーラブルなパイプラインを実現しました
特にTarget AllocatorによりPrometheusスクレイピングを重複なくスケール可能にしています

背景

我が家ではKubernetesクラスタを運用しておりObservabilityの仕組みとして、ログにはfluentd・メトリクスにはPrometheus/Grafanaを利用しています（トレースは未使用）。 1年近くこのスタックで運用してきましたが、ツールがばらけていることもあり、あまりログやメトリクスは上手く活用できていませんでした。

最近OpenTelemetryの資格を取ったこともあり、OpenTelemetryを利用してObservability基盤を再検討・構築してみることにしました。

アーキテクチャ

Observability基盤のアーキテクチャの要件は要件としては以下のように考えています。

スケールすること
パイプラインによるデータの変換・変更は集約した形で行えるようにすること
- ログはfluentdのやり方で変換・メトリクスはprometheus側で変換などだと運用負荷が高いので単一の仕組みで行いたい
Kubernetes・ホストの情報をシグナルに付与できること
テレメトリシグナルの保持・可視化を行うバックエンドツールに依存しないこと

これを踏まえ、以下のようなアーキテクチャとしました。

このアーキテクチャの特徴は3種類のOpenTelemetry Collectorを利用している点であり、公式ドキュメントで紹介されているagentとgatewayの組み合わせを参考にしています。また、APM製品やベンダーから公開されているディストリビューションは使わず、OpenTelemetry公式のコレクタを利用することにしています。

agentコレクタ

まず、各ノード・物理マシンに1台ずつ配置するコレクタ（agent）は、各ノード上のPodからのログやノードそのもののメトリクスを収集します。このコレクタで行うテレメトリシグナルの変換はノード固有の情報を付与することのみであり、本格的な変換は行いません。また、agentを配置することによって、アプリケーションは自身のノード上のagentに対してシグナルを送信できるためデータのロスやアプリケーション側のオーバーヘッドを最低限にできます。

gatewayコレクタ

クラスタ内にスケール可能な形で配置するコレクタ（gateway）は、各コレクタからのデータを受け取り、共通して必要な情報の付与や変換を行ったのちにObservabilityバックエンドにデータを送信します。また、prometheusでメトリクスを公開しているアプリケーションに対してはこのコレクタでスクレイプを行います。

gatewayコレクタにおいて重要なことは、クラスタ全体のテレメトリシグナル処理による負荷を考慮してスケーラビリティを確保することです。とはいえ基本的にはコレクタから収集したデータをステートレスに処理するだけであるため、スケールアウトの障壁は高くはありません。ただし例外もあって、その一つがメトリクスのスクレイピングです¹。スクレイピング設定を設定した状態でコレクタをスケールアウトすると、同じターゲットに対して複数のコレクタがスクレイピングを行うことになり、データが重複してしまいます。

これを防ぐために、OpenTelemetry OperatorによるTarget Allocatorを利用します。 Target Allocatorはあらかじめ取得したいメトリクスのターゲット一覧を取得し、それを各コレクタに割り振ります。各コレクタはTarget Allocatorから自身が担当するターゲットの情報を取得し、それに従ってスクレイピングを行います。

クラスタに1つなコレクタ（clusteragentコレクタ）

このコレクタはクラスタ全体の情報のうち、gatewayコレクタを使ってスケールする形で取得できない情報を収集します。例えばkubernetesクラスタのイベント情報が該当します。

clusteragentという名前にしていますがこれは公式による命名ではなく、cluster-wideなagentという意味で私が勝手に命名したものです。

構築

OpenTelemetry Collectorをデプロイするにあたっては、OpenTelemetry公式が用意しているOpenTelemetry Operatorを利用します。このOperatorが提供しているOpenTelemetryCollectorというCustom Resourceを利用することで、簡単にOpenTelemetry Collectorをデプロイすることができます。

なおこの記事を書いている時点では、物理マシン上のagentコレクタ・k8sノードのOSログ収集の設定はまだ実装できていません（なので実は最初のアーキテクチャ図は一部未実装）。ただしそれぞれ、

Operatorの代わりにコンテナでデプロイする
取得するログを指定する

というだけで実装でき、パイプラインに多少追加が必要になるだけなので割愛します²。

Operatorのデプロイ

Operatorは公式ドキュメントに従ってマニフェストをapplyしてもいいですしHelm Chartを利用してもいいです。私はArgoCDを利用しているので、Helm Chartを利用してデプロイしました。

Helm Chartでデプロイする場合にはvalues.yamlでコレクタ自体のイメージを指定することができます。今回は下のように、k8sディストrビューションの最新版を指定しました。 contribなど他のディストリビューションやカスタムビルドのコレクタを利用したい場合にはここで指定します。

1
manager:
2
  # ...
3
  collectorImage:
4
    repository: "otel/opentelemetry-collector-k8s"
5
    tag: 0.122.1

agentコレクタのデプロイ

agentコレクタ関連のマニフェスト

1
# agentコレクタ用のServiceAccount
2
apiVersion: v1
3
kind: ServiceAccount
4
metadata:
5
  namespace: monitoring
6
  name: agent-collector
7
---
8

9
# agentコレクタ用のClusterRole
10
apiVersion: rbac.authorization.k8s.io/v1
11
kind: ClusterRole
12
metadata:
13
  name: agent-collector
14
rules:
15
  # This is for k8s node resourcedetection processor
16
  # cf. https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md#k8s-node-metadata
17
  - apiGroups: [""]
18
    resources: ["nodes"]
19
    verbs: ["get", "list"]
20
  # This is for kubeletstats receiver
21
  - apiGroups: [""]
22
    resources: ["nodes/stats"]
23
    verbs: ["get"]
24
  # This is for cadvisor job of prometheus receiver
25
  - apiGroups: [""]
26
    resources: ["nodes"]
27
    verbs: ["watch"]
28
  - apiGroups:
29
    - ''
30
    resources:
31
      - nodes/proxy
32
      - nodes/metrics
33
    verbs:
34
      - get
35
---
36

37
# agentコレクタ用のClusterRoleBinding
38
apiVersion: rbac.authorization.k8s.io/v1
39
kind: ClusterRoleBinding
40
metadata:
41
  name: agent-collector
42
subjects:
43
  - kind: ServiceAccount
44
    namespace: monitoring
45
    name: agent-collector
46
roleRef:
47
  kind: ClusterRole
48
  name: agent-collector
49
  apiGroup: rbac.authorization.k8s.io
50
---
51

52
# agentコレクタ自体のマニフェスト
53
apiVersion: opentelemetry.io/v1beta1
54
kind: OpenTelemetryCollector
55
metadata:
56
  name: agent
57
spec:
58
  mode: daemonset
59
  serviceAccount: agent-collector
60

61
  # This is for running on control plane nodes
62
  tolerations:
63
  - key: "node-role.kubernetes.io/control-plane"
64
    operator: Exists
65
    effect: NoSchedule
66
  - key: "node-role.kubernetes.io/master"
67
    operator: Exists
68
    effect: NoSchedule
69

70
  volumeMounts:
71
  - name: varlogpods
72
    mountPath: /var/log/pods
73
    readOnly: true
74
  - name: varlibdockercontainers
75
    mountPath: /var/lib/docker/containers
76
    readOnly: true
77
  - name: hostfs
78
    mountPath: /hostfs
79
    readOnly: true
80
    mountPropagation: HostToContainer
81

82
  volumes:
83
  # This is for filelog receiver
84
  - name: varlogpods
85
    hostPath:
86
      path: /var/log/pods
87
  # This is for filelog receiver
88
  - name: varlibdockercontainers
89
    hostPath:
90
      path: /var/lib/docker/containers
91
  # This is for hostmetrics receiver
92
  - name: hostfs
93
    hostPath:
94
      path: /
95

96
  env:
97
  - name: K8S_POD_IP
98
    valueFrom:
99
      fieldRef:
100
        apiVersion: v1
101
        fieldPath: status.podIP
102
  - name: K8S_NODE_NAME
103
    valueFrom:
104
      fieldRef:
105
        fieldPath: spec.nodeName
106
  - name: K8S_NODE_IP
107
    valueFrom:
108
      fieldRef:
109
        fieldPath: status.hostIP
110
  # This is for resource detection from env processor
111
  - name: OTEL_RESOURCE_ATTRIBUTES
112
    value: "host.name=$(K8S_NODE_NAME),host.ip=$(K8S_NODE_IP)"
113
  - name: METRICS_SCRAPE_INTERVAL
114
    value: "1m"
115

116
  config:
117
    receivers:
118
      prometheus/self:
119
        config:
120
          scrape_configs:
121
          - job_name: opentelemetry-collector
122
            scrape_interval: ${env:METRICS_SCRAPE_INTERVAL}
123
            static_configs:
124
            - targets:
125
              - ${env:K8S_POD_IP}:8888
126
              labels:
127
                # This label must not be job, because this is not recognized as attribute
128
                job_label: opentelemetry-collector
129

130
      prometheus:
131
        config:
132
          scrape_configs:
133
          - job_name: node-exporter
134
            scrape_interval: ${env:METRICS_SCRAPE_INTERVAL}
135
            static_configs:
136
              - targets:
137
                  - ${env:K8S_NODE_IP}:9100
138
                labels:
139
                  job_label: node-exporter
140

141
          # cf. https://github.com/newrelic/helm-charts/blob/master/charts/nr-k8s-otel-collector/collector.md#cadvisor
142
          - job_name: cadvisor
143
            scrape_interval: ${env:METRICS_SCRAPE_INTERVAL}
144
            bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
145
            kubernetes_sd_configs:
146
            - role: node
147
            relabel_configs:
148
            - replacement: kubernetes.default.svc.cluster.local:443
149
              target_label: __address__
150
            - regex: (.+)
151
              replacement: /api/v1/nodes/$${1}/proxy/metrics/cadvisor
152
              source_labels:
153
                - __meta_kubernetes_node_name
154
              target_label: __metrics_path__
155
            - action: replace
156
              target_label: job_label
157
              replacement: cadvisor
158
            - source_labels: [__meta_kubernetes_node_name]
159
              regex: ${K8S_NODE_NAME}
160
              action: keep
161
            scheme: https
162
            tls_config:
163
              ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
164
              insecure_skip_verify: false
165
              server_name: kubernetes
166

167
          # cf. https://github.com/newrelic/helm-charts/blob/master/charts/nr-k8s-otel-collector/collector.md#kubelet
168
          - job_name: kubelet
169
            scrape_interval: ${env:METRICS_SCRAPE_INTERVAL}
170
            bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
171
            kubernetes_sd_configs:
172
            - role: node
173
            relabel_configs:
174
            - replacement: kubernetes.default.svc.cluster.local:443
175
              target_label: __address__
176
            - regex: (.+)
177
              replacement: /api/v1/nodes/$${1}/proxy/metrics
178
              source_labels:
179
                - __meta_kubernetes_node_name
180
              target_label: __metrics_path__
181
            - action: replace
182
              target_label: job_label
183
              replacement: kubelet
184
            - source_labels: [__meta_kubernetes_node_name]
185
              regex: ${K8S_NODE_NAME}
186
              action: keep
187
            scheme: https
188
            tls_config:
189
              ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
190
              insecure_skip_verify: false
191
              server_name: kubernetes
192

193
      # cf. https://opentelemetry.io/docs/platforms/kubernetes/collector/components/#filelog-receiver
194
      filelog:
195
        include:
196
          - /var/log/pods/*/*/*.log
197
        exclude:
198
          # Exclude logs from all containers named otel-collector
199
          - /var/log/pods/*/otel-collector/*.log
200
        start_at: end
201
        include_file_path: true
202
        include_file_name: false
203
        operators:
204
          # parse container logs
205
          - type: container
206
            id: container-parser
207

208
      # cf. https://github.com/newrelic/helm-charts/blob/master/charts/nr-k8s-otel-collector/collector.md#hostmetrics-receiver
209
      hostmetrics:
210
        root_path: /hostfs
211
        collection_interval: ${env:METRICS_SCRAPE_INTERVAL}
212
        scrapers:
213
          cpu:
214
            metrics:
215
              system.cpu.time:
216
                enabled: false
217
              system.cpu.utilization:
218
                enabled: true
219
          load:
220
          memory:
221
            metrics:
222
              system.memory.utilization:
223
                enabled: true
224
          paging:
225
            metrics:
226
              system.paging.utilization:
227
                enabled: false
228
              system.paging.faults:
229
                enabled: false
230
          filesystem:
231
            metrics:
232
              system.filesystem.utilization:
233
                enabled: true
234
          disk:
235
            metrics:
236
              system.disk.merged:
237
                enabled: false
238
              system.disk.pending_operations:
239
                enabled: false
240
              system.disk.weighted_io_time:
241
                enabled: false
242
          network:
243
            metrics:
244
              system.network.connections:
245
                enabled: false
246
          processes:
247
          process:
248
            metrics:
249
              process.cpu.utilization:
250
                enabled: true
251
              process.cpu.time:
252
                enabled: false
253
            mute_process_name_error: true
254
            mute_process_exe_error: true
255
            mute_process_io_error: true
256
            mute_process_user_error: true
257

258
      # cf. https://github.com/newrelic/helm-charts/blob/master/charts/nr-k8s-otel-collector/collector.md#kubeletstats-receiver
259
      kubeletstats:
260
        collection_interval: ${env:METRICS_SCRAPE_INTERVAL}
261
        auth_type: "serviceAccount"
262
        endpoint: "https://${env:K8S_NODE_IP}:10250"
263
        insecure_skip_verify: true
264
        metrics:
265
          # This rename cpu utilization to cpu usage
266
          k8s.node.cpu.utilization:
267
            enabled: false
268
          k8s.node.cpu.usage:
269
            enabled: true
270
          k8s.pod.cpu.utilization:
271
            enabled: false
272
          k8s.pod.cpu.usage:
273
            enabled: true
274
          container.cpu.utilization:
275
            enabled: false
276
          container.cpu.usage:
277
            enabled: true
278

279

280
    processors:
281
      batch: {}
282

283
      memory_limiter:
284
        # This value if from example in the documentation
285
        # https://github.com/open-telemetry/opentelemetry-collector/blob/main/processor/memorylimiterprocessor/README.md
286
        check_interval: 1s
287
        limit_percentage: 80
288
        spike_limit_percentage: 15
289

290
      attributes/job_label_hostmetrics:
291
        actions:
292
          - key: job_label
293
            action: upsert
294
            value: hostmetrics
295

296
      attributes/job_label_kubeletstats:
297
        actions:
298
          - key: job_label
299
            action: upsert
300
            value: kubeletstats
301

302
      # cf. https://opentelemetry.io/docs/platforms/kubernetes/collector/components/#kubernetes-attributes-processor
303
      k8sattributes:
304
        # cf. https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/k8sattributesprocessor/README.md#as-a-gateway
305
        passthrough: true
306

307
      # cf. https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md#k8s-node-metadata
308
      resourcedetection/k8snode:
309
        detectors: [k8snode]
310
        k8snode:
311
          node_from_env_var: "K8S_NODE_NAME"
312

313
      # Because system detector cannot be used in container for host detection, extract from env manually
314
      resourcedetection/env:
315
        detectors: [env]
316

317
      # This is for pod annotation adding in gateway collector
318
      resource/append_pod_ip:
319
        attributes:
320
          - key: k8s.pod.ip
321
            action: insert
322
            value: ${env:K8S_POD_IP}
323

324
    connectors:
325
      routing/metrics_common:
326
        table:
327
          - condition: "true"
328
            pipelines:
329
              - metrics
330

331
    exporters:
332
      otlp:
333
        endpoint: gateway-collector:4317
334
        tls:
335
          insecure: true
336

337
    service:
338
      pipelines:
339
        logs:
340
          receivers:
341
          - filelog
342
          processors:
343
          - memory_limiter
344
          - batch
345
          - k8sattributes
346
          - resourcedetection/k8snode
347
          - resourcedetection/env
348
          exporters:
349
          - otlp
350

351
        metrics/hostmetrics:
352
          receivers:
353
            - hostmetrics
354
          processors:
355
            - attributes/job_label_hostmetrics
356
          exporters:
357
            - routing/metrics_common
358

359
        metrics/kubeletstats:
360
          receivers:
361
            - kubeletstats
362
          processors:
363
            - attributes/job_label_kubeletstats
364
          exporters:
365
            - routing/metrics_common
366

367
        metrics/self:
368
          receivers:
369
            - prometheus/self
370
          processors:
371
            - resource/append_pod_ip
372
          exporters:
373
            - routing/metrics_common
374

375
        metrics:
376
          receivers:
377
          - routing/metrics_common
378
          - prometheus
379
          processors:
380
          - memory_limiter
381
          - batch
382
          - k8sattributes
383
          - resourcedetection/k8snode
384
          - resourcedetection/env
385
          exporters:
386
          - otlp
387
      telemetry:
388
        metrics:
389
          readers:
390
          - pull:
391
              exporter:
392
                prometheus:
393
                  host: ${env:K8S_POD_IP}
394
                  port: 8888

一つ一つの設定を説明していると長くなるので、マニフェスト自体は折りたたみますが、agentコレクタのパイプラインは以下のようになっています。

このアーキテクチャにおいてagentコレクタはノードの情報を付与することに徹しているため、そのためのprocessorが連なっています。

基本的にはやっていることはシンプルですが、k8sattributes processorは説明がないとわかりにくいので説明をします。

processorの設定自体は下のように非常にシンプルとなっており、実際にagentコレクタではpodのIPアドレスを付与することしか行っていません。

1
k8sattributes:
2
  passthrough: true

というのも、公式ドキュメントにあるように、gateway/agent形式でパイプラインを構築する場合には全コレクタがメタデータ付与のためにAPIサーバーにアクセスして高負荷になるのを避けるために以下の2つのどちらかの設定が推奨されているためです。

agentコレクタにおいて自ノードに関するメタデータのみにアクセスするようにフィルタリングする
実際にAPIサーバーにアクセスしメタデータを付与するのはgatewayコレクタのみにする
- gatewayではpodのIPアドレスが不明なためagentコレクタはpodのIPを連携する

今回はgatewayコレクタをスケーラブルにするといってもagentよりは数が少ない見込みなこと、gatewayでまとめて行えばキャッシュなどが効いたりするかもという期待から後者を採用しました。

gatewayコレクタのデプロイ

gatewayコレクタ関連のマニフェスト

1
# gatewayコレクタ用のServiceAccount
2
apiVersion: v1
3
kind: ServiceAccount
4
metadata:
5
  namespace: monitoring
6
  name: gateway-collector
7
---
8

9
# gatewayコレクタ用のClusterRole
10
apiVersion: rbac.authorization.k8s.io/v1
11
kind: ClusterRole
12
metadata:
13
  name: gateway-collector
14
rules:
15
  # This is for k8sattributes processor
16
  # cf. https://opentelemetry.io/docs/platforms/kubernetes/collector/components/#kubernetes-attributes-processor
17
  - apiGroups:
18
      - ''
19
    resources:
20
      - 'pods'
21
      - 'namespaces'
22
    verbs:
23
      - 'get'
24
      - 'watch'
25
      - 'list'
26
  - apiGroups:
27
      - 'apps'
28
    resources:
29
      - 'replicasets'
30
    verbs:
31
      - 'get'
32
      - 'list'
33
      - 'watch'
34
  - apiGroups:
35
      - 'extensions'
36
    resources:
37
      - 'replicasets'
38
    verbs:
39
      - 'get'
40
      - 'list'
41
      - 'watch'
42
  # This rule is for apiserver job of prometheus receiver
43
  # cf. https://sysdig.jp/blog/monitor-kubernetes-api-server/
44
  - nonResourceURLs:
45
    - /metrics
46
    verbs:
47
    - get
48
---
49

50
# gatewayコレクタ用のClusterRoleBinding
51
apiVersion: rbac.authorization.k8s.io/v1
52
kind: ClusterRoleBinding
53
metadata:
54
  name: gateway-collector
55
subjects:
56
  - kind: ServiceAccount
57
    namespace: monitoring
58
    name: gateway-collector
59
roleRef:
60
  kind: ClusterRole
61
  name: gateway-collector
62
  apiGroup: rbac.authorization.k8s.io
63
---
64

65
# gatewayコレクタのTarget Allocator用のServiceAccount
66
apiVersion: v1
67
kind: ServiceAccount
68
metadata:
69
  namespace: monitoring
70
  name: gateway-target-allocator
71
---
72

73
# gatewayコレクタのTarget Allocator用のClusterRole
74
apiVersion: rbac.authorization.k8s.io/v1
75
kind: ClusterRole
76
metadata:
77
  name: gateway-target-allocator
78
rules:
79
  # This is for target allocation of kube-state-metrics
80
  - apiGroups:
81
      - ''
82
    resources:
83
      - 'pods'
84
    verbs:
85
      - 'list'
86
      - 'watch'
87
  # This is for target allocation of api-server
88
  - apiGroups:
89
      - ''
90
    resources:
91
      - 'endpoints'
92
      - 'services'
93
    verbs:
94
      - 'list'
95
      - 'watch'
96
---
97

98
# gatewayコレクタのTarget Allocator用のClusterRoleBinding
99
apiVersion: rbac.authorization.k8s.io/v1
100
kind: ClusterRoleBinding
101
metadata:
102
  name: gateway-target-allocator
103
subjects:
104
  - kind: ServiceAccount
105
    namespace: monitoring
106
    name: gateway-target-allocator
107
roleRef:
108
  kind: ClusterRole
109
  name: gateway-target-allocator
110
  apiGroup: rbac.authorization.k8s.io
111
---
112

113
# gatewayコレクタ自体のマニフェスト
114
apiVersion: opentelemetry.io/v1beta1
115
kind: OpenTelemetryCollector
116
metadata:
117
  name: gateway
118
spec:
119
  # Deployment mode does not support target allocator
120
  mode: statefulset
121
  targetAllocator:
122
    enabled: true
123
    serviceAccount: gateway-target-allocator
124

125

126
  serviceAccount: gateway-collector
127

128
  env:
129
  - name: K8S_POD_IP
130
    valueFrom:
131
      fieldRef:
132
        apiVersion: v1
133
        fieldPath: status.podIP
134
  - name: METRICS_SCRAPE_INTERVAL
135
    value: "1m"
136

137
  config:
138
    receivers:
139
      otlp:
140
        protocols:
141
          grpc:
142
            endpoint: ${env:K8S_POD_IP}:4317
143

144
      prometheus/self:
145
        config:
146
          scrape_configs:
147
          - job_name: opentelemetry-collector
148
            scrape_interval: "${env:METRICS_SCRAPE_INTERVAL}"
149
            static_configs:
150
            - targets:
151
              - ${env:K8S_POD_IP}:8888
152
              labels:
153
                # This label must not be job, because this is not recognized as attribute
154
                job_label: opentelemetry-collector
155

156
      prometheus:
157
        config:
158
          global:
159
            # Currently, target allocator config seems not to recognize environment variables
160
            # cf. https://github.com/open-telemetry/opentelemetry-operator/issues/2257
161
            scrape_interval: "1m"
162
          scrape_configs:
163

164
          - job_name: node-exporter
165
            dns_sd_configs:
166
              - type: SRV
167
                names:
168
                - _node-exporter._tcp.lab.kotaro7750.net
169
            relabel_configs:
170
            - action: replace
171
              target_label: job_label
172
              replacement: node-exporter
173

174
          # cf. https://github.com/newrelic/helm-charts/blob/master/charts/nr-k8s-otel-collector/collector.md#kube-state-metrics
175
          - job_name: kube-state-metrics
176
            kubernetes_sd_configs:
177
            - role: pod
178
            relabel_configs:
179
            - action: keep
180
              regex: kube-state-metrics
181
              source_labels:
182
              - __meta_kubernetes_pod_label_app_kubernetes_io_name
183
            - action: replace
184
              target_label: job_label
185
              replacement: kube-state-metrics
186

187
          # cf. https://github.com/newrelic/helm-charts/blob/master/charts/nr-k8s-otel-collector/collector.md#apiserver
188
          - job_name: apiserver
189
            kubernetes_sd_configs:
190
            - role: endpoints
191
              namespaces:
192
                names:
193
                  - default
194
            scheme: https
195
            tls_config:
196
              ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
197
              insecure_skip_verify: false
198
            bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
199
            relabel_configs:
200
            - action: keep
201
              regex: default;kubernetes;https
202
              source_labels:
203
              - __meta_kubernetes_namespace
204
              - __meta_kubernetes_service_name
205
              - __meta_kubernetes_endpoint_port_name
206
            - action: replace
207
              source_labels:
208
              - __meta_kubernetes_namespace
209
              target_label: namespace
210
            - action: replace
211
              source_labels:
212
              - __meta_kubernetes_service_name
213
              target_label: service
214
            - action: replace
215
              target_label: job_label
216
              replacement: apiserver
217

218
          # cf. https://github.com/newrelic/helm-charts/blob/master/charts/nr-k8s-otel-collector/collector.md#controller-manager
219
          - job_name: controller-manager
220
            metrics_path: /metrics
221
            kubernetes_sd_configs:
222
            - role: endpoints
223
            scheme: https
224
            tls_config:
225
              ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
226
              insecure_skip_verify: false
227
            bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
228
            relabel_configs:
229
            - action: keep
230
              regex: default;kubernetes;https
231
              source_labels:
232
              - __meta_kubernetes_namespace
233
              - __meta_kubernetes_service_name
234
              - __meta_kubernetes_endpoint_port_name
235
            - action: replace
236
              source_labels:
237
              - __meta_kubernetes_namespace
238
              target_label: namespace
239
            - action: replace
240
              source_labels:
241
              - __meta_kubernetes_pod_name
242
              target_label: pod
243
            - action: replace
244
              source_labels:
245
              - __meta_kubernetes_service_name
246
              target_label: service
247
            - action: replace
248
              target_label: job_label
249
              replacement: controller-manager
250

251
          # cf. https://github.com/newrelic/helm-charts/blob/master/charts/nr-k8s-otel-collector/collector.md#scheduler
252
          - job_name: scheduler
253
            kubernetes_sd_configs:
254
            - role: endpoints
255
            scheme: https
256
            tls_config:
257
              ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
258
              insecure_skip_verify: true
259
            bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
260
            relabel_configs:
261
            - action: keep
262
              regex: default;kubernetes;https
263
              source_labels:
264
              - __meta_kubernetes_namespace
265
              - __meta_kubernetes_service_name
266
              - __meta_kubernetes_endpoint_port_name
267
            - action: replace
268
              source_labels:
269
              - __meta_kubernetes_namespace
270
              target_label: namespace
271
            - action: replace
272
              source_labels:
273
              - __meta_kubernetes_service_name
274
              target_label: service
275
            - action: replace
276
              target_label: job_label
277
              replacement: scheduler
278

279
    processors:
280
      batch: {}
281
      memory_limiter:
282
        # This value if from example in the documentation
283
        # https://github.com/open-telemetry/opentelemetry-collector/blob/main/processor/memorylimiterprocessor/README.md
284
        check_interval: 1s
285
        limit_percentage: 80
286
        spike_limit_percentage: 15
287

288
      # cf. https://opentelemetry.io/docs/platforms/kubernetes/collector/components/#kubernetes-attributes-processor
289
      # k8s attributes processor on gateway collector can be used when pod ip is received from agent collector
290
      # cf. https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/k8sattributesprocessor/README.md#as-a-gateway
291
      k8sattributes:
292
        auth_type: 'serviceAccount'
293
        extract:
294
          metadata: # extracted from the pod
295
            - k8s.namespace.name
296
            - k8s.pod.name
297
            - k8s.pod.start_time
298
            - k8s.pod.uid
299
            - k8s.deployment.name
300
            - k8s.daemonset.name
301
            - k8s.statefulset.name
302
            - k8s.cronjob.name
303
            - k8s.job.name
304
            - k8s.node.name
305
        pod_association:
306
          - sources: # First try to use the value of the resource attribute k8s.pod.ip
307
              - from: resource_attribute
308
                name: k8s.pod.ip
309
          - sources: # Then try to use the value of the resource attribute k8s.pod.uid
310
              - from: resource_attribute
311
                name: k8s.pod.uid
312
          - sources: # If neither of those work, use the request's connection to get the pod IP.
313
              - from: connection
314

315
      resource/append_pod_ip:
316
        attributes:
317
          - key: k8s.pod.ip
318
            action: insert
319
            value: ${env:K8S_POD_IP}
320

321
      resource/delete_pod_ip:
322
        attributes:
323
        - key: k8s.pod.ip
324
          action: delete
325

326
      resource/append_environment_info:
327
        attributes:
328
        - key: k8s.cluster.name
329
          value: lab-production
330
          action: upsert
331
        - key: deployment.environment.name
332
          value: production
333
          action: upsert
334

335
      resource/new_relic:
336
        attributes:
337
        - key: newrelicOnly
338
          action: upsert
339
          value: 'true'
340
        - key: service.name
341
          action: delete
342
        - key: service_name
343
          action: delete
344

345
      # This is for NewRelic
346
      # cf. https://github.com/newrelic/helm-charts/blob/master/charts/nr-k8s-otel-collector/collector.md#processors
347
      metricstransform/k8s_cluster_info:
348
        transforms:
349
        - include: kubernetes_build_info
350
          action: update
351
          new_name: k8s.cluster.info
352

353
      # This is for NewRelic
354
      metricstransform/kube_pod_status_phase:
355
        transforms:
356
          - include: 'kube_pod_container_status_waiting'
357
            match_type: strict
358
            action: update
359
            new_name: 'kube_pod_container_status_phase'
360
            operations:
361
            - action: add_label
362
              new_label: container_phase
363
              new_value: waiting
364
          - include: 'kube_pod_container_status_running'
365
            match_type: strict
366
            action: update
367
            new_name: 'kube_pod_container_status_phase'
368
            operations:
369
            - action: add_label
370
              new_label: container_phase
371
              new_value: running
372
          - include: 'kube_pod_container_status_terminated'
373
            match_type: strict
374
            action: update
375
            new_name: 'kube_pod_container_status_phase'
376
            operations:
377
            - action: add_label
378
              new_label: container_phase
379
              new_value: terminated
380

381
      # This is for NewRelic
382
      metricstransform/hostmetrics_cpu:
383
        transforms:
384
          - include: system.cpu.utilization
385
            action: update
386
            operations:
387
              - action: aggregate_labels
388
                label_set:
389
                # Only exclude cpu attribute
390
                - state
391
                - host_ip
392
                - k8s_node_uid
393
                - host_name
394
                - k8s_node_name
395
                - job_label
396
                - k8s_cluster_name
397
                - deployment_environment_name
398
                aggregation_type: mean
399
          - include: system.paging.operations
400
            action: update
401
            operations:
402
              - action: aggregate_labels
403
                label_set: [ direction ]
404
                aggregation_type: sum
405

406
    exporters:
407
      otlp/signoz:
408
        endpoint: 172.16.1.59:4317
409
        tls:
410
          insecure: true
411
      otlphttp/new_relic:
412
        endpoint: https://otlp.nr-data.net:4318
413
        headers:
414
          api-key: "1e249af1eea27fa5ee8304a883a86f14FFFFNRAL"
415

416
    connectors:
417
      routing/metrics_common:
418
        table:
419
          - condition: "true"
420
            pipelines:
421
              - metrics
422

423
      routing/metrics_per_backend:
424
        table:
425
          - condition: "true"
426
            pipelines:
427
              - metrics/new_relic
428

429
      routing/logs_per_backend:
430
        table:
431
          - condition: "true"
432
            pipelines:
433
              - logs/new_relic
434

435
      routing/traces_per_backend:
436
        table:
437
          - condition: "true"
438
            pipelines:
439
              - traces/new_relic
440

441
    service:
442
      pipelines:
443
        traces:
444
          receivers: [otlp]
445
          processors:
446
          - memory_limiter
447
          - batch
448
          - k8sattributes
449
          - resource/delete_pod_ip
450
          - resource/append_environment_info
451
          exporters:
452
          - routing/traces_per_backend
453

454
        traces/new_relic:
455
          receivers:
456
          - routing/traces_per_backend
457
          processors:
458
          - resource/new_relic
459
          exporters:
460
          - otlp/signoz
461
          # - otlphttp/new_relic
462

463
        logs:
464
          receivers: [otlp]
465
          processors:
466
          - memory_limiter
467
          - batch
468
          - k8sattributes
469
          - resource/delete_pod_ip
470
          - resource/append_environment_info
471
          exporters:
472
          - routing/logs_per_backend
473

474
        logs/new_relic:
475
          receivers:
476
          - routing/logs_per_backend
477
          processors:
478
          - resource/new_relic
479
          exporters:
480
          - otlp/signoz
481
          # - otlphttp/new_relic
482

483
        metrics/self:
484
          receivers:
485
            - prometheus/self
486
          processors:
487
            - resource/append_pod_ip
488
          exporters:
489
            - routing/metrics_common
490

491
        metrics:
492
          receivers:
493
          - otlp
494
          - prometheus
495
          - routing/metrics_common
496
          processors:
497
          - memory_limiter
498
          - batch
499
          - k8sattributes
500
          - resource/delete_pod_ip
501
          - resource/append_environment_info
502
          exporters:
503
          - routing/metrics_per_backend
504

505
        metrics/new_relic:
506
          receivers:
507
          - routing/metrics_per_backend
508
          processors:
509
          - resource/new_relic
510
          - metricstransform/k8s_cluster_info
511
          - metricstransform/kube_pod_status_phase
512
          - metricstransform/hostmetrics_cpu
513
          exporters:
514
          - otlp/signoz
515
          # - otlphttp/new_relic
516

517
      telemetry:
518
        metrics:
519
          readers:
520
          - pull:
521
              exporter:
522
                prometheus:
523
                  host: ${env:K8S_POD_IP}
524
                  port: 8888

今回のパイプラインでもっとも複雑なのがgatewayコレクタです。そのため、画像でも多少省略している部分があります。

gatewayコレクタにおいて重要な点は以下の3つです。

kubernetesのメタデータを実際に付与している
バックエンドに応じてデータを変換する
Target Allocatorを利用してスケーラブルにしている

1つ目に関しては、agentコレクタの部分でも説明したように、k8sattributes processorによるAPIサーバーに対する負荷を考慮してgatewayコレクタでまとめてメタデータを付与しているというものです。

2つ目に関しては、各バックエンド（このマニフェストではNewRelicを想定）に応じてデータの変換を行うというものです。製品によっては必要なメタデータやメトリクスが異なりますが、実際にバックエンドに送る直前にデータの変換を行うことでバックエンドの仕様変更・追加に柔軟に対応できるようにしています。また、コストの観点からもそれぞれに応じてメトリクスを減らしたりラベルのカーディナリティを減らすことでコスト削減も可能にします³。

3つ目については次のセクションで説明します。

clusteragentコレクタのデプロイ

clusteragentコレクタ関連のマニフェスト

1
# clusteragentコレクタ用のServiceAccount
2
apiVersion: v1
3
kind: ServiceAccount
4
metadata:
5
  namespace: monitoring
6
  name: clusteragent-collector
7
---
8

9
# clusteragentコレクタ用のClusterRole
10
apiVersion: rbac.authorization.k8s.io/v1
11
kind: ClusterRole
12
metadata:
13
  name: clusteragent-collector
14
rules:
15
  # This is for k8s_events receiver
16
  # cf. https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/k8seventsreceiver
17
  - apiGroups:
18
    - ""
19
    resources:
20
    - events
21
    - namespaces
22
    - namespaces/status
23
    - nodes
24
    - nodes/spec
25
    - pods
26
    - pods/status
27
    - replicationcontrollers
28
    - replicationcontrollers/status
29
    - resourcequotas
30
    - services
31
    verbs:
32
    - get
33
    - list
34
    - watch
35
  - apiGroups:
36
    - apps
37
    resources:
38
    - daemonsets
39
    - deployments
40
    - replicasets
41
    - statefulsets
42
    verbs:
43
    - get
44
    - list
45
    - watch
46
  - apiGroups:
47
    - extensions
48
    resources:
49
    - daemonsets
50
    - deployments
51
    - replicasets
52
    verbs:
53
    - get
54
    - list
55
    - watch
56
  - apiGroups:
57
    - batch
58
    resources:
59
    - jobs
60
    - cronjobs
61
    verbs:
62
    - get
63
    - list
64
    - watch
65
  - apiGroups:
66
      - autoscaling
67
    resources:
68
      - horizontalpodautoscalers
69
    verbs:
70
      - get
71
      - list
72
      - watch
73
---
74

75
# clusteragentコレクタ用のClusterRoleBinding
76
apiVersion: rbac.authorization.k8s.io/v1
77
kind: ClusterRoleBinding
78
metadata:
79
  name: clusteragent-collector
80
subjects:
81
  - kind: ServiceAccount
82
    namespace: monitoring
83
    name: clusteragent-collector
84
roleRef:
85
  kind: ClusterRole
86
  name: clusteragent-collector
87
  apiGroup: rbac.authorization.k8s.io
88
---
89

90
# clusteragentコレクタ自体のマニフェスト
91
apiVersion: opentelemetry.io/v1beta1
92
kind: OpenTelemetryCollector
93
metadata:
94
  name: clusteragent
95
spec:
96
  mode: deployment
97
  serviceAccount: clusteragent-collector
98
  # This collector is for cluster-wide telemetry but not scalable with target allocator, so replicas must be 1 for avoiding duplication
99
  replicas: 1
100

101
  env:
102
  - name: K8S_POD_IP
103
    valueFrom:
104
      fieldRef:
105
        apiVersion: v1
106
        fieldPath: status.podIP
107
  - name: METRICS_SCRAPE_INTERVAL
108
    value: "1m"
109

110
  config:
111
    receivers:
112
      k8s_events: {}
113

114
      prometheus:
115
        config:
116
          scrape_configs:
117
          - job_name: opentelemetry-collector
118
            scrape_interval: ${env:METRICS_SCRAPE_INTERVAL}
119
            static_configs:
120
            - targets:
121
              - ${env:K8S_POD_IP}:8888
122
              labels:
123
                # This label must not be job, because this is not recognized as attribute
124
                job_label: opentelemetry-collector
125

126
    processors:
127
      batch: {}
128
      memory_limiter:
129
        # This value if from example in the documentation
130
        # https://github.com/open-telemetry/opentelemetry-collector/blob/main/processor/memorylimiterprocessor/README.md
131
        check_interval: 1s
132
        limit_percentage: 80
133
        spike_limit_percentage: 15
134

135
      # This is for pod annotation adding in gateway collector
136
      resource/append_pod_ip:
137
        attributes:
138
          - key: k8s.pod.ip
139
            action: insert
140
            value: ${env:K8S_POD_IP}
141

142

143
    exporters:
144
      otlp:
145
        endpoint: gateway-collector:4317
146
        tls:
147
          insecure: true
148

149
    connectors:
150
      routing/metrics_common:
151
        table:
152
          - condition: "true"
153
            pipelines:
154
              - metrics
155

156
    service:
157
      pipelines:
158
        logs:
159
          receivers: [k8s_events]
160
          processors:
161
          - memory_limiter
162
          - batch
163
          exporters: [otlp]
164

165
        metrics/prometheus:
166
          receivers:
167
            - prometheus
168
          processors:
169
            - resource/append_pod_ip
170
          exporters:
171
            - routing/metrics_common
172

173
        metrics:
174
          receivers:
175
          - routing/metrics_common
176
          processors:
177
          - memory_limiter
178
          - batch
179
          exporters: [otlp]
180

181
      telemetry:
182
        metrics:
183
          readers:
184
          - pull:
185
              exporter:
186
                prometheus:
187
                  host: ${env:K8S_POD_IP}
188
                  port: 8888

アーキテクチャセクションで記載したようにclusteragentコレクタではTarget Allocatorを利用できないが重複を避けたいシグナルを取得しています。そのためdeploymentのレプリカ数は1にしています。

パイプラインとしては非常にシンプルで、k8sevents receiverでk8sのイベントを取得するのみを担当しています。 k8sのイベントを1つのコレクタで取得している時点でスケールしないのでは？と思うかもしれませんが、メトリクスと比較すると軽量である見込みが高いためこのような構成としています⁴。

Target AllocatorによるPrometheusスクレイプ分散

今回のアーキテクチャでもっとも重要な部分ともいえるのが、gatewayコレクタのTarget Allocatorによるprometheusメトリクスの分担スクレイプです。これにより、メトリクスの重複なしにコレクタをスケールすることが可能になります。

公式ドキュメントから引用した以下の図に示すように、Target Allocatorがスクレイプ対象のメトリクスを各コレクタに割り振り、各コレクタがそれを参照してスクレイプすることで分担を可能にしています。 Target Allocatorの仕組み（公式ドキュメントから引用）

何やら複雑な仕組みですが、実際に行う必要のある設定は以下のようにyamlに数行各程度であり、スクレイプ設定自体はTarget Allocatorを使わない場合と全く同じです。

1
spec:
2
  # deploymentモードはTarget Allocatorを利用できないので注意
3
  mode: statefulset
4
  targetAllocator:
5
    enabled: true
6
    serviceAccount: gateway-target-allocator

なお、公式ドキュメントにはデバッグの方法が書かれており、Target Allocatorに対し実際に分担されたターゲットを参照することができます。

実際に参照した例が下で、apiサーバーへのスクレイプは1つ目のレプリカに割り振られ、kube-state-metricsへのスクレイプはもう一つのレプリカに割り振られていることがわかります。

1
// あらかじめTarget AllocatorのServiceに対してport-forwardしておく
2
// kubectl port-forward svc/otelcol-targetallocator -n opentelemetry 8080:80
3

4
// curl localhost:8080/jobs
5
{
6
  "apiserver": {
7
    "_link": "/jobs/apiserver/targets"
8
  },
9
  "kube-state-metrics": {
10
    "_link": "/jobs/kube-state-metrics/targets"
11
  }
12
  // ...
13
}
14

15
// curl localhost:8080/jobs/apiserver/targets
16
{
17
  "gateway-collector-0": {
18
    "_link": "/jobs/apiserver/targets?collector_id=gateway-collector-0",
19
    "targets": [
20
      {
21
        "targets": [
22
          "172.16.1.7:6443"
23
        ],
24
        "labels": {
25
          "__address__": "172.16.1.7:6443",
26
          "__meta_kubernetes_endpoint_port_name": "https",
27
          // ...
28
          "__meta_kubernetes_service_name": "kubernetes"
29
        }
30
      }
31
    ]
32
  },
33
  "gateway-collector-1": {
34
    "_link": "/jobs/apiserver/targets?collector_id=gateway-collector-1",
35
    "targets": []
36
  }
37
}
38
// curl localhost:8080/jobs/kube-state-metrics/targets
39
{
40
  "gateway-collector-0": {
41
    "_link": "/jobs/kube-state-metrics/targets?collector_id=gateway-collector-0",
42
    "targets": []
43
  },
44
  "gateway-collector-1": {
45
    "_link": "/jobs/kube-state-metrics/targets?collector_id=gateway-collector-1",
46
    "targets": [
47
      {
48
        "targets": [
49
          "10.0.1.251:8080"
50
        ],
51
        "labels": {
52
          "__address__": "10.0.1.251:8080",
53
          "__meta_kubernetes_namespace": "monitoring",
54
          "__meta_kubernetes_pod_container_id": "containerd://46c6a053c90e445464ac3d3ef41b5039ffba591c145976dc50ad3e8ee2269a0d",
55
          // ...
56
          "__meta_kubernetes_pod_uid": "285e7b4e-8b28-4a6d-8a32-d1ba302eeba9"
57
        }
58
      }
59
    ]
60
  }
61
}

なお、今回は利用していませんが、Target AllocatorはPrometheus OperatorのCustom Resourceを参照する機能も持っています。

可視化による確認

実際にデプロイした後は、Observabilityバックエンドにデータを送信して可視化してみます。今回はNewRelicとSigNozを利用してみました⁵。

実際に活用するためにはそれぞれに応じてデータの変換を調整する必要がありますが、同じパイプラインで異なるバックエンドにデータを送信することができています。

まとめ

この記事では、自宅サーバー環境に統一的・スケーラブルなObservabilityパイプラインを構築しました。

今後はこのアーキテクチャをベースに、Observabilityの強化を図っていきたいです。

その他にはtail baseサンプリング（特定の条件を満たすトレーススパンのみをサンプルする機能）があります。これを行うためには同じトレースIDを持つスパンを同じコレクタで処理する必要があります。この記事では紹介しませんが、これを実現する手段としてload-balancing-exporterを利用することができます。 ↩
割愛とお茶を濁していますが実際には記事を書いている時に気づきました。特に前者は自分の場合ちゃんとAnsibleプレイブックを書かないといけなく、労力の割に話題としては重要ではないということもあり先に記事を書いています。そのうち別記事として追加するかも。 ↩
この設定はNewRelicのドキュメントを参考にしていますが、必要十分なメトリクス・カーディナリティの調整は検証しきれていないので、あくまでも参考程度にしてください。 ↩
とはいえ全くもってスケールできないわけではなく、取得対象のnamespaceを分担すればスケールが可能です。ただしその場合対象のnamespaceの指定を行う必要があり、特に何も考えないと別々の設定ファイルを使うことに繋がるためやるにしても何らかの仕組みがないと運用が面倒になります。 ↩
SigNozはDatadogよりもコスト効率が良いと謳っているOSSのAPMツールで、OpenTelemetryネイティブを標榜しており、docker composeで簡単に立ち上げられるため検証には便利です。 ↩