Explicación de Durable Objects
Comprenda Durable Objects para aplicaciones serverless con estado, manteniendo un estado coherente de forma global.
Explicación de Durable Objects 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.
The State Problem at the Edge
Serverless functions, like Cloudflare Workers, are typically stateless. This means each request is processed independently, without remembering past interactions.
While great for scalability and cost-efficiency, what if you need to maintain a consistent piece of information across multiple requests or users globally? Think about a live chat room, a game lobby, or a shared counter.
Introducing Durable Objects
Cloudflare Durable Objects solve this fundamental challenge. They are a powerful primitive for building stateful serverless applications directly at the edge.
- They provide a single-instance, globally consistent object.
- Each Durable Object instance has a unique ID and its own private storage.
- They act like tiny, persistent servers that live at the edge.
Unique IDs & Global Consistency
The core concept behind Durable Objects is their unique identity. When you create or retrieve a Durable Object using a specific ID, Cloudflare ensures that only one instance of that object exists and runs globally.
No matter where a request originates from (e.g., Tokyo, New York, London), if it targets the same Durable Object ID, it will be routed to that single, consistent instance. This eliminates the need for complex distributed synchronization.
Anatomy of a Durable Object
A Durable Object is defined as a standard JavaScript class. It must have:
- A
constructor(state, env)method, wherestateprovides access to its storage andenvholds environment variables. - An
async fetch(request)method, which processes incoming HTTP requests, similar to a regular Worker.
It's essentially a self-contained, stateful mini-Worker.
Persistent Storage with state.storage
Each Durable Object instance has its own private, durable key-value storage, accessible via this.state.storage. This allows the object to persist data across invocations and even across restarts.
await this.state.storage.put('key', value): Stores data.await this.state.storage.get('key'): Retrieves data.await this.state.storage.delete('key'): Removes data.
Values can be any JSON-serializable type, making it versatile for various data needs.
Code: Counter Worker & DO
This example shows a Cloudflare Worker interacting with a simple Counter Durable Object. The DO maintains a count that persists across requests and is globally consistent.
To run this, you'd define the Counter Durable Object binding in your wrangler.toml file.
export class Counter {
constructor(state, env) {
this.state = state;
this.env = env;
}
async fetch(request) {
let url = new URL(request.url);
// Retrieve current count from storage, default to 0
let currentCount = (await this.state.storage.get("value")) || 0;
if (url.pathname === "/increment") {
currentCount++;
await this.state.storage.put("value", currentCount);
return new Response(`Count: ${currentCount}`);
} else if (url.pathname === "/decrement") {
currentCount--;
await this.state.storage.put("value", currentCount);
return new Response(`Count: ${currentCount}`);
} else if (url.pathname === "/get") {
return new Response(`Count: ${currentCount}`);
}
return new Response("Not found", { status: 404 });
}
}
export default {
async fetch(request, env) {
// Get a unique Durable Object ID based on a name
// 'COUNTER' is the binding name configured in wrangler.toml
let id = env.COUNTER.idFromName("global-counter");
// Get a 'stub' (a proxy) to interact with the Durable Object
let stub = env.COUNTER.get(id);
// Forward the incoming request to the Durable Object's fetch method
return stub.fetch(request);
}
};How the Counter Code Works
1. The Counter class defines the Durable Object's behavior, handling /increment, /decrement, and /get routes and persisting its value.
2. The main Worker's fetch handler:
- It uses
env.COUNTER.idFromName("global-counter")to obtain a deterministic ID for our counter. env.COUNTER.get(id)returns a stub, which is a network proxy to the Durable Object.stub.fetch(request)forwards the original request to the Durable Object instance, allowing it to process the request and update its state.
Global Consistency in Action
Imagine users from different locations (e.g., Europe, Asia, Americas) all interacting with the /increment endpoint of your Worker. Because they all target the "global-counter" ID, Cloudflare guarantees they will all interact with the exact same instance of the Counter Durable Object.
This ensures that the count is always consistent, regardless of the user's location, simplifying complex distributed state management that would otherwise be very challenging.
Common Use Cases for DOs
Durable Objects are ideal for scenarios requiring strong consistency and shared, mutable state at the edge:
- Real-time Collaboration: Shared whiteboards, document editing.
- Gaming: Game lobbies, player state, matchmaking.
- Live Chat: Chat rooms, message queues for real-time communication.
- Stateful APIs: Managing user sessions, shopping carts, or unique resource locks.
They bring traditional stateful patterns to the serverless edge, making complex applications simpler to build.
Quick Check: Durable Objects
Which of the following best describes the primary benefit of Cloudflare Durable Objects?
Recap: Durable Objects Explained
In this lesson, we explored Cloudflare Durable Objects, a powerful tool for stateful serverless applications.
- They provide globally consistent, single-instance state at the edge.
- Each DO has a unique ID and private, durable storage (
state.storage). - Workers interact with DOs by obtaining stubs and forwarding requests.
- They are ideal for real-time, collaborative, and stateful applications that demand strong consistency.
Durable Objects bridge the gap between stateless serverless and traditional stateful services, simplifying complex distributed systems.
Preguntas frecuentes
¿La lección «Explicación de Durable Objects» es gratis?
Sí — el texto completo de «Explicación de Durable Objects» 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 «Explicación de Durable Objects»?
Comprenda Durable Objects para aplicaciones serverless con estado, manteniendo un estado coherente de forma global. 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 «Explicación de Durable Objects»?
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
- Almacén Cloudflare KV
- Explicación de Durable Objects
- Integración de Deno con almacenamiento en el edge
- Consultar con D1 SQL en el edge