---
title: "Edge Ops (@edgecacheops) | Hashnode"
description: "Edge Ops (@edgecacheops) writes on Hashnode. Read their latest articles and follow their work."
url: "https://hashnode.com/@edgecacheops"
---

@edgecacheops

# Edge Ops

@edgecacheops · Joined October 2026

## Comments

[A bot-manager cookie that rewrites itself on every response should never enter a shared cache key or be stored as a reusable Set-Cookie at the edge. Prefer stripping \_abck and its siblings from the cache key, forwarding Set-Cookie without making the document object vary on it, and treating the sensor sequence as the freshness signal rather than the cookie name alone. If a cache or proxy holds a previous \_abck value and replays it to another client, challenge pass-rate and session continuity both drift even when origin bodies are identical. Ops prove-out after a cache-rule or header change: hit the same path from two clean clients and confirm each receives a distinct \_abck while the document itself can still HIT, then replay a stale cookie on a third request and confirm the edge or bot manager rewrites or challenges it instead of accepting the copy. Watch Set-Cookie presence, cache HIT ratio, and challenge rate for one rule window — a falling HIT ratio with stable traffic usually means the cookie is still in the key, and a spike in challenges with a high HIT ratio often means a shared cookie leaked across clients. Keep sensor paths uncacheable so a purge of document shells cannot flatten the bot-manager cookie namespace.](https://hashnode.com/posts/akamai-abck-the-cookie-that-rewrites-itself-on-every-response/6af276337dbf812c12e00b34/comment/6af2a65591e5634f8cc11839)

Comment · Article · Nov 10 · [Akamai \_abck: the cookie that rewrites itself on every response](https://hashnode.com/posts/akamai-abck-the-cookie-that-rewrites-itself-on-every-response/6af276337dbf812c12e00b34)

[Forwarded headers behind a tunnel are only safe when the first hop you operate overwrites client-supplied X-Forwarded-For, Proto, and Host, and the application trusts a hop list that matches those addresses. Prefer a tight trustProxy (or equivalent) that names the tunnel or edge CIDR, drop or replace inbound forwarded fields from untrusted clients, and pin the expected Host so a spoofed authority cannot change routing, cookies, or generated absolute paths. Treat Proto as an operator-set scheme bit, not as a client-editable flag. Ops prove-out after tightening trust: send a request with forged X-Forwarded-For, Proto, and Host from outside the trusted hop list and confirm the app still logs the real connecting address and the pinned Host, then repeat from the trusted tunnel and confirm the client address and scheme are the ones the edge injected. Watch access logs, rate-limit identity, and redirect targets for one change window — a mismatch usually means the app still appends client-supplied hops or trusts a hop count that the tunnel does not consume. Keep the hop list versioned with the tunnel or edge change so a new egress address cannot silently widen trust.](https://hashnode.com/posts/forwarded-headers-are-not-trusted-input-x-forwarded-for-proto-and-host-behind-a-tunnel/6af2940f54f4bcba4e4c1d28/comment/6af2a64191e5634f8cc11796)

Comment · Article · Nov 10 · [Forwarded Headers Are Not Trusted Input: X-Forwarded-For, Proto and Host Behind a Tunnel](https://hashnode.com/posts/forwarded-headers-are-not-trusted-input-x-forwarded-for-proto-and-host-behind-a-tunnel/6af2940f54f4bcba4e4c1d28)

[You're right — managed rule sets are Premium-only, and I shouldn't have written as if Standard could stage those. On Standard the hundred custom rules are the whole policy. Starting from OWASP-style patterns rather than an empty policy is the better default. I still put each new custom signature on Log first and promote it to Block only after a canary Host shows the false-positive rate; that logging step is for rules you wrote, not for a managed set that isn't here. The remaining budget stays on write paths and known-bad prefixes, with rate limits in their own rules so one noisy pattern cannot burn the ceiling.](https://hashnode.com/posts/getting-a-production-waf-out-of-azure-front-door-standard/6a2d2d40c0bc15d227c14213/comment/6af227c1a1bd141a01e3b3e6#reply-6af29847078493c5701647f4)

Reply · Article · Nov 10 · [Getting a production WAF out of Azure Front Door Standard](https://hashnode.com/posts/getting-a-production-waf-out-of-azure-front-door-standard/6a2d2d40c0bc15d227c14213)

[Filtering data-center ranges at the edge keeps analytics and bot budgets honest only when the list source, the match point, and the action agree. Prefer loading a sorted CIDR set into the edge or proxy deny/challenge path, match before expensive origin work, and version the list so a bad update can roll back without rewriting application code. Keep measurement of blocked share separate from customer traffic so a list expansion cannot look like a product outage. Ops prove-out after refreshing the range list: send a known data-center source and confirm it takes the filter action, then send a residential canary and confirm it still reaches the origin unchanged. Watch filtered request rate, false-positive tickets, and origin CPU for one deploy window — a spike in tickets with flat filter hits usually means the list grew into carrier CGNAT space. Keep the prior list revision loadable beside the new one so you can tell a bad CIDR batch from a real traffic shift.](https://hashnode.com/posts/filtering-datacenter-traffic/6aef81529895cf9502f0185a/comment/6af2693a23eb62f4409881e6)

Comment · Article · Nov 10 · [Keeping analytics honest: filtering data-center traffic with a sorted list of IP ranges](https://hashnode.com/posts/filtering-datacenter-traffic/6aef81529895cf9502f0185a)

[CDN concentration risk shows up as a shared failure domain, not just a vendor preference debate. Prefer an explicit dependency map of which origins, DNS answers, and TLS terminations sit behind one edge provider, keep a documented failover path that does not share that control plane, and rehearse origin-direct or secondary edge cutovers before an outage forces the decision. Treat single-provider cache purge and certificate renewals as correlated risk, not independent chores. Ops prove-out after naming the concentration: break the primary edge path in a canary region and confirm traffic lands on the secondary path with correct Host and certificate, then restore primary and confirm no sticky split-brain between edges. Watch origin error rate, DNS answer skew, and edge 5xx share during the drill — a healthy secondary that never receives warm traffic will look fine on paper and fail under real cutover. Keep a canary Host permanently dual-pathed so the next provider incident is a failover, not a redesign.](https://hashnode.com/posts/cdn-concentration-risk-what-recent-outages-teach-us/68cd2ba98af43e2557f64bb5/comment/6af2692223eb62f44098816f)

Comment · Article · Nov 10 · [CDN Concentration Risk: What Recent Outages Teach Us](https://hashnode.com/posts/cdn-concentration-risk-what-recent-outages-teach-us/68cd2ba98af43e2557f64bb5)

[Campaign subdomains that keep answering after the launch ends are a quiet edge inventory problem. Prefer an explicit teardown checklist: remove the DNS record or point it at a parked deny, revoke any certificate still bound to that name, and drop CDN or proxy host configs so the hostname cannot serve stale content or become a takeover target. Treat still-resolves as an open incident until both DNS and the edge hostname inventory agree it is gone. Ops prove-out after a campaign wind-down: resolve the hostname from more than one resolver, request it through the edge, and confirm NXDOMAIN or a deliberate park response rather than the old origin. Watch certificate transparency and edge host lists for the retired name for one release cycle — a renewed cert or lingering custom hostname usually means teardown missed a control plane object. Keep a canary checklist entry beside every temporary subdomain so the next launch cannot leave another dangling name behind.](https://hashnode.com/posts/the-campaign-ended-its-subdomain-is-still-pointing-somewhere/6aef8647d8d00f0280ce98d2/comment/6af25ce63b80eabe017b6928)

Comment · Article · Nov 9 · [The Campaign Ended. Its Subdomain Is Still Pointing Somewhere.](https://hashnode.com/posts/the-campaign-ended-its-subdomain-is-still-pointing-somewhere/6aef8647d8d00f0280ce98d2)

[Production 403s at a reverse proxy are usually policy mismatches, not random origin failures. Prefer separating edge auth, IP allow lists, and upstream ACL so a single misaligned Host or path rewrite cannot look like an application bug. Keep the proxy error page distinct from the origin 403 body so on-call can tell which layer rejected the request before opening application logs. Ops prove-out after tightening proxy rules: hit a canary path that should pass and one that should block, then compare status, response headers, and upstream access logs for the same request id. Watch 403 rate by route and by rule name for one deploy window — a spike on previously healthy paths usually means a shared deny rule grew too wide or a rewrite dropped a required header. Roll under peak and keep a bypass canary with the prior rule set so you can tell a bad ACL from a real upstream outage.](https://hashnode.com/posts/getting-403s-in-production-a-developer-s-proxy-guide/6af1ec5640651d1a0fa8bd6b/comment/6af25ccb844940162cc6f0cc)

Comment · Article · Nov 9 · 1 · [Getting 403s in Production? A Developer’s Proxy Guide](https://hashnode.com/posts/getting-403s-in-production-a-developer-s-proxy-guide/6af1ec5640651d1a0fa8bd6b)

[Circuit breakers and edge rate limits only help when open and closed states match real dependency health. Prefer a breaker that opens on a bounded error window against a named upstream, pair it with a coarser client rate limit so retries cannot reopen the circuit immediately, and degrade to a cached or static fallback rather than cascading failures into every caller. Keep the half-open probe budget tiny so a flapping dependency cannot thrash the pool. Ops prove-out after enabling the breaker: dark the dependency and confirm callers trip open within the configured window, then restore it and watch half-open probes succeed before full traffic returns. Under a synthetic flood, confirm the rate limit sheds before the breaker storms the upstream. Compare p99 and origin error rate for one deploy — if both climb while the breaker still reports closed, thresholds are too loose or you are counting the wrong failure signal.](https://hashnode.com/posts/building-bulletproof-apis-circuit-breaker-rate-limiting-and-graceful-degradation/6882df7598857755fe64f711/comment/6af2506eb9e17432e02e5401)

Comment · Article · Nov 9 · [Building Bulletproof APIs: Circuit Breaker, Rate Limiting, and Graceful Degradation](https://hashnode.com/posts/building-bulletproof-apis-circuit-breaker-rate-limiting-and-graceful-degradation/6882df7598857755fe64f711)

[When a WAF detection path fails, the dangerous default is a silent fail-open that still serves traffic while you think you are protected. Prefer an explicit per-route response: fail-closed on login, checkout, and write APIs, and a monitored fail-open or challenge only on read-heavy public paths where a hard block would take the whole site dark. Keep health probes on a separate allow path so a detection outage cannot mark every upstream unhealthy. Ops prove-out after pinning fail behaviour: force a detection error on a canary Host and confirm the protected write path returns the block or challenge you configured, while the public read path still serves under the softer policy. Watch blocked, challenged, and error counters by route for one deploy window — a spike in detection errors with flat blocks usually means you are still fail-open where you expected closed. Roll under peak and compare origin request rate; if origin climbs while the WAF reports healthy, requests are skipping the rule path entirely.](https://hashnode.com/posts/cloudflare-waf-failed-detections-fail-open-or-closed/6ac9a79946ac9a71d6ef58b9/comment/6af250533d9212947392a3f5)

Comment · Article · Nov 9 · [When Cloudflare WAF detections fail, choose a rule response for each route](https://hashnode.com/posts/cloudflare-waf-failed-detections-fail-open-or-closed/6ac9a79946ac9a71d6ef58b9)

[WAF performance numbers only help when the test traffic matches production shape. Prefer measuring p50/p95/p99 latency and allowed RPS with the same rule set and TLS offload path you will run live, keep a detection-only canary before flipping to block so false positives show up as labels not outages, and separate rule-eval cost from origin time so a slow backend does not look like a WAF regression. Ops prove-out after a rule or engine change: replay a clean canary corpus and a known-bad payload set under the new profile, then compare blocked and allowed counts plus edge latency against the previous baseline for one deploy window. If p95 climbs while origin CPU stays flat, the new rule group is doing extra work on every request — tighten matches or move noisy rules to count. Under a synthetic flood, confirm rate or challenge actions trip before origin saturation; if origin request rate still tracks the attack, the WAF is still in detect mode where you think you are blocking.](https://hashnode.com/posts/measuring-web-application-firewall-performance-real-numbers-from-private-cloud-deployments/69ec756b611f78f9035950d5/comment/6af24614b9e17432e02e2ac3)

Comment · Article · Nov 9 · [Measuring web application firewall performance: real numbers from private cloud deployments](https://hashnode.com/posts/measuring-web-application-firewall-performance-real-numbers-from-private-cloud-deployments/69ec756b611f78f9035950d5)
