Créer un flux d’événements

Découvrez comment créer des flux d’événements à l’aide d’AWS EventBridge ou de webhooks.

Vous pouvez créer des flux d’événements qui surveillent différents types d’événements, 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. 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.

1. Accédez à Dashboard > Applications > 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 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/.

• Autorisations AWS IAM

• Bus d’événements AWS EventBridge

• ID de compte AWS et région

​

Créer un flux d’événements (EventBridge)

Management API

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 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.

auth0 events create --name ng-demo-eventbridge --type eventbridge --subscriptions "user.created" --configuration '{"aws_account_id":"<your-aws-account-id>","aws_region":"<your-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.

{
  "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": "<your-aws-account-id>",
      "aws_region": "<your-aws-region>",
      "aws_partner_event_source": "default"
    }
  }
}

Dashboard

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.

Terraform

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 :

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 :

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 :

aws_account_id = "<your-aws-account-id>" # p. ex., "123456789012"
aws_region     = "<your-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).

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 :

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

terraform init

2. Vérifiez vos modifications :

terraform plan

3. Créez le flux :

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). 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.

   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 :

   API_TOKEN=`openssl rand -hex 32`
   echo "API_TOKEN=$API_TOKEN" > .env
   

5. Démarrez votre serveur :

   node webhook.js
   

6. Pour tester le webhook, exposez votre gestionnaire de webhook à l’aide d’un outil comme ngrok :

   ngrok http 3000
   

   Cela fournit une URL publique pour votre gestionnaire de webhook local, par exemple :

   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 que vous souhaitez surveiller. Vous utiliserez ensuite votre gestionnaire de webhook pour créer un flux d’événements, comme illustré ci-dessous.

Management API

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.

source .env # Assurez-vous d'être dans le répertoire webhook où vous avez créé votre fichier .env
WEBHOOK_URL="<ngrok 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.

{
  "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 :

auth0 events show <EVENT_STREAM_ID>

Dashboard

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.

Terraform

​

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 :

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 :

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_ :

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.

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.

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

terraform init

2. Lancez le plan :

URL="<your-ngrok-url>/webhook"
terraform plan -var="webhook_endpoint_url=${URL}"

3. Créez le flux d’événements :

terraform apply -var="webhook_endpoint_url=https://<your-ngrok-url>/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.

​

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)

Management API

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 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.

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.

{
    "configuration": {
      "action_id": "act_xyz789...",
      "status": "enabled"
  }
}

Dashboard

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.

/**
 * 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
• Tests d’événements, observabilité et reprise après échec
• Meilleures pratiques pour Events