> ## Documentation Index > Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > Découvrez comment créer des flux d’événements à l’aide d’AWS EventBridge ou de webhooks. # Créer un flux d’événements En vous abonnant à des événements et en les acheminant vers la destination de votre choix au moyen de flux d’événements, vous pouvez répondre à plusieurs cas d’usage connexes, notamment : * Envoyer des courriels aux nouveaux clients pour leur souhaiter la bienvenue ou leur demander de vérifier leur adresse courriel. * Surveiller les changements du cycle de vie des utilisateurs afin de mettre à jour les systèmes CRM (gestion de la relation client) ou de facturation. Vous pouvez créer un flux d’événements à l’aide d’AWS EventBridge ou de webhooks. Les sections ci-dessous décrivent le processus de configuration pour les deux options.
## Accès à la Management API (facultatif)
Les flux d’événements peuvent être configurés soit à l’aide du Auth0 Dashboard, soit avec la [Management API](https://auth0.com/docs/api/management/v2). Si vous utilisez la Management API, vous devez, avant de pouvoir configurer un flux d’événements, créer une application machine à machine (M2M) et vous authentifier avec un jeton de la Management API. Pour en savoir plus, consultez [Jetons d’accès de la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens). 1. Accédez à [Dashboard > Applications > Applications](https://manage.auth0.com/#/applications) et sélectionnez **Create Application**. 2. Saisissez un nom descriptif pour votre application et choisissez **Machine to Machine Applications**. Sélectionnez ensuite **Create**. 3. Sélectionnez l’API que vous souhaitez appeler avec votre application. Dans ce cas, utilisez **Auth0 Management API**. 4. Choisissez les autorisations à inclure dans le jeton d’accès de votre application, puis sélectionnez **Authorize**. À des fins de test, sélectionnez : * `read:event_streams` * `create:event_streams` * `update:event_streams` * `delete:event_streams` * `read:event_deliveries` * `update:event_deliveries` * `create:users` 5. Accédez à l’onglet **Settings** pour obtenir votre **ID client**, votre **Secret client** et votre **Domaine**. 6. Consultez [Obtenir des jetons d’accès de la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production) pour récupérer et stocker votre jeton d’accès.
## AWS EventBridge
Les renseignements ci-dessous expliquent comment créer et activer un flux d’événements à l’aide d’AWS EventBridge.
### Prérequis pour EventBridge
Pour utiliser AWS EventBridge avec les flux d’événements, vous aurez besoin des éléments suivants : * Compte AWS * Votre compte AWS doit disposer des autorisations requises pour utiliser EventBridge. Si vous n’avez pas de compte, inscrivez-vous à [https://aws.amazon.com/eventbridge/](https://aws.amazon.com/eventbridge/). * Autorisations AWS IAM * Bus d’événements AWS EventBridge * ID du compte AWS et région
### Créer un flux d’événements (EventBridge)
Les flux d’événements vous permettent de capter les changements en temps réel au sein de votre locataire Auth0 et de les envoyer à un système externe pour traitement. Avant de configurer un flux d’événements, vous devez identifier les [types d’événements](/fr-CA/docs/customize/events/event-types) que vous souhaitez surveiller. Ensuite, vous utiliserez l’identifiant et la région de votre compte AWS pour configurer votre flux d’événements, comme illustré ci-dessous. Cet exemple utilise la CLI Auth0 pour créer un flux d’événements qui s’abonne à l’événement `user.created`, lequel se déclenche chaque fois qu’un nouvel utilisateur est créé dans votre locataire. ```bash wrap lines theme={null} auth0 events create --name ng-demo-eventbridge --type eventbridge --subscriptions "user.created" --configuration '{"aws_account_id":"","aws_region":""}' ``` En cas de réussite, cette requête renvoie le JSON suivant avec l’`id` de votre flux d’événements. Les nouveaux flux d’événements sont activés par défaut. ```json lines theme={null} { "id": "est_8of6RXoM1997qikH7NS11h", "status": "enabled", "name": "ng-demo-eventbridge", "subscriptions": [ { "event_type": "user.created" } ], "created_at": "2025-01-29T18:08:43.440Z", "updated_at": "2025-01-29T18:08:43.440Z", "destination": { "type": "eventbridge", "configuration": { "aws_account_id": "", "aws_region": "", "aws_partner_event_source": "default" } } } ``` Pour créer un flux d’événements dans Auth0 Dashboard à l’aide d’AWS EventBridge : 1. Accédez à **Auth0 Dashboard** > **Event Streams (Early)**. 2. Sélectionnez **+Create Event Stream**. 3. Dans la liste des types de flux, sélectionnez **AWS EventBridge**. Le formulaire de configuration de votre nouveau flux EventBridge s’ouvre. 4. **Configurer les détails du flux :** Dans le formulaire de configuration, vous devez fournir les renseignements suivants : * **Nom du flux :** Saisissez un nom descriptif pour votre flux d’événements. Cela vous aidera à l’identifier dans Auth0 Dashboard. * **ID de compte AWS :** Saisissez l’ID à 12 chiffres du compte AWS auquel vous souhaitez envoyer les événements Auth0. * **Région AWS :** Sélectionnez la région AWS précise où se trouve votre bus d’événements EventBridge. 5. **Sélectionner les types d’événements :** Dans la section **Select Event Types**, choisissez les types d’événements Auth0 précis à inclure dans ce flux. Vous pouvez en sélectionner plusieurs selon vos besoins (par ex., `user.created`, `user.updated`, `user.deleted`). 6. **Enregistrer les modifications :** Une fois le nom du flux, les détails AWS et les types d’événements souhaités configurés, cliquez sur le bouton **Save Changes**. Votre nouveau flux d’événements est maintenant créé et Auth0 peut commencer à publier les types d’événements sélectionnés vers le bus d’événements AWS EventBridge indiqué. Vous pouvez surveiller l’état de votre flux d’événements et le gérer à partir de la page Event Streams (Early) dans Auth0 Dashboard. Avant de commencer avec Terraform, vous devez : * Installer l’interface de ligne de commande Terraform * Installer l’interface de ligne de commande Auth0 et vous authentifier avec `auth0 login` * Avoir l’ID de votre compte AWS ainsi que votre région AWS pour configurer un flux EventBridge ### Configuration des fichiers Pour provisionner votre flux d’événements avec Terraform, vous avez besoin d’une structure de répertoires de projet. Consultez l’exemple de configuration ci-dessous si vous effectuez cette procédure pour la première fois : ```bash theme={null} auth0-event-streams/ ├── main.tf # Configuration principale : définit les fournisseurs et la ressource 'auth0_event_stream'. ├── variables.tf # Déclaration des variables : définit les entrées comme 'aws_account_id' et 'aws_region'. └── terraform.tfvars # Valeurs des variables : contient les valeurs de configuration réelles (p. ex., « 123456789012 »). ``` ### Définir les variables Dans votre fichier `variables.tf`, déclarez les variables d’entrée nécessaires à la configuration de votre flux d’événements : ```bash theme={null} variable "aws_account_id" { description = "The 12-digit AWS Account ID where the EventBridge event bus resides." type = string } variable "aws_region" { description = "The AWS region (e.g., us-east-1) for the EventBridge event bus." type = string } ``` ### Définir les valeurs des variables Dans votre fichier `terraform.tfvars`, indiquez les valeurs réelles propres à votre environnement : ```bash theme={null} aws_account_id = "" # p. ex., "123456789012" aws_region = "" # p. ex., "us-east-1" ``` ### Définir les variables d’environnement Dans votre terminal, définissez les trois variables d’environnement requises à l’aide des identifiants copiés dans la section Access Management API (facultatif) ci-dessus. ```bash theme={null} export AUTH0_DOMAIN="your-tenant-name.auth0.com" export AUTH0_CLIENT_ID="your_m2m_client_id" export AUTH0_CLIENT_SECRET="your_m2m_client_secret" ``` ## Créer un flux d’événements Cet exemple utilise la ressource `auth0_event_stream` pour créer un flux d’événements qui s’abonne à l’événement `user.created`, lequel se déclenche chaque fois qu’un nouvel utilisateur est créé dans votre locataire. Utilisez l’exemple suivant dans votre fichier `main.tf` : ```hcl theme={null} terraform { required_providers { auth0 = { source = "auth0/auth0" version = ">= 1.0.0" } } } provider "auth0" {} resource "auth0_event_stream" "eventbridge_stream" { name = "ng-demo-eventbridge-tf" destination_type = "eventbridge" # Requis subscriptions = ["user.created"] eventbridge_configuration { aws_account_id = var.aws_account_id aws_region = var.aws_region } } ``` Si l’appel réussit, cette requête renvoie le JSON suivant, avec l’`id` de votre flux d’événements. Les nouveaux flux d’événements sont activés par défaut. Après avoir créé et enregistré les trois fichiers ci-dessus, vous pouvez créer votre flux. 1. Initialisez le fournisseur ```bash theme={null} terraform init ``` 2. Vérifiez vos modifications : ```bash theme={null} terraform plan ``` 3. Créez le flux d’événements : ```bash theme={null} terraform apply ```
## Webhooks
Comme solution de rechange à AWS EventBridge, vous pouvez utiliser des webhooks pour prendre en charge les flux d’événements. Pour commencer, configurez d’abord un gestionnaire de webhook afin de recevoir des notifications en temps réel lorsqu’un événement précis se produit. Ensuite, vous pourrez créer votre flux d’événements. Vous pouvez soit créer un gestionnaire de webhook de base en suivant les instructions ci-dessous, soit utiliser un service existant comme : * Vercel * Inngest Si vous décidez d’utiliser un service existant, vous pouvez passer à [Créer un flux d’événements (webhook)](#create-an-event-stream-webhooks-). Sinon, suivez les instructions ci-dessous pour créer votre propre gestionnaire de webhook de base.
### Prérequis du webhook
Assurez-vous d’avoir installé les éléments suivants pour pouvoir écrire votre gestionnaire de webhook : * `node.js` * `jq` * `npm` * `ngrok`
### Écrire le gestionnaire du webhook
1. Installez `express` dans votre dossier `node_modules` et ajoutez-le aux dépendances de votre `package.json`. 2. Installez `dotenv` à la racine de votre projet pour utiliser un fichier `.env` afin d’y stocker les variables d’environnement. 3. Créez un fichier `webhook.js` pour recevoir l’événement `user.created` et l’enregistrer dans une base de données. ```javascript lines expandable theme={null} const express = require('express'); const app = express(); // Middleware d’autorisation app.use((req, res, next) => { const token = req.headers["authorization"]; if (token !== `Bearer ${API_TOKEN}`) { return res.status(401).json({ error: "Unauthorized" }); } next(); }); // Point de terminaison du webhook app.post("/webhook", async (req, res) => { console.log("Webhook received:", JSON.stringify(req.body, null, 2)); const eventData = req.body; const { id, type, time, data } = eventData; const user = data.object; try { switch (type) { case "user.created": await handleUserCreated(user, time); break; case "user.updated": await handleUserUpdated(user, time); break; case "user.deleted": await handleUserDeleted(user, time); break; default: await handleDefaultEvent(id, type, time, data); } console.log(`Webhook event of type '${type}' committed to the database.`); res.sendStatus(204); } catch (err) { console.error("Error processing webhook:", err); res.status(500).json({ error: "Internal server error" }); } }); // Fonction spécifique pour traiter l’événement de création d’utilisateur // Dans cet exemple, nous nous assurons que les utilisateurs sont également créés dans notre propre base de données async function handleUserCreated(user, time) { const { user_id, email, name, nickname, created_at, updated_at } = user; const query = ` INSERT INTO users (user_id, email, name, nickname, created_at, updated_at, raw_user, last_event_processed) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) `; const values = [ user_id, email, name, nickname, created_at, updated_at, user, time, ]; try { await getPool().query(query, values); } catch (err) { if (err.code === "23505") { console.error(`Duplicate user_id=${user_id}, skipping insert.`); } else { console.error(`Database error while creating user_id=${user_id}:`, err); throw err; } } } ``` 4. À la racine de votre projet, créez un fichier `.env` et ajoutez-y votre jeton d’API en utilisant : ```bash lines theme={null} API_TOKEN=`openssl rand -hex 32` echo "API_TOKEN=$API_TOKEN" > .env ``` 5. Démarrez votre serveur : ```bash lines theme={null} node webhook.js ``` 6. Pour tester le webhook, exposez votre gestionnaire de webhook à l’aide d’un outil comme ngrok : ```bash lines theme={null} ngrok http 3000 ``` Cela fournit une URL publique pour votre gestionnaire de webhook local, par exemple : ```bash lines theme={null} http://localhost:3000 ```
### Créer un flux d’événements (webhooks)
Les flux d’événements vous permettent de capter les changements en temps réel au sein de votre locataire Auth0 et de les envoyer à un système externe pour les traiter. Avant de configurer un flux d’événements, vous devez identifier les [types d’événements](/fr-CA/docs/customize/events/event-types) que vous souhaitez surveiller. Vous utiliserez ensuite votre gestionnaire de webhook pour créer un flux d’événements, comme illustré ci-dessous. Cet exemple utilise Auth0 CLI pour créer un flux d’événements abonné à l’événement `user.created`, qui se déclenche chaque fois qu’un nouvel utilisateur est inscrit dans votre locataire. Les données de l’événement sont ensuite transmises à un point de terminaison webhook pour traitement ultérieur. ```bash lines theme={null} source .env # Assurez-vous d'être dans le répertoire webhook où vous avez créé votre fichier .env WEBHOOK_URL="/webhook" auth0 events create -n my-event1 -t webhook -s "user.created" -c '{"webhook_endpoint":"'"${WEBHOOK_URL}"'","webhook_authorization":{"method":"bearer","token":'"${API_TOKEN}"'"}}' ``` Si l’opération réussit, le JSON suivant est renvoyé avec l’`id` de votre flux d’événements. Les nouveaux flux d’événements sont activés par défaut. ```hcl theme={null} { "id": "est_8of6RXoM1997qikH7NS11h", "status": "enabled", "name": "ng-demo-2", "subscriptions": [ { "event_type": "user.created" } ], "created_at": "2025-01-29T18:08:43.440Z", "updated_at": "2025-01-29T18:08:43.440Z", "destination": { "type": "webhook", "configuration": { "webhook_endpoint": "https://example.com/webhook", "webhook_authorization": { "method": "bearer" } } } } ``` #### Vérifier le flux d’événements Après avoir créé un flux d’événements, vous pouvez vérifier son existence à l’aide de la commande suivante : ```bash lines theme={null} auth0 events show ``` Pour créer un flux d’événements dans Auth0 Dashboard à l’aide d’AWS EventBridge : 1. Accédez à **Auth0 Dashboard** > **Event Streams (Early)**. 2. Sélectionnez **+Create Event Stream**. 3. Dans la liste des types de flux, sélectionnez **Webhook**. Le formulaire de configuration de votre nouveau flux webhook s’ouvrira. 4. **Configurer les détails du flux :** Dans le formulaire de configuration, vous devrez fournir les renseignements suivants : * **Nom du flux :** Entrez un nom descriptif pour votre flux d’événements. Cela vous aidera à l’identifier dans Auth0 Dashboard. * **Point de terminaison :** Entrez l’URL complète du point de terminaison HTTP auquel vous voulez qu’Auth0 envoie les événements. Il s’agit du service qui recevra et traitera les données d’événement. * **Méthode d’authentification :** Choisissez la méthode d’authentification requise par votre point de terminaison. * **Jeton d’autorisation :** Si vous avez sélectionné **Bearer Token** comme méthode d’authentification, entrez ici le jeton d’autorisation requis. 5. **Sélectionner les types d’événements :** Dans la section **Select Event Types**, choisissez les types d’événements Auth0 précis que vous voulez inclure dans ce flux. Vous pouvez sélectionner plusieurs types d’événements selon vos besoins (p. ex., `user.created`, `user.updated`, `user.deleted`). 6. **Enregistrer les modifications :** Une fois que vous avez configuré le nom du flux, les détails AWS et sélectionné les types d’événements souhaités, cliquez sur le bouton **Save Changes**. Votre nouveau flux d’événements est maintenant créé, et Auth0 peut commencer à publier les types d’événements sélectionnés vers le webhook spécifié. Vous pouvez surveiller l’état de votre flux d’événements et le gérer à partir de la page Event Streams (Early) dans Auth0 Dashboard. ### Configuration des fichiers Pour provisionner votre flux d’événements à l’aide de Terraform, vous aurez besoin d’une arborescence de projet structurée. Consultez ci-dessous un exemple de configuration pour une première mise en place : ```bash theme={null} auth0-event-streams/ ├── main.tf # Configuration principale : définit les fournisseurs et la ressource 'auth0_event_stream'. ├── variables.tf # Déclaration des variables : définit les entrées comme 'aws_account_id' et 'aws_region'. └── terraform.tfvars # Valeurs des variables : contient les valeurs de configuration réelles (p. ex., "123456789012"). ``` ### Définir les variables Dans votre fichier `variables.tf`, déclarez les variables d’entrée nécessaires à la configuration de votre flux : ```bash theme={null} variable "api_token" { description = "The secret token used for Webhook Bearer Authorization." type = string sensitive = true } variable "webhook_endpoint_url" { description = "The public HTTPS URL for the webhook handler (e.g., your ngrok URL)." type = string } ``` ### Configuration de l’environnement À l’aide du jeton d’API généré ci-dessus, définissez de façon sécurisée la variable d’environnement dans votre terminal à l’aide du préfixe `TF_VAR_` : ```bash wrap lines theme={null} export AUTH0_DOMAIN="your-tenant-name.auth0.com" export AUTH0_CLIENT_ID="your_m2m_client_id" export AUTH0_CLIENT_SECRET="your_m2m_client_secret" ``` Si l’opération réussit, le JSON suivant est renvoyé avec l’`id` de votre flux d’événements. Les nouveaux flux d’événements sont activés par défaut. ```bash theme={null} export TF_VAR_api_token="${API_TOKEN}" export AUTH0_DOMAIN="your-tenant-name.auth0.com" export AUTH0_CLIENT_ID="your_m2m_client_id" export AUTH0_CLIENT_SECRET="your_m2m_client_secret" ``` ## Créer un flux d’événements Cet exemple utilise la ressource `auth0_event_stream` pour créer un flux d’événements abonné à l’événement `user.created`, qui se déclenche chaque fois qu’un nouvel utilisateur est enregistré dans votre locataire. Utilisez l’exemple suivant dans votre fichier `main.tf` : Si l’opération réussit, cet appel renvoie le JSON suivant avec l’`id` de votre flux d’événements. Les nouveaux flux d’événements sont activés par défaut. ```hcl theme={null} terraform { required_providers { auth0 = { source = "auth0/auth0" version = ">= 1.0.0" } } } provider "auth0" {} resource "auth0_event_stream" "webhook_stream" { name = "my-webhook-handler-stream-tf" destination_type = "webhook" subscriptions = ["user.created"] webhook_configuration { webhook_endpoint = var.webhook_endpoint_url webhook_authorization { method = "bearer" token = var.api_token } } } ``` Après avoir créé et enregistré les trois fichiers ci-dessus, vous pouvez maintenant créer votre flux. 1. Initialisez le fournisseur ```bash theme={null} terraform init ``` 2. Exécutez le plan : ```bash theme={null} URL="/webhook" terraform plan -var="webhook_endpoint_url=${URL}" ``` 3. Créez le flux d’événements : ```bash theme={null} terraform apply -var="webhook_endpoint_url=https:///webhook" ``` Une fois le flux activé, vous pouvez tester le flux d’événements. Pour en savoir plus, consultez [**Tests des événements, observabilité et reprise après échec**](/fr-CA/docs/customize/events/event-testing-observability-and-failure-recovery).
## Auth0 Actions
Les informations ci-dessous décrivent comment créer et activer un flux d’événements à l’aide d’Auth0 Actions.
### Créer un flux d’événements (Actions)
Les flux d’événements vous permettent de capturer les changements en temps réel dans votre locataire Auth0 et de les envoyer à un système externe pour traitement. Avant de configurer un flux d’événements, vous devez identifier les [types d’événements](/fr-CA/docs/customize/events/event-types) que vous souhaitez surveiller. Cet exemple utilise Auth0 CLI pour créer un flux d’événements qui s’abonne à l’événement `user.created`, lequel se déclenche chaque fois que votre locataire enregistre un nouvel utilisateur. ```bash wrap lines theme={null} auth0 event-streams create \ --name actions-1 \ --type action \ --subscriptions "user.created,user.updated,user.deleted" \ --configuration '{"action_id":"385db79f-28a4-43d9-909d-6f5511dd6632"}' ``` Si l’appel réussit, il renvoie le JSON suivant avec l’`id` de votre flux d’événements. Les nouveaux flux d’événements sont activés par défaut. ```json lines theme={null} { "configuration": { "action_id": "act_xyz789...", "status": "enabled" } } ``` Pour créer un flux d’événements dans Auth0 Dashboard à l’aide d’Auth0 Actions : 1. Accédez à **Auth0 Dashboard** > **Event Streams (Early)**. 2. Sélectionnez **+Create Event Stream**. 3. Dans la liste des types de flux, sélectionnez **+Auth0 Actions**. Cette option ouvre le formulaire de configuration de votre nouveau flux Auth0 Actions. 4. **Configurer les détails du flux :** Dans le formulaire de configuration, vous devez fournir les renseignements suivants : * **Nom du flux :** Entrez un nom descriptif pour votre flux d’événements. Cela vous aidera à l’identifier dans Auth0 Dashboard. 5. **Sélectionner les types d’événements :** Dans la section **Select Event Types**, choisissez les types d’événements Auth0 précis que vous souhaitez inclure dans ce flux. Vous pouvez sélectionner plusieurs types d’événements selon vos besoins (p. ex., `Created`, `Updated`, `Deleted`). 6. Dans **Action Editor**, écrivez votre code de gestionnaire. Le système exige la fonction `onExecuteEventStream`. Vous pouvez utiliser l’objet `api` pour gérer les états de réussite ou d’échec. ```javascript theme={null} /** * Gestionnaire appelé pendant l’exécution d’un flux d’événements. * @param {Event} event - Détails sur le Cloud Event. * @param {EventStreamAPI} api - Interface dont les méthodes peuvent être utilisées pour traiter l’événement. */ exports.onExecuteEventStream = async (event, api) => { const eventType = event.message.type; const eventData = event.message.data; console.log(`Received event: ${eventType}`); // Logique personnalisée : p. ex., envoyer des données à une API externe // await axios.post('https://my-crm.com/ingest', eventData); // GESTION DES ÉCHECS : // Pour déclencher une nouvelle tentative, lancez une erreur ou utilisez api.message.fail() if (!eventData) { // api.message.fail('No data received'); throw new Error('No data received'); } // SUCCÈS : // Si la fonction se termine sans erreur, l’événement est marqué comme livré. }; ``` 7. **Enregistrer les modifications :** Une fois le nom du flux et le gestionnaire Action configurés, le système crée automatiquement l’Action, l’associe à un flux et l’active. Votre nouveau flux d’événements est maintenant créé, et Auth0 peut commencer à publier les types d’événements sélectionnés vers l’Action Auth0 spécifiée. Vous pouvez surveiller l’état de votre flux d’événements et le gérer à partir de la page Event Streams (Early) dans Auth0 Dashboard.
## En savoir plus
* [Types d’événements](/fr-CA/docs/customize/events/event-types) * [Tests d’événements, observabilité et reprise après échec](/fr-CA/docs/customize/events/event-testing-observability-and-failure-recovery) * [Bonnes pratiques pour les événements](/fr-CA/docs/customize/events/events-best-practices)