thanks for the response! Any insight as to how they would've built this by chance? Maybe using in-me

thanks for the response! Any insight as to how they would've built this by chance? Maybe using in-memory state I'm guessing, similar to a rate limiting DO?

FFernando Barroso thanks for the response! Any insight as to how they would've built this by chanc...

lambrospetrou•3/6/25, 2:15 PM

What is the metric you are interested in to decide if you need to scale out?
I am working on a dynamic sharding abstraction so having some concrete needs is useful. Unofficially, for my

durable-utils

durable-utils

library.

Fernando BarrosoOP•3/6/25, 2:23 PM

I would use both, the size of my database (given the tiny 1 GB limit for now) and requests per second (given the traffic limit as well of 1,000 req per sec)

Iggy•3/6/25, 5:13 PM

why does it sometimes take ~500ms to get a stub even with frequent traffic to it?

Iggy•3/6/25, 5:19 PM

it looks like it's because of this: https://github.com/cloudflare/workers-sdk/issues/2700. are there any workarounds or do you just have to accept ~500ms cold starts?

GitHub

Issues · cloudflare/workers-sdk

Home to Wrangler, the CLI for Cloudflare Workers® - Issues · cloudflare/workers-sdk

Iggy•3/6/25, 5:22 PM

ah nvm - looks a bit extreme on my end with some db seeding code

mau•3/7/25, 9:44 PM

Cannot create binding for class 'MyYServer' because it is not currently configured to implement Durable Objects. Ensure a --new-class migration has been applied to it. [code: 10061]

Getting this error after adding a new class.

Mmau Cannot create binding for class 'MyYServer' because it is not currently configur...

Hard@Work•3/7/25, 9:47 PM

Do you have a migration in your

wrangler

wrangler

config that includes the new class?

mau•3/7/25, 10:21 PM

Yes, I had… after a lot of tinkering… finally added v2 and added that with v2 tag and it worked.

hunt•3/8/25, 8:58 AM

Cool little utility I wrote to make accessing DO's easier in case anyone's interested:

import { DurableObject as DurableObjectPrimitive } from "cloudflare:workers";

const iife = <T>(fn: () => T): T => fn();

export function DurableObject<TEnv>(accessor: keyof TEnv) {
  return class DurableObject extends DurableObjectPrimitive<TEnv> {
    /**
     * Retrieves a durable object stub for a given id.
     *
     * @template T - The type of the DurableObject.
     * @param {TEnv} env - The env object containing the durable object's namespace.
     * @param {DurableObjectId | string} [id] - The id of the DurableObject. If not provided, `newUniqueId()` will be used.
     * @returns {DurableObjectStub<T>} The DurableObjectStub for the given id.
     */
    static getStub<T extends DurableObjectPrimitive>(
      this: { new (...args: any[]): T },
      env: TEnv,
      id?: DurableObjectId | string
    ): DurableObjectStub<T> {
      const namespace = env[accessor] as DurableObjectNamespace<T>;
      const stubId = iife(() => {
        if (!id) return namespace.newUniqueId();
        if (typeof id === "string") {
          // Check if the provided id is a string representation of the
          // 256-bit Durable Object ID
          if (id.match(/^[0-9a-f]{64}$/)) return namespace.idFromString(id);
          else return namespace.idFromName(id);
        }
        return id;
      });
      const stub = namespace.get(stubId);
      return stub;
    }
  };
}

import { DurableObject as DurableObjectPrimitive } from "cloudflare:workers";

const iife = <T>(fn: () => T): T => fn();

export function DurableObject<TEnv>(accessor: keyof TEnv) {
  return class DurableObject extends DurableObjectPrimitive<TEnv> {
    /**
     * Retrieves a durable object stub for a given id.
     *
     * @template T - The type of the DurableObject.
     * @param {TEnv} env - The env object containing the durable object's namespace.
     * @param {DurableObjectId | string} [id] - The id of the DurableObject. If not provided, `newUniqueId()` will be used.
     * @returns {DurableObjectStub<T>} The DurableObjectStub for the given id.
     */
    static getStub<T extends DurableObjectPrimitive>(
      this: { new (...args: any[]): T },
      env: TEnv,
      id?: DurableObjectId | string
    ): DurableObjectStub<T> {
      const namespace = env[accessor] as DurableObjectNamespace<T>;
      const stubId = iife(() => {
        if (!id) return namespace.newUniqueId();
        if (typeof id === "string") {
          // Check if the provided id is a string representation of the
          // 256-bit Durable Object ID
          if (id.match(/^[0-9a-f]{64}$/)) return namespace.idFromString(id);
          else return namespace.idFromName(id);
        }
        return id;
      });
      const stub = namespace.get(stubId);
      return stub;
    }
  };
}

interface Env {
  FOO_OBJECT: DurableObjectNamespace<FooObject>;
  BAR_OBJECT: DurableObjectNamespace<BarObject>;
}

export class FooObject extends DurableObject<Env>("FOO_OBJECT") {
  getFoo() {
    return "foo!";
  }
}

export class BarObject extends DurableObject<Env>("BAR_OBJECT") {
  getBar() {
    return 41;
  }
}

// example usage:
const fooStub = FooObject.getStub(env, "123");
const barStub = BarObject.getStub(env, "123");

fooStub.getFoo(); // () -> Promise<string>
barStub.getBar(); // () -> Promise<number>

interface Env {
  FOO_OBJECT: DurableObjectNamespace<FooObject>;
  BAR_OBJECT: DurableObjectNamespace<BarObject>;
}

export class FooObject extends DurableObject<Env>("FOO_OBJECT") {
  getFoo() {
    return "foo!";
  }
}

export class BarObject extends DurableObject<Env>("BAR_OBJECT") {
  getBar() {
    return 41;
  }
}

// example usage:
const fooStub = FooObject.getStub(env, "123");
const barStub = BarObject.getStub(env, "123");

fooStub.getFoo(); // () -> Promise<string>
barStub.getBar(); // () -> Promise<number>

Ashley•3/8/25, 10:10 AM

Someone asked me the other day, and now I’m curious, what’s the max number of concurrent WebSocket connections that a DO can have? Assuming it’s using hibernation, and to keep it simple let’s say each message sent is just relayed to all connected clients so nothing complex or computationally-heavy.

Ashley•3/8/25, 10:13 AM

My guess was that it’s effectively unlimited, but it’s “gated” by the fact it’s single-threaded so it can only process so much (e.g. if you had 100,000 clients, and they are all sending messages, there’s likely no way the single thread can process and broadcast all these messages without falling behind)

1984 Ford Laser•3/8/25, 10:56 AM

https://developers.cloudflare.com/durable-objects/api/state/#:~:text=The%20WebSocket%20Hibernation%20API%20permits,practical%20number%20of%20simultaneous%20connections.

The maximum limit of WebSocket connections per DO is 32768

Edit: with Hibernation

Ashley•3/8/25, 12:08 PM

Oh nice, thank you!

AAshley Oh nice, thank you!

Milan•3/8/25, 5:26 PM

That's a hard limit, but of course it depends on how much memory your application is using

, if you run out of memory before you have 32ki connections you won't even reach that limit.

Milan•3/8/25, 5:26 PM

You probably don't want that many connections to a single DO anyways though, I would try to build a tree where your clients connect to leaf nodes, and the leaf nodes connect to a root

AAshley Someone asked me the other day, and now I’m curious, what’s the max number of co...

CodingCoop | Co-Founder Nullshot•3/9/25, 12:03 AM

Website says 1000 rps under limits somewhere and there is a DOG service that allows for scaling DO horizontally - with DOs having 128mb memory to play with it wouldn’t be able to handle tens of thousands.

https://developers.cloudflare.com/durable-objects/platform/limits/

I have leaned into this project to help me scale to 10k:

https://github.com/cloudflare/dog

Cloudflare Docs

Limits · Cloudflare Durable Objects docs

Durable Objects are only available on the Workers Paid plan. Durable Objects limits are the same as Workers Limits, as well as the following limits that are specific to Durable Objects:

GitHub

GitHub - cloudflare/dog: Durable Object Groups

Durable Object Groups. Contribute to cloudflare/dog development by creating an account on GitHub.

CCodingCoop | Co-Founder Nullshot Website says 1000 rps under limits somewhere and there is a DOG service that all...

mihaaai•3/9/25, 11:02 AM

The 1000rps is for requests, not websocket messages

AAshley Someone asked me the other day, and now I’m curious, what’s the max number of co...

mihaaai•3/9/25, 11:06 AM

With hibernation the DO server should be able to hold up to 32k client connections at a time and broadcast between each-others

DaniFoldi•3/9/25, 11:01 PM

although if you're broadcasting to all of them, from my experience it can't really handle more than a few thousand, so I'd recommend soft limiting to 2-4k

DaniFoldi•3/9/25, 11:02 PM

and at around 20-25k connections it became pretty unreliable

DaniFoldi•3/9/25, 11:02 PM

(these are from my testing done a few months ago)

DDaniFoldi although if you're broadcasting to all of them, from my experience it can't real...

akazwz•3/10/25, 3:33 PM

single Do right ?

Aakazwz single Do right ?

DaniFoldi•3/10/25, 3:33 PM

correct

rh•3/12/25, 10:45 AM

Is something like https://github.com/cloudflare/workers-rs also available for C++? Or does anybody have an example on how to use the SQLite storage API in a C++ to WASM build?

