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.

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

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

• Autorisations AWS IAM

• Bus d’événements AWS EventBridge

• ID du 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 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 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.

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>"}'

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.

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

Tableau de bord

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.

Terraform

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 :

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 :

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 identifiants copiés dans la section Access Management API (facultatif) ci-dessus.

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 :

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

terraform init

2. Vérifiez vos modifications :

terraform plan

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

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

   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 :

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

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

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

Tableau de bord

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.

Terraform

​

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 :

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 :

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

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.

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.

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

terraform init

2. Exécutez 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 des événements, observabilité et reprise après échec.

​

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)

Management API

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

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.

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

Dashboard

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.

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