Arquiteturas orientadas a eventos
Crie sistemas orientados a eventos usando Workers e Deno, reagindo a dados em tempo real e ações dos usuários.
Arquiteturas orientadas a eventos é uma aula grátis de Edge Computing with Cloudflare Workers & Deno no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Edge Computing with Cloudflare Workers & Deno, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Edge Computing with Cloudflare Workers & Deno inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em 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!
Perguntas Frequentes
A aula “Arquiteturas orientadas a eventos” é grátis?
Sim — o texto completo de “Arquiteturas orientadas a eventos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Edge Computing with Cloudflare Workers & Deno, atualize para CoddyKit PRO. O curso de Edge Computing with Cloudflare Workers & Deno inclui 4 aulas no total.
O que vou aprender em “Arquiteturas orientadas a eventos”?
Crie sistemas orientados a eventos usando Workers e Deno, reagindo a dados em tempo real e ações dos usuários. Você pratica Edge Computing with Cloudflare Workers & Deno com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Edge Computing with Cloudflare Workers & Deno?
Nenhuma experiência prévia é necessária. Edge Computing with Cloudflare Workers & Deno no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Arquiteturas orientadas a eventos”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Edge Computing with Cloudflare Workers & Deno?
Sim. Cada aula de Edge Computing with Cloudflare Workers & Deno inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Microsserviços na borda
- Arquiteturas orientadas a eventos
- Geolocalização e localização
- Objetos Duráveis e coordenação com estado