Blog
Point de vue

Comment utiliser l'API Datadog

Que vous intégriez des applis, automatisiez des flux ou étendiez Datadog, l'API est essentielle.

Louis Dupont

Louis Dupont

5 June 2025

Comment utiliser l'API Datadog

```html

💡
Lorsque vous travaillez avec l'API Datadog ou toute autre API, il est crucial de disposer d'une plateforme de développement et de test d'API puissante. Apidog se distingue comme une excellente alternative à Postman, offrant une suite complète d'outils pour le développement d'API.
button

Introduction à l'API Datadog

L'API de Datadog fournit un accès programmatique aux capacités robustes de surveillance et d'analyse de la plateforme. Cette API RESTful permet aux développeurs d'envoyer des données, de créer des visualisations et de gérer leurs comptes Datadog via du code. Que vous intégriez des applications personnalisées, automatisiez des flux de travail ou étendiez les fonctionnalités de Datadog, il est essentiel de comprendre comment exploiter l'API pour maximiser le potentiel de la plateforme.

L'API Datadog est conçue avec une architecture orientée ressources qui utilise des codes de réponse HTTP standard, accepte et renvoie du JSON dans toutes les requêtes et utilise des méthodes HTTP standard. Cela la rend intuitive pour les développeurs familiarisés avec les services web RESTful. La fonctionnalité complète de l'API permet à la fois des opérations de lecture et d'écriture, vous permettant non seulement de récupérer des données de surveillance, mais également de configurer divers aspects de votre environnement Datadog.

En maîtrisant l'API Datadog, vous pourrez :

Premiers pas avec l'authentification de l'API Datadog

Avant de faire des appels d'API, vous devrez configurer correctement l'authentification pour garantir un accès sécurisé à vos ressources Datadog.

Obtention des clés API et d'application Datadog

Pour commencer à utiliser l'API Datadog, vous aurez besoin de deux types de clés :

  1. Clé API : celle-ci identifie votre compte Datadog et est requise pour toutes les requêtes d'API.
  1. Clé d'application : requise pour de nombreux points de terminaison de gestion, celle-ci fournit une authentification supplémentaire et spécifie les autorisations d'accès.

Configuration des en-têtes d'authentification de l'API Datadog

Lors de l'envoi de requêtes d'API, vous devrez inclure ces clés en tant qu'en-têtes :

Voici un exemple de requête authentifiée de base :

curl -X GET "<https://api.datadoghq.com/api/v1/dashboard>" \\\\
-H "Content-Type: application/json" \\\\
-H "DD-API-KEY: your_api_key_here" \\\\
-H "DD-APPLICATION-KEY: your_app_key_here"

Gestion de la sécurité des clés API Datadog

Compte tenu de l'accès important que ces clés fournissent, il est crucial de suivre les meilleures pratiques de sécurité :

Concepts de base de l'API Datadog

Comprendre les concepts fondamentaux de l'API Datadog vous aidera à naviguer plus efficacement dans ses vastes capacités.

Structure des points de terminaison de l'API Datadog

L'API Datadog est logiquement organisée en domaines fonctionnels qui reflètent les capacités de la plateforme :

Effectuer votre premier appel d'API Datadog

Commençons par un cas d'utilisation courant : la soumission d'une métrique personnalisée. Cet exemple montre comment envoyer une métrique de jauge simple avec des balises :

import requests
import time
import json

api_key = "your_api_key_here"
current_time = int(time.time())

payload = {
    "series": [
        {
            "metric": "custom.application.performance",
            "points": [[current_time, 100]],
            "type": "gauge",
            "tags": ["environment:production", "application:web", "region:us-east"]
        }
    ]
}

headers = {
    "Content-Type": "application/json",
    "DD-API-KEY": api_key
}

response = requests.post("<https://api.datadoghq.com/api/v1/series>",
                        headers=headers,
                        data=json.dumps(payload))

print(f"Response Status Code: {response.status_code}")
print(f"Response Body: {response.json()}")

Cet extrait de code :

Comprendre le format de réponse de l'API Datadog

Les réponses de l'API Datadog suivent généralement un format JSON cohérent :

{
  "status": "ok",
  "errors": [],
  "data": {
    "id": "abc-123-xyz",
    "name": "Example Resource",
    "created_at": "2023-06-01T12:00:00.000Z",
    "modified_at": "2023-06-02T15:30:00.000Z",
    ...
  }
}

Les champs clés incluent :

Cas d'utilisation et exemples courants de l'API Datadog

Explorons les applications pratiques de l'API Datadog à travers des exemples détaillés couvrant les principales fonctionnalités.

Récupération des informations du tableau de bord de l'API Datadog

Les tableaux de bord sont au cœur des capacités de visualisation de Datadog. Voici comment récupérer les détails d'un tableau de bord spécifique :

curl -X GET "<https://api.datadoghq.com/api/v1/dashboard/dashboard_id>" \\\\
-H "Content-Type: application/json" \\\\
-H "DD-API-KEY: your_api_key_here" \\\\
-H "DD-APPLICATION-KEY: your_app_key_here"

Pour créer un nouveau tableau de bord par programme :

import requests
import json

api_key = "your_api_key_here"
app_key = "your_app_key_here"

dashboard_payload = {
    "title": "API Generated Dashboard",
    "description": "Created via the Datadog API",
    "widgets": [
        {
            "definition": {
                "type": "timeseries",
                "requests": [
                    {
                        "q": "avg:system.cpu.user{*} by {host}",
                        "display_type": "line"
                    }
                ],
                "title": "CPU Usage by Host"
            }
        }
    ],
    "layout_type": "ordered"
}

headers = {
    "Content-Type": "application/json",
    "DD-API-KEY": api_key,
    "DD-APPLICATION-KEY": app_key
}

response = requests.post("<https://api.datadoghq.com/api/v1/dashboard>",
                        headers=headers,
                        data=json.dumps(dashboard_payload))

print(f"Dashboard created with ID: {response.json().get('id')}")

Création d'un moniteur avec l'API Datadog

Les moniteurs sont essentiels pour les alertes proactives. Voici comment créer un moniteur qui alerte lorsque l'utilisation du processeur dépasse un seuil :

import requests
import json

api_key = "your_api_key_here"
app_key = "your_app_key_here"

monitor_payload = {
    "name": "High CPU Usage Alert",
    "type": "metric alert",
    "query": "avg(last_5m):avg:system.cpu.user{*} > 80",
    "message": "CPU usage is above 80% for the last 5 minutes. @slack-alerts-channel @email.address@example.com",
    "tags": ["app:web", "env:production", "team:infrastructure"],
    "priority": 3,
    "options": {
        "notify_no_data": True,
        "no_data_timeframe": 10,
        "new_host_delay": 300,
        "evaluation_delay": 60,
        "thresholds": {
            "critical": 80,
            "warning": 70
        },
        "include_tags": True,
        "notify_audit": False,
        "require_full_window": False
    }
}

headers = {
    "Content-Type": "application/json",
    "DD-API-KEY": api_key,
    "DD-APPLICATION-KEY": app_key
}

response = requests.post("<https://api.datadoghq.com/api/v1/monitor>",
                        headers=headers,
                        data=json.dumps(monitor_payload))

print(f"Response Status: {response.status_code}")
print(f"Monitor created: {response.json()}")

Cet exemple :

Intégration avec AWS à l'aide de l'API Datadog

La connexion de Datadog avec les services cloud étend ses capacités de surveillance. Voici comment créer une intégration AWS :

curl -X POST "<https://api.datadoghq.com/api/v1/integration/aws>" \\\\
-H "Content-Type: application/json" \\\\
-H "DD-API-KEY: your_api_key_here" \\\\
-H "DD-APPLICATION-KEY: your_app_key_here" \\\\
-d '{
  "account_id": "your_aws_account_id",
  "role_name": "DatadogAWSIntegrationRole",
  "access_key_id": "your_access_key",
  "secret_access_key": "your_secret_key",
  "filter_tags": ["env:production", "service:critical"],
  "host_tags": ["account:main", "region:us-east-1"],
  "account_specific_namespace_rules": {
    "auto_scaling": true,
    "opsworks": false,
    "elasticache": true
  },
  "excluded_regions": ["us-west-2", "ca-central-1"]
}'

Cette configuration d'intégration :

Envoi de journaux via l'API Datadog

Les journaux fournissent des informations contextuelles critiques pour le dépannage. Voici comment envoyer des journaux directement à Datadog :

import requests
import json
import datetime

api_key = "your_api_key_here"

logs_payload = [{
    "ddsource": "python",
    "ddtags": "env:production,service:payment-processor,version:1.2.3",
    "hostname": "payment-service-01",
    "message": "Payment transaction completed successfully for order #12345",
    "service": "payment-service",
    "status": "info",
    "timestamp": datetime.datetime.now().isoformat(),
    "attributes": {
        "transaction_id": "tx_789012345",
        "amount": 99.95,
        "currency": "USD",
        "customer_id": "cust_123456",
        "payment_method": "credit_card"
    }
}]

headers = {
    "Content-Type": "application/json",
    "DD-API-KEY": api_key
}

response = requests.post("<https://http-intake.logs.datadoghq.com/v1/input>",
                        headers=headers,
                        data=json.dumps(logs_payload))

print(f"Log submission response: {response.status_code}")

Cet exemple :

Utilisation des limites de débit de l'API Datadog

Datadog applique des limites de débit pour garantir la stabilité de la plateforme et une utilisation équitable entre les clients. Comprendre et respecter ces limites est crucial pour une intégration d'API fiable.

Comprendre la limitation du débit de l'API Datadog

Différents points de terminaison ont des limites de débit différentes en fonction de leur intensité de ressources et de leurs modèles d'utilisation typiques :

Surveillance des en-têtes de limite de débit de l'API Datadog

Lors de l'envoi de requêtes d'API, vérifiez ces en-têtes de réponse pour comprendre l'état actuel de votre limite de débit :

Implémentation de la gestion des limites de débit dans les appels d'API Datadog

Voici une implémentation robuste pour la gestion des limites de débit avec un repli exponentiel :

import requests
import time
import random

def make_api_request_with_backoff(url, headers, payload=None, max_retries=5):
    retries = 0
    while retries < max_retries:
        response = requests.post(url, headers=headers, json=payload) if payload else requests.get(url, headers=headers)

        if response.status_code == 429:  # Too Many Requests
            # Extract rate limit information
            limit = response.headers.get('X-RateLimit-Limit', 'Unknown')
            remaining = response.headers.get('X-RateLimit-Remaining', 'Unknown')
            reset = int(response.headers.get('X-RateLimit-Reset', 60))

            print(f"Rate limit hit: {remaining}/{limit} requests remaining. Reset in {reset} seconds.")

            # Calculate backoff time with jitter
            backoff_time = min(2 ** retries + random.uniform(0, 1), reset)
            print(f"Backing off for {backoff_time:.2f} seconds")
            time.sleep(backoff_time)
            retries += 1
        else:
            return response

    raise Exception(f"Failed after {max_retries} retries due to rate limiting")

Utilisation des bibliothèques clientes de l'API Datadog

Pour plus de commodité, Datadog propose des bibliothèques clientes officielles dans plusieurs langues, simplifiant l'authentification et le formatage des requêtes.

Client API Datadog Python

Le client Python officiel fournit une interface claire et idiomatique vers l'API Datadog :

pip install datadog-api-client

Voici un exemple de soumission de métriques à l'aide du client :

from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.metrics_api import MetricsApi
from datadog_api_client.v1.model.metrics_payload import MetricsPayload
from datadog_api_client.v1.model.metrics_series import MetricsSeries
from datadog_api_client.v1.model.point import Point
import time

configuration = Configuration()
configuration.api_key["apiKeyAuth"] = "your_api_key_here"
configuration.api_key["appKeyAuth"] = "your_app_key_here"

with ApiClient(configuration) as api_client:
    api_instance = MetricsApi(api_client)
    body = MetricsPayload(
        series=[
            MetricsSeries(
                metric="application.request.duration",
                points=[
                    Point([int(time.time()), 250.0])
                ],
                type="gauge",
                host="web-server-01",
                tags=["endpoint:login", "environment:staging"]
            )
        ]
    )
    response = api_instance.submit_metrics(body=body)
    print(f"Metrics submission successful: {response}")

Client API Datadog Ruby

Pour les applications Ruby, la bibliothèque cliente officielle rationalise les interactions avec l'API :

gem install datadog_api_client -v 2.31.1

Exemple d'utilisation pour la création d'un moniteur :

require 'datadog_api_client'

DatadogAPIClient.configure do |config|
  config.api_key = 'your_api_key_here'
  config.application_key = 'your_app_key_here'
end

api_instance = DatadogAPIClient::V1::MonitorsAPI.new
body = {
  'name' => 'API test monitor',
  'type' => 'metric alert',
  'query' => 'avg(last_5m):avg:system.cpu.user{*} > 75',
  'message' => 'CPU usage is high',
  'tags' => ['test:api', 'monitor:automated'],
  'options' => {
    'thresholds' => {
      'critical' => 75,
      'warning' => 65
    }
  }
}

begin
  result = api_instance.create_monitor(body)
  puts "Monitor created successfully with ID: #{result['id']}"
rescue DatadogAPIClient::APIError => e
  puts "Error creating monitor: #{e}"
end

Meilleures pratiques pour l'utilisation de l'API Datadog

Le respect de ces directives vous aidera à créer des intégrations plus fiables, sécurisées et efficaces avec l'API Datadog.

Sécurisation de vos clés API Datadog

La sécurité de vos clés API est primordiale :

Utilisation efficace des balises dans les appels d'API Datadog

Les balises sont un mécanisme puissant pour organiser et filtrer vos données Datadog :

Implémentation de la gestion des erreurs pour les requêtes d'API Datadog

Une gestion robuste des erreurs garantit que vos intégrations restent fiables :

def send_to_datadog(endpoint, payload, headers):
    try:
        response = requests.post(endpoint,
                                json=payload,
                                headers=headers,
                                timeout=10)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.Timeout:
        print("Request timed out - Datadog API may be experiencing delays")
    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 400:
            print(f"Bad request: {e.response.json().get('errors', [])}")
        elif e.response.status_code == 403:
            print("Authentication error - check your API and application keys")
        elif e.response.status_code == 429:
            print("Rate limit reached - implement backoff and retry")
        else:
            print(f"HTTP error: {e.response.status_code}")
    except requests.exceptions.RequestException as e:
        print(f"Request failed: {e}")

    return None

Tests dans des environnements sandbox avec l'API Datadog

Avant de mettre en œuvre en production :

Surveillance de l'utilisation de l'API Datadog

Suivez votre utilisation de l'API pour détecter les problèmes rapidement :

Conclusion : maîtriser l'API Datadog

L'API Datadog offre de puissantes capacités pour étendre et personnaliser votre plateforme de surveillance et d'analyse. En comprenant le processus d'authentification, les concepts de base et les meilleures pratiques décrites dans ce guide, vous serez bien équipé pour intégrer Datadog dans vos applications et automatiser efficacement vos flux de travail.

Que vous envoyiez des métriques personnalisées, créiez des moniteurs ou construisiez des tableaux de bord complexes, l'API offre la flexibilité nécessaire pour adapter Datadog à vos besoins spécifiques. Au fur et à mesure que votre utilisation évolue, envisagez de mettre en œuvre des modèles plus avancés comme :

Les capacités programmatiques fournies par l'API Datadog vous permettent de créer un écosystème de surveillance qui s'adapte à votre infrastructure et s'adapte aux exigences uniques de votre organisation.

N'oubliez pas de consulter régulièrement la documentation officielle de l'API Datadog, car de nouveaux points de terminaison et fonctionnalités sont fréquemment ajoutés pour étendre les capacités de la plateforme. Grâce aux connaissances acquises grâce à ce guide, vous êtes prêt à créer des solutions de surveillance sophistiquées et automatisées qui tirent parti de toute la puissance de la plateforme d'observabilité de Datadog.

button

```

Explore more

Fathom-R1-14B : Modèle de raisonnement IA avancé d'Inde

Fathom-R1-14B : Modèle de raisonnement IA avancé d'Inde

L'IA en expansion rapide. Fathom-R1-14B (14,8 milliards de paramètres) excelle en raisonnement mathématique et général, conçu par Fractal AI Research.

5 June 2025

Mistral Code : L'assistant de codage le plus personnalisable basé sur l'IA pour les entreprises

Mistral Code : L'assistant de codage le plus personnalisable basé sur l'IA pour les entreprises

Découvrez Mistral Code, l'IA d'aide au code la plus personnalisable pour les entreprises.

5 June 2025

Comment Claude Code transforme le codage de l'IA en 2025

Comment Claude Code transforme le codage de l'IA en 2025

Découvrez Claude Code en 2025 : codage IA révolutionné. Fonctionnalités, démo, et pourquoi il gagne du terrain après Windsurf d'Anthropic. Indispensable !

5 June 2025

Pratiquez le Design-first d'API dans Apidog

Découvrez une manière plus simple de créer et utiliser des API

S'inscrire gratuitementTélécharger