Kubernetes · credential lifecycle operator

Keys expire.
Rotate them on purpose.

Ward watches every managed credential age, mints a fresh one on the schedule you declare, rolls it out to the systems that use it, and retires the old one — recording each step. The secret value itself never lives in the operator.

Policy-driven · crash-safe · never holds the value
The shift

Three ways teams rotate a secret.

Rotation isn't hard. Remembering to, and finishing it when something breaks halfway — that's the hard part.

01 / BY HAND

When you remember.

“I'll rotate it next quarter.”

A calendar reminder and a runbook. It works until the quarter you forget — or the 2am page when a token quietly expires in production.

02 / SCRIPTS & CRON

With a script.

“Hope the script finished.”

A cron job that mostly works. When it dies mid-run it has no memory of where it stopped, and you're left guessing which half of the swap actually happened.

03 / RENEW

As a proven operation.

“Done — and here's the record.”

You declare the policy once. A crash-safe state machine does the swap, keeps the old key valid until the new one is verified, and writes down every step.

Why it matters

A credential you never rotate
is a leak you haven't noticed yet.

Every long-lived key is a blast radius that only grows. Ward turns rotation from a chore you postpone into a property of the cluster — constant, boring, and auditable.

One rotation, start to finish

The old key stays live
until the new one is proven.

Five beats, scheduled or triggered by hand with wardctl. There's no window where nothing works.

both valid · zero downtime credential v6 · active retired credential v7 · staged → active generatestageapplyverifyrevoke 0102030405
active & verified new, not yet trusted retired
01GenerateA fresh value is minted and written to your secret store.
02StageAn opaque reference — not the value — is handed to the adapter.
03ApplyThe adapter sets the new value on the real target system.
04VerifyWard confirms the new credential actually works before trusting it.
05RevokeOnly now is the old value retired. No gap, no overlap left behind.
What's inside

Three parts, each kept
in its own lane.

You write policy. The core runs the loop. Adapters touch the real systems. The split is the point — a mistake in one can't leak a secret from another.

You declare

Policy

Set the cadence, the shape of generated values, and which stores and adapters are even allowed. A managed credential points at a policy and says where its result is delivered.

  • CredentialPolicy — cadence, length, max-age, allow-lists
  • ManagedCredential — what to manage, where to deliver
The operator runs

The lifecycle core

Every operation — bootstrap, adopt, rotate, recover, decommission — runs as a strict state machine. Each effect is recorded before it happens, so a crash resumes at the exact boundary.

  • record-then-act — a durable step log of references only
  • recover — roll back when safe, else flag for a human
Adapters touch reality

Target adapters

Each system — Grafana, Redis, your own service — has its own adapter in its own least-privilege process. It does the step it's told to, reads by reference, and reports back by version ID.

  • never sees the value, never decides timing
  • SDK + conformance suite to write your own
Safe to trust

Guarantees built into the shape of it.

Rotating credentials is easy until the one time it half-finishes. These aren't bolted on — they're how the thing is put together, and each is covered by the test suite.

01

Never holds the value.

Credential bytes live in exactly one guarded type. A leak-detecting test fails if a value ever reaches a log, an event or a resource status.

02

Record before effect.

Every step is written down before it changes anything real. A pod can die mid-rotation and the engine resumes from the exact boundary, not a guess.

03

No silent half-state.

Once a step has touched the target, failure either rolls back — only when the adapter declared that safe — or stops for recovery. It never assumes.

04

No gap in coverage.

The old credential stays valid until the new one is verified working. Rotation never leaves a window where nothing authenticates.

05

Store-agnostic.

OpenBao in dev and CI, GCP Secret Manager in production — same contract. Every backend passes one shared conformance suite before it can land.

06

Least-privilege reach.

Each adapter runs under its own ServiceAccount and RBAC, advertises its capabilities, and is approved by an admin before it can act.

Works with

Your stores and your systems.

Pluggable at both ends: where secrets are kept, and where they're used.

Secret store

OpenBao

The dev and CI backend. Vault-compatible, never a production requirement.

Secret store

GCP Secret Manager

The production target, behind the same SecretStore interface.

Delivery

Kubernetes Secret

Delivered only where a ManagedCredential explicitly names it. Never adopted implicitly.

Adapter

Grafana & Redis

In-tree adapters, plus a fake for tests — each built on the public SDK.

Adapter

Your own

Write one with sdk/adapter and prove it with the conformance suite.

Control

wardctl

Request a rotation and read credential health — without ever printing a value.

In one line

Declare it once.
Forget the rotation.

A Kubernetes operator that keeps credentials fresh across your real systems — crash-safe, auditable, and built so it can never become the thing that leaks them.