Comment Construire des APIs Événementielles avec Webhooks et Files d'Attente de Messages ?

TL;DR

Les API événementielles utilisent des webhooks pour les notifications externes et des files de messages pour le traitement interne. Publiez les événements dans une file d'attente (RabbitMQ, Kafka), traitez-les de manière asynchrone et informez les clients via des webhooks. La Modern PetstoreAPI utilise ce modèle pour le traitement des commandes, les mises à jour d'inventaire et les notifications de paiement.

Introduction

Un client passe une commande. Votre API doit débiter le paiement, mettre à jour l'inventaire, envoyer un e-mail, notifier l'entrepôt et déclencher des webhooks. Faites-vous tout cela de manière synchrone, faisant attendre le client 10 secondes ? Ou répondez-vous immédiatement et traitez-vous de manière asynchrone ?

Les API événementielles répondent rapidement et traitent en arrière-plan. Le point de terminaison de commande renvoie immédiatement 201 Created. Les événements déclenchent le traitement en arrière-plan. Les webhooks notifient les clients une fois le traitement terminé.

Modern PetstoreAPI utilise une architecture événementielle pour les commandes, les paiements et l'inventaire.

Apidog vous aide à tester les webhooks, à valider les flux d'événements et à simuler le traitement asynchrone.

Architecture Événementielle

Les API événementielles publient des événements lorsque des choses se produisent. D'autres services s'abonnent et réagissent.

Composants

1. Producteur d'événements - Point de terminaison API qui publie des événements
2. Bus/File d'attente d'événements - Acheminenement des événements (RabbitMQ, Kafka, SQS)
3. Consommateur d'événements - Travailleurs en arrière-plan qui traitent les événements
4. Webhooks - Notifient les clients externes

Flux

Client → POST /orders → API
API → Publier "order.created" → File d'attente
API → Renvoyer 201 Created → Client
Travailleur → Consommer l'événement → Traiter la commande
Travailleur → Publier "order.completed" → File d'attente
Travailleur Webhook → Envoyer webhook → Client

Webhooks pour les Événements Externes

Les webhooks notifient les clients externes des événements.

// Publier un événement lorsqu'une commande est créée
app.post('/v1/orders', async (req, res) => {
  const order = await createOrder(req.body);

  await eventBus.publish('order.created', {
    orderId: order.id,
    userId: order.userId,
    total: order.total
  });

  res.status(201).json(order);
});

// Le travailleur en arrière-plan envoie des webhooks
eventBus.subscribe('order.completed', async (event) => {
  const webhooks = await getWebhooks(event.userId, 'order.completed');

  for (const webhook of webhooks) {
    await sendWebhook(webhook.url, {
      event: 'order.completed',
      data: event
    });
  }
});

Files de Messages pour les Événements Internes

Les files de messages gèrent le traitement interne des événements.

Exemple RabbitMQ

// Éditeur
await publishEvent('order.created', { orderId: '019b4132' });

// Consommateur
await consumeEvents('order.*', async (event) => {
  await processOrder(event);
});

Comment Modern PetstoreAPI Implémente les API Événementielles

Traitement des Commandes

1. POST /orders renvoie 201 immédiatement
2. Publier l'événement order.created
3. Le travailleur de paiement traite le paiement
4. Le travailleur d'inventaire met à jour le stock
5. Le travailleur d'e-mail envoie la confirmation
6. Le travailleur webhook notifie le client

Voir l'architecture événementielle de Modern PetstoreAPI.

Tester avec Apidog

Apidog prend en charge les tests d'API événementielles :

• Tester la livraison des webhooks
• Valider les charges utiles des événements
• Simuler le traitement asynchrone
• Tester la logique de réessai

Conclusion

Les API événementielles améliorent les performances et l'évolutivité. Utilisez les webhooks pour les notifications externes et les files de messages pour le traitement interne. Modern PetstoreAPI démontre des modèles événementiels prêts pour la production.

FAQ

Quelle est la différence entre les webhooks et les files de messages ?

Les webhooks notifient les clients externes via HTTP. Les files de messages gèrent la communication interne des services.

Quelle file de messages dois-je utiliser ?

RabbitMQ pour la simplicité, Kafka pour un débit élevé, AWS SQS pour un service géré.

Comment gérez-vous les échecs de webhook ?

Implémentez une logique de réessai avec un backoff exponentiel (consultez notre guide sur la fiabilité des webhooks).

Pouvez-vous utiliser des événements sans files de messages ?

Oui, mais les files d'attente offrent durabilité, réessai et découplage.

Comment testez-vous les API événementielles ?

Utilisez Apidog pour tester les webhooks et valider les flux d'événements.