Pour activer la surveillance du réseau cloud avec l’Agent Datadog, utilisez les configurations suivantes :

1. Si vous utilisez un Agent plus ancien que v6.14, activez d’abord la collecte de processus en direct, sinon passez cette étape.

2. Copiez l’exemple de configuration du système-probe :

   sudo -u dd-agent install -m 0640 /etc/datadog-agent/system-probe.yaml.example /etc/datadog-agent/system-probe.yaml
   

3. Modifiez /etc/datadog-agent/system-probe.yaml pour définir le drapeau d’activation sur true :

   network_config:   # use system_probe_config for Agent's older than 7.24.1
     ## @param enabled - boolean - optional - default: false
     ## Set to true to enable Cloud Network Monitoring.
     #
     enabled: true
   

   Optional: To monitor DNS traffic on non-standard ports (Agent v7.76.0+), add the dns_monitoring_ports option:

   network_config:
     enabled: true
     dns_monitoring_ports:
       - 53
       - 5353
   

4. Si vous exécutez un Agent plus ancien que v6.18 ou 7.18, démarrez manuellement le système-probe et activez-le pour qu’il démarre au démarrage (depuis v6.18 et v7.18, le système-probe démarre automatiquement lorsque l’Agent est démarré) :

   sudo systemctl start datadog-agent-sysprobe
   sudo systemctl enable datadog-agent-sysprobe
   

   Note: If the systemctl command is not available on your system, start it with following command instead: sudo service datadog-agent-sysprobe start and then set it up to start on boot before datadog-agent starts.

5. Redémarrer l’Agent.

   sudo systemctl restart datadog-agent
   

   Note: If the systemctl command is not available on your system, run the following command instead: sudo service datadog-agent restart

Systèmes avec SELinux activé

Sur les systèmes disposant de SELinux, le binaire system-probe requiert des autorisations spéciales pour utiliser les fonctionnalités eBPF.

Le package RPM de l’Agent Datadog pour les systèmes basés sur CentOS comprend une stratégie SELinux permettant d’accorder ces autorisations au binaire system-probe.

Si vous devez utiliser la surveillance du réseau cloud sur d’autres systèmes avec SELinux activé, procédez comme suit :

1. Modifiez la politique SELinux de base pour correspondre à votre configuration SELinux. Selon votre système, il est possible que certains types ou attributs n’existent pas ou qu’ils possèdent d’autres noms.

2. Compilez la politique en un module ; en supposant que votre fichier de politique s’appelle system_probe_policy.te :

   checkmodule -M -m -o system_probe_policy.mod system_probe_policy.te
   semodule_package -o system_probe_policy.pp -m system_probe_policy.mod
   

3. Appliquez le module à votre système SELinux :

   semodule -v -i system_probe_policy.pp
   

4. Changez le type binaire system-probe pour utiliser celui défini dans la politique ; en supposant que votre répertoire d’installation de l’Agent est /opt/datadog-agent :

   semanage fcontext -a -t system_probe_t /opt/datadog-agent/embedded/bin/system-probe
   restorecon -v /opt/datadog-agent/embedded/bin/system-probe
   

5. Redémarrer l’Agent.

Remarque : ces instructions nécessitent d’avoir certains utilitaires SELinux installés sur le système (checkmodule, semodule, semodule_package, semanage et restorecon) qui sont disponibles sur la plupart des distributions standard (Ubuntu, Debian, RHEL, CentOS, SUSE). Vérifiez votre distribution pour des détails sur la façon de les installer.

Si ces utilitaires ne sont pas disponibles pour votre distribution, suivez les mêmes instructions, mais utilisez à la place les utilitaires dont vous disposez.

La collecte de logs réseau pour Windows repose sur un pilote de filtre.

Pour activer la surveillance du réseau Cloud pour les hôtes Windows :

1. Installez le Datadog Agent (version 7.27.1 ou supérieure) avec le composant du pilote réseau activé.

   [DÉPRÉCIÉ] (version 7.44 ou inférieure) Pendant l’installation, passez ADDLOCAL="MainApplication,NPM" à la commande msiexec, ou sélectionnez “Surveillance du réseau Cloud” lors de l’exécution de l’installation de l’Agent via l’interface graphique.

2. Modifiez C:\ProgramData\Datadog\system-probe.yaml pour définir le drapeau activé sur true :

   network_config:
       enabled: true
   

   Optional: To monitor DNS traffic on non-standard ports (Agent v7.76.0+), add the dns_monitoring_ports option:

   network_config:
       enabled: true
       dns_monitoring_ports:
           - 53
           - 5353
   

3. Redémarrer l’Agent.

   Pour PowerShell (powershell.exe) :

   restart-service -f datadogagent
   

   For Command Prompt (cmd.exe):

   net /y stop datadogagent && net start datadogagent
   

Remarque : La surveillance du réseau Cloud surveille uniquement les hôtes Windows, et non les conteneurs Windows.

Pour activer la surveillance du réseau Cloud avec Kubernetes en utilisant Helm, ajoutez ce qui suit à votre fichier values.yaml.
Remarque : La version du graphique Helm v3.135.3+ est requise. Pour plus d’informations, consultez la documentation du graphique Helm Datadog.

datadog:
  ...
  networkMonitoring:
    enabled: true

Optionnel : Pour surveiller le trafic DNS sur des ports non standards (Agent v7.76.0+), ajoutez l’option dnsMonitoringPorts :

datadog:
  networkMonitoring:
    enabled: true
    dnsMonitoringPorts:
      - 53
      - 5353

Vous pourriez avoir besoin de l’une des étapes supplémentaires suivantes en fonction de votre environnement :

providers:
  gke:
    autopilot: true

providers:
  gke:
    cos: true

agents:
  containers:
    systemProbe:
      securityContext:
        seLinuxOptions:
          user: "system_u"
          role: "system_r"
          type: "super_t"
          level: "s0"

Si vous n’utilisez pas Helm, vous pouvez activer la surveillance du réseau Cloud avec Kubernetes à partir de zéro :

1. Téléchargez le modèle de manifeste datadog-agent.yaml manifest.

2. Remplacez <DATADOG_API_KEY> par votre clé API Datadog.

3. Optionnel - Définissez votre site Datadog. Si vous utilisez le site Datadog EU, définissez la variable d’environnement DD_SITE sur datadoghq.eu dans le manifeste datadog-agent.yaml.

4. Déployez le DaemonSet avec la commande :

   kubectl apply -f datadog-agent.yaml
   

Si l’Agent est déjà exécute avec un manifeste :

1. Pour les versions de Kubernetes inférieures à 1.30, ajoutez l’annotation container.apparmor.security.beta.kubernetes.io/system-probe: unconfined sur le modèle datadog-agent :

   spec:
       selector:
           matchLabels:
               app: datadog-agent
       template:
           metadata:
               labels:
                   app: datadog-agent
               name: datadog-agent
               annotations:
                   container.apparmor.security.beta.kubernetes.io/system-probe: unconfined
   

   For Kubernetes versions 1.30+, add the following securityContext on the datadog-agent template:

   spec:
       selector:
           matchLabels:
               app: datadog-agent
       template:
           metadata:
               labels:
                   app: datadog-agent
               name: datadog-agent
           spec:
               serviceAccountName: datadog-agent
               securityContext:
                 appArmorProfile:
                   type: Unconfined
               containers:
               # (...)
   

2. Activez la collecte des processus et le système probe avec les variables d’environnement suivantes dans le DaemonSet de l’Agent. Si vous exécutez un conteneur par processus Agent, ajoutez les variables d’environnement suivantes au conteneur du Process Agent ; sinon, ajoutez-les au conteneur de l’Agent.

     # (...)
                     env:
                     # (...)
                         - name: DD_PROCESS_AGENT_ENABLED
                           value: 'true'
                         - name: DD_SYSTEM_PROBE_ENABLED
                           value: 'true'
                         - name: DD_SYSTEM_PROBE_EXTERNAL
                           value: 'true'
                         - name: DD_SYSPROBE_SOCKET
                           value: /var/run/sysprobe/sysprobe.sock
                         - name: DD_AUTH_TOKEN_FILE_PATH
                           value: /etc/datadog-agent/auth/token
   

3. Montez les volumes supplémentaires suivants dans le conteneur datadog-agent :

    # (...)
           spec:
               serviceAccountName: datadog-agent
               containers:
                   - name: datadog-agent
                     image: 'registry.datadoghq.com/agent:latest'
                     # (...)
                 volumeMounts:
                     - name: procdir
                       mountPath: /host/proc
                       readOnly: true
                     - name: cgroups
                       mountPath: /host/sys/fs/cgroup
                       readOnly: true
                     - name: debugfs
                       mountPath: /sys/kernel/debug
                     - name: sysprobe-socket-dir
                       mountPath: /var/run/sysprobe
                     - name: auth-token
                       mountPath: /etc/datadog-agent/auth
                       readOnly: false # needs RW to write auth token
   

