Installez BYOC Logs sur Azure AKS.

Ce produit n'est pas pris en charge pour le site Datadog que vous avez sélectionné. ().

Présentation

Ce document vous guide tout au long du processus de configuration de votre environnement Azure et d’installation de BYOC (Bring Your Own Cloud) Logs sur Azure AKS.

Prérequis

Avant d’installer BYOC Logs sur Azure, vous devez mettre en place un ensemble de ressources d’infrastructure de support. Ces composants fournissent les services fondamentaux de calcul, de stockage, de base de données et de mise en réseau dont dépendent BYOC Logs.

Exigences en matière d’infrastructure

Voici les composants que vous devez provisionner :

Azure Kubernetes Service (AKS)

BYOC Logs s’exécute entièrement sur Kubernetes. Vous avez besoin d’un cluster AKS avec suffisamment de CPU, de mémoire et d’espace disque configurés pour votre charge de travail. Consultez les recommandations de dimensionnement du cluster Kubernetes pour obtenir des conseils.

Déployez le cluster AKS.

Vérifiez la connectivité et l’état du cluster

Pour confirmer que le cluster est accessible et que les nœuds sont dans l’état Ready, exécutez la commande suivante :

kubectl get nodes -o wide

Azure PostgreSQL Flexible Server

BYOC Logs stocke ses métadonnées et sa configuration dans une base de données PostgreSQL. Datadog recommande Azure Database pour PostgreSQL Flexible Server. Il doit être accessible depuis le cluster AKS, idéalement avec un réseau privé activé. Consultez les recommandations de dimensionnement Postgres pour plus de détails.

Créer la base de données PostgreSQL

Vérifiez la connectivité à la base de données

Pour des raisons de sécurité, créez une base de données et un utilisateur dédiés pour BYOC Logs, et accordez à l'utilisateur des droits uniquement sur cette base de données, et non à l'échelle du cluster.

Connectez-vous à votre base de données PostgreSQL depuis le réseau AKS en utilisant le client PostgreSQL, psql. Tout d’abord, démarrez un pod interactif dans votre cluster Kubernetes en utilisant une image qui inclut psql :

kubectl run psql-client \
  -n <NAMESPACE_NAME> \
  --rm -it \
  --image=bitnami/postgresql:latest \
  --command -- bash

Ensuite, exécutez la commande suivante directement depuis le shell, en remplaçant les valeurs fictives par vos valeurs réelles :

psql "host=<HOST> \
      port=<PORT> \
      dbname=<DATABASE> \
      user=<USERNAME> \
      password=<PASSWORD>"

Si l’opération réussit, vous devriez voir une invite similaire à :

psql (15.2)
SSL connection (protocol: TLS...)
Type "help" for help.

<DATABASE>=>

Conteneur de stockage Blob

BYOC Logs utilise Azure Blob Storage pour conserver les logs. Créez un conteneur dédié à cet effet.

Créer un conteneur de stockage Blob

Utilisez un conteneur dédié par environnement (par exemple, byoc-logs-prod, byoc-logs-staging), et attribuez des rôles RBAC avec le privilège minimum au niveau du conteneur, plutôt qu’au niveau du compte de stockage.

Identité et autorisations du client

Une application Azure AD doit se voir accorder un accès en lecture/écriture au conteneur de stockage Blob. Enregistrez une application dédiée pour BYOC Logs et attribuez au principal de service correspondant le rôle Contributor sur le conteneur de stockage Blob créé ci-dessus.

Enregistrer l’application

Enregistrer une application dans Microsoft Entra ID

Attribuer le rôle de contributeur

Attribuer un rôle Azure pour l’accès aux données blob

Contrôleur d’entrée NGINX

Contrôleur d’entrée NGINX public

L’entrée publique est essentielle pour permettre à Datadog de gérer et d’interroger les clusters BYOC Logs sur l’internet public. Elle fournit un accès sécurisé à l’API gRPC de BYOC Logs via les mécanismes suivants :

  • Crée un équilibreur de charge Azure accessible sur Internet qui accepte le trafic provenant des services Datadog
  • Implémente le chiffrement TLS avec terminaison au niveau du contrôleur d’entrée
  • Utilise HTTP/2 (gRPC) pour la communication entre Datadog et les clusters BYOC Logs
  • Nécessite une authentification TLS mutuelle (mTLS) où les services Datadog doivent présenter des certificats clients valides
  • Configure le contrôleur en mode TLS passthrough pour transférer les certificats clients aux pods de BYOC Logs avec l’en-tête ssl-client-cert.
  • Rejette les demandes auxquelles il manque des certificats clients valides ou l’en-tête de certificat

Utilisez le fichier de valeurs Helm nginx-public.yaml suivant afin de créer le contrôleur d’entrée NGINX public :

nginx-public.yaml

controller:
  electionID: public-ingress-controller-leader
  ingressClass: nginx-public
  ingressClassResource:
    name: nginx-public
    enabled: true
    default: false
    controllerValue: k8s.io/public-ingress-nginx
  service:
    type: LoadBalancer
    annotations:
      service.beta.kubernetes.io/azure-load-balancer-health-probe-request-path: /healthz

