Urgent.News

What's breaking now, across thousands of outlets.

Tech

Nothing could start without the dependency we had filed as optional

Our configuration service was tier three. No SLO, no pager, a single replica for a long time, and a line in the architecture document describing it as a soft dependency because clients cache their values and can carry on if it is unavailable. That sentence was true about the steady state and completely false about the one moment that mattered. It went down at 09:40 during a routine node pool…

The configuration service was a tier three component, with no service level objective (SLO), no pager, and only a single replica. It was considered a soft dependency in the architecture document since clients cached their values and could continue functioning even if it was unavailable. However, the reality was starkly different during a routine node pool rotation at 09:40, when the configuration service went down, causing pods to be rescheduled across the fleet.

A restarted pod had an empty in-memory cache, leading the client library to fetch configuration data during application startup. This process blocked and retried for two minutes before failing, resulting in readiness never being attained. Kubernetes then restarted the affected pods, but this triggered a cascade of failures, impacting services that were unrelated to configuration and were otherwise healthy.

This incident highlighted the importance of recognizing hard dependencies, which are those dependencies a process cannot start without, regardless of their tier designation. The client was ultimately fixed, with the last known good configuration stored on disk and read at startup, along with defaults baked into the image for situations where there is no network.

Consequently, the service was reclassified as tier one, with three replicas and a pager, due to its newfound criticality. This experience led to the adoption of a quarterly practice of blocking a dependency at the network level and restarting all services to uncover hidden dependencies, as relying solely on dependency diagrams could be misleading.

Written by urgent.news from Dev.to's reporting — not their text. Machine-written — may contain errors; check the original before relying on it.

Read the original at dev.to →

More in Tech

Consolidation in the Vendor Market Is Now a Technical Risk

Three of the products we depend on changed hands in the last eighteen months. In each case the acquirer was larger, already sold us something else, and made reassuring noises about continuity.

  • Vendor market consolidation has reduced credible suppliers from eight to three.
  • Acquisitions led to abrupt loss of leverage and abrupt end of fallback options.

I Made Four Authorization Engines Answer the Same Questions

"Which authorization engine should I use" always gets answered with a table. Cedar is analyzable, Rego is expressive, Zanzibar is relationship-based. I could never feel the difference from any of it.

  • Four authorization engines tested with identical rules and simultaneous requests
  • Cedar, Rego, Zanzibar, and Casbin engines each with unique strengths and weaknesses
  • ReBAC failed to handle time-based constraints during business hours

One rounding, not many: why a provably-fair verifier must match the server bit for bit

Originally published on the Betkyo Journal , where every figure is read from the game engine's source. Every provably fair round on this site turns a 256-bit hash into a number between 0 and 1 and…

  • Provably-fair verifier must match server bit for bit
  • Hash conversion involves rounding due to precision limits
  • Single rounding ensures accurate game outcome verification

Stop Slamming Downstream Services: Singleflight Request Coalescing with Java Virtual Threads

Stop Slamming Downstream Services: Singleflight Request Coalescing with Java Virtual Threads Virtual threads solved your JVM I/O bottlenecks, but downstream internal services are now on fire because…

  • Singleflight request coalescing pattern addresses virtual thread load on services.
  • Developers often use Redis or synchronized blocks, worsening the issue.
  • JVM-based Singleflight ensures efficient, scalable high-throughput handling.

More from Saturday 12 September →