Installer le collecteur DDOT en tant que passerelle sur Kubernetes
Présentation
Le collecteur OpenTelemetry peut être déployé de plusieurs manières. Le modèle daemonset est un déploiement courant où une instance de collecteur s’exécute sur chaque nœud Kubernetes aux côtés du Datadog Agent principal.
Le modèle gateway offre une option de déploiement supplémentaire qui utilise un service de collecteur centralisé et autonome. Cette couche de passerelle peut effectuer des actions telles que l’échantillonnage du suivi, l’agrégation, le filtrage et le routage avant d’exporter les données vers un ou plusieurs backends tels que Datadog. Il agit comme un point central pour la gestion et l’application des politiques d’observabilité.
Lorsque vous activez la passerelle :
- Un déploiement Kubernetes (
<RELEASE_NAME>-datadog-otel-agent-gateway-deployment) gère les pods autonomes du collecteur de passerelle. - Un service Kubernetes (
<RELEASE_NAME>-datadog-otel-agent-gateway) expose les pods de la passerelle et assure l’équilibrage de charge. - Les pods du collecteur DaemonSet existants sont configurés par défaut pour envoyer leurs données de télémétrie au service de passerelle au lieu de les envoyer directement à Datadog.
Dans un déploiement de passerelle, ajoutez les informations du host avant que la télémétrie n’atteigne la passerelle. Pour la configuration recommandée du nom de host, consultez Nom de host et tagging.
Prérequis
Avant de commencer, assurez-vous de disposer des éléments suivants :
- Compte Datadog:
- Logiciel :
- Un cluster Kubernetes (v1.29+). EKS Fargate et GKE Autopilot ne sont pas pris en charge.
- Helm (v3+).
- Version 3.160.1+ du chart Helm Datadog ou version 1.23.0+ de Datadog Operator.
- kubectl.
- Réseau :
When using the Datadog SDK with OpenTelemetry API support, telemetry is routed to different components depending on the signal source. Ensure the following ports are accessible on your Datadog Agent or Collector:
| Signal Source | Protocol | Port | Destination Component |
|---|
| OTel Metrics and Logs API | OTLP (gRPC/HTTP) | 4317 / 4318 | Datadog Agent OTLP Receiver or DDOT Collector |
| Datadog Tracing | Datadog trace intake | 8126 (TCP) | Datadog Trace Agent |
| Runtime Metrics | DogStatsD | 8125 (UDP) | DogStatsD Server |
Installation et configuration
Ce guide montre comment configurer la passerelle du collecteur DDOT en utilisant Datadog Operator ou le chart Helm.
Cette installation est requise pour les configurations Datadog SDK + DDOT et OpenTelemetry SDK + DDOT. Bien que le SDK Datadog implémente l'API OpenTelemetry, il nécessite toujours le Collector DDOT pour traiter et transférer les métriques et logs OTLP.
Choisissez l’une des méthodes d’installation suivantes :
- Datadog Operator : une approche native Kubernetes qui réconcilie et maintient automatiquement votre configuration Datadog. Il signale l’état du déploiement, l’intégrité et les erreurs dans le statut de sa ressource personnalisée (Custom Resource), et limite le risque de mauvaise configuration grâce à des options de configuration de plus haut niveau.
- Chart Helm : Un moyen simple de déployer Datadog Agent. Il offre des fonctionnalités de gestion des versions, de restauration et de création de modèles, rendant les déploiements cohérents et plus faciles à répliquer.
Installez Datadog Operator ou Helm
Si vous n’avez pas encore installé Datadog Operator, vous pouvez l’installer dans votre cluster en utilisant le chart Helm de Datadog Operator :
helm repo add datadog https://helm.datadoghq.com
helm repo update
helm install datadog-operator datadog/datadog-operator
Pour plus d’informations, consultez la documentation de Datadog Operator.
Si vous n’avez pas encore ajouté le dépôt Helm de Datadog, ajoutez-le maintenant :
helm repo add datadog https://helm.datadoghq.com
helm repo update
Pour plus d’informations sur les options de configuration de Helm, consultez le README du chart Helm de Datadog.
Déploiement de la passerelle avec un DaemonSet
Pour commencer, activez à la fois la passerelle et le collecteur DaemonSet dans votre ressource DatadogAgent. Il s’agit de la configuration la plus courante.
Créez un fichier nommé datadog-agent.yaml :
apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
name: datadog
spec:
global:
credentials:
apiSecret:
secretName: datadog-secret
keyName: api-key
features:
# Enable the Collector in the Agent DaemonSet
otelCollector:
enabled: true
# Enable the standalone Gateway Deployment
otelAgentGateway:
enabled: true
override:
otelAgentGateway:
# Number of replicas
replicas: 3
# Control placement of gateway pods
nodeSelector:
gateway: "true"
Appliquez la configuration :
kubectl apply -f datadog-agent.yaml
Pour commencer, activez à la fois la passerelle et le collecteur DaemonSet dans votre fichier values.yaml. Il s’agit de la configuration la plus courante.
# values.yaml
targetSystem: "linux"
datadog:
apiKey: <DATADOG_API_KEY>
appKey: <DATADOG_APP_KEY>
# Enable the Collector in the Agent Daemonset
otelCollector:
enabled: true
# Enable the standalone Gateway Deployment
otelAgentGateway:
enabled: true
replicas: 3
nodeSelector:
# Example selector to place gateway pods on specific nodes
gateway: "true"
Dans ce cas, le collecteur DaemonSet utilise une configuration par défaut qui envoie les données OTLP au service Kubernetes de la passerelle :
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
exporters:
debug:
verbosity: detailed
otlphttp:
endpoint: http://<release>-datadog-otel-agent-gateway:4318
tls:
insecure: true
sending_queue:
batch:
flush_timeout: 10s
processors:
infraattributes:
cardinality: 2
connectors:
datadog/connector:
traces:
compute_top_level_by_span_kind: true
peer_tags_aggregation: true
compute_stats_by_span_kind: true
service:
pipelines:
traces:
receivers: [otlp]
processors: [infraattributes]
exporters: [otlphttp, datadog/connector]
metrics:
receivers: [otlp, datadog/connector]
processors: [infraattributes]
exporters: [otlphttp]
logs:
receivers: [otlp]
processors: [infraattributes]
exporters: [otlphttp]
Le collecteur de la passerelle utilise une configuration par défaut qui écoute sur les ports de service et envoie les données à Datadog :
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
exporters:
debug:
verbosity: detailed
datadog:
api:
key: ${env:DD_API_KEY}
sending_queue:
batch:
flush_timeout: 10s
processors:
extension:
datadog:
api:
key: ${env:DD_API_KEY}
deployment_type: gateway
service:
pipelines:
traces:
receivers: [otlp]
exporters: [datadog]
metrics:
receivers: [otlp]
exporters: [datadog]
logs:
receivers: [otlp]
exporters: [datadog]
Pour les utilisateurs de Helm : Configurez otelAgentGateway.affinity ou otelAgentGateway.nodeSelector pour contrôler le placement des pods, et ajustez otelAgentGateway.replicas pour mettre à l'échelle la passerelle.
Pour les utilisateurs de l'Opérateur : Utilisez override.otelAgentGateway.affinity, override.otelAgentGateway.nodeSelector, et override.otelAgentGateway.replicas pour ces paramètres.
Déployer une passerelle autonome
Si vous disposez d’un déploiement DaemonSet existant, vous pouvez déployer la passerelle indépendamment en désactivant d’autres composants :
apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
name: datadog-gateway
spec:
global:
credentials:
apiSecret:
secretName: datadog-secret
keyName: api-key
features:
otelAgentGateway:
enabled: true
override:
otelAgentGateway:
# Number of replicas
replicas: 3
# Control placement of gateway pods
nodeSelector:
gateway: "true"
# Disable the Agent DaemonSet
nodeAgent:
disabled: true
# Disable the Cluster Agent
clusterAgent:
disabled: true
Après avoir déployé la passerelle, vous devez mettre à jour la configuration de vos collecteurs DaemonSet existants pour envoyer des données vers le nouvel endpoint du service passerelle (par exemple, http://datadog-gateway-otel-agent-gateway:4318).
Si vous disposez d’un déploiement DaemonSet existant, vous pouvez déployer la passerelle indépendamment.
# values.yaml
targetSystem: "linux"
fullnameOverride: "gw-only"
agents:
enabled: false
clusterAgent:
enabled: false
datadog:
apiKey: <DATADOG_API_KEY>
appKey: <DATADOG_APP_KEY>
otelAgentGateway:
enabled: true
replicas: 3
nodeSelector:
gateway: "true"
Après avoir déployé la passerelle, vous devez mettre à jour la configuration de vos collecteurs DaemonSet existants pour envoyer des données vers le nouvel endpoint du service passerelle (par exemple, http://gw-only-otel-agent-gateway:4318).
Personnalisation des configurations du collecteur
Vous pouvez personnaliser la configuration du collecteur de la passerelle à l’aide de ConfigMaps. Créez une ConfigMap avec votre configuration personnalisée :
apiVersion: v1
kind: ConfigMap
metadata:
name: otel-gateway-config
data:
otel-gateway-config.yaml: |
receivers:
otlp:
protocols:
grpc:
endpoint: "0.0.0.0:4317"
http:
endpoint: "0.0.0.0:4318"
exporters:
datadog:
api:
key: ${env:DD_API_KEY}
sending_queue:
batch:
flush_timeout: 10s
service:
pipelines:
traces:
receivers: [otlp]
exporters: [datadog]
metrics:
receivers: [otlp]
exporters: [datadog]
logs:
receivers: [otlp]
exporters: [datadog]
Référencez-la ensuite dans votre ressource DatadogAgent :
apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
name: datadog
spec:
global:
credentials:
apiSecret:
secretName: datadog-secret
keyName: api-key
features:
otelAgentGateway:
enabled: true
# Reference the custom ConfigMap
config:
configMap:
name: otel-gateway-config
override:
otelAgentGateway:
replicas: 3
Pour les ConfigMaps multi-éléments ou la configuration en ligne, consultez les exemples DatadogAgent.
Vous pouvez remplacer les configurations par défaut des collecteurs DaemonSet et passerelle en utilisant respectivement les valeurs datadog.otelCollector.config et otelAgentGateway.config.
# values.yaml
targetSystem: "linux"
fullnameOverride: "my-gw"
datadog:
apiKey: <DATADOG_API_KEY>
appKey: <DATADOG_APP_KEY>
# Enable and configure the DaemonSet Collector
otelCollector:
enabled: true
config: |
receivers:
otlp:
protocols:
grpc:
endpoint: "localhost:4317"
exporters:
otlp:
endpoint: http://my-gw-otel-agent-gateway:4317
tls:
insecure: true
service:
pipelines:
traces:
receivers: [otlp]
exporters: [otlp]
metrics:
receivers: [otlp]
exporters: [otlp]
logs:
receivers: [otlp]
exporters: [otlp]
# Enable and configure the gateway Collector
otelAgentGateway:
enabled: true
replicas: 3
nodeSelector:
gateway: "true"
ports:
- containerPort: 4317
name: "otel-grpc"
config: |
receivers:
otlp:
protocols:
grpc:
endpoint: "0.0.0.0:4317"
exporters:
datadog:
api:
key: ${env:DD_API_KEY}
sending_queue:
batch:
flush_timeout: 10s
service:
pipelines:
traces:
receivers: [otlp]
exporters: [datadog]
metrics:
receivers: [otlp]
exporters: [datadog]
logs:
receivers: [otlp]
exporters: [datadog]
For the infraattributes processor to add Kubernetes tags, your telemetry must include the container.id resource attribute. This is often, but not always, added by OTel SDK auto-instrumentation.
If your tags are missing, see the troubleshooting guide for details on how to add this attribute.
Si vous définissez fullnameOverride, le nom du service Kubernetes de la passerelle devient -otel-agent-gateway. Les ports définis dans otelAgentGateway.ports sont exposés sur ce service. Assurez-vous que ces ports correspondent à la configuration du récepteur OTLP dans la passerelle et à la configuration de l'exportateur OTLP dans le DaemonSet.
Les exemples de configuration utilisent TLS non sécurisé par souci de simplicité. Suivez les instructions OTel configtls si vous souhaitez activer TLS.
Options de configuration avancées
Datadog Operator fournit des options de configuration supplémentaires pour la passerelle de l’Agent OTel sous override.otelAgentGateway (NON features.otelAgentGateway sauf featureGates) :
apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
name: datadog
spec:
global:
credentials:
apiSecret:
secretName: datadog-secret
keyName: api-key
features:
otelAgentGateway:
enabled: true
# Feature gates for OTel collector (feature-specific configuration)
featureGates: "telemetry.UseLocalHostAsDefaultMetricsAddress"
override:
otelAgentGateway:
# Number of replicas
replicas: 3
# Node selector for pod placement
nodeSelector:
kubernetes.io/os: linux
gateway: "true"
# Affinity configuration
affinity:
podAntiAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
podAffinityTerm:
labelSelector:
matchExpressions:
- key: app
operator: In
values:
- datadog-otel-agent-gateway
topologyKey: kubernetes.io/hostname
# Tolerations for tainted nodes
tolerations:
- key: "dedicated"
operator: "Equal"
value: "otel-gateway"
effect: "NoSchedule"
# Priority class for scheduling
priorityClassName: high-priority
# Environment variables
env:
- name: OTEL_LOG_LEVEL
value: "info"
# Environment variables from ConfigMaps or Secrets
envFrom:
- configMapRef:
name: otel-gateway-config
# Custom image (optional)
image:
name: ddot-collector
tag: "7.83.1"
pullPolicy: IfNotPresent
# Pod-level security context
securityContext:
runAsUser: 1000
runAsGroup: 1000
fsGroup: 1000
# Configure resources
containers:
otel-agent:
resources:
requests:
cpu: 200m
memory: 512Mi
limits:
cpu: 500m
memory: 1Gi
# Additional labels and annotations
labels:
team: observability
annotations:
prometheus.io/scrape: "true"
Pour une référence complète de toutes les options disponibles, consultez la documentation de configuration de DatadogAgent v2alpha1.
Pour les déploiements basés sur Helm, bon nombre de ces options de configuration avancées peuvent être définies directement dans le fichier values.yaml sous la section otelAgentGateway. Pour une référence complète, consultez le README du chart Helm Datadog.
Cas d’utilisation avancés
Échantillonnage du suivi avec l’exportateur d’équilibrage de charge
Un cas d’utilisation principal pour la passerelle est l’échantillonnage du suivi. Pour garantir que toutes les étendues (spans) d’une trace donnée soient traitées par le même pod de passerelle, utilisez l’exportateur d’équilibrage de charge dans vos collecteurs DaemonSet. Cet exportateur achemine systématiquement les étendues en fonction d’une clé, telle que traceID.
Le collecteur DaemonSet est configuré avec l’exportateur loadbalancing, qui utilise le résolveur de service Kubernetes pour découvrir et acheminer les données vers les pods passerelle. Le collecteur passerelle utilise le processeur tail_sampling pour échantillonner les traces en fonction de politiques définies avant de les exporter vers Datadog.
Remarque : des autorisations RBAC sont requises pour le résolveur k8s dans l’exportateur d’équilibrage de charge.
Créez une ConfigMap pour la configuration du collecteur DaemonSet avec l’exportateur d’équilibrage de charge :
apiVersion: v1
kind: ConfigMap
metadata:
name: otel-daemonset-config
data:
otel-config.yaml: |
receivers:
otlp:
protocols:
grpc:
endpoint: "localhost:4317"
exporters:
loadbalancing:
routing_key: "traceID"
protocol:
otlp:
tls:
insecure: true
resolver:
k8s:
service: datadog-otel-agent-gateway
ports:
- 4317
service:
pipelines:
traces:
receivers: [otlp]
exporters: [loadbalancing]
Créez une ConfigMap pour la configuration du collecteur de la passerelle avec l’échantillonnage du suivi :
apiVersion: v1
kind: ConfigMap
metadata:
name: otel-gateway-tailsampling-config
data:
otel-gateway-config.yaml: |
receivers:
otlp:
protocols:
grpc:
endpoint: "0.0.0.0:4317"
processors:
tail_sampling:
decision_wait: 10s
policies:
# Add your sampling policies here
- name: sample-errors
type: status_code
status_code:
status_codes: [ERROR]
- name: sample-slow-traces
type: latency
latency:
threshold_ms: 1000
connectors:
datadog/connector:
exporters:
datadog:
api:
key: ${env:DD_API_KEY}
service:
pipelines:
traces/sample:
receivers: [otlp]
processors: [tail_sampling]
exporters: [datadog]
traces:
receivers: [otlp]
exporters: [datadog/connector]
metrics:
receivers: [datadog/connector]
exporters: [datadog]
Appliquez la configuration DatadogAgent :
apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
name: datadog
spec:
global:
credentials:
apiSecret:
secretName: datadog-secret
keyName: api-key
features:
otelCollector:
enabled: true
# Reference the custom DaemonSet config
config:
configMap:
name: otel-daemonset-config
# RBAC permissions for the k8s resolver
rbac:
create: true
otelAgentGateway:
enabled: true
# Reference the custom gateway config
config:
configMap:
name: otel-gateway-tailsampling-config
override:
otelAgentGateway:
replicas: 3
Créez un ClusterRole pour que le DaemonSet puisse accéder aux endpoints :
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: otel-collector-k8s-resolver
rules:
- apiGroups: [""]
resources: ["endpoints"] # for v0.139.0 and before
verbs: ["get", "watch", "list"]
- apiGroups: ["discovery.k8s.io"]
resources: ["endpointslices"] # for v0.140.0 and after
verbs: ["get", "watch", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: otel-collector-k8s-resolver
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: otel-collector-k8s-resolver
subjects:
- kind: ServiceAccount
name: datadog-agent
namespace: default
Pour garantir que les statistiques APM sont calculées sur 100 % de vos traces avant l'échantillonnage, le datadog/connector s'exécute dans un pipeline séparé sans le tail_sampling processeur. Le connecteur peut s'exécuter soit dans le DaemonSet, soit dans la couche passerelle.
Dans la configuration ci-dessous :
- Le collecteur DaemonSet (
datadog.otelCollector) est configuré avec l’exportateur loadbalancing, qui utilise le résolveur de service Kubernetes pour découvrir et acheminer les données vers les pods passerelle. - Le collecteur passerelle (
otelAgentGateway) utilise le processeur tail_sampling pour échantillonner les traces en fonction de politiques définies avant de les exporter vers Datadog.
# values.yaml
targetSystem: "linux"
fullnameOverride: "my-gw"
datadog:
apiKey: <DATADOG_API_KEY>
appKey: <DATADOG_APP_KEY>
otelCollector:
enabled: true
# RBAC permissions are required for the k8s resolver in the loadbalancing exporter
rbac:
create: true
rules:
- apiGroups: [""]
resources: ["endpoints"] # for v0.139.0 and before
verbs: ["get", "watch", "list"]
- apiGroups: ["discovery.k8s.io"]
resources: ["endpointslices"] # for v0.140.0 and after
verbs: ["get", "watch", "list"]
config: |
receivers:
otlp:
protocols:
grpc:
endpoint: "localhost:4317"
exporters:
loadbalancing:
routing_key: "traceID"
protocol:
otlp:
tls:
insecure: true
resolver:
k8s:
service: my-gw-otel-agent-gateway
ports:
- 4317
service:
pipelines:
traces:
receivers: [otlp]
exporters: [loadbalancing]
otelAgentGateway:
enabled: true
replicas: 3
ports:
- containerPort: 4317
name: "otel-grpc"
config: |
receivers:
otlp:
protocols:
grpc:
endpoint: "0.0.0.0:4317"
processors:
tail_sampling:
decision_wait: 10s
policies: <Add your sampling policies here>
connectors:
datadog/connector:
exporters:
datadog:
api:
key: ${env:DD_API_KEY}
service:
pipelines:
traces/sample:
receivers: [otlp]
processors: [tail_sampling]
exporters: [datadog]
traces:
receivers: [otlp]
exporters: [datadog/connector]
metrics:
receivers: [datadog/connector]
exporters: [datadog]
Pour garantir que les statistiques APM sont calculées sur 100 % de vos traces avant l'échantillonnage, le datadog/connector s'exécute dans un pipeline séparé sans le tail_sampling processeur. Le connecteur peut s'exécuter soit dans le DaemonSet, soit dans la couche passerelle.
Utilisation d’une image de collecteur personnalisée
Pour utiliser une image de collecteur personnalisée pour votre passerelle, spécifiez le dépôt d’images et le tag. Si vous avez besoin d’instructions sur la façon de créer les images personnalisées, consultez Utiliser des composants OpenTelemetry personnalisés.
Remarque : Datadog Operator prend en charge les formats de nom d'image suivants :
name - Le nom de l'image (par exemple, ddot-collector)name:tag - Nom de l'image avec tag (par exemple, ddot-collector:7.83.1)registry/name:tag - Référence complète de l'image (par exemple, gcr.io/datadoghq/ddot-collector:7.83.1)
Le format
registry/name (sans tag dans le champ name)
n'est pas pris en charge lors de l'utilisation d'un champ
tag séparé. Incluez la référence complète de l'image avec tag dans le champ
name ou utilisez le nom de l'image avec un champ
tag séparé.
apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
name: datadog
spec:
global:
credentials:
apiSecret:
secretName: datadog-secret
keyName: api-key
features:
otelAgentGateway:
enabled: true
override:
otelAgentGateway:
image:
name: <YOUR REPO>:<IMAGE TAG>
# values.yaml
targetSystem: "linux"
agents:
enabled: false
clusterAgent:
enabled: false
otelAgentGateway:
enabled: true
image:
repository: <YOUR REPO>
tag: <IMAGE TAG>
doNotCheckTag: true
ports:
- containerPort: "4317"
name: "otel-grpc"
config: | <YOUR CONFIG>
Activer la mise à l’échelle automatique avec le Horizontal Pod Autoscaler (HPA)
La passerelle DDOT Collector prend en charge la mise à l’échelle automatique avec la fonctionnalité Horizontal Pod Autoscaler (HPA) de Kubernetes.
Remarque : Datadog Operator ne gère pas directement les ressources HPA. Vous devez créer la ressource HPA séparément et la configurer pour cibler le déploiement de l’OTel Agent Gateway.
Créer une ressource HPA :
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: datadog-otel-agent-gateway-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: datadog-otel-agent-gateway
minReplicas: 2
maxReplicas: 10
metrics:
# Aim for high CPU utilization for higher throughput
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 80
behavior:
scaleUp:
stabilizationWindowSeconds: 30
scaleDown:
stabilizationWindowSeconds: 60
Appliquez la configuration DatadogAgent avec les demandes/limites de ressources (requises pour HPA) :
apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
name: datadog
spec:
global:
credentials:
apiSecret:
secretName: datadog-secret
keyName: api-key
features:
otelAgentGateway:
enabled: true
override:
otelAgentGateway:
replicas: 4 # Initial replicas, HPA will override based on metrics
containers:
otel-agent:
resources:
requests:
cpu: 200m
memory: 512Mi
limits:
cpu: 500m
memory: 1Gi
Pour activer HPA, configurez otelAgentGateway.autoscaling :
# values.yaml
targetSystem: "linux"
agents:
enabled: false
clusterAgent:
enabled: false
otelAgentGateway:
enabled: true
ports:
- containerPort: "4317"
name: "otel-grpc"
config: | <YOUR CONFIG>
replicas: 4 # 4 replicas to begin with and HPA may override it based on the metrics
autoscaling:
enabled: true
minReplicas: 2
maxReplicas: 10
metrics:
# Aim for high CPU utilization for higher throughput
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 80
behavior:
scaleUp:
stabilizationWindowSeconds: 30
scaleDown:
stabilizationWindowSeconds: 60
Vous pouvez utiliser des métriques de ressources (CPU ou mémoire), des métriques personnalisées (Pod ou objet Kubernetes) ou des métriques externes comme entrées de mise à l’échelle automatique. Pour les métriques de ressources, assurez-vous que le Kubernetes metrics server est en cours d’exécution dans votre cluster. Pour les métriques personnalisées ou externes, envisagez de configurer le fournisseur de métriques du Datadog Cluster Agent.
Déploiement d’une passerelle multicouche
Pour les scénarios avancés, vous pouvez déployer plusieurs couches de passerelle afin de créer une chaîne de traitement.
Déployez chaque couche en tant que ressource DatadogAgent distincte, en commençant par la couche finale et en procédant dans l’ordre inverse.
- Déployer la couche 1 (couche finale) : Cette couche reçoit les données de la couche 2 et les exporte vers Datadog.
apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
name: datadog-gw-layer-1
spec:
global:
credentials:
apiSecret:
secretName: datadog-secret
keyName: api-key
features:
otelAgentGateway:
enabled: true
config:
configMap:
name: gw-layer-1-config
override:
otelAgentGateway:
replicas: 3
nodeSelector:
gateway: "gw-node-1"
nodeAgent:
disabled: true
clusterAgent:
disabled: true
---
apiVersion: v1
kind: ConfigMap
metadata:
name: gw-layer-1-config
data:
otel-gateway-config.yaml: |
receivers:
otlp:
protocols:
grpc:
endpoint: "0.0.0.0:4317"
exporters:
datadog:
api:
key: ${env:DD_API_KEY}
service:
pipelines:
traces:
receivers: [otlp]
exporters: [datadog]
metrics:
receivers: [otlp]
exporters: [datadog]
logs:
receivers: [otlp]
exporters: [datadog]
- Déployer la couche 2 (couche intermédiaire) : Cette couche reçoit les données du DaemonSet et les exporte vers la couche 1.
apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
name: datadog-gw-layer-2
spec:
global:
credentials:
apiSecret:
secretName: datadog-secret
keyName: api-key
features:
otelAgentGateway:
enabled: true
config:
configMap:
name: gw-layer-2-config
override:
otelAgentGateway:
replicas: 3
nodeSelector:
gateway: "gw-node-2"
nodeAgent:
disabled: true
clusterAgent:
disabled: true
---
apiVersion: v1
kind: ConfigMap
metadata:
name: gw-layer-2-config
data:
otel-gateway-config.yaml: |
receivers:
otlp:
protocols:
grpc:
endpoint: "0.0.0.0:4317"
exporters:
otlp:
endpoint: http://datadog-gw-layer-1-otel-agent-gateway:4317
tls:
insecure: true
service:
pipelines:
traces:
receivers: [otlp]
exporters: [otlp]
metrics:
receivers: [otlp]
exporters: [otlp]
logs:
receivers: [otlp]
exporters: [otlp]
- Déployer le DaemonSet : Configurez le DaemonSet pour exporter les données vers la couche 2.
apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
name: datadog
spec:
global:
credentials:
apiSecret:
secretName: datadog-secret
keyName: api-key
features:
otelCollector:
enabled: true
config:
configMap:
name: daemonset-layer2-config
---
apiVersion: v1
kind: ConfigMap
metadata:
name: daemonset-layer2-config
data:
otel-config.yaml: |
receivers:
otlp:
protocols:
grpc:
endpoint: "localhost:4317"
exporters:
otlp:
endpoint: http://datadog-gw-layer-2-otel-agent-gateway:4317
tls:
insecure: true
service:
pipelines:
traces:
receivers: [otlp]
exporters: [otlp]
metrics:
receivers: [otlp]
exporters: [otlp]
logs:
receivers: [otlp]
exporters: [otlp]
Déployez chaque couche en tant que release Helm distincte, en commençant par la couche finale et en procédant dans l’ordre inverse.
Déployer la couche 1 (couche finale) : Cette couche reçoit les données de la couche 2 et les exporte vers Datadog.
# layer-1-values.yaml
targetSystem: "linux"
fullnameOverride: "gw-layer-1"
agents:
enabled: false
clusterAgent:
enabled: false
otelAgentGateway:
enabled: true
replicas: 3
nodeSelector:
gateway: "gw-node-1"
ports:
- containerPort: "4317"
hostPort: "4317"
name: "otel-grpc"
config: |
receivers:
otlp:
protocols:
grpc:
endpoint: "0.0.0.0:4317"
exporters:
datadog:
api:
key: <API Key>
service:
pipelines:
traces:
receivers: [otlp]
exporters: [datadog]
metrics:
receivers: [otlp]
exporters: [datadog]
logs:
receivers: [otlp]
exporters: [datadog]
Déployer la couche 2 (couche intermédiaire) : Cette couche reçoit les données du DaemonSet et les exporte vers la couche 1.
# layer-2-values.yaml
targetSystem: "linux"
fullnameOverride: "gw-layer-2"
agents:
enabled: false
clusterAgent:
enabled: false
otelAgentGateway:
enabled: true
replicas: 3
nodeSelector:
gateway: "gw-node-2"
ports:
- containerPort: "4317"
hostPort: "4317"
name: "otel-grpc"
config: |
receivers:
otlp:
protocols:
grpc:
endpoint: "0.0.0.0:4317"
exporters:
otlp:
endpoint: http://gw-layer-1-otel-agent-gateway:4317
tls:
insecure: true
service:
pipelines:
traces:
receivers: [otlp]
exporters: [otlp]
metrics:
receivers: [otlp]
exporters: [otlp]
logs:
receivers: [otlp]
exporters: [otlp]
Déployer le DaemonSet : Configurez le DaemonSet pour exporter les données vers la couche 2.
# daemonset-values.yaml
targetSystem: "linux"
datadog:
apiKey: <DATADOG_API_KEY>
appKey: <DATADOG_APP_KEY>
otelCollector:
enabled: true
config: |
receivers:
otlp:
protocols:
grpc:
endpoint: "localhost:4317"
exporters:
otlp:
endpoint: http://gw-layer-2-otel-agent-gateway:4317
tls:
insecure: true
service:
pipelines:
traces:
receivers: [otlp]
exporters: [otlp]
metrics:
receivers: [otlp]
exporters: [otlp]
logs:
receivers: [otlp]
exporters: [otlp]
Afficher les pods de passerelle sur Fleet Automation
La passerelle DDOT Collector inclut Datadog extension par défaut. Cette extension exporte les informations de build et les configurations du Collector vers Datadog, vous permettant de surveiller votre pipeline de télémétrie depuis Infrastructure Monitoring et Fleet Automation.
Pour afficher vos pods de passerelle :
- Accédez à Integrations > Fleet Automation.
- Sélectionnez un pod de passerelle pour afficher les informations de build détaillées et la configuration du collecteur en cours d’exécution.
Limitations connues
- Condition de concurrence au démarrage : lors du déploiement du DaemonSet et de la passerelle dans la même release, les pods du DaemonSet peuvent démarrer avant que le service de passerelle ne soit prêt, ce qui provoque des logs d’erreurs de connexion initiale. L’exportateur OTLP effectue automatiquement des tentatives, ces logs peuvent donc être ignorés en toute sécurité. Alternativement, déployez d’abord la passerelle et attendez qu’elle soit prête avant de déployer le DaemonSet.
Pour aller plus loin
Documentation, liens et articles supplémentaires utiles: