Configuration de Database Monitoring pour MariaDB géré par Amazon RDS

Database Monitoring offre une visibilité approfondie sur vos bases de données MariaDB en exposant les métriques de requêtes, les échantillons de requêtes, les plans d’exécution, les données de connexion, les métriques système et la télémétrie pour le moteur de stockage InnoDB.

L’Agent recueille les données de télémétrie directement depuis la base de données, en se connectant en tant qu’utilisateur en lecture seule. Effectuez la configuration suivante pour activer Database Monitoring avec votre base de données MariaDB :

  1. Configurez l’intégration AWS
  2. Configurez les paramètres de base de données
  3. Accordez à l’Agent l’accès à la base de données
  4. Installez et configurez l’Agent
  5. Installez l’intégration RDS

Avant de commencer

Versions de MariaDB prises en charge
10.5, 10.6, 10.11 ou 11.4

Database Monitoring pour MariaDB est pris en charge avec des limitations connues.
Versions de l’Agent prises en charge
7.61.0+
Impact sur les performances
La configuration par défaut de l’Agent pour Database Monitoring est prudente, mais vous pouvez ajuster les paramètres tels que l’intervalle de collecte et le taux d’échantillonnage des requêtes pour mieux répondre à vos besoins. Pour la plupart des charges de travail, l’Agent représente moins de 1 % du temps d’exécution des requêtes sur la base de données et moins de 1 % du CPU.

Database Monitoring s’exécute en tant qu’intégration au-dessus de l’Agent de base (voir les benchmarks).
Proxys, équilibreurs de charge et répartiteurs de connexion
Le Datadog Agent doit se connecter directement au host surveillé, de préférence via l’endpoint de l’instance. L’Agent ne doit pas se connecter à la base de données via un proxy, un équilibreur de charge ou un pooler de connexions. Si l’Agent se connecte à différents hosts pendant son exécution (comme dans le cas d’un basculement, d’un équilibrage de charge, etc.), l’Agent calcule la différence de statistiques entre deux hosts, ce qui produit des métriques inexactes.
Considérations relatives à la sécurité des données
Consultez Informations sensibles pour savoir quelles données l’Agent collecte depuis vos bases de données et comment les sécuriser.

Configurez l’intégration AWS

Activez Standard Collection dans la section Resource Collection de votre tuile d’intégration Amazon Web Services.

Configurez les paramètres MariaDB

Configurez les éléments suivants dans le groupe de paramètres de base de données, puis redémarrez le serveur pour que les paramètres prennent effet :

ParamètreValeurDescription
performance_schema1Requis. Active le schéma de performance. MariaDB ne l’active pas par défaut.
max_digest_length4096Requis pour la collecte de requêtes plus volumineuses. Augmente la taille du texte de résumé SQL dans les tableaux events_statements_*. Si la valeur par défaut est conservée, les requêtes de plus de 1024 caractères ne sont pas collectées.
performance_schema_max_digest_length4096Doit correspondre à max_digest_length.
performance_schema_max_sql_text_length4096Doit correspondre à max_digest_length.

Accorder l’accès à l’Agent

Le Datadog Agent nécessite un accès en lecture seule à la base de données pour collecter des statistiques et des requêtes.

Les instructions suivantes accordent à l’Agent la permission de se connecter depuis n’importe quel host en utilisant datadog@'%'. Vous pouvez restreindre l’utilisateur datadog pour qu’il ne soit autorisé à se connecter qu’à partir de localhost en utilisant datadog@'localhost'. Consultez la documentation MariaDB pour plus d’informations.

Créez l’utilisateur datadog et accordez les permissions de base :

CREATE USER datadog@'%' IDENTIFIED by '<UNIQUEPASSWORD>';
ALTER USER datadog@'%' WITH MAX_USER_CONNECTIONS 5;
GRANT REPLICATION CLIENT ON *.* TO datadog@'%';
GRANT PROCESS ON *.* TO datadog@'%';
GRANT SELECT ON performance_schema.* TO datadog@'%';

La collecte des requêtes bloquantes utilise information_schema.INNODB_LOCK_WAITS et INNODB_TRX, conjointement avec performance_schema, donc les octrois PROCESS et SELECT ON performance_schema.* ci-dessus sont suffisants ; aucun octroi supplémentaire n’est requis. La collecte des requêtes bloquantes est désactivée par défaut. Activez-la avec query_activity.collect_blocking_queries: true dans la configuration de votre instance.

Créez le schéma suivant :

CREATE SCHEMA IF NOT EXISTS datadog;
GRANT EXECUTE ON datadog.* to datadog@'%';

Créez la procédure explain_statement pour permettre à l’Agent de collecter les plans d’exécution :

DELIMITER $$
CREATE PROCEDURE datadog.explain_statement(IN query TEXT)
    SQL SECURITY DEFINER
BEGIN
    SET @explain := CONCAT('EXPLAIN FORMAT=json ', query);
    PREPARE stmt FROM @explain;
    EXECUTE stmt;
    DEALLOCATE PREPARE stmt;
END $$
DELIMITER ;

De plus, créez cette procédure dans chaque schéma à partir duquel vous souhaitez collecter des plans d’exécution. Remplacez <YOUR_SCHEMA> par votre schéma de base de données :

DELIMITER $$
CREATE PROCEDURE <YOUR_SCHEMA>.explain_statement(IN query TEXT)
    SQL SECURITY DEFINER
BEGIN
    SET @explain := CONCAT('EXPLAIN FORMAT=json ', query);
    PREPARE stmt FROM @explain;
    EXECUTE stmt;
    DEALLOCATE PREPARE stmt;
END $$
DELIMITER ;
GRANT EXECUTE ON PROCEDURE <YOUR_SCHEMA>.explain_statement TO datadog@'%';

Pour collecter les métriques d’index, accordez à l’utilisateur datadog un privilège supplémentaire :

GRANT SELECT ON mysql.innodb_index_stats TO datadog@'%';

Configuration des consommateurs au runtime

Avec RDS, les consommateurs de performance_schema ne peuvent pas être activés de manière permanente dans une configuration. Créez la procédure suivante pour donner à l’Agent la capacité d’activer les consommateurs performance_schema.events_* au moment de l’exécution.

DELIMITER $$
CREATE PROCEDURE datadog.enable_events_statements_consumers()
    SQL SECURITY DEFINER
BEGIN
    UPDATE performance_schema.setup_consumers SET enabled='YES' WHERE name LIKE 'events_statements_%';
    UPDATE performance_schema.setup_consumers SET enabled='YES' WHERE name = 'events_waits_current';
END $$
DELIMITER ;
GRANT EXECUTE ON PROCEDURE datadog.enable_events_statements_consumers TO datadog@'%';

Stockez votre mot de passe de manière sécurisée

Store your password using secret management software such as Vault. You can then reference this password as ENC[<SECRET_NAME>] in your Agent configuration files: for example, ENC[datadog_user_database_password]. See Secrets Management for more information.

The examples on this page use datadog_user_database_password to refer to the name of the secret where your password is stored. It is possible to reference your password in plain text, but this is not recommended.

Collecte des schémas

À partir de l’Agent 7.65, le Datadog Agent peut collecter des informations de schéma à partir des bases de données MariaDB. Activez-la avec collect_schemas.enabled: true dans la configuration de votre instance (utilisez schemas_collection à la place sur l’Agent 7.68 et versions antérieures). La collecte de schémas est désactivée par défaut.

instances:
  - dbm: true
    ...
    collect_schemas:
      enabled: true

Sur MariaDB 10.5 et versions ultérieures (comme MySQL), INFORMATION_SCHEMA n’expose un tableau qu’à un utilisateur qui détient un privilège sur celle-ci ; par conséquent, sans octroi, l’utilisateur datadog ne voit aucune table. Accordez le privilège REFERENCES pour rendre les métadonnées de tableau visibles sans donner à l’Agent la capacité de lire les données du tableau :

GRANT REFERENCES ON *.* TO datadog@'%';

REFERENCES est également requis pour collecter les valeurs de clé étrangère delete_rule et update_rule depuis INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS ; le privilège SELECT au niveau du tableau n’expose pas cette vue.

Consultez Exploration des schémas de base de données pour les options de réglage collect_schemas disponibles.

Installez et configurez l’Agent

Pour surveiller les hosts RDS, installez le Datadog Agent dans votre infrastructure et configurez-le pour qu’il se connecte à distance à l’endpoint de chaque instance. L’Agent n’a pas besoin de s’exécuter sur la base de données, il doit seulement s’y connecter. Pour d’autres méthodes d’installation de l’Agent non mentionnées ici, consultez les instructions d’installation de l’Agent.

Pour configurer ce check pour un Agent s’exécutant sur un host, par exemple si vous provisionnez une petite instance EC2 pour l’Agent afin de recueillir des données depuis une base de données RDS, procédez comme suit :

Modifiez le fichier mysql.d/conf.yaml, dans le dossier conf.d/ à la racine de votre répertoire de configuration de l’Agent pour commencer à collecter vos métriques MariaDB. Consultez l’exemple mysql.d/conf.yaml pour connaître toutes les options de configuration disponibles, y compris celles pour les métriques personnalisées.

