Crear un flujo de eventos

Aprenda cómo crear flujos de eventos con AWS EventBridge o webhooks.

Al suscribirse a eventos y entregarlos a un destino de su elección mediante flujos de eventos, puede habilitar varios casos de uso relacionados, entre ellos:

• Enviar correos electrónicos a nuevos clientes para darles la bienvenida o pedirles que verifiquen su dirección de correo electrónico.
• Supervisar los cambios en el ciclo de vida del usuario para poder actualizar los sistemas de CRM (gestión de relaciones con clientes) o de facturación.

Puede crear un flujo de eventos con AWS EventBridge o webhooks. En las secciones siguientes se describe el proceso de configuración para ambas opciones.

​

Acceso a la Management API (opcional)

Los flujos de eventos se pueden aprovisionar mediante el Auth0 Dashboard o la Auth0 Management API. Si usa la Management API, antes de poder configurar un flujo de eventos, debe crear una aplicación de máquina a máquina (M2M) y autenticarse con un token de acceso de la Management API. Para obtener más información, consulte Tokens de acceso de la Management API.

1. Vaya a Dashboard > Applications > Applications y seleccione Create Application.

2. Introduzca un nombre descriptivo para su aplicación y elija Machine to Machine Applications. Luego, seleccione Create.

3. Seleccione la API a la que desea llamar desde su aplicación. En este caso, use Auth0 Management API.

4. Elija los permisos que quiere que se incluyan en el token de acceso de su aplicación y luego seleccione Authorize. Para fines de prueba, seleccione:

   • read:event_streams
   • create:event_streams
   • update:event_streams
   • delete:event_streams
   • read:event_deliveries
   • update:event_deliveries
   • create:users

5. Vaya a la pestaña Settings para obtener su Client ID, Client Secret y Domain.

6. Revise Obtener tokens de acceso para la Management API para recuperar y almacenar su token de acceso.

​

AWS EventBridge

La siguiente información describe cómo crear y habilitar un flujo de eventos con AWS EventBridge.

​

Requisitos previos de EventBridge

Para usar AWS EventBridge para los flujos de eventos, necesitará lo siguiente:

• Cuenta de AWS

  • Su cuenta de AWS debe tener permisos para usar EventBridge. Si no tiene una, regístrese en https://aws.amazon.com/eventbridge/.

• Permisos de AWS IAM

• Bus de eventos de AWS EventBridge

• ID y región de la cuenta de AWS

​

Crear un flujo de eventos (EventBridge)

Management API

Los flujos de eventos le permiten capturar cambios en tiempo real dentro de su inquilino de Auth0 y enviarlos a un sistema externo para su procesamiento.

Antes de configurar un flujo de eventos, debe identificar los tipos de eventos que desea supervisar. Luego, usará el ID y la región de su cuenta de AWS para configurar el flujo de eventos, como se muestra a continuación.

Este ejemplo usa la CLI de Auth0 para crear un flujo de eventos que se suscribe al evento user.created, el cual se activa cada vez que se registra un nuevo usuario en su inquilino.

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 llamada se realiza correctamente, devuelve el siguiente JSON con el id de tu flujo de eventos. Los flujos de eventos nuevos se habilitan de forma predeterminada.

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

Panel

Para crear un flujo de eventos en el Auth0 Dashboard mediante AWS EventBridge:

1. Vaya a Auth0 Dashboard > Event Streams (Early).

2. Seleccione +Create Event Stream.

3. En la lista de tipos de flujo, seleccione AWS EventBridge. Se abrirá el formulario de configuración de su nuevo flujo de EventBridge.

4. Configurar los detalles del flujo: En el formulario de configuración, deberá proporcionar la siguiente información:

   • Nombre del flujo:

     Introduzca un nombre descriptivo para su flujo de eventos. Esto le ayudará a identificarlo en el Auth0 Dashboard.

   • ID de la cuenta de AWS:

     Introduzca el ID de la cuenta de AWS de 12 dígitos a la que desea enviar los eventos de Auth0.

   • Región de AWS:

     Seleccione la región de AWS específica en la que se encuentra el bus de eventos de EventBridge.

5. Seleccionar tipos de eventos: En la sección Select Event Types, elija los tipos de eventos de Auth0 concretos que desea incluir en este flujo. Puede seleccionar varios tipos de eventos según sus necesidades (por ejemplo, user.created, user.updated, user.deleted).

