Créer un flux d’événements

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

​

API de gestion des accès (facultatif)

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

​

Prérequis pour EventBridge

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

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

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

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

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
}

aws_account_id = "<your-aws-account-id>" # p. ex., "123456789012"
aws_region     = "<your-aws-region>"     # p. ex., "us-east-1"

export AUTH0_DOMAIN="your-tenant-name.auth0.com"
export AUTH0_CLIENT_ID="your_m2m_client_id"
export AUTH0_CLIENT_SECRET="your_m2m_client_secret"

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

terraform init

terraform plan

terraform apply

​

Webhooks

• Vercel
• Inngest

​

Prérequis pour les webhooks

• 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;
       }
     }
   }
   

   See all 74 lines
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)

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

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

auth0 events show <EVENT_STREAM_ID>

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

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
}

export AUTH0_DOMAIN="your-tenant-name.auth0.com"
export AUTH0_CLIENT_ID="your_m2m_client_id"
export AUTH0_CLIENT_SECRET="your_m2m_client_secret"

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"

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

terraform init

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

terraform apply -var="webhook_endpoint_url=https://<your-ngrok-url>/webhook"

​

Auth0 Actions

​

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

auth0 event-streams create \
  --name actions-1 \
  --type action \
  --subscriptions "user.created,user.updated,user.deleted" \
  --configuration '{"action_id":"385db79f-28a4-43d9-909d-6f5511dd6632"}'

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

/**
 * 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é.
};

​

En savoir plus

• Catalogue d’événements
• Tests d’événements, observabilité et reprise après échec
• Meilleures pratiques pour Events