Join the discussion
Write your take first — we'll ask for email only when you're ready to publish.
- Hacker News
- Reinventing the web, one service at a time. Is it really that hard to build things like this on a per-case base, small scale, all on a bare bones VPS? Do we need a global gateway to help us not screw up the basics? Service looks nice but makes me sad somehow.
- As a DevOps engineer, if you learn to implement CF Workers with Claude Code's Cloudflare skill, you will no longer be burdened by this question. I'm running a Docker swarm on my homelab, a Docker swarm on a EC2 instance, but there's no longer a single web service in either of them. Workers is insanely good.by jesse_dot_id
- i just love the sweet $0 invoice at the end of each month for all these services.
Thanks CF.
by TimCTRL - Finally proper stale-while-revalidate support!
- That landed a few months agoby dbbk
- Amazing, exactly what Workers lacked, I was quite annoyed that a worker would spin up when 99% of my requests then return a cache. Waste of 3ms, times millions.by lekevicius
- The previous Worker in-front of the cache never made sense to my old school proxy in-front of the appserver mindset. Already using this to speed up a tool. Nice work.
- Cloudflare Snippets were actually better if you wanted to run logic before the cache (they are entirely free)by dbbk
- It makes sense in a world where Cloudflare is something that runs in front of your app. You need to run some arbitrary code before their logic, including their cache. If you wanted something that ran after the cache, you could put it in your app, you didn’t need the worker. That was Cloudflare when Workers launched.
But now the platform has evolved to where you’re running the entire app from Workers.
by drdexebtjl - finally, this was needed.
A big worry was always "why does workers sit in front of my cache? that's a waste of an invocation if i'm returning a cached result"
by dangoodmanUT - Finally :)
Time to migrate rarely-updating websites that still need a CMS to Cloudflare.
> One thing to watch: when caching is enabled, requests that are normally free — static asset requests and worker-to-worker invocations through service bindings or ctx.exports — are billed at the standard request rate, because each one now consults the cache in front of your Worker.
That’s a very weird limitation from a product standpoint. You might end up spending more money by enabling caching.
I wonder if static assets and worker-to-worker invocations are really more expensive to them with caching enabled, or if this is just a metering problem.
I would have made this free in the interest of making billing simpler and of making the decision to enable caching more straightforward.
If you’re min-maxing costs, this encourages awkward setups where you split workers into two, one with caching enabled and one with caching disabled.
by drdexebtjl
Incredible! This is why I shoehorn all my server side usecases on to the Workers Platform. Cloudflare, since 2020 when I first went all-in, has consistently shipped features that reduce bills significantly (except for 2023 Workers usage model changes). In one case, when they shipped free Snippets (Workers but 32kb code size & 5s CPU time) for Pro accounts ($200/yr), our bills went from £15k+ to £0.When Workers Cache is enabled, every cacheable request to your Worker hits Cloudflare's cache first. If there's a fresh cached response, Cloudflare returns it directly — your Worker doesn't run, and you don't pay CPU time for it. On a miss, your Worker runs, and if your response is cacheable, Cloudflare stores it for the next request. The next request from anywhere on Earth can be served straight from cache.I know about the infamous "Enterprise plan" (especially, when your bandwidth is as high as ours in 100s of TBs) and know of at least one other tech shop that was required to pay for it ... but we haven't got that sales call, yet.
by ignoramous- Our bandwidth is very high, we constantly get invited onto the call with their team, but after talking with them a few times it makes absolutely zero sense for us to have a committed spend, all the stuff I needed an account manager for in GCP/AWS just doesn't exist in CF. Support wise I imagine if it's broken for us it's also broken for 2 million other people so... yeah... Thanks CF!by PUSH_AX
- I was a bit confused what this adds other than just standard CDN-Cache-Control page caching that we do now. Some quirks I've found;
- You still get billed per request, whether the request hits cache or not (but don't get billed for CPU time)
- You now get billed for static asset requests! This makes no sense to me. "One thing to watch: when caching is enabled, requests that are normally free — static asset requests and worker-to-worker invocations through service bindings or ctx.exports — are billed at the standard request rate, because each one now consults the cache in front of your Worker." Yeah that sounds like a bug that just happens to generate them more money.
- The cache key automatically has the worker deployment version, so even gradual deployments populate their own cache which is nice
- It seems like you can set a totally custom cache key? But that was previously Enterprise only, can't see if that's still the case here.
by dbbk - CPU time is not billedby sidcool
- > Yeah that sounds like a bug that just happens to generate them more money.
Yeah. It sounds like they moved the component that counts requests earlier in the pipeline so that it can count cache hits, and now it also counts these.
by drdexebtjl - > I was a bit confused what this adds other than just standard CDN-Cache-Control page caching that we do now.
Until now these cache headers didn't work if you set them in a Worker, because Workers were always run in front of the cache. You could use them if you're running Cloudflare cache in front of another origin, but not if you were e.g. rendering a site in Workers. This changes that.
by ascorbic - Great feature. Although I’m starting to get annoyed by obvious signs of LLM writing like no X, no Y etc.by mchav
- At least for me I don't really read these posts/docs, I just give the link to claude and it'll implement it regardless of wordingby 383toast
- People that don't like writing now get to write by offloading it to an LLM, and this is the result. I miss the world where articles were mostly written by people who had the interest and patience to do it.by xpct
- Huge props to just sticking with the HTTP spec on this one with `Cache-Control` headers with `stale-while-revalidate` support. It's amazing how many other providers mess that up.
On top of that the cache tags are a slick way to do invalidation. This looks like a great product.
by vlucas - > This is the caching API we've always wanted Workers to have. Here's why it took us this long
I was looking forward to the "why it took us this long" explanation but it wasn't explicitly spelled out. Any Cloudflare staff here able to expand on that?
(The article does a good job of showing how many different smart design decisions went into this, but given caching is core to what a Cloudflare does I'm still a little surprised it took 9 years to get here!)
by simonw - The article was very clearly written or heavily edited by AI, which I suspect explains some of the peculiarities in structure and wording.by tshaddox
- The honest answer is:
We implemented the "standard" Cache API back in the early days because it was a standard, one which was intended to be used together with the Service Workers API, which we were also building around back then.
But it was never a good fit. The get/put API was designed for a local browser cache, not a distributed cache like Cloudflare's. We probably should have realized this before implementing it, but it really became obvious over the years of actual use.
But given we had something that mostly worked for most use cases, it was hard to prioritize redoing it against all the other things on our plate. So we deferred.
More recently, architectural changes we've been making in Workers for other reasons happened to make it significantly easier to finally implement this the way we wanted, and we were able to find some engineering time to get it over the line.
Gory details for the curious: We've been improving the infrastructure around the notion of workers having multiple "entrypoints", with the ability to parameterize those entrypoints. ctx.props[0] and ctx.exports[1] are part of this. A lot of this was motivated by Dynamic Workers sandboxing, but the concept also presents a clean way to inject a cache between two parts of the same worker, by applying it to the entrypoint and having the worker call itself using ctx.exports.
Moreover, the introduction of "channel tokens" made a big difference[2][3]. Essentially I created a way to encode a token (bytes) representing an arbitrary entrypoint to a Worker, complete with its serialized parameters. I did this to enable these entrypoint stubs to be passed over RPC, which is again useful for sandboxing use cases, but it also created a convenient, encapsulated way to pass information through our cache infrastructure about what worker should run at the other end.
It's not a huge breakthrough or anything, but I think it made the architecture clearer in everyone's mind to the point that we got excited about using it to implement caching properly, finally.
[0] https://developers.cloudflare.com/workers/runtime-apis/conte...
[1] https://developers.cloudflare.com/workers/runtime-apis/conte...
[2] https://github.com/cloudflare/workerd/blob/main/src/workerd/...
[3] https://github.com/cloudflare/workerd/blob/main/src/workerd/...
by kentonv