Ajoutez ce bloc de configuration à votre mysql.d/conf.yaml pour collecter les métriques MariaDB :

init_config:
instances:
  - dbm: true
    host: '<AWS_INSTANCE_ENDPOINT>'
    port: <PORT>
    username: datadog
    password: 'ENC[datadog_user_database_password]' # from the CREATE USER step earlier, stored as a secret

    # After adding your project and instance, configure the Datadog AWS integration to pull additional cloud data such as CPU and Memory.
    aws:
      instance_endpoint: '<AWS_INSTANCE_ENDPOINT>'
      region: <AWS_REGION>

Si vous souhaitez vous authentifier avec IAM, spécifiez les paramètres region et instance_endpoint, et définissez managed_authentication.enabled sur true.

Remarque : n’activez managed_authentication que si vous souhaitez utiliser l’authentification IAM. L’authentification IAM prévaut sur le champ password. L’authentification de base de données IAM nécessite l’Agent 7.67.0 ou une version ultérieure, et AWS ne prend pas en charge l’authentification de base de données IAM sur toutes les versions de MariaDB RDS. Consultez la matrice des fonctionnalités d’authentification de base de données IAM pour confirmer la prise en charge de votre version et de votre région MariaDB RDS.

init_config:
instances:
  - dbm: true
    host: '<AWS_INSTANCE_ENDPOINT>'
    port: <PORT>
    username: datadog
    aws:
      instance_endpoint: '<AWS_INSTANCE_ENDPOINT>'
      region: <AWS_REGION>
      managed_authentication:
        enabled: true

Pour plus d’informations sur la configuration de l’authentification IAM sur votre instance RDS, consultez Connexion avec l’authentification gérée.

Redémarrez l’Agent pour commencer à envoyer des métriques MariaDB à Datadog.

Pour configurer Database Monitoring Agent qui s’exécute dans un conteneur Docker, par exemple dans ECS ou Fargate, vous pouvez définir des modèles d’intégration Autodiscovery en tant qu’étiquettes Docker sur le conteneur de votre Agent.

Remarque : L’Agent doit disposer d’une autorisation de lecture sur le socket Docker pour que l’Autodiscovery des étiquettes fonctionne.

Ligne de commande

Exécutez la commande suivante pour démarrer l’agent depuis votre ligne de commande. Remplacez les valeurs pour qu’elles correspondent à votre compte et à votre environnement :

export DD_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
export DD_AGENT_VERSION=<AGENT_VERSION>

docker run -e "DD_API_KEY=${DD_API_KEY}" \
  -v /var/run/docker.sock:/var/run/docker.sock:ro \
  -l com.datadoghq.ad.check_names='["mysql"]' \
  -l com.datadoghq.ad.init_configs='[{}]' \
  -l com.datadoghq.ad.instances='[{
    "dbm": true,
    "host": "<AWS_INSTANCE_ENDPOINT>",
    "port": <PORT>,
    "username": "datadog",
    "password": "<UNIQUEPASSWORD>",
    "aws": {
      "instance_endpoint": "<AWS_INSTANCE_ENDPOINT>",
      "region": "<AWS_REGION>"
    }
  }]' \
  registry.datadoghq.com/agent:${DD_AGENT_VERSION}

Dockerfile

Les étiquettes peuvent également être spécifiées dans un Dockerfile, afin que vous puissiez créer et déployer un agent personnalisé sans modifier la configuration de l’infrastructure :

FROM registry.datadoghq.com/agent:<AGENT_VERSION>

LABEL "com.datadoghq.ad.check_names"='["mysql"]'
LABEL "com.datadoghq.ad.init_configs"='[{}]'
LABEL "com.datadoghq.ad.instances"='[{"dbm": true, "host": "<AWS_INSTANCE_ENDPOINT>", "port": <PORT>,"username": "datadog","password": "ENC[datadog_user_database_password]", "aws": {"instance_endpoint": "<AWS_INSTANCE_ENDPOINT>", "region": "<AWS_REGION>"}}]'

Pour surveiller des bases de données sur un cluster Kubernetes, utilisez l’Agent de cluster Datadog pour Database Monitoring.

Suivez les instructions pour activer les checks de cluster s’ils ne sont pas déjà activés dans votre cluster Kubernetes. Vous pouvez déclarer la configuration MySQL soit avec des fichiers statiques montés dans le conteneur du Cluster Agent, soit en utilisant des annotations de service :

Opérateur

