> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Intégration PagerDuty

> Acheminez les incidents PagerDuty vers Devin pour une investigation automatisée

<div id="overview">
  ## Vue d’ensemble
</div>

PagerDuty s’intègre à Devin en tant que mécanisme d’acheminement des alertes. Lorsque des incidents se produisent dans PagerDuty, ils activent des sessions Devin via l’[API Devin](/fr/api-reference/overview) au moyen d’une passerelle webhook légère. Devin enquête ensuite automatiquement sur l’incident — en récupérant la télémétrie, en identifiant les causes racines et, si nécessaire, en ouvrant des PR de correctif.

Cette approche fonctionne particulièrement bien lorsqu’elle est combinée à l’[intégration Datadog MCP](/fr/enterprise/integrations/datadog), où PagerDuty achemine l’alerte vers Devin et Devin utilise Datadog pour examiner les journaux et les métriques.

<div id="setup">
  ## Configuration
</div>

<Steps>
  <Step title="Déployer un service passerelle webhook">
    Mettez en place un petit handler qui reçoit les payloads d'incident PagerDuty et appelle l'API Devin pour lancer des sessions d'investigation.

    Créez un [utilisateur de service](/fr/api-reference/v3/overview) dans **Settings > Service Users** avec l'autorisation `ManageOrgSessions`. Stockez le jeton d'API dans `DEVIN_API_KEY`, l'ID de votre organisation dans `DEVIN_ORG_ID` et un secret partagé dans `WEBHOOK_SECRET` sur votre service passerelle. Vous configurerez ce même secret dans les **Custom Headers** du webhook PagerDuty à l'étape suivante.

    ```javascript theme={null}
    const express = require('express');
    const crypto = require('crypto');
    const app = express();
    app.use(express.json());

    function verifySignature(req) {
      const secret = Buffer.from(req.headers['x-webhook-secret'] || '');
      const expected = Buffer.from(process.env.WEBHOOK_SECRET || '');
      if (!expected.length) throw new Error('WEBHOOK_SECRET environment variable is not set');
      if (secret.length !== expected.length) return false;
      return crypto.timingSafeEqual(secret, expected);
    }

    app.post('/pagerduty-alert', async (req, res) => {
      if (!verifySignature(req)) return res.status(401).send('Bad signature');

      const event = req.body?.event;
      if (!event || event.event_type !== 'incident.triggered') {
        return res.sendStatus(200);
      }

      const incident = event.data;
      const title = incident.title || 'Unknown incident';
      const service = incident.service?.summary || 'unknown-service';
      const urgency = incident.urgency || 'high';
      const incidentUrl = incident.html_url || '';

      const orgId = process.env.DEVIN_ORG_ID;
      const response = await fetch(
        `https://api.devin.ai/v3/organizations/${orgId}/sessions`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${process.env.DEVIN_API_KEY}`,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          prompt: [
            `PagerDuty incident triggered: "${title}"`,
            `Service: ${service}`,
            `Urgency: ${urgency}`,
            `Incident URL: ${incidentUrl}`,
            ``,
            `Investigate this incident:`,
            `1. Check recent logs and metrics for ${service}`,
            `2. Identify the root cause of the issue`,
            `3. If the root cause is a code issue, open a hotfix PR`,
            `4. Post your findings to #incidents on Slack`,
          ].join('\n'),
          tags: ['pagerduty-triage', `service:${service}`],
        }),
      });

      const { session_id } = await response.json();
      console.log(`Started Devin session ${session_id} for: ${title}`);
      res.sendStatus(200);
    });

    app.listen(3000);
    ```

    Déployez ce service partout où il peut recevoir du trafic HTTPS — par exemple dans un Cloudflare Worker, une AWS Lambda ou un petit conteneur.
  </Step>

  <Step title="Ajouter une intégration webhook dans PagerDuty">
    1. Dans PagerDuty, accédez à **Services > \[votre service] > Integrations**
    2. Cliquez sur **Add Integration** et sélectionnez **Generic Webhooks (v3)**
    3. Renseignez la **Webhook URL** avec l'endpoint de votre service passerelle (par ex. `https://your-bridge.example.com/pagerduty-alert`)
    4. Dans **Custom Headers**, ajoutez `X-Webhook-Secret` avec la même valeur que celle stockée dans `WEBHOOK_SECRET` sur votre service passerelle
    5. Dans **Event Subscription**, filtrez sur le type d'événement `incident.triggered` pour ne déclencher le webhook que pour les nouveaux incidents
  </Step>

  <Step title="Vérifier le pipeline">
    Déclenchez un incident de test dans PagerDuty (ou utilisez un service de test) et confirmez que :

    1. Votre passerelle reçoit le payload du webhook
    2. Une nouvelle session Devin est créée sur [app.devin.ai](https://app.devin.ai)
    3. Devin commence à analyser l'incident
  </Step>
</Steps>

<div id="best-practices">
  ## Bonnes pratiques
</div>

* **Commencez par des monitors de niveau warning.** Testez le pipeline avec des incidents non critiques avant d’acheminer des alertes P1 de production vers Devin.
* **Filtrez par service ou par gravité.** Utilisez les abonnements aux événements webhook de PagerDuty ou ajoutez une logique dans votre passerelle pour ignorer les services peu prioritaires ou trop bruyants. Cela évite que Devin soit submergé par des alertes peu utiles.
* **Utilisez des playbooks différents selon la gravité.** Acheminez les alertes P1 pour une investigation immédiate et un correctif d’urgence. Acheminez les alertes P3 uniquement pour une analyse des causes racines. Transmettez des valeurs `playbook_id` différentes dans la requête à l’API Devin selon le niveau d’urgence.
* **Étiquetez les sessions pour en faciliter le suivi.** L’exemple de code étiquette chaque session avec `pagerduty-triage` et le nom du service, ce qui facilite le filtrage et l’examen dans le tableau de bord Devin.

<div id="combining-with-datadog">
  ## Combiner avec Datadog
</div>

PagerDuty est souvent utilisé avec l’[intégration Datadog MCP](/fr/enterprise/integrations/datadog). Dans cette configuration :

1. **PagerDuty** achemine l’alerte vers Devin (ce qui active la session d’investigation)
2. **Devin** utilise le **Datadog MCP** pour interroger les journaux, les métriques et les traces du service concerné

Devin dispose ainsi à la fois du contexte de l’alerte fourni par PagerDuty et des données d’observabilité détaillées de Datadog, ce qui permet des investigations plus approfondies.

<Tip>
  Ajoutez dans [Knowledge](/fr/product-guides/knowledge) des informations sur l’architecture de votre service et vos runbooks d’astreinte afin que Devin puisse suivre automatiquement les procédures d’investigation de votre équipe.
</Tip>

<div id="related-resources">
  ## Ressources connexes
</div>

* [Intégration Datadog](/fr/enterprise/integrations/datadog)
* [Documentation sur MCP Marketplace](/fr/work-with-devin/mcp)
* [Référence de l’API Devin](/fr/api-reference/overview)