4. Ajoutez un nouveau system-probe en tant que side-car à l’Agent :

    # (...)
           spec:
               serviceAccountName: datadog-agent
               containers:
                   - name: datadog-agent
                     image: 'registry.datadoghq.com/agent:latest'
                   # (...)
                   - name: system-probe
                     image: 'registry.datadoghq.com/agent:latest'
                     imagePullPolicy: Always
                     securityContext:
                         capabilities:
                             add:
                                 - SYS_ADMIN
                                 - SYS_RESOURCE
                                 - SYS_PTRACE
                                 - NET_ADMIN
                                 - NET_BROADCAST
                                 - NET_RAW
                                 - IPC_LOCK
                                 - CHOWN
                     command:
                         - /opt/datadog-agent/embedded/bin/system-probe
                     env:
                         - name: DD_SYSTEM_PROBE_ENABLED
                           value: 'true'
                         - name: DD_SYSPROBE_SOCKET
                           value: /var/run/sysprobe/sysprobe.sock
                         - name: DD_AUTH_TOKEN_FILE_PATH
                           value: /etc/datadog-agent/auth/token
                     resources:
                         requests:
                             memory: 150Mi
                             cpu: 200m
                         limits:
                             memory: 300Mi
                             cpu: 400m
                     volumeMounts:
                         - name: procdir
                           mountPath: /host/proc
                           readOnly: true
                         - name: cgroups
                           mountPath: /host/sys/fs/cgroup
                           readOnly: true
                         - name: debugfs
                           mountPath: /sys/kernel/debug
                         - name: sysprobe-socket-dir
                           mountPath: /var/run/sysprobe
                         - name: auth-token
                           mountPath: /etc/datadog-agent/auth
                           readOnly: true
   

5. Enfin, ajoutez les volumes suivants à votre manifeste :

               volumes:
                   - name: debugfs
                     hostPath:
                         path: /sys/kernel/debug
                   - name: sysprobe-socket-dir
                     emptyDir: { }
                   - name: auth-token
                     emptyDir: { }
   

Datadog Operator simplifie le déploiement du Datadog Agent sur Kubernetes et OpenShift. Il fournit l’état de déploiement, la santé et le reporting des erreurs via son Custom Resource status, tout en réduisant le risque de mauvaise configuration grâce à des options de configuration de niveau supérieur.

Pour activer la Surveillance du Réseau Cloud sur le Datadog Operator, utilisez la configuration suivante :

apiVersion: datadoghq.com/v2alpha1
metadata:
  name: placeholder
  namespace: placeholder
spec:
  features:
    npm:
      enabled: true

Pour activer la Surveillance du Réseau Cloud dans Docker, utilisez la configuration suivante lors du démarrage du conteneur Agent :

docker run --cgroupns host \
--pid host \
-e DD_API_KEY="<DATADOG_API_KEY>" \
-e DD_SYSTEM_PROBE_NETWORK_ENABLED=true \
-e DD_PROCESS_AGENT_ENABLED=true \
-v /var/run/docker.sock:/var/run/docker.sock:ro \
-v /proc/:/host/proc/:ro \
-v /sys/fs/cgroup/:/host/sys/fs/cgroup:ro \
-v /sys/kernel/debug:/sys/kernel/debug \
--security-opt apparmor:unconfined \
--cap-add=SYS_ADMIN \
--cap-add=SYS_RESOURCE \
--cap-add=SYS_PTRACE \
--cap-add=NET_ADMIN \
--cap-add=NET_BROADCAST \
--cap-add=NET_RAW \
--cap-add=IPC_LOCK \
--cap-add=CHOWN \
registry.datadoghq.com/agent:latest

Remplacez <DATADOG_API_KEY> par votre Datadog API key.

Si vous utilisez docker-compose, faites les ajouts suivants au service du Datadog Agent :

version: '3'
services:
  datadog:
    image: "registry.datadoghq.com/agent:latest"
    environment:
      - DD_SYSTEM_PROBE_NETWORK_ENABLED=true
      - DD_PROCESS_AGENT_ENABLED=true
      - DD_API_KEY=<DATADOG_API_KEY>
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /proc/:/host/proc/:ro
      - /sys/fs/cgroup/:/host/sys/fs/cgroup:ro
      - /sys/kernel/debug:/sys/kernel/debug
    cap_add:
      - SYS_ADMIN
      - SYS_RESOURCE
      - SYS_PTRACE
      - NET_ADMIN
      - NET_BROADCAST
      - NET_RAW
      - IPC_LOCK
      - CHOWN
    security_opt:
      - apparmor:unconfined

Pour configurer CNM sur Amazon ECS, consultez la page de documentation Amazon ECS.

Pour activer la Surveillance du Réseau Cloud sur ECS Fargate, utilisez les instructions suivantes :

Nécessite la version du Datadog Agent 7.58 ou supérieure.

• Pour un nouveau déploiement Fargate, configurez le Datadog Agent pour surveiller Fargate sur ECS en activant process collection sur vos hôtes Fargate.

• Pour les déploiements existants, mettez à jour votre fichier task.json pour inclure les paramètres de configuration suivants :

{
 "containerDefinitions": [
   (...)
     "environment": [
       (...)
       {
         "name": "DD_SYSTEM_PROBE_NETWORK_ENABLED",
         "value": "true"
       },
       {
          "name": "DD_NETWORK_CONFIG_ENABLE_EBPFLESS",
          "value": "true"
       },
       {
          "name": "DD_PROCESS_AGENT_ENABLED",
          "value": "true"
       }      
     ],
     "linuxParameters": {
      "capabilities": {
        "add": [
          "SYS_PTRACE"
        ]
      }
    },
 ],
}