En utilisant les instructions de l’opérateur dans Kubernetes et les intégrations comme référence, suivez les étapes ci-dessous pour configurer l’intégration MySQL :

  1. Créez ou mettez à jour le fichier datadog-agent.yaml avec la configuration suivante :

    apiVersion: datadoghq.com/v2alpha1
    kind: DatadogAgent
    metadata:
      name: datadog
    spec:
      global:
        clusterName: <CLUSTER_NAME>
        site: <DD_SITE>
        credentials:
          apiSecret:
            secretName: datadog-agent-secret
            keyName: api-key
    
      features:
        clusterChecks:
          enabled: true
    
      override:
        nodeAgent:
          image:
            name: agent
            tag: <AGENT_VERSION>
    
        clusterAgent:
          extraConfd:
            configDataMap:
              mysql.yaml: |-
                cluster_check: true
                init_config:
                instances:
                - host: <AWS_INSTANCE_ENDPOINT>
                  port: <PORT>
                  username: datadog
                  password: 'ENC[datadog_user_database_password]'
                  dbm: true
                  aws:
                    instance_endpoint: <AWS_INSTANCE_ENDPOINT>
                    region: <AWS_REGION>
    
  2. Appliquez les modifications au Datadog Operator en utilisant la commande suivante :

    kubectl apply -f datadog-agent.yaml
    

Helm

  1. Suivez les instructions d’installation du Datadog Agent pour Helm.

  2. Mettez à jour votre fichier de configuration YAML (datadog-values.yaml dans les instructions d’installation du Cluster Agent) pour inclure ce qui suit :

    clusterAgent:
      confd:
        mysql.yaml: |-
          cluster_check: true
          init_config:
          instances:
            - dbm: true
              host: <AWS_INSTANCE_ENDPOINT>
              port: <PORT>
              username: datadog
              password: 'ENC[datadog_user_database_password]'
              aws:
                instance_endpoint: <AWS_INSTANCE_ENDPOINT>
                region: <AWS_REGION>
    
    clusterChecksRunner:
      enabled: true
    
  3. Déployez l’Agent avec le fichier de configuration ci-dessus depuis la ligne de commande :

    helm install datadog-agent -f datadog-values.yaml datadog/datadog
    
Pour Windows, ajoutez --set targetSystem=windows à la commande helm install .

Configuration avec des fichiers montés

Pour configurer un check de cluster avec un fichier de configuration monté, montez le fichier de configuration dans le conteneur du Cluster Agent sur le chemin /conf.d/mysql.yaml :

cluster_check: true  # Make sure to include this flag
init_config:
instances:
  - dbm: true
    host: '<AWS_INSTANCE_ENDPOINT>'
    port: <PORT>
    username: datadog
    password: 'ENC[datadog_user_database_password]'
    aws:
      instance_endpoint: <AWS_INSTANCE_ENDPOINT>
      region: <AWS_REGION>

Configuration avec des annotations de service Kubernetes

Plutôt que de monter un fichier, vous pouvez déclarer la configuration de l’instance en tant que service Kubernetes. Pour configurer ce check pour un Agent s’exécutant sur Kubernetes, créez un service en utilisant la syntaxe suivante :

apiVersion: v1
kind: Service
metadata:
  name: mysql
  labels:
    tags.datadoghq.com/env: '<ENV>'
    tags.datadoghq.com/service: '<SERVICE>'
  annotations:
    ad.datadoghq.com/service.check_names: '["mysql"]'
    ad.datadoghq.com/service.init_configs: '[{}]'
    ad.datadoghq.com/service.instances: |
      [
        {
          "dbm": true,
          "host": "<AWS_INSTANCE_ENDPOINT>",
          "port": <PORT>,
          "username": "datadog",
          "password": "ENC[datadog_user_database_password]",
          "aws": {
            "instance_endpoint": "<AWS_INSTANCE_ENDPOINT>",
            "region": "<AWS_REGION>"
          }
        }
      ]
spec:
  ports:
  - port: <PORT>
    protocol: TCP
    targetPort: <PORT>
    name: mysql

L’Agent de cluster enregistre automatiquement cette configuration et commence à exécuter le check MySQL.

Pour éviter d’exposer le mot de passe de datadogl’utilisateur en texte clair, utilisez le package de gestion des secrets de l’Agent et déclarez le mot de passe en utilisant la syntaxe ENC[].

Validez

Exécutez la sous-commande status de l’Agent et recherchez mysql dans la section Checks, ou consultez la page Databases pour commencer !

Installez l’intégration RDS

Pour voir les métriques d’infrastructure d’AWS, telles que le CPU, parallèlement à la télémétrie de base de données dans DBM, installez l’intégration RDS (facultatif).

Dépannage

Si vous avez respecté les instructions d’installation et de configuration des intégrations et de l’Agent, mais que vous rencontrez un problème, consultez la section Dépannage de la surveillance Datadog.

Pour aller plus loin

Documentation, liens et articles supplémentaires utiles: