Vous pouvez activer App and API Protection de Datadog pour le trafic géré par Envoy Gateway afin d’inspecter et de protéger le trafic à la périphérie de votre infrastructure.

Prérequis

• Un cluster Kubernetes en cours d’exécution avec Envoy Gateway installé.
• Le Datadog Agent est installé et configuré dans votre cluster Kubernetes.
  • Activez et configurez Remote Configuration pour permettre le blocage des attaquants via l’interface utilisateur Datadog.
  • Activez APM dans l’Agent pour permettre au service de processeur de sécurité d’envoyer ses propres traces à l’Agent.
    • Optionnellement, activez le Cluster Agent Admission Controller pour injecter automatiquement les informations de host du Datadog Agent dans le service du processeur de sécurité App and API Protection.

Configuration automatisée avec App and API Protection pour Kubernetes

Configuration

1. Déployez le processeur de sécurité en utilisant le manifeste de déploiement indiqué dans Déployez le service de processeur de sécurité Datadog ci-dessous.

2. Activez la configuration automatique en utilisant le Datadog Operator ou Helm.

   Ajoutez des annotations à votre ressource DatadogAgent. L’annotation du nom de service est requise et doit correspondre à votre service de processeur de sécurité :

   apiVersion: datadoghq.com/v2alpha1
   kind: DatadogAgent
   metadata:
     name: datadog
     annotations:
       agent.datadoghq.com/appsec.injector.enabled: "true"
       agent.datadoghq.com/appsec.injector.processor.service.name: "datadog-aap-extproc-service"  # Required
       agent.datadoghq.com/appsec.injector.processor.service.namespace: "datadog"
   spec:
     override:
       clusterAgent:
         env:
           - name: DD_CLUSTER_AGENT_APPSEC_INJECTOR_MODE
             value: "external"
   

   Appliquez la configuration :

   kubectl apply -f datadog-agent.yaml
   

   Ajoutez ce qui suit à votre values.yaml :

   datadog:
     appsec:
       injector:
         enabled: true
         mode: "external"
         processor:
           service:
             name: datadog-aap-extproc-service  # Required: must match your security processor service name
             namespace: datadog                 # Must match the namespace where the service is deployed
   

   Installez ou mettez à niveau le chart Helm Datadog :

   helm upgrade -i datadog-agent datadog/datadog -f values.yaml
   

   Une fois cette option activée, le Datadog Cluster Agent :

   • Détecte vos installations Envoy Gateway
   • Crée des ressources EnvoyExtensionPolicy pour chaque Gateway
   • Configure les politiques pour acheminer le trafic vers le processeur de sécurité

3. Vérifiez la configuration en recherchant les politiques créées :

   kubectl get envoyextensionpolicy -A
   

Pour les options de configuration et le dépannage, consultez App and API Protection for Kubernetes.

Configuration manuelle (alternative)

Pour un contrôle précis sur des passerelles spécifiques, utilisez la configuration manuelle :

1. Déployez le service du processeur Datadog Security dans votre cluster.
2. Configurez un EnvoyExtensionPolicy qui pointe vers celui-ci.

Étape 1 : Déployez le service du processeur de sécurité Datadog

Ce serveur gRPC reçoit les requêtes et les réponses d’Envoy pour l’analyse App and API Protection.

Déployez-le dans un espace de noms accessible par votre passerelle Envoy. L’image Docker se trouve sur le registre GitHub du traceur Go de Datadog.

Exemple de manifeste (datadog-aap-extproc-service.yaml) :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: datadog-aap-extproc-deployment
  namespace: <your-preferred-namespace> # Change to your preferred namespace, ensure it's resolvable by the Envoy Gateway
  labels:
    app: datadog-aap-extproc
spec:
  replicas: 1 # Adjust replica count based on your load
  selector:
    matchLabels:
      app: datadog-aap-extproc
  template:
    metadata:
      labels:
        app: datadog-aap-extproc
    spec:
      containers:
      - name: datadog-aap-extproc-container
        image: ghcr.io/datadog/dd-trace-go/service-extensions-callout:v2.4.0 # Replace with the latest released version
        ports:
        - name: grpc
          containerPort: 443 # Default gRPC port for the security processor
        - name: health
          containerPort: 80  # Default health check port
        env:
        # Optional: Agent Configuration
        # If you enabled the Cluster Agent Admission Controller, you can skip this section as the Agent host information is automatically injected.
        # Otherwise, configure the address of your Datadog Agent for the security processor
        - name: DD_AGENT_HOST
          value: "<your-datadog-agent-service>.<your-datadog-agent-namespace>.svc.cluster.local"
        - name: DD_TRACE_AGENT_PORT # Optional if your Agent's trace port is the default 8126
          value: "8126"

        # Disable TLS for communication between Envoy Gateway and the security processor. Default is true.
        # Cannot be enabled for now
        - name: DD_SERVICE_EXTENSION_TLS
          value: "false"

        readinessProbe:
          httpGet:
            path: /
            port: health
          initialDelaySeconds: 5
          periodSeconds: 10
        livenessProbe:
          httpGet:
            path: /
            port: health
          initialDelaySeconds: 15
          periodSeconds: 20
