> ## 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 Vous pouvez créer des flux d’événements qui surveillent différents [types d’événements](/docs/fr-ca/events), comme la création d’un nouveau profil utilisateur. En vous abonnant aux événements et en les acheminant vers la destination de votre choix à l’aide de flux d’événements, vous pouvez prendre en charge plusieurs cas d’utilisation 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 dans le cycle de vie des utilisateurs afin de pouvoir mettre à jour les systèmes de 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 présentent le processus de configuration pour les deux options. En activant les flux d’événements, vous devenez le responsable du traitement des données exportées depuis la plateforme Auth0 et êtes responsable des informations diffusées, de leur sécurisation et de leur utilisation. Si vous configurez un endpoint de destination situé dans une région géographique différente de votre environnement Auth0, cette configuration entraîne un transfert de données interrégional. Vous êtes seul responsable de la gestion de vos configurations de destination et de vous assurer que tout transfert transfrontalier de données qui en résulte respecte vos politiques internes et les lois applicables en matière de protection des données.
## API de gestion des accès (facultatif)
Les flux d’événements peuvent être configurés soit au moyen du Auth0 Dashboard, soit à l’aide de l’[Auth0 Management API](https://auth0.com/docs/api/management/v2). Si vous utilisez la Management API, vous devez d’abord créer une application machine-to-machine (M2M) et vous authentifier avec un jeton de la Management API avant de pouvoir configurer un flux d’événements. Pour en savoir plus, consultez [Jetons d’accès de la Management API](/docs/fr-ca/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. Entrez un nom descriptif pour votre application et choisissez **Machine to Machine Applications**. Ensuite, sélectionnez **Create**. 3. Sélectionnez l’API que vous souhaitez appeler à partir de votre application. Dans ce cas-ci, utilisez l’**Auth0 Management API**. 4. Choisissez les permissions à 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 relever votre **Client ID**, votre **Client Secret** et votre **Domain**. 6. Consultez [Obtenir des jetons d’accès de la Management API](/docs/fr-ca/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 de ce qui suit : * Compte AWS * Votre compte AWS doit avoir les autorisations requises pour utiliser EventBridge. Si vous n’avez pas de compte, inscrivez-vous à l’adresse [https://aws.amazon.com/eventbridge/](https://aws.amazon.com/eventbridge/). * Autorisations AWS IAM * Bus d’événements AWS EventBridge * ID de 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 tenant 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](/docs/fr-ca/events) que vous souhaitez surveiller. Ensuite, vous utiliserez l’ID et la région de votre compte AWS pour configurer votre flux d’événements, comme illustré ci-dessous. Cet exemple utilise l’Auth0 CLI 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 tenant. ```bash wrap lines theme={null} auth0 events create --name ng-demo-eventbridge --type eventbridge --subscriptions "user.created" --configuration '{"aws_account_id":"","aws_region":""}' ``` Si la requête réussit, elle 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 event stream dans le 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 stream, sélectionnez **AWS EventBridge**. Le formulaire de configuration de votre nouveau stream EventBridge s’ouvrira. 4. **Configure Stream Details:** Dans le formulaire de configuration, vous devrez fournir les renseignements suivants : * **Stream Name:** Entrez un nom descriptif pour votre event stream. Cela vous aidera à l’identifier dans le Auth0 Dashboard. * **AWS Account ID:** Entrez l’ID du compte AWS à 12 chiffres auquel vous voulez envoyer les événements Auth0. * **AWS Region:** Sélectionnez la région AWS précise où se trouve votre bus d’événements EventBridge. 5. **Select Event Types:** Dans la section **Select Event Types**, choisissez les types d’événements Auth0 précis que vous souhaitez inclure dans ce stream. Vous pouvez sélectionner plusieurs types d’événements selon vos besoins (p. ex., `user.created`, `user.updated`, `user.deleted`). 6. **Save Changes:** Une fois le nom du stream, les détails AWS et les types d’événements voulus configurés, cliquez sur le bouton **Save Changes**. Votre nouvel event stream 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 son état et gérer votre event stream à partir de la page Event Streams (Early) dans le Auth0 Dashboard. Avant de commencer à utiliser Terraform, vous devez : * Installer la CLI Terraform * Installer l’Auth0 CLI et vous authentifier avec `auth0 login` * Avoir votre ID de compte AWS et votre région AWS pour configurer un flux d’événements EventBridge ### Configuration des fichiers Pour provisionner votre flux d’événements à l’aide de Terraform, vous avez besoin d’un répertoire de projet structuré. 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 des variables Dans votre fichier `variables.tf`, déclarez les variables d’entrée nécessaires à la configuration de votre flux : ```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 informations d’identification que vous avez copiées plus haut dans Access Management API (facultatif). ```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 est déclenché chaque fois qu’un nouvel utilisateur est créé dans votre tenant. 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 elle 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 êtes prêt à 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 : ```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 pour 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 pour les webhooks
Assurez-vous d’avoir installé les outils suivants pour créer correctement votre gestionnaire de webhook : * `node.js` * `jq` * `npm` * `ngrok`
### Écrire le gestionnaire de webhook
1. Installez `express` dans votre dossier `node_modules` et parmi les 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 précise pour traiter l’événement de création d’utilisateur // Dans cet exemple, nous nous assurons que les utilisateurs sont aussi 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 token d’API à l’aide de : ```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 tenant Auth0 et de les envoyer vers un système externe pour les traiter. Avant de configurer un flux d’événements, vous devez identifier les [types d’événements](/docs/fr-ca/events) 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 l’Auth0 CLI 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 inscrit dans votre tenant. Les données de l’événement sont ensuite transmises à un point de terminaison webhook pour un 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 la requête 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. **Configure Stream Details:** Dans le formulaire de configuration, vous devrez fournir les renseignements suivants : * **Stream Name:** Entrez un nom descriptif pour votre flux d’événements. Cela vous aidera à l’identifier dans **Auth0 Dashboard**. * **Endpoint:** Entrez l’URL complète du endpoint HTTP où vous voulez qu’Auth0 envoie les événements. Il s’agit du service qui recevra et traitera les données d’événement. * **Authentication Method:** Choisissez la méthode d’authentification requise par votre endpoint. * **Authorization Token:** Si vous avez sélectionné **Bearer Token** comme méthode d’authentification, entrez ici le jeton d’autorisation requis. 5. **Select Event Types:** Dans la section **Select Event Types**, choisissez les event types Auth0 précis que vous voulez inclure dans ce flux. Vous pouvez sélectionner plusieurs event types selon vos besoins (p. ex., `user.created`, `user.updated`, `user.deleted`). 6. **Save Changes:** Une fois le nom du flux, les détails AWS et les event types 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 event types sélectionnés vers le **Webhook** indiqué. Vous pouvez surveiller le status et gérer votre flux d’événements à partir de la page **Event Streams (Early)** dans **Auth0 Dashboard**. ### Configuration des fichiers Pour configurer votre flux d’événements avec Terraform, vous aurez besoin d’un répertoire de projet structuré. Vous trouverez 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 des 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écuritaire 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 la requête 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 event stream Cet exemple utilise la ressource `auth0_event_stream` pour créer un event stream qui s’abonne à l’événement `user.created`, lequel se déclenche chaque fois qu’un nouvel utilisateur est inscrit dans votre tenant. Utilisez l’exemple ci-dessous dans votre fichier `main.tf` : Si la requête réussit, elle renvoie le JSON suivant avec l’`id` de votre event stream. Les nouveaux event streams 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 } } } ``` Une fois les trois fichiers ci-dessus créés et enregistrés, vous pouvez créer votre stream. 1. Initialisez le provider ```bash theme={null} terraform init ``` 2. Lancez 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 d’événements, observabilité et reprise après échec**](/docs/fr-ca/customize/events/event-testing-observability-and-failure-recovery).
## Auth0 Actions
Les renseignements ci-dessous expliquent 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 capter les changements en temps réel dans votre tenant Auth0 et de les acheminer vers un système externe pour traitement. Avant de configurer un flux d’événements, vous devez identifier les [types d’événements](/docs/fr-ca/events) que vous souhaitez surveiller. Cet exemple utilise l’Auth0 CLI pour créer un flux d’événements abonné à l’événement `user.created`, qui se déclenche chaque fois que votre tenant 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 la requête réussit, elle 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 l’Auth0 Dashboard à l’aide d’Auth0 Actions : 1. Accédez à **Auth0 Dashboard** > **Flux d’événements (accès anticipé)**. 2. Sélectionnez **+Créer un flux d’événements**. . 3. Dans la liste des types de flux, sélectionnez **+Auth0 Actions**. Cela 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 :** Saisissez un nom descriptif pour votre flux d’événements. Cela vous aidera à l’identifier dans l’Auth0 Dashboard. 5. **Sélectionner les types d’événements :** Dans la section **Sélectionner les types d’événements**, choisissez les types d’événements Auth0 précis que vous souhaitez inclure dans ce flux. Vous pouvez en sélectionner plusieurs selon vos besoins (p. ex. : `Created`, `Updated`, `Deleted`). 6. Dans l’**éditeur d’Action**, é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 gérer 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'); } // RÉUSSITE : // 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 d’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’Auth0 Action spécifiée. Vous pouvez surveiller l’état de votre flux d’événements et le gérer à partir de la page Flux d’événements (accès anticipé) dans l’Auth0 Dashboard.
## En savoir plus
* [Catalogue d’événements](/docs/fr-ca/events) * [Tests d’événements, observabilité et reprise après échec](/docs/fr-ca/customize/events/event-testing-observability-and-failure-recovery) * [Meilleures pratiques pour Events](/docs/fr-ca/customize/events/events-best-practices)