Ensuite, installez le contrôleur avec Helm en utilisant la commande suivante :

helm upgrade --install nginx-public ingress-nginx \
  --repo https://kubernetes.github.io/ingress-nginx \
  --namespace nginx-ingress-public \
  --create-namespace \
  -f nginx-public.yaml

Vérifiez que le pod du contrôleur est en cours d’exécution :

kubectl get pods -n nginx-ingress-public -l app.kubernetes.io/component=controller

Vérifiez que le service expose une adresse IP externe :

kubectl get svc -n nginx-ingress-public -l app.kubernetes.io/component=controller

Contrôleur d’entrée NGINX interne

L’ingress interne permet l’ingestion de logs depuis les agents Datadog et d’autres collecteurs de logs au sein de votre environnement via HTTP. Utilisez le fichier de valeurs Helm nginx-internal.yaml suivant afin de créer le contrôleur d’entrée NGINX public :

nginx-internal.yaml

controller:
  electionID: internal-ingress-controller-leader
  ingressClass: nginx-internal
  ingressClassResource:
    name: nginx-internal
    enabled: true
    default: false
    controllerValue: k8s.io/internal-ingress-nginx
  service:
    type: LoadBalancer
    annotations:
      service.beta.kubernetes.io/azure-load-balancer-internal: true
      service.beta.kubernetes.io/azure-load-balancer-health-probe-request-path: /healthz

Ensuite, installez le contrôleur avec Helm en utilisant la commande suivante :

helm upgrade --install nginx-internal ingress-nginx \
  --repo https://kubernetes.github.io/ingress-nginx \
  --namespace nginx-ingress-internal \
  --create-namespace \
  -f nginx-internal.yaml

Vérifiez que le pod du contrôleur est en cours d’exécution :

kubectl get pods -n nginx-ingress-internal -l app.kubernetes.io/component=controller

Vérifiez que le service expose une adresse IP externe :

kubectl get svc -n nginx-ingress-internal -l app.kubernetes.io/component=controller

DNS

Optionnellement, vous pouvez ajouter une entrée DNS pointant vers l’adresse IP de l’équilibreur de charge public, afin que les futurs changements d’IP ne nécessitent pas de mettre à jour la configuration du côté de Datadog.

Étapes d’installation

  1. Installer le chart Helm BYOC Logs
  2. Vérifier l’installation

Installer le chart Helm BYOC Logs

  1. Ajouter et mettre à jour le dépôt Helm Datadog :

    helm repo add datadog https://helm.datadoghq.com
    helm repo update
    
  2. Créer un espace de noms Kubernetes pour le chart :

    kubectl create namespace <NAMESPACE_NAME>
    

    Par exemple, pour créer un espace de noms byoc-logs :

    kubectl create namespace byoc-logs
    

    Remarque : Vous pouvez définir un espace de noms par défaut pour votre contexte actuel afin d’éviter d’avoir à taper -n <NAMESPACE_NAME> à chaque commande :

    kubectl config set-context --current --namespace=byoc-logs
    
  3. Stockez la clé d’API Datadog en tant que secret Kubernetes :

    kubectl create secret generic datadog-secret \
    -n <NAMESPACE_NAME> \
    --from-literal api-key="<DD_API_KEY>"
    
  4. Stockez la chaîne de connexion à la base de données PostgreSQL en tant que secret Kubernetes : Pour récupérer vos détails de connexion PostgreSQL, accédez au portail Azure, naviguez vers All resources, puis cliquez sur votre instance Azure Database for PostgreSQL flexible server. Enfin, dans l’onglet Getting started, cliquez sur le lien View connection strings dans la carte Connect.

    kubectl create secret generic byoc-logs-metastore-uri \
      -n <NAMESPACE_NAME> \
      --from-literal QW_METASTORE_URI=postgres://<USERNAME>:<PASSWORD>@<HOST>:<PORT>/<DATABASE>
    

    Par exemple, pour stocker un secret metastore-uri dans l’espace de noms byoc-logs :

    USERNAME=byoc-logs-prod
    PASSWORD=1234567890
    HOST=byoc-logs-prod.postgres.database.azure.com
    PORT=5432
    DATABASE=byoc_logs_prod
    kubectl create secret generic metastore-uri \
      -n byoc-logs \
      --from-literal QW_METASTORE_URI="postgres://$USERNAME:$PASSWORD@$HOST:$PORT/$DATABASE"
    
  5. Stockez le secret client ou la clé d’accès au compte de stockage en tant que secret Kubernetes :

    kubectl create secret generic <SECRET_NAME> \
      -n <NAMESPACE_NAME> \
      --from-literal <SECRET_KEY>=<SECRET_VALUE>
    
  6. Personnalisez le chart Helm :

    Créez un fichier datadog-values.yaml pour remplacer les valeurs par défaut par votre configuration personnalisée. C’est ici que vous définissez les paramètres spécifiques à l’environnement tels que le tag d’image, l’ID de locataire Azure, le compte de service, la configuration de l’ingress, les demandes et limites de ressources, et plus encore.

    Tous les paramètres qui ne sont pas explicitement remplacés dans datadog-values.yaml retombent sur les valeurs par défaut définies dans le values.yaml du chart Helm.

     # Show default values
     helm show values datadog/cloudprem
    

    Voici un exemple de fichier datadog-values.yaml avec des remplacements pour Azure :

    datadog-values.yaml

    # Datadog configuration
    datadog:
      # The Datadog site (https://docs.datadoghq.com/getting_started/site/) to connect to. Defaults to `datadoghq.com`.
      # site: datadoghq.com
      # The name of the existing Secret containing the Datadog API key. The secret key name must be `api-key`.
      apiKeyExistingSecret: datadog-secret
    
    azure:
      tenantId: <TENANT_ID> # required
      clientId: <CLIENT_ID> # required when using AD App to authenticate with Blob Storage
      clientSecretRef:
        name: <SECRET_NAME>
        key: <SECRET_KEY>
      storageAccount:
        name: <STORAGE_ACCOUNT_NAME> # required
        # If you are using a storage account access key to authenticate with Blob Storage,
        # comment out the `clientSecretRef` section above,
        # and uncomment the `storageAccount` section below:
        # accessKeySecretRef:
          # name: <SECRET_NAME>
          # key: <SECRET_KEY>
    
       # Service account configuration
       # If `serviceAccount.create` is set to `true`, a service account is created with the specified name.
       # Additional annotations can be added using serviceAccount.extraAnnotations.
       serviceAccount:
         create: true
         name: byoc-logs
    
    # BYOC Logs node configuration
    config:
      # The root URI where index data is stored. This should be an Azure path.
      # All indexes created in BYOC Logs are stored under this location.
      default_index_root_uri: azure://<CONTAINER_NAME>/indexes
    
    # Internal ingress configuration
    # The internal ingress NLB is created in private subnets.
    #
    # Additional annotations can be added to customize the ALB behavior.
    ingress:
      # The internal ingress is used by Datadog Agents and other collectors running outside
      # the Kubernetes cluster to send their logs to BYOC Logs.
      internal:
        enabled: true
        ingressClassName: nginx-internal
        host: byoc-logs.acme.internal
        extraAnnotations: {}
    
    # Metastore configuration
    # The metastore is responsible for storing and managing index metadata.
    # It requires a PostgreSQL database connection string to be provided by a Kubernetes secret.
    # The secret should contain a key named `QW_METASTORE_URI` with a value in the format:
    # postgresql://<username>:<password>@<host>:<port>/<database>
    #
    # The metastore connection string is mounted into the pods using extraEnvFrom to reference the secret.
    metastore:
      extraEnvFrom:
        - secretRef:
            name: byoc-logs-metastore-uri
    
    # Indexer configuration
    # The indexer is responsible for processing and indexing incoming data it receives data from various sources (for example, Datadog Agents, log collectors)
    # and transforms it into searchable files called "splits" stored in S3.
    #
    # The indexer is horizontally scalable - you can increase `replicaCount` to handle higher indexing throughput.
    # The `podSize` parameter sets vCPU, memory, and component-specific settings automatically.
    # See the sizing guide for available tiers and their configurations.
    indexer:
      replicaCount: 2
      podSize: xlarge
      persistentVolume:
        enabled: true
        storage: 250Gi
        storageClass: managed-csi
    
       # Searcher configuration
       # The searcher is responsible for executing search queries against the indexed data stored in S3.
       # It handles search requests from Datadog's query service and returns matching results.
       #
       # The searcher is horizontally scalable - you can increase `replicaCount` to handle more concurrent searches.
       # Resource requirements for searchers are highly workload-dependent and should be determined empirically.
       # Key factors that impact searcher performance include:
       # - Query complexity (for example, number of terms, use of wildcards or regex)
       # - Query concurrency (number of simultaneous searches)
       # - Amount of data scanned per query
       # - Data access patterns (cache hit rates)
       #
       # Memory is particularly important for searchers as they cache frequently accessed index data in memory.
       searcher:
         replicaCount: 2
         podSize: xlarge
  7. Installez ou mettez à niveau le chart Helm.

    helm upgrade --install <RELEASE_NAME> datadog/cloudprem \
      -n <NAMESPACE_NAME> \
      -f datadog-values.yaml
    

Vérification

Vérifier le statut du déploiement

Vérifiez que tous les composants BYOC Logs sont en cours d’exécution :

kubectl get pods -n <NAMESPACE_NAME>
kubectl get ingress -n <NAMESPACE_NAME>
kubectl get services -n <NAMESPACE_NAME>

Désinstallez

Pour désinstaller BYOC Logs, exécutez la commande suivante :

helm uninstall <RELEASE_NAME>

Étape suivante

Configurer l’ingestion de logs avec le Datadog Agent - Configurez le Datadog Agent pour envoyer les logs à BYOC Logs