Arquitecturas orientadas a eventos
Construya sistemas orientados a eventos con Workers y Deno que reaccionen a datos en tiempo real y acciones de los usuarios.
Arquitecturas orientadas a eventos es una lección gratuita de Edge Computing with Cloudflare Workers & Deno en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Edge Computing with Cloudflare Workers & Deno, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Edge Computing with Cloudflare Workers & Deno incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
What is Event-Driven Architecture?
Welcome! Today we'll explore Event-Driven Architecture (EDA). It's a design pattern where services communicate by producing and consuming events, rather than direct calls.
Think of it like a news channel: producers (reporters) publish news (events), and consumers (viewers) react to the news they're interested in.
- Event: A significant change in state, like 'user registered'.
- Producer: The system that generates and sends an event.
- Consumer: The system that listens for and reacts to an event.
Why Event-Driven at the Edge?
EDA shines brightly at the edge, offering significant benefits for performance and scalability:
- Decoupling: Services operate independently, reducing dependencies.
- Scalability: Individual components can scale up or down based on event load.
- Real-time Responsiveness: React to user actions or data changes instantly.
- Resilience: If one consumer fails, others can still process events.
This makes your edge applications more robust and flexible.
Cloudflare Workers as Event Reactors
Cloudflare Workers are perfect for event-driven systems because they are inherently reactive. They spring into action when triggered by an event!
Common events that trigger Workers include:
- Incoming HTTP requests (e.g., an API call)
- Messages from a queue (e.g., Cloudflare Queues)
- Scheduled cron jobs
- Other Cloudflare service bindings
They act as lightweight, distributed consumers.
Code: Worker Reacting to HTTP Event
Here's a basic Worker that processes an incoming HTTP request as an 'event'. It reads a custom header to identify the event type and logs it.
Try changing the X-Event-Type header when you test it!
export default {
async fetch(request, env, ctx) {
const eventType = request.headers.get('X-Event-Type') || 'unknown_event';
const eventData = await request.json().catch(() => ({}));
console.log(`Worker received event: ${eventType}`);
console.log(`Event data: ${JSON.stringify(eventData)}`);
// In a real app, you'd process eventData here
return new Response(`Event '${eventType}' processed!`, { status: 200 });
},
};Deno as an Event Originator
Just as Workers consume events, Deno applications can act as event producers. A Deno backend service or a CLI tool might generate events.
For instance, a Deno script could:
- Detect a file change and send an event.
- Process data and publish a 'data_processed' event.
- Handle a user action and send a 'user_activity' event to your edge Worker.
Code: Deno Sends Event to Worker
This Deno script acts as a producer, sending a 'user_registered' event to our Cloudflare Worker via an HTTP POST request. The Worker then acts as the consumer.
Remember to replace 'YOUR_WORKER_URL' with your deployed Worker's URL!
// main.ts
async function sendUserRegisteredEvent() {
const workerUrl = "https://your-worker-name.your-account.workers.dev"; // Replace this!
const response = await fetch(workerUrl, {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-Event-Type": "user_registered"
},
body: JSON.stringify({ userId: "user_abc", timestamp: Date.now() })
});
if (response.ok) {
console.log("User registered event sent successfully!");
} else {
console.error("Failed to send event:", response.status, await response.text());
}
}
sendUserRegisteredEvent();Cloudflare Queues for Robust Events
For truly robust event-driven systems, especially at the edge, Cloudflare Queues are invaluable. They act as an event bus, providing a reliable buffer between producers and consumers.
- Asynchronous: Producers don't wait for consumers to finish.
- Guaranteed Delivery: Messages are durably stored until processed.
- Load Leveling: Handles bursts of events without overwhelming consumers.
- Decoupling: Producers and consumers don't need to know about each other directly.
Code: Worker Publishes to a Queue
Here, a Worker receives an HTTP request (an event) and then publishes a message to a Cloudflare Queue. This offloads heavy processing to a separate consumer.
To make this runnable, you'd need to bind a Queue in your wrangler.toml file (e.g., [[queues.producers]] binding = "MY_QUEUE" queue_name = "my-event-queue").
export default {
async fetch(request, env, ctx) {
const eventData = await request.json().catch(() => ({}));
const eventType = eventData.type || 'api_trigger_event';
// Publish event to a Cloudflare Queue
// 'env.MY_QUEUE' refers to the queue binding configured
await env.MY_QUEUE.send({
eventType: eventType,
payload: eventData
});
return new Response(`Event '${eventType}' queued successfully!`, { status: 202 });
},
};Code: Worker Consuming Queue Messages
This Worker is configured to consume messages directly from a Cloudflare Queue. It processes each message in a batch, extracting the event type and payload.
This Worker would have a queue handler instead of (or in addition to) a fetch handler. You'd configure this in your wrangler.toml (e.g., [[queues.consumers]] queue = "my-event-queue").
export default {
async queue(batch, env, ctx) {
for (const message of batch.messages) {
const { eventType, payload } = message.body;
console.log(`Processing event from queue: ${eventType}`);
console.log(`Payload: ${JSON.stringify(payload)}`);
// Implement your actual event processing logic here
// e.g., update a database, send a notification, call another API
}
},
};Quick Check: Event-Driven Concepts
Which of the following are key benefits of using an Event-Driven Architecture at the edge?
Recap: Event-Driven Edge Apps
Great job! You've learned about Event-Driven Architectures and how they supercharge applications at the edge.
- EDA uses events, producers, and consumers for decoupled communication.
- Cloudflare Workers are ideal for consuming and producing edge events.
- Deno applications can act as powerful event producers.
- Cloudflare Queues provide robust, asynchronous event delivery for resilience and scale.
This pattern is key for building highly responsive, scalable, and fault-tolerant edge applications. Keep exploring how events can transform your architecture!
Preguntas frecuentes
¿La lección «Arquitecturas orientadas a eventos» es gratis?
Sí — el texto completo de «Arquitecturas orientadas a eventos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Edge Computing with Cloudflare Workers & Deno, actualiza a CoddyKit PRO. El curso de Edge Computing with Cloudflare Workers & Deno incluye 4 lecciones en total.
¿Qué aprenderé en «Arquitecturas orientadas a eventos»?
Construya sistemas orientados a eventos con Workers y Deno que reaccionen a datos en tiempo real y acciones de los usuarios. Practicas Edge Computing with Cloudflare Workers & Deno con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Edge Computing with Cloudflare Workers & Deno?
No se requiere experiencia previa. Edge Computing with Cloudflare Workers & Deno en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Arquitecturas orientadas a eventos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Edge Computing with Cloudflare Workers & Deno?
Sí. Cada lección de Edge Computing with Cloudflare Workers & Deno incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Microservicios en el edge
- Arquitecturas orientadas a eventos
- Geolocalización y localización
- Durable Objects y coordinación con estado