ProductNot yet confirmed elsewhere1 publisher2 min readPublished
Kubernetes Secrets are a distribution problem, and the database is where it shows
Red Hat's pitch for SPIFFE and SPIRE on OpenShift is an argument about exposure windows: a leaked Secret stays valid until someone notices it. Agents sharing the analysts' database worsen the arithmetic.
The Product Desk

What happened
- Red Hat argues the old split of humans logging in and machines holding secrets is breaking down, and that databases are where the ambiguity surfaces.
- Its complaint against Kubernetes Secrets is operational: manual rotation, distribution and revocation, plus routine sharing across replicas and teams.
- One data store now answers to analysts and DBAs arriving through OIDC and OAuth and to microservices, pipelines and AI agents connecting programmatically.
- The proposed replacement is SPIFFE and SPIRE, shipped on OpenShift through the zero trust workload identity manager, issuing identity without long-lived tokens.
- The write-up offers application-to-database access as the first adoption step, two authentication patterns, lessons learned and a demo readers can run.
Why it matters
- cost Manual rotation, distribution and revocation is recurring human labour priced per credential per team, and it is the platform group that pays it every time a service or an agent is added.
- exposure When an agent, a batch job and three replicas hold the same Secret, the database log cannot say which of them ran the query, so the audit trail stops at the credential.
- decision Adopting issued identity forces a call on where enforcement actually lives: platform RBAC, or the database's own roles and row-level policies, which are the things that must accept the new credential.
- precedent Once workload identity ships as a supported platform component rather than a project to assemble, the expectation becomes that a new service arrives with an identity instead of a Secret to provision.
Nothing in a Secret binds the credential to the workload that reads it. Red Hat's own list of complaints concedes as much: rotation, distribution and revocation are manual operations, and the same value ends up spread across replicas and across teams [5]. A credential that can be copied answers no useful question about which caller is on the other end of the connection.
The consequence the post states plainly is the one worth doing arithmetic on. An exposed Secret stays valid until somebody notices [6]. Because revocation is a manual step [5], the working life of a leaked credential is detection time plus response time, and neither of those is a number the platform sets [14]. Cryptographic workload identity issued without long-lived tokens does not make leaks less likely; it moves the leak's useful life from your monitoring into issuance policy [7].
Why the database is the wedge rather than service-to-service traffic: most systems serve one class of caller, and databases are the exception, frequently the same instance and sometimes the same tables [2]. The human side of that boundary is already settled, through OIDC, SAML or LDAP federated via an identity provider such as Microsoft Entra ID or CyberArk, with authorization landing either in OpenShift RBAC or in database roles and row-level policies [8]. Red Hat's position is that the pipeline, the integration service and the AI agent are principals on the same footing as the DBA, each needing to be identifiable, authorized and auditable [9]. That is the sentence that does the work, because the database is where the two mechanisms have to agree on one answer.
Two things the material does not settle. The first is delegation: enterprise applications often need to act on behalf of a user [12], and the supplied excerpt breaks off mid-sentence as it starts that example [13], so the hardest case for workload-bound identity is left open here. The second is operational evidence. What is on offer runs on Red Hat's platform, delivered through Red Hat's own component [7], and stops at patterns, lessons learned and a demo [11] rather than issuance intervals or a production comparison.
For a team whose agents already query the same store as its analysts, the sequencing is the transferable part. The identity claim is only worth what the data store will accept in place of a password, and that acceptance lives in the database's role model [8], not in the platform that issued the certificate.
What to watch
- Whether the two authentication patterns work against unmodified data stores or require database-side support or an intermediary proxy.
- Whether the full post resolves impersonation and delegation, which is the case that workload-bound identity handles least naturally.
- Whether SPIRE issuance intervals, certificate lifetimes and revocation behaviour get documented with actual numbers rather than described as short-lived.
Clarity's read
What the record supports and how the coverage leans. The claims behind it follow.
Reality
- Evidence34
- Adoption
- Insufficient
- Hype gap+22
- Incentives82
- Confidence42
Claim ledger
Ranked by verification strength, evidence, and original report placement.
- [1]
The same data store must serve humans (analysts and DBAs connecting through corporate identity systems like OIDC and OAuth) and machines (microservices, pipelines and AI agents that connect programmatically), and the risks of misconfiguration, identity theft and security breaches grow quickly.
- [2]
Most systems primarily serve one kind of caller (admin consoles for humans, internal APIs for workloads), while databases routinely serve both, often through the same database instance and sometimes through the same tables.
- [3]
Red Hat writes that enterprise security used to draw a clean line between humans logging in and machines using secrets, that the line is blurring, and that interactions with databases are often where the ambiguity appears.
- [4]
Historically, usernames and passwords have been stored in configuration or Kubernetes Secrets, with long-lived tokens and API keys also kept in Secrets on the assumption they are safer than passwords.
- [5]
Red Hat states that Secrets must be rotated, distributed and revoked manually, and are frequently shared across replicas or teams.
- [6]
Red Hat states that if a Secret is exposed, an attacker has a credential that remains valid until someone notices.
- [7]
SPIFFE (Secure Production Identity Framework for Everyone) and SPIRE (SPIFFE Runtime Environment), delivered on Red Hat OpenShift via the zero trust workload identity manager, give workloads cryptographic identity without long-lived passwords or tokens.
- [8]
For humans, authentication runs through OIDC, SAML or LDAP, often federated via an identity provider such as Microsoft Entra ID or CyberArk, with authorization configured either in the platform (for example OpenShift RBAC) or downstream in an application or data store such as database roles or row-level policies.
- [9]
Red Hat argues that a microservice, batch job, data pipeline, AI agent or integration service is a principal that needs to be identifiable, authorized and auditable in the same way as a person logging into a web console.
- [10]
A Secret shared across replicas and teams cannot attribute a given connection to a single workload, so the per-caller auditability requirement Red Hat sets out is not met by shared Secrets.
- [11]
The post moves from two SPIFFE-enabled applications talking to one another, to a roadmap for enterprise adoption using application-to-database access as a practical first step, and finishes with two concrete authentication patterns, lessons learned and a demo readers can run.
- [12]
Red Hat notes that enterprise business applications often require user impersonation or delegation capabilities.
- [13]
The supplied text ends mid-sentence while beginning an example of user impersonation or delegation in enterprise business applications.
- [14]
Because revocation is manual and an exposed Secret stays valid until noticed, the usable lifetime of a leaked Secret is set by detection and response time rather than by a configured credential lifetime.
Sources
1 independent publisher whose own reporting we read for this story.
- redhat.comPasswordless workload identity on OpenShift
1 article · August 23, 2026
Topics and entities
Follow any of these and your For You feed starts watching them — no settings page required.
Topics
- Agent Identity and AuditFollow
- Database Access ControlFollow
- Kubernetes Secrets ManagementFollow
- Zero-Trust ArchitectureFollow
- Workload IdentityFollow