GitHub

GitHub - cloudflare/workers-rs: Write Cloudflare Workers in 100% Ru...

Write Cloudflare Workers in 100% Rust via WebAssembly - cloudflare/workers-rs

Larry•3/13/25, 4:09 PM

Is there any way to know the "name" as in "foo" in this example,

env.MY_DURABLE_OBJECT.idFromName("foo")

env.MY_DURABLE_OBJECT.idFromName("foo")

, once inside of a DO instance? At one point I know the answer used to be "no" but I'm wondering if this has changed.

LLarry Is there any way to know the "name" as in "foo" in this example, `env.MY_DURABLE...

Unsmart•3/13/25, 4:12 PM

You would have to send the name to the DO yourself and save it

LLarry Is there any way to know the "name" as in "foo" in this example, `env.MY_DURABLE...

Hard@Work•3/13/25, 4:17 PM

Here's the thread: https://github.com/cloudflare/workerd/issues/2240

GitHub

bug: `DurableObjectId::id.name` doesn't work · Issue #2240 · cloudf...

(maybe this is a feature request?) When creating a durable object with .idFromName(name), I would expect this.ctx.id.name inside a durable object. to reflect the same. The types imply that it shoul...

Iggy•3/13/25, 6:35 PM

what's the SQL-in-DO durability? is it the same as R2 with 11 9s?

IIggy what's the SQL-in-DO durability? is it the same as R2 with 11 9s?

lambrospetrou•3/13/25, 6:52 PM

No numbers are advertised, but all writes are acknowledged by a quorum from five followers before returning to your worker. See details in https://blog.cloudflare.com/sqlite-in-durable-objects/

To solve this problem, we take advantage of our global network. Every time SQLite commits a transaction, SRS will immediately forward the change log to five "follower" machines across our network. Once at least three of these followers respond that they have received the change, SRS informs the application that the write is confirmed. (As discussed earlier, the write confirmation opens the Durable Object's "output gate", unblocking network communications to the rest of the world.)

When a follower receives a change, it temporarily stores it in a buffer on local disk, and then awaits further instructions. Later on, once SRS has successfully uploaded the change to object storage as part of a batch, it informs each follower that the change has been persisted. At that point, the follower can simply delete the change from its buffer.
[...]
Each of a database's five followers is located in a different physical data center. Cloudflare's network consists of hundreds of data centers around the world, which means it is always easy for us to find four other data centers nearby any Durable Object (in addition to the one it is running in). In order for a confirmed write to be lost, then, at least four different machines in at least three different physical buildings would have to fail simultaneously (three of the five followers, plus the Durable Object's host machine). Of course, anything can happen, but this is exceedingly unlikely.

Iggy•3/13/25, 6:54 PM

awesome, thank you!

Llambrospetrou No numbers are advertised, but all writes are acknowledged by a quorum from five...

Iggy•3/13/25, 7:39 PM

in the case of a DO w/ SQLite becoming unresponsive and the followers have to start a new one, do you know the details here? does it have to replicate the SQLite back to the new DO's disk, or does it use the same disk, or something else?

IIggy in the case of a DO w/ SQLite becoming unresponsive and the followers have to st...

lambrospetrou•3/13/25, 7:43 PM

If the new DO ends up on the same machine, then the same disk is used. If it ends up in a separate machine, it loads the db from cold storage and resumes replication from that point on.

Iggy•3/13/25, 7:44 PM

do you know the likelihood of being on the same machine vs a new one? or how frequently do DOs become unresponsive at the infra level?

IIggy do you know the likelihood of being on the same machine vs a new one? or how fre...

Milan•3/13/25, 8:34 PM

Generally it should be pretty likely it goes back to the same machine, unless that machine becomes unhealthy (in which case you wouldn't even want it to be scheduled there again, a cold start is preferable to no start!)

It's really tricky to say how often individual DOs suffer from infra issues:
1. not all PoPs are the same,
2. you could have some DOs in a namespace have nearly perfect availability over some period, and then a handful with terrible availability (ex. if they only do 10 requests in a month, but all 10 were during an incident, or when a PoP was under a lot of load and we were doing maintenance so there were fewer resources than normal, etc)

Not that any of this has any bearing on durability/application correctness

Iggy•3/13/25, 8:37 PM

makes sense, thanks! Does CF have an uptime SLA? I couldn’t find one

IIggy makes sense, thanks! Does CF have an uptime SLA? I couldn’t find one

1984 Ford Laser•3/13/25, 9:00 PM

100%, with it being possible to apply for a credit for the amount of time that was lost X your average usage. Usually, large platform downtimes are measured in minutes, not hours, so even if there is possibility for a credit, it wouldn't even be that much

Iggy•3/13/25, 9:02 PM

yeah I’m familiar with the contracts but do they actually advertise 100% uptime?

generally it’s a proxy for stability, idrc about the credit aspect

IIggy yeah I’m familiar with the contracts but do they actually advertise 100% uptime?...

Isaac McFadyen•3/13/25, 9:03 PM

Because the service isn't different for Enterprise versus non-Enterprise, the uptime for customers on SLA and not on SLA is likely to be identical. But yes, Enterprise customers have 100% uptime SLAs, if they request it.

1984 Ford Laser•3/13/25, 9:09 PM

oh yeah I forgot the Ent requirement there. Stability is very good here, I think there's been like maybe 2 hours of platform downtime in the last 6 months or something, and that was technically a subset of products, not the entire thing

11984 Ford Laser oh yeah I forgot the Ent requirement there. Stability is very good here, I think...

Iggy•3/13/25, 9:20 PM

isn’t that like 99.95%?

IIggy isn’t that like 99.95%?

1984 Ford Laser•3/13/25, 9:29 PM

On that non-specific timeframe I provided, maybe. Not sure why you're so concerned about possible downtime, go build some stuff!

Iggy•3/13/25, 9:30 PM

I’m doing service provider evaluation, I can’t not be concerned about possible downtime

Iggy•3/13/25, 9:31 PM

historical downtime and failover behavior are important

1984 Ford Laser•3/13/25, 9:48 PM

Hopefully others can chime in here, but in my experience CF works very hard to provide constant service, and when there is a downtime, it is a followed with an in-depth post-mortem explaining what happened. Of course every platform has downtime, but part of the benefit of the global network is that its very hard to take down the entire network/platform, one location fails then we just spin up another instance elsewhere. Durable Objects themselves don't really have platform downtime, I can't remember any in the last 6 months I've been working with it

1984 Ford Laser•3/13/25, 9:49 PM

https://blog.cloudflare.com/cloudflare-incident-on-february-6-2025/
https://blog.cloudflare.com/cloudflare-incident-on-november-14-2024-resulting-in-lost-logs/

Here are some incident post-mortems if you're curious. Can help you to understand what errors may occur, and how they are handled internally and from an outward perspective

Iggy•3/13/25, 9:56 PM

Thanks! CF makes amazing public posts

IIggy Thanks! CF makes amazing public posts

1984 Ford Laser•3/13/25, 9:57 PM

Very transparent, has given me a lot of confidence in the platform. The devs are also super clever and have built some really cool tech between everything they do

o7•3/15/25, 6:27 AM

is the SQLite in DO usage separate than D1? 50B (25b + 25b) reads combined for a paid Worker plan?

o7•3/15/25, 6:28 AM

I’m assuming not but must confirm

Oo7 is the SQLite in DO usage separate than D1? 50B (25b + 25b) reads combined for a...

lambrospetrou•3/15/25, 10:00 AM

separate

import { DurableObject as DurableObjectPrimitive } from "cloudflare:workers"; const iife = <T>(fn: () => T): T => fn(); export function DurableObject<TEnv>(accessor: keyof TEnv) { return class DurableObject extends DurableObjectPrimitive<TEnv> { /** * Retrieves a durable object stub for a given id. * * @template T - The type of the DurableObject. * @param {TEnv} env - The env object containing the durable object's namespace. * @param {DurableObjectId | string} [id] - The id of the DurableObject. If not provided, `newUniqueId()` will be used. * @returns {DurableObjectStub<T>} The DurableObjectStub for the given id. */ static getStub<T extends DurableObjectPrimitive>( this: { new (...args: any[]): T }, env: TEnv, id?: DurableObjectId | string ): DurableObjectStub<T> { const namespace = env[accessor] as DurableObjectNamespace<T>; const stubId = iife(() => { if (!id) return namespace.newUniqueId(); if (typeof id === "string") { // Check if the provided id is a string representation of the // 256-bit Durable Object ID if (id.match(/^[0-9a-f]{64}$/)) return namespace.idFromString(id); else return namespace.idFromName(id); } return id; }); const stub = namespace.get(stubId); return stub; } }; }

interface Env { FOO_OBJECT: DurableObjectNamespace<FooObject>; BAR_OBJECT: DurableObjectNamespace<BarObject>; } export class FooObject extends DurableObject<Env>("FOO_OBJECT") { getFoo() { return "foo!"; } } export class BarObject extends DurableObject<Env>("BAR_OBJECT") { getBar() { return 41; } } // example usage: const fooStub = FooObject.getStub(env, "123"); const barStub = BarObject.getStub(env, "123"); fooStub.getFoo(); // () -> Promise<string> barStub.getBar(); // () -> Promise<number>

thanks for the response! Any insight as to how they would've built this by chance? Maybe using in-me

Similar Threads

Similar Threads

Similar Threads