Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Invocation de DevOps l'agent via Webhook
<a name="configuring-capabilities-for-aws-devops-agent-invoking-devops-agent-through-webhook"></a>

Les webhooks permettent aux systèmes externes de déclencher automatiquement les investigations des AWS DevOps agents. Cela permet l'intégration aux systèmes de billetterie, aux outils de surveillance et à d'autres plateformes qui peuvent envoyer des requêtes HTTP en cas d'incident.

## Conditions préalables
<a name="prerequisites"></a>

Avant de configurer l'accès au webhook, assurez-vous d'avoir :
+ Un espace d'agent configuré dans AWS DevOps l'agent
+ Accès à la console de AWS DevOps l'agent
+ Le système externe qui enverra les demandes de webhook

## Types de webhooks
<a name="webhook-types"></a>

AWS DevOps L'agent prend en charge les types de webhooks suivants :
+ **Integration-specific webhooks** : générés automatiquement lorsque vous configurez des intégrations tierces telles que Dynatrace, Splunk, Datadog, New Relic ou Slack. ServiceNow Ces webhooks sont associés à l'intégration spécifique et utilisent des méthodes d'authentification déterminées par le type d'intégration.
+ **Webhooks génériques** : ils peuvent être créés manuellement pour déclencher des enquêtes à partir de n'importe quelle source non couverte par une intégration spécifique. Les webhooks génériques utilisent actuellement l'authentification **HMAC** (le jeton porteur n'est pas disponible actuellement).
+ **Webhooks d'alerte Grafana —** Grafana peut envoyer des notifications d'alerte directement à l' AWS DevOps agent via les points de contact des webhooks. Pour les instructions de configuration, y compris un modèle de notification personnalisé, voir [Connecting Grafana](connecting-telemetry-sources-connecting-grafana.md).

## Méthodes d'authentification Webhook
<a name="webhook-authentication-methods"></a>

La méthode d'authentification de votre webhook dépend de l'intégration à laquelle il est associé :

**Authentification HMAC** — Utilisée par :
+ Webhooks d'intégration de Dynatrace
+ Webhooks génériques (non liés à une intégration tierce spécifique)

**Authentification par jeton au porteur** : utilisée par :
+ Webhooks d'intégration Splunk
+ Webhooks d'intégration à Datadog
+ Webhooks d'intégration New Relic
+ ServiceNow webhooks d'intégration
+ Webhooks d'intégration à Slack
+ Webhooks d'intégration Grafana

### Comprendre l'authentification HMAC
<a name="understanding-hmac-authentication"></a>

Le HMAC (Hash-based Message Authentication Code) est un mécanisme cryptographique qui vérifie à la fois l'intégrité et l'authenticité d'une demande de webhook. Lorsque vous envoyez un webhook avec authentification HMAC, vous générez une signature en hachant l'horodatage et la charge utile de la demande à l'aide de votre clé secrète et de l'algorithme. SHA-256 AWS DevOps L'agent calcule indépendamment le même hachage de son côté et compare les deux signatures. S'ils correspondent, la demande est acceptée.

L'horodatage étant inclus dans la signature, HMAC fournit également une protection contre les rediffusions. AWS DevOps L'agent peut rejeter les demandes dont l'horodatage remonte trop loin dans le passé, empêchant ainsi un attaquant de capturer et de renvoyer une demande valide.

### Choisir entre le jeton HMAC et le jeton Bearer
<a name="choosing-between-hmac-and-bearer-token"></a>


| Considération | HMAC | Jeton au porteur | 
| --- | --- | --- | 
| Complexité de configuration | Plus complexe : votre client doit calculer une signature pour chaque demande à l'aide de l'horodatage et de la charge utile | Plus simple : incluez un jeton statique dans l'Authorizationen-tête | 
| Intégrité de la charge utile | Vérifié : toute modification de la charge utile après signature invalide la signature | Non vérifié : le jeton authentifie l'expéditeur mais ne protège pas le contenu de la charge utile | 
| Protection contre les rediffusions | Built-in — l'horodatage dans la signature permet au serveur de rejeter les demandes périmées | Non intégré : un jeton capturé peut être réutilisé jusqu'à ce qu'il soit pivoté | 
| Risque d'exposition secret | Inférieur : le secret n'est jamais transmis dans la demande ; seule la signature calculée est envoyée | Plus élevé : le jeton est envoyé dans chaque en-tête de demande, ce qui augmente l'exposition en cas d'interception du trafic | 
| Quand l’utiliser | Recommandé lorsque vous avez besoin de garanties de sécurité renforcées, par exemple pour les webhooks génériques ou les environnements soumis à des exigences de conformité strictes | Convient lorsque la facilité d'intégration est une priorité et que le transport de votre réseau est fiable, par exemple pour les intégrations SaaS gérées via HTTPS | 

**Remarque :** La méthode d'authentification est déterminée par le type d'intégration. Integration-specific les webhooks (Splunk, Datadog, New Relic, ServiceNow Slack, Grafana) utilisent l'authentification par jeton au porteur. Dynatrace et les webhooks génériques utilisent l'authentification HMAC. Vous ne pouvez pas modifier la méthode d'authentification pour un webhook spécifique à une intégration.

## Configuration de l'accès au webhook
<a name="configuring-webhook-access"></a>

### Étape 1 : Accédez à la configuration du webhook
<a name="step-1-navigate-to-the-webhook-configuration"></a>

1. Connectez-vous à la console AWS de gestion et accédez à la console de l' AWS DevOps agent

1. Sélectionnez votre espace d'agent

1. Accédez à l'onglet **Fonctionnalités**

1. **Dans la section **Webhook**, cliquez sur Configurer**

### Étape 2 : générer les informations d'identification du webhook
<a name="step-2-generate-webhook-credentials"></a>

**Pour les webhooks spécifiques à l'intégration :**

Les webhooks sont automatiquement générés lorsque vous terminez la configuration d'une intégration tierce. L'URL et les informations d'identification du point de terminaison du webhook sont fournies à la fin du processus de configuration de l'intégration.

**Pour les webhooks génériques :**

1. Cliquez sur **Générer un webhook**

1. Le système générera une paire de clés HMAC

1. Stockez en toute sécurité la clé et le secret générés, vous ne pourrez plus les récupérer

1. Copiez l'URL du point de terminaison du webhook fournie

### Étape 3 : Configuration de votre système externe
<a name="step-3-configure-your-external-system"></a>

Utilisez l'URL et les informations d'identification du point de terminaison du webhook pour configurer votre système externe afin d'envoyer des demandes à l' AWS DevOps agent. Les étapes de configuration spécifiques dépendent de votre système externe.

## Gestion des informations d'identification du webhook
<a name="managing-webhook-credentials"></a>

**Suppression des informations d'identification** **: pour supprimer les informations d'identification du webhook, accédez à la section de configuration du webhook et cliquez sur Supprimer.** Après avoir supprimé les informations d'identification, le point de terminaison du webhook n'acceptera plus les demandes tant que vous n'aurez pas généré de nouvelles informations d'identification.

**Régénération des informations d'identification** : pour générer de nouvelles informations d'identification, supprimez d'abord les informations d'identification existantes, puis générez une nouvelle paire de clés ou un nouveau jeton.

## Utilisation du webhook
<a name="using-the-webhook"></a>

### Format de demande de webhook
<a name="webhook-request-format"></a>

Pour déclencher une enquête, votre système externe doit envoyer une requête HTTP POST à l'URL du point de terminaison du webhook.

**Pour la version 1 (authentification HMAC) :**

En-têtes :
+ `Content-Type: application/json`
+ `x-amzn-event-signature: <HMAC signature>`
+ `x-amzn-event-timestamp: <+%Y-%m-%dT%H:%M:%S.000Z>`

La signature HMAC est générée en signant le corps de la demande avec votre clé secrète à l'aide SHA-256 de.

**Pour la version 2 (authentification par jeton porteur) :**

En-têtes :
+ `Content-Type: application/json`
+ `Authorization: Bearer <your-token>`

**Corps de la demande :**

Le corps de la demande doit inclure des informations sur l'incident :

```
json

{
  "title": "Incident title",
  "severity": "high",
  "affectedResources": ["resource-id-1", "resource-id-2"],
  "timestamp": "2025-11-23T18:00:00Z",
  "description": "Detailed incident description",
  "data": {
    "metadata": {
        "region": "us-east-1",
        "environment": "production"
    }
  }
}
```

**Schéma de charge utile :**

```
{
    eventType: 'incident';
    incidentId: string;
    action: 'created' | 'updated' | 'closed' | 'resolved';
    priority: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "MINIMAL";
    title: string;
    description?: string;
    timestamp?: string;
    service?: string;
    // The original event generated by service is attached here.
    data?: object;
}
```

### Exemple de code
<a name="example-code"></a>

**Version 1 (authentification HMAC) - : JavaScript**

```
const crypto = require('crypto');

// Webhook configuration
const webhookUrl = 'https://your-webhook-endpoint.amazonaws.com/invoke';
const webhookSecret = 'your-webhook-secret-key';

// Incident data
const incidentData = {  
    eventType: 'incident',
    incidentId: 'incident-123',
    action: 'created',
    priority: "HIGH",
    title: 'High CPU usage on production server',
    description: 'High CPU usage on production server host ABC in AWS account 1234 region us-east-1',
    timestamp: new Date().toISOString(),
    service: 'MyTestService',
    data: {
      metadata: {
        region: 'us-east-1',
        environment: 'production'
      }
    }
};

// Convert data to JSON string
const payload = JSON.stringify(incidentData);
const timestamp = new Date().toISOString();
const hmac = crypto.createHmac("sha256", webhookSecret);
hmac.update(`${timestamp}:${payload}`, "utf8");
const signature = hmac.digest("base64");

// Send the request
fetch(webhookUrl, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-amzn-event-timestamp': timestamp,
    'x-amzn-event-signature': signature
  },
  body: payload
})
.then(res => {
  console.log(`Status Code: ${res.status}`);
  return res.text();
})
.then(data => {
  console.log('Response:', data);
})
.catch(error => {
  console.error('Error:', error);
});
```

**Version 1 (authentification HMAC) - cURL :**

```
#!/bin/bash

# Configuration
WEBHOOK_URL="https://event-ai.us-east-1.api.aws/webhook/generic/YOUR_WEBHOOK_ID"
SECRET="YOUR_WEBHOOK_SECRET"

# Create payload
TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%S.000Z)
INCIDENT_ID="test-alert-$(date +%s)"

PAYLOAD=$(cat <<EOF
{
"eventType": "incident",
"incidentId": "$INCIDENT_ID",
"action": "created",
"priority": "HIGH",
"title": "Test Alert",
"description": "Test alert description",
"service": "TestService",
"timestamp": "$TIMESTAMP"
}
EOF
)

# Generate HMAC signature
SIGNATURE=$(echo -n "${TIMESTAMP}:${PAYLOAD}" | openssl dgst -sha256 -hmac "$SECRET" -binary | base64)

# Send webhook
curl -X POST "$WEBHOOK_URL" \
-H "Content-Type: application/json" \
-H "x-amzn-event-timestamp: $TIMESTAMP" \
-H "x-amzn-event-signature: $SIGNATURE" \
-d "$PAYLOAD"
```

**Version 2 (authentification par jeton porteur) - : JavaScript**

```
function sendEventToWebhook(webhookUrl, secret) {
  const timestamp = new Date().toISOString();
  
  const payload = {
    eventType: 'incident',
    incidentId: 'incident-123',
    action: 'created',
    priority: "HIGH",
    title: 'Test Alert',
    description: 'Test description',
    timestamp: timestamp,
    service: 'TestService',
    data: {}
  };

  fetch(webhookUrl, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-amzn-event-timestamp": timestamp,
      "Authorization": `Bearer ${secret}`,  // Fixed: template literal
    },
    body: JSON.stringify(payload),
  });
}
```

**Version 2 (authentification par jeton porteur) - cURL :**

```
#!/bin/bash

# Configuration
WEBHOOK_URL="https://event-ai.us-east-1.api.aws/webhook/generic/YOUR_WEBHOOK_ID"
SECRET="YOUR_WEBHOOK_SECRET"

# Create payload
TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%S.000Z)
INCIDENT_ID="test-alert-$(date +%s)"

PAYLOAD=$(cat <<EOF
{
"eventType": "incident",
"incidentId": "$INCIDENT_ID",
"action": "created",
"priority": "HIGH",
"title": "Test Alert",
"description": "Test alert description",
"service": "TestService",
"timestamp": "$TIMESTAMP"
}
EOF
)

# Send webhook
curl -X POST "$WEBHOOK_URL" \
-H "Content-Type: application/json" \
-H "x-amzn-event-timestamp: $TIMESTAMP" \
-H "Authorization: Bearer $SECRET" \
-d "$PAYLOAD"
```

## Résolution des problèmes liés aux webhooks
<a name="troubleshooting-webhooks"></a>

### Si vous ne recevez pas de 200
<a name="if-you-do-not-receive-a-200"></a>

Un 200 et un message tel que webhook reçus indiquent que l'authentification a été réussie et que le message a été mis en file d'attente pour que le système le vérifie et le traite. Si vous n'obtenez pas un 200 mais un 4xx, il y a probablement un problème avec l'authentification ou les en-têtes. Essayez d'envoyer manuellement à l'aide des options curl pour aider à débuguer l'authentification.

### Si vous recevez un 200 mais qu'une enquête ne démarre pas
<a name="if-you-receive-a-200-but-an-investigation-does-not-start"></a>

La cause probable est une charge utile mal formatée.

1. Vérifiez que l'horodatage et l'identifiant de l'incident sont à jour et uniques. Les messages dupliqués sont dédupliqués.

1. Vérifiez que le message est valide au format JSON

1. Vérifiez que le format est correct

### Si vous recevez un 200$ et que l'enquête est immédiatement annulée
<a name="if-you-receive-a-200-and-investigation-is-immediately-cancelled"></a>

Vous avez probablement atteint la limite du mois. Adressez-vous à votre AWS contact pour demander une modification de la limite de taux, le cas échéant.

## Rubriques en relation
<a name="related-topics"></a>
+ [Création d'un espace d'agents](getting-started-with-aws-devops-agent-creating-an-agent-space.md)
+ [Qu'est-ce qu'une application Web pour DevOps agents ?](about-aws-devops-agent-what-is-a-devops-agent-web-app.md)
+ [DevOps Autorisations IAM de l'agent](aws-devops-agent-security-devops-agent-iam-permissions.md)