> ## 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. > Aprenda cómo crear flujos de eventos con AWS EventBridge o webhooks. # Crear un flujo de eventos 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](https://auth0.com/docs/api/management/v2). 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](/es/docs/secure/tokens/access-tokens/management-api-access-tokens). 1. Vaya a [Dashboard > Applications > Applications](https://manage.auth0.com/#/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](/es/docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production) 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/](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)
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](/es/docs/customize/events/event-types) 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. ```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 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. ```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" } } } ``` 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. 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: ```bash theme={null} 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: ```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 } ``` ### Establezca los valores de las variables En su archivo `terraform.tfvars`, proporcione los valores reales correspondientes a su entorno específico: ```bash theme={null} aws_account_id = "" # p. ej., "123456789012" 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. ```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" ``` ## 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`: ```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" # 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 ```bash theme={null} terraform init ``` 2. Revise los cambios: ```bash theme={null} terraform plan ``` 3. Cree el flujo de eventos: ```bash theme={null} 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)](#create-an-event-stream-webhooks-). 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. ```javascript lines expandable theme={null} 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: ```bash lines theme={null} API_TOKEN=`openssl rand -hex 32` echo "API_TOKEN=$API_TOKEN" > .env ``` 5. Inicia el servidor: ```bash lines theme={null} node webhook.js ``` 6. Para probar el webhook, expón tu controlador de webhook con una herramienta como ngrok: ```bash lines theme={null} ngrok http 3000 ``` Esto proporciona una URL pública para tu controlador de webhook local, por ejemplo: ```bash lines theme={null} 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](/es/docs/customize/events/event-types) que desea supervisar. Luego, usará su controlador de webhook para crear un flujo de eventos, como se muestra a continuación. 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. ```bash lines theme={null} source .env # Asegúrate de estar en el directorio del webhook donde creaste tu archivo .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 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. ```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" } } } } ``` #### Verifique el flujo de eventos Después de crear un flujo de eventos, puede comprobar que existe con el siguiente comando: ```bash lines theme={null} auth0 events show ``` 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. ### 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: ```bash theme={null} 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: ```bash theme={null} 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_`: ```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 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. ```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" ``` ## 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. ```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 } } } ``` Después de crear y guardar los tres archivos anteriores, ya puedes crear el flujo. 1. Inicializa el proveedor ```bash theme={null} terraform init ``` 2. Ejecuta el plan: ```bash theme={null} URL="/webhook" terraform plan -var="webhook_endpoint_url=${URL}" ``` 3. Cree el flujo: ```bash theme={null} terraform apply -var="webhook_endpoint_url=https:///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**](/es/docs/customize/events/event-testing-observability-and-failure-recovery).
## 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)
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](/es/docs/customize/events/event-types) 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. ```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 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. ```json lines theme={null} { "configuration": { "action_id": "act_xyz789...", "status": "enabled" } } ``` 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. ```javascript theme={null} /** * 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](/es/docs/customize/events/event-types) * [Pruebas de eventos, observabilidad y recuperación ante fallos](/es/docs/customize/events/event-testing-observability-and-failure-recovery) * [Prácticas recomendadas para eventos](/es/docs/customize/events/events-best-practices)