---
apiVersion: v1
kind: Service
metadata:
  name: datadog-aap-extproc-service # This name will be used in the EnvoyExtensionPolicy configuration
  namespace: <your-preferred-namespace> # Change to your preferred namespace, ensure it's resolvable by the Envoy Gateway
  labels:
    app: datadog-aap-extproc
spec:
  ports:
  - name: grpc
    port: 443
    targetPort: grpc
    protocol: TCP
  selector:
    app: datadog-aap-extproc
  type: ClusterIP

Options de configuration pour le processeur de sécurité

Le processeur Datadog Security expose certains paramètres :

Configurez la connexion du processeur de sécurité au Datadog Agent en utilisant ces variables d’environnement :

Le processeur de sécurité est construit sur le Datadog Go Tracer et hérite de toutes ses variables d’environnement. Consultez Configuring the Go SDK et App and API Protection Library Configuration.

Étape 2 : Configurez une EnvoyExtensionPolicy

Utilisez une EnvoyExtensionPolicy pour indiquer à Envoy Gateway d’appeler le processeur de sécurité Datadog. Vous pouvez attacher la politique à une passerelle ou à des ressources HTTPRoute/GRPCRoute spécifiques.

Cela envoie tout le trafic sur la passerelle sélectionnée vers le processeur de sécurité. Exemple de manifeste (datadog-aap-extproc-eep.yaml) :

apiVersion: gateway.envoyproxy.io/v1alpha1
kind: EnvoyExtensionPolicy
metadata:
  name: datadog-aap-extproc-eep
  namespace: <your-preferred-namespace> # same namespace as the Gateway
spec:
  targetRefs:
  # Target the entire Gateway
  - group: gateway.networking.k8s.io
    kind: Gateway
    name: <your-gateway-name> # update to your specific gateway name
  # Target specific HTTPRoutes/GRPCRoutes
  #- group: gateway.networking.k8s.io
  #  kind: HTTPRoute
  #  name: <your-http-route-name>
  extProc:
  - backendRefs:
    - group: ""
      kind: Service
      name: datadog-aap-extproc-service
      namespace: <your-preferred-namespace> # namespace of the security processor Service
      port: 443

    # Optional: Enable fail open mode. Default is false.
    # Normally, if the security processor fails or times out, the filter fails and Envoy
    # returns a 5xx error to the downstream client. Setting this to true allows requests
    # to continue without error if a failure occurs.
    failOpen: true

    # Optional: Set a timeout by processing message. Default is 200ms.
    # There is a maxium of 2 messages per requests with headers only and 4 messages maximum
    # with body processing enabled.
    # Note: This timeout also includes the data communication between Envoy and the security processor.
    # The timeout should be adjusted to accommodate the additional possible processing time.
    # Larger payloads will require a longer timeout.
    messageTimeout: 200ms

    processingMode:
      # The security processor can dynamically override the processing mode as needed, instructing
      # Envoy to forward request and response bodies to the security processor.
      allowModeOverride: true
      # Only enable the request and response header modes by default.
      request: {}
      response: {}

Référence inter-espaces de noms

Si votre processeur de sécurité Service se trouve dans un espace de noms différent de la politique, ajoutez un ReferenceGrant dans l’espace de noms du processeur. Par exemple, vous pouvez le faire avec un manifeste tel que datadog-aap-eep-rg.yaml.

apiVersion: gateway.networking.k8s.io/v1beta1
kind: ReferenceGrant
metadata:
  name: datadog-aap-eep-rg
  namespace: <your-extproc-namespace>   # namespace of the security processor Service
spec:
  from:
  - group: gateway.envoyproxy.io
    kind: EnvoyExtensionPolicy
    namespace: <your-policy-namespace>  # namespace of the EnvoyExtensionPolicy (and the Gateway)
  to:
  - group: ""
    kind: Service
    name: datadog-aap-extproc-service

Étape 3 : Validez

Après avoir appliqué la politique, le trafic passant par la passerelle/les routes ciblées est inspecté par App and API Protection.

After this configuration is complete, the library collects security data from your application and sends it to the Agent. The Agent sends the data to Datadog, where out-of-the-box detection rules flag attacker techniques and potential misconfigurations so you can take steps to remediate.

1. To see App and API Protection threat detection in action, send known attack patterns to your application. For example, trigger the Security Scanner Detected rule by running a file that contains the following curl script:

   for ((i=1;i<=250;i++)); 
   do
   # Target existing service's routes
   curl https://your-application-url/existing-route -A dd-test-scanner-log;
   # Target non existing service's routes
   curl https://your-application-url/non-existing-route -A dd-test-scanner-log;
   done

   Note: The dd-test-scanner-log value is supported in the most recent releases.

   A few minutes after you enable your application and send known attack patterns to it, threat information appears in the Application Signals Explorer and vulnerability information appears in the Vulnerabilities explorer.

Limitations

Le mode d’observabilité (analyse asynchrone) n’est pas disponible pour Envoy Gateway.

Pour plus de détails sur les compatibilités de l’intégration Envoy Gateway, consultez la page de compatibilité de l’intégration Envoy Gateway.

Pour aller plus loin

Documentation, liens et articles supplémentaires utiles:

Code source de l'intégration EnvoyCODE SOURCE Règles de protection des applications et des API prêtes à l'emploiDOCUMENTATION Dépannage de la protection des applications et des APIDOCUMENTATION