6. Guardar cambios: Una vez que haya configurado el nombre del flujo, los detalles de AWS y los tipos de eventos que desea incluir, haga clic en el botón Save Changes.

Su nuevo flujo de eventos ya se ha creado, y Auth0 puede comenzar a publicar los tipos de eventos seleccionados en el bus de eventos de AWS EventBridge especificado. Puede supervisar su estado y administrar el flujo desde la página Event Streams (Early) en el Auth0 Dashboard.

Terraform

Antes de comenzar con Terraform, necesitas:

• Instalar la CLI de Terraform
• Instalar la CLI de Auth0 y autenticarte con auth0 login
• Tener el ID de tu cuenta de AWS y la región de AWS para configurar un flujo de eventos de EventBridge

​

Configuración del archivo

Para aprovisionar tu flujo de eventos con Terraform, necesitas un directorio de proyecto estructurado. A continuación, se muestra una configuración de ejemplo para hacerlo por primera vez:

auth0-event-streams/
├── main.tf             # Configuración principal: define los proveedores y el recurso 'auth0_event_stream'.
├── variables.tf        # Declaración de variables: define las entradas como 'aws_account_id' y 'aws_region'.
└── terraform.tfvars    # Valores de variables: contiene los valores de configuración reales (p. ej., "123456789012").

​

Definir variables

En el archivo variables.tf, declare las variables de entrada necesarias para la configuración del flujo:

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
}

​

Establezca los valores de las variables

En su archivo terraform.tfvars, proporcione los valores reales correspondientes a su entorno específico:

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

​

Configurar variables de entorno

En la terminal, configure las tres variables de entorno necesarias con las credenciales que copió en Access Management API (opcional) arriba.

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

​

Crear un flujo de eventos

Este ejemplo usa el recurso auth0_event_stream para crear un flujo de eventos que se suscribe al evento user.created, que se activa cada vez que se registra un nuevo usuario en tu inquilino. Usa el siguiente ejemplo en tu archivo 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" # Requerido
  subscriptions    = ["user.created"]

  eventbridge_configuration {
    aws_account_id = var.aws_account_id
    aws_region     = var.aws_region
  }
}

Si la llamada se realiza correctamente, devuelve el siguiente JSON con el id de su flujo de eventos. Los nuevos flujos de eventos se habilitan de forma predeterminada.

Después de crear y guardar los tres archivos anteriores, ya puede crear su flujo.

1. Inicialice el proveedor

terraform init

2. Revise los cambios:

terraform plan

3. Cree el flujo de eventos:

terraform apply

​

Webhooks

Como alternativa a AWS EventBridge, puede usar webhooks para implementar flujos de eventos.

Para comenzar, primero configure un controlador de webhook para recibir notificaciones en tiempo real cuando se produzca un evento específico. Luego, podrá crear su flujo de eventos.

Puede crear un controlador de webhook básico siguiendo las instrucciones que aparecen a continuación, o usar un servicio existente, como:

• Vercel
• Inngest

Si decide usar un servicio existente, puede continuar con Crear un flujo de eventos (webhook). De lo contrario, siga las instrucciones que aparecen a continuación para crear su propio controlador de webhook básico.

​

Requisitos previos del webhook

Asegúrate de tener instalados los siguientes elementos para escribir correctamente el controlador del webhook:

• node.js
• jq
• npm
• ngrok

​

Escribe el controlador de webhook

1. Instala express en la carpeta node_modules y agrégalo a las dependencias de tu package.json.

2. Instala dotenv en el directorio raíz para usar un archivo .env con el que almacenar variables de entorno.

3. Crea un archivo webhook.js para recibir el evento user.created y almacenarlo en una base de datos.

   const express = require('express');
   const app = express();
   
   // Middleware de autorización
   app.use((req, res, next) => {
     const token = req.headers["authorization"];
     if (token !== `Bearer ${API_TOKEN}`) {
       return res.status(401).json({ error: "Unauthorized" });
     }
     next();
   });
   
   // Endpoint del 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" });
     }
   });
   
   // Función específica para manejar el evento de creación de usuario
   // En este ejemplo, nos aseguramos de que los usuarios también se creen en nuestra propia base de datos
   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. En la raíz de tu proyecto, crea un archivo .env y agrega tu token de API con lo siguiente:

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

5. Inicia el servidor:

   node webhook.js
   

6. Para probar el webhook, expón tu controlador de webhook con una herramienta como ngrok:

   ngrok http 3000
   

   Esto proporciona una URL pública para tu controlador de webhook local, por ejemplo:

   http://localhost:3000
   

​

Crear un flujo de eventos (webhooks)

Los flujos de eventos le permiten capturar cambios en tiempo real en su inquilino de Auth0 y enviarlos a un sistema externo para su procesamiento.

Antes de configurar un flujo de eventos, debe identificar los tipos de eventos que desea supervisar. Luego, usará su controlador de webhook para crear un flujo de eventos, como se muestra a continuación.

Management API

Este ejemplo utiliza la CLI de Auth0 para crear un flujo de eventos que se suscribe al evento user.created, que se produce cada vez que se registra un nuevo usuario en tu inquilino. Después, los datos del evento se reenvían a un endpoint de webhook para su procesamiento posterior.

source .env # Asegúrate de estar en el directorio del webhook donde creaste tu archivo .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 operación se realiza correctamente, se devuelve el siguiente JSON con el id de tu flujo de eventos. Los flujos de eventos nuevos se habilitan de forma predeterminada.

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

​

Verifique el flujo de eventos

Después de crear un flujo de eventos, puede comprobar que existe con el siguiente comando:

auth0 events show <EVENT_STREAM_ID>

Panel

Para crear un flujo de eventos en el Auth0 Dashboard con AWS EventBridge:

1. Vaya a Auth0 Dashboard > Event Streams (Early).

2. Seleccione +Create Event Stream.

3. En la lista de tipos de flujo, seleccione Webhook. Se abrirá el formulario de configuración de su nuevo flujo de webhook.

4. Configure los detalles del flujo: En el formulario de configuración, deberá proporcionar la siguiente información:

   • Nombre del flujo:

     Introduzca un nombre descriptivo para su flujo de eventos. Esto le ayudará a identificarlo en el Auth0 Dashboard.

   • Endpoint: Introduzca la URL completa del endpoint HTTP al que desea que Auth0 envíe los eventos. Este es el servicio que recibirá y procesará los datos de eventos.

   • Método de autenticación: Elija el método de autenticación que requiere su endpoint.

   • Token de autorización: Si seleccionó Bearer Token como método de autenticación, introduzca aquí el token de autorización requerido.

5. Seleccione los tipos de eventos: En la sección Select Event Types, elija los tipos de eventos específicos de Auth0 que desea incluir en este flujo. Puede seleccionar varios tipos de eventos según sus necesidades (por ejemplo, user.created, user.updated, user.deleted).

6. Guardar cambios: Una vez que haya configurado el nombre del flujo, los detalles de AWS y haya seleccionado los tipos de eventos deseados, haga clic en el botón Save Changes.

Su nuevo flujo de eventos ya se ha creado, y Auth0 puede empezar a publicar los tipos de eventos seleccionados en el webhook especificado. Puede supervisar el estado y administrar su flujo de eventos desde la página Event Streams (Early) en el Auth0 Dashboard.

Terraform

​

Configuración de archivos

Para aprovisionar tu flujo de eventos con Terraform, necesitarás un directorio de proyecto bien estructurado. A continuación, se muestra un ejemplo de configuración para una implementación inicial:

auth0-event-streams/
├── main.tf             # Configuración principal: define los proveedores y el recurso 'auth0_event_stream'.
├── variables.tf        # Declaración de variables: define entradas como 'aws_account_id' y 'aws_region'.
└── terraform.tfvars    # Valores de variables: contiene los valores de configuración reales (p. ej., "123456789012").

​

Definir variables

En el archivo variables.tf, declare las variables de entrada necesarias para la configuración de su flujo:

variable "api_token" {
  description = "El token secreto utilizado para la autorización Bearer de Webhook."
  type        = string
  sensitive   = true 
}

variable "webhook_endpoint_url" {
  description = "La URL HTTPS pública del manejador de webhook (p. ej., tu URL de ngrok)."
  type        = string
}

​

Configuración del entorno

Con el token de API generado anteriormente, establece de forma segura la variable de entorno en tu terminal usando el prefijo 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 operación se realiza correctamente, se devuelve el siguiente JSON con el id de tu flujo de eventos. Los nuevos flujos de eventos están habilitados de forma predeterminada.

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"

​

Crear un flujo de eventos

Este ejemplo usa el recurso auth0_event_stream para crear un flujo de eventos que se suscribe al evento user.created, que se desencadena cada vez que se registra un nuevo usuario en tu inquilino. Usa el siguiente ejemplo en tu archivo main.tf:

Si la llamada se realiza correctamente, devuelve el siguiente JSON con el id de tu flujo de eventos. Los nuevos flujos de eventos se habilitan de forma predeterminada.

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

Después de crear y guardar los tres archivos anteriores, ya puedes crear el flujo.

1. Inicializa el proveedor

terraform init

2. Ejecuta el plan:

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

3. Cree el flujo:

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

Una vez que el flujo esté activo, puede probar el flujo de eventos. Para obtener más información, consulte Pruebas de eventos, observabilidad y recuperación ante fallos.

​

Auth0 Actions

A continuación, se describe cómo puede crear y habilitar un flujo de eventos con Auth0 Actions.

​

Crear un flujo de eventos (Actions)

Management API

Los flujos de eventos le permiten capturar cambios en tiempo real dentro de su inquilino de Auth0 y enviarlos a un sistema externo para procesarlos.

Antes de configurar un flujo de eventos, debe identificar los tipos de eventos que desea supervisar. En este ejemplo, se usa Auth0 CLI para crear un flujo de eventos que se suscribe al evento user.created, que se activa cada vez que su inquilino registra un nuevo usuario.

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 operación se realiza correctamente, esta llamada devuelve el siguiente JSON con el id de su flujo de eventos. Los nuevos flujos de eventos están habilitados de forma predeterminada.

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

Dashboard

Para crear un flujo de eventos en el Auth0 Dashboard con Auth0 Actions:

1. Vaya a Auth0 Dashboard > Event Streams (Early).

2. Seleccione +Create Event Stream.

3. En la lista de tipos de flujo, seleccione +Auth0 Actions. Esto abre el formulario de configuración de su nuevo flujo de Auth0 Actions.

4. Configurar los detalles del flujo: En el formulario de configuración, debe proporcionar la siguiente información:

   • Nombre del flujo:

     Introduzca un nombre descriptivo para su flujo de eventos. Esto le ayudará a identificarlo dentro del Auth0 Dashboard.

5. Seleccionar tipos de eventos: En la sección Select Event Types, elija los tipos de eventos de Auth0 específicos que desea incluir en este flujo. Puede seleccionar varios tipos de eventos según sus necesidades (por ejemplo, Created, Updated, Deleted).

6. En el Action Editor, escriba el código de su controlador. El sistema requiere la función onExecuteEventStream. Puede usar el objeto api para gestionar los estados de éxito o error.

/**
 * Controlador que se llamará durante la ejecución de un flujo de eventos.
 * @param {Event} event - Detalles sobre el Cloud Event.
 * @param {EventStreamAPI} api - Interfaz cuyos métodos pueden usarse para gestionar el evento.
 */
exports.onExecuteEventStream = async (event, api) => {
  const eventType = event.message.type;
  const eventData = event.message.data;

  console.log(`Received event: ${eventType}`);

  // Lógica personalizada: p. ej., enviar datos a una API externa
  // await axios.post('https://my-crm.com/ingest', eventData);

  // GESTIÓN DE ERRORES:
  // Para activar un reintento, genere un error o use api.message.fail()
  if (!eventData) {
     // api.message.fail('No data received');
     throw new Error('No data received');
  }

  // ÉXITO:
  // Si la función finaliza sin errores, el evento se marca como entregado.
};

7. Guardar cambios: Una vez que haya configurado el nombre del flujo y el controlador de Action, el sistema crea automáticamente la Action, la vincula a un flujo y la habilita.

Su nuevo flujo de eventos ya está creado, y Auth0 puede comenzar a publicar los tipos de eventos seleccionados en la Auth0 Action especificada. Puede supervisar el estado y gestionar su flujo de eventos desde la página Event Streams (Early) en el Auth0 Dashboard.

​

Más información

• Tipos de eventos
• Pruebas de eventos, observabilidad y recuperación ante fallos
• Prácticas recomendadas para eventos