Architetture basate sugli eventi
Costruisca sistemi basati sugli eventi usando Workers e Deno, in risposta a dati in tempo reale e azioni degli utenti.
Architetture basate sugli eventi è una lezione Edge Computing with Cloudflare Workers & Deno gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Edge Computing with Cloudflare Workers & Deno, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Edge Computing with Cloudflare Workers & Deno include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
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!
Domande Frequenti
La lezione «Architetture basate sugli eventi» è gratuita?
Sì — il testo completo di «Architetture basate sugli eventi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Edge Computing with Cloudflare Workers & Deno, passa a CoddyKit PRO. Il corso Edge Computing with Cloudflare Workers & Deno include 4 lezioni in totale.
Cosa imparerò in «Architetture basate sugli eventi»?
Costruisca sistemi basati sugli eventi usando Workers e Deno, in risposta a dati in tempo reale e azioni degli utenti. Eserciti Edge Computing with Cloudflare Workers & Deno con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Edge Computing with Cloudflare Workers & Deno?
Non è richiesta alcuna esperienza precedente. Edge Computing with Cloudflare Workers & Deno su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Architetture basate sugli eventi»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Edge Computing with Cloudflare Workers & Deno?
Sì. Ogni lezione Edge Computing with Cloudflare Workers & Deno include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Microservizi sull'edge
- Architetture basate sugli eventi
- Geolocalizzazione e localizzazione
- Durable Objects e coordinamento con stato