The previous pages settled where the roof vendor key lives: in a secrets manager, read only by the assessment service, used only after the policy decision point allows the request (the design is on API keys, which owns it). Now the assessment service moves to a managed cloud runtime, and the deployment ticket contains one line that undoes the design: "create an access key for the assessment service so it can read the vendor secret; put it in an environment variable".
Follow that line. The vendor key is guarded by the secrets manager, and the secrets manager is guarded by a cloud credential, and that cloud credential is now a long-lived string in an environment variable, a CI setting and probably a wiki page. The secret that protects the secrets is the weakest secret in the system. During a later access review, the team finds an access key created two years earlier, still active, used by "something in the pipeline"; nobody can say what would break if it were revoked.
This is often called the "secret zero" problem: every chain of secrets needs a first credential. The obvious fix, guarding that key better, still leaves a copyable string that never expires. The question of this page is different: can the platform vouch for the workload, so that the first credential is never a string anyone holds? On all three large clouds, the documented answer is yes, and the mechanism is the same shape on each.
The platform vouches; a token service issues short-lived credentials#
A workload already runs somewhere the cloud controls: a virtual machine, a container service, a function. The cloud knows which workload that is, because it started it. So instead of the workload presenting a key, the platform attaches an identity to the workload, and code inside it asks a local endpoint for a credential. The credential comes back with an expiry measured in minutes or hours, and the platform refreshes it.
A tiny example: the assessment service starts on a runtime configured with the identity "assessment-service". Its SDK asks the runtime for credentials, receives a temporary set valid for an hour, and uses them to read one secret. Nothing in the deployment, the image or the environment contains a key.
Plain English. The cloud already knows which program it is running. It gives that program a badge that expires soon and renews it automatically. Nobody ever writes the badge down.
Before AI. On an application server, a datasource bound by JNDI let code use a database without seeing the password; a Kerberos keytab let a service log in as a service account. Cloud workload identity takes the same idea further: there is no keytab file either, because the platform itself is the authority that vouches. The agent changes nothing here; the agent application is one more workload that needs its own identity.
Product (AWS IAM, as documented on 2026-11-18): the IAM best practices include "Require workloads to use temporary credentials with IAM roles to access AWS", and "Where possible, we recommend relying on temporary credentials instead of creating long-term credentials such as access keys." Product (Google Cloud IAM): a service account key is a credential, and holding one is "similar to knowing a user's password"; the advice is to "avoid user-managed service account keys" and use attached service accounts or Workload Identity Federation. Product (Microsoft Entra, managed identities): "Applications can use managed identities to obtain Microsoft Entra tokens without having to manage any credentials."
The smallest primitive: a role, two policies and a temporary credential#
AWS makes the parts visible, so start there. An IAM role is an identity with no password or key of its own; principals that the role trusts can take it on and receive temporary credentials. Product (AWS STS, as documented on 2026-11-18): a role has two policies: "a role trust policy that specifies who can assume the role, and a permissions policy that specifies what can be done with the role." STS (Security Token Service) is the service that issues those temporary credentials. AssumeRole "Returns a set of temporary security credentials", an access key id, a secret access key and a security token; DurationSeconds runs from 900 seconds to the role's maximum session duration, default 3600.
The permissions side, for the assessment service, is one statement on one secret. Documented policy shape, with placeholders; not run here:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "secretsmanager:GetSecretValue",
"Resource": "ARN-OF-THE-ROOF-VENDOR-SECRET"
}
]
}
On AWS compute, code never calls AssumeRole for this. Product (AWS IAM): on services such as EC2 and Lambda, "AWS delivers the temporary credentials of an IAM role to that compute resource", and the SDKs discover them. On a virtual machine the delivery path is the instance metadata service.
A metadata service is an HTTP endpoint inside the machine, reachable only from it, that tells code about the instance and hands out the attached identity's credentials. Because any process that can make a local HTTP request can reach it, it is also what an attacker tries to reach through a server-side request forgery (SSRF): a bug that makes your server fetch a URL the attacker chooses. Product (Amazon EC2 IMDS, as documented on 2026-11-18): IMDSv2 is session-oriented. The caller first sends a PUT to get a session token, then sends that token on each read; when token use is required, requests without it get 401 - Unauthorized. The documented exchange, shape only (the credentials path is left out; read it on AWS's page):
PUT /latest/api/token HTTP/1.1
Host: 169.254.169.254
X-aws-ec2-metadata-token-ttl-seconds: 21600
200 OK
<session token>
GET /latest/meta-data/ HTTP/1.1
Host: 169.254.169.254
X-aws-ec2-metadata-token: <session token>
Three documented details make that harder to abuse through SSRF: "PUT requests are rejected if they contain an X-Forwarded-For header", the response hop limit defaults to 1, and AWS links IMDSv2 to defense against "open firewalls, reverse proxies, and SSRF vulnerabilities". The documentation read here says both versions are allowed "By default"; it does not say whether new instance types default to IMDSv2 only, so require IMDSv2 explicitly.
The same shape on three clouds#
Google Cloud. A service account is an identity for a workload rather than a person. Code on Google compute runs as an attached service account and gets short-lived tokens from the platform. The risk Google's documentation spends most words on is the downloadable key: leaked keys matter because "service accounts are not subject to any additional sign-in verifications". Product (Google Cloud, as documented on 2026-11-18): the organization policy constraints that disable service account key creation and upload are "enforced by default" for organizations created on or after May 3, 2024; leaked keys may be disabled automatically, but "Google Cloud doesn't guarantee that it will detect leaked keys." Google's documentation now lives under docs.cloud.google.com; the old cloud.google.com/... paths answer with a permanent redirect.
Microsoft Azure. A managed identity is an Entra identity that Azure creates and manages for a resource. Product (Microsoft Entra, as documented on 2026-11-18): a system-assigned identity is a service principal "of a special type", tied to the resource's lifecycle, and "only that Azure resource can use this identity to request tokens"; a user-assigned identity is a standalone resource that "can be used by multiple resources" and is "the recommended managed identity type for Microsoft services". Code obtains tokens through MSAL or Azure.Identity, and "This token acquisition doesn't require any secrets".
Workloads outside the cloud. A pipeline, an on-premises service or a workload in another cloud is not started by the cloud that holds the resource, so that cloud cannot vouch for it directly. Workload identity federation closes the gap: the outside workload gets a signed token from its own identity provider, and the cloud's token service exchanges it for a short-lived cloud credential after checking issuer, audience and subject. Product (Google Cloud): the Security Token Service "verifies the identity on the credential, and then returns a federated token in exchange", following OAuth 2.0 token exchange; pools and providers describe which external identities are trusted, attribute mappings such as google.subject=assertion.sub name them, and a CEL attribute condition restricts them. Product (Entra workload identity federation): a user-assigned managed identity or app registration trusts tokens from an external identity provider; the federated credential's issuer, subject and audience "must case-sensitively match" the token, and the flow "does not support tokens issued by Microsoft Entra ID". Product (AWS STS): AssumeRoleWithWebIdentity "does not require the use of AWS security credentials"; the caller presents an OAuth 2.0 access token or OIDC ID token, and the role "must trust the identity provider that is associated with the identity token".
Diagram: Reading the vendor key with no stored cloud key · inside the cloud and outside it
Top lane: the assessment service runs on a cloud runtime. The platform attached an identity at deployment; the metadata endpoint or runtime hands the SDK a temporary credential. Bottom lane: a workload outside the cloud presents a token from its own identity provider, and the cloud's token service exchanges it after checking issuer, audience and subject. Both lanes meet at the secrets manager, which checks the identity's permission on one secret. The business decision on SUB-1004 is separate: the PDP allows the request before the key is used.
- Inside the cloud · attached identity
- runtime starts the assessment service: The platform knows which workload it started and attaches its identity: an AWS role, a Google service account or an Azure managed identity.
- metadata endpoint returns a credential: Code asks a local endpoint for temporary credentials. On EC2 that is IMDSv2: a PUT for a session token, then reads with it.
- Outside the cloud · federation
- workload's own identity provider: A pipeline, an on-premises service or another cloud gets a signed OIDC token from its own provider.
- cloud token service exchanges it: The cloud verifies the signature and the configured conditions, then issues a short-lived cloud credential.
- Then, on every read
- secrets manager checks read on one secret: The secrets manager allows the read only if the identity holds permission on that secret.
- PDP allows SUB-1004 before the key is used: The cloud identity proves which workload asks. Whether this caller may see roof data for this submission is decided on the record.
The diagram follows one read of the vendor key on each path. Inside the cloud, the runtime vouches and the metadata endpoint returns the credential. Outside, the workload's own identity provider vouches and the cloud's token service exchanges that token. In both, the secrets manager checks the identity's permission on one secret, and in both, the assessment service still asks the policy decision point about the submission before using the key.
The insurance example on a cloud runtime#
Step 4 of the insurance flow says the vendor key stays in a secrets manager or connector service, never in model-visible context. The cloud version of that step has four parts, each with a different owner:
| Part | What it is | Who decides | Fails how |
|---|---|---|---|
| Workload identity | The assessment service's cloud identity (role, service account or managed identity) | The platform team, at deployment | Shared identity: another service can read the vendor key |
| Permission on the secret | Read on the one secret roof-vendor, nothing else | The secrets manager, on each read | Wildcard resource: every secret readable |
| The vendor key | The roof data provider's API key, held in the secrets manager | The assessment service uses it, never returns it | Key copied into config, prompt or trace |
| Business authorization | May this caller read roof data for SUB-1004? | The policy decision point, before the vendor call | Cloud identity mistaken for business permission |
The last row is the one this site exists for. The cloud identity proves that the code asking for the vendor key is the assessment service; it says nothing about whether the underwriting agent, acting for underwriter u-uw-w1, may see roof data for SUB-1004 today. In the example that decision is rule R-AZ-04 or R-AZ-05 in the policy decision point, made before SecretsStore.call_vendor runs (the run and its output are on API keys). A valid token is not a permission, and a valid cloud credential is not one either.
The LLM gateway is the same pattern with a different secret. When the model runs on a cloud platform, the gateway's own cloud identity is the credential. Product (Amazon Bedrock, as documented on 2026-11-18): an invocation "is authorized like any other bedrock:InvokeModel request, against the policies that apply to the principal making it." Which models a workload may call, and who sees prompts and bills, is the subject of Model providers.
Where each cloud attaches permissions#
The three clouds answer "may this identity read this secret?" from different places, and reviews go wrong when a team checks only one place. Product (AWS IAM, as documented on 2026-11-18): identity-based policies "are attached to an IAM user, group, or role", resource-based policies "are attached to a resource" such as an S3 bucket or a KMS key, and "Resource-based policies are inline only, not managed"; within one account, AWS checks every policy for a Deny first, and an allow in either kind is enough; across accounts, both sides must allow. Product (Google Cloud IAM): "An allow policy is a YAML or JSON object that's attached to a Google Cloud resource", and a policy set on a container "also applies to all resources in that container"; separate deny policies "prevent principals from using certain permissions, even if they're granted a role with the permission." Product (Azure RBAC): "A role assignment consists of three elements: security principal, role definition, and scope", the scope is a management group, subscription, resource group or resource, the model is additive, and a matching deny assignment blocks access.
| Question | AWS | Google Cloud | Microsoft Azure |
|---|---|---|---|
| The workload's identity | IAM role, assumed for temporary credentials | Service account, attached or impersonated | Managed identity (system- or user-assigned) |
| Permissions on the identity | Identity-based policies on the role | Not attached to the identity; granted on resources | Role assignments name the identity as principal |
| Permissions on the resource | Resource-based policies (inline), on services that support them | Allow policy on the resource, inherited from project, folder, organization | Role assignment at resource scope (or above, inherited) |
| Who may become the identity | Role trust policy | Attachment to a workload; for federation, the Workload Identity User role plus attribute conditions | System-assigned: that resource only; federated credentials for outside workloads |
| Explicit deny | A Deny in any policy wins; SCPs and RCPs grant nothing | Deny policies | Deny assignments |
| Read one secret | Allow secretsmanager:GetSecretValue on the secret's ARN, or a resource policy on the secret | roles/secretmanager.secretAccessor granted on the one secret | Key Vault Secrets User; Microsoft recommends vault scope, one vault per application per environment |
The table is a neutral map, not a ranking. Read it for the review question each column raises. On AWS, a secret may be readable because of the role's policy or because of a policy on the secret itself, so a review reads both. On Google Cloud, a permission granted on the project reaches every secret below it, so a project-level accessor grant is broader than it looks. On Azure, Microsoft's Key Vault guidance prefers one vault per application and environment with roles at vault scope, and assigning roles on individual secrets "is not recommended" except in named cases; the isolation unit is the vault. Product (Google Secret Manager, as documented on 2026-11-18): the accessor role "Allows accessing the payload of secrets" and can be granted on a single secret, with the advice to "apply permissions at the lowest level in the resource hierarchy."
CI to cloud: OIDC federation instead of stored keys#
Pipelines were the classic home of long-lived cloud keys, and they are now the classic case for federation. CI OIDC federation means the CI system issues a signed OIDC token for each job, and the cloud exchanges it for short-lived credentials only when the token's claims match conditions the cloud account defined. Product (GitHub Actions, as documented on 2026-11-18): the workflow or job must grant id-token: write, without which "the OIDC JWT ID token cannot be requested"; the issuer is https://token.actions.githubusercontent.com; and the cloud's trust definition "must define at least one condition", otherwise untrusted repositories could request access tokens.
The subject claim is what the condition usually matches. Default formats include repo:ORG-NAME/REPO-NAME:ref:refs/heads/BRANCH-NAME and repo:ORG-NAME/REPO-NAME:environment:ENVIRONMENT-NAME. Product (GitHub, as documented on 2026-11-18): repositories created after July 15, 2026 use "an immutable default subject format that includes both the owner ID and repository ID", for example repo:octo-org@123456/octo-repo@456789:ref:refs/heads/main; renamed or transferred repositories switch too, older repositories can opt in, and the rollout does not include GitHub Enterprise Server. The reason is that a name can be reused after a rename or deletion, while the numeric ids cannot. Google's federation guide gives the same advice for its conditions: use the numeric *_id fields, "which are unique and can't be reused".
A documented AWS trust policy for one repository and branch, with placeholders (GitHub's AWS guide, read 2026-11-18; not run here):
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Federated": "arn:aws:iam::ACCOUNT-ID:oidc-provider/token.actions.githubusercontent.com"},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"token.actions.githubusercontent.com:aud": "sts.amazonaws.com",
"token.actions.githubusercontent.com:sub": "repo:octo-org/octo-repo:ref:refs/heads/octo-branch"
}
}
}
]
}
And the workflow side, as GitHub documents it:
permissions:
id-token: write # required for requesting the JWT
contents: read # required for actions/checkout
Diagram: CI to cloud with OIDC federation · no stored key in the pipeline
Time runs down the page. The job, granted id-token: write, asks GitHub's OIDC provider for a token. The token names the repository and environment in its sub claim, and its audience is the cloud's token service. The cloud's STS verifies the signature against the issuer's keys and the trust policy's conditions, then returns credentials for one role that expire. A token from another repository or branch fails the sub condition. Nothing is stored.
- Deploy job to GitHub OIDC provider: request ID token (id-token: write). Without id-token: write the token cannot be requested, as GitHub documents.
- GitHub OIDC provider to Deploy job: signed JWT · iss, aud, sub. The token names the repository and the ref or environment. Repositories created after 15 July 2026 get an immutable sub with owner and repository ids.
- Deploy job to Cloud token service: AssumeRoleWithWebIdentity + token. The job presents the token; no cloud key is involved.
- Cloud token service to Deploy job: temporary credentials · expire. Issued only if every condition matches. Default duration one hour, as documented.
- Deploy job to Cloud APIs: deploy with temporary credentials. The role's permissions policy limits what the deploy can do.
The sequence shows who checks what. GitHub's OIDC provider signs a token that names the repository, branch or environment; the cloud's token service verifies the signature and the conditions; the job receives credentials for one role that expire within the session limit. No step stores a key, and a token from another repository fails the sub condition.
In a coding agent. The coding agent opens a pull request; it never holds the deployment role. A person with merge rights merges; the deployment job, bound to a protected environment, gets a federated token whose sub names that environment, and only that subject may assume the deploy role. The agent's sandbox has no cloud credential at all. Coding agents owns this case in depth, and https://diff-to-deploy.sammuthu.com covers the shipping workflow.
Secrets managers, dynamic secrets and keyless rotation#
Federation removes the cloud key. It does not remove every secret: the roof vendor still issues an API key, and a database still wants a password. A secrets manager is a service that stores such secrets, returns them only to identities with permission, records each read, and helps rotate them.
Rotation differs by product. Product (AWS Secrets Manager, as documented on 2026-11-18): managed rotation ("doesn't use a Lambda function"), managed external secrets rotation for partners, and rotation by a Lambda function for other secrets; rotation updates "the credentials in both the secret and the database or service." Product (Google Secret Manager): it does not rotate values itself; it sends a SECRET_ROTATE message to Pub/Sub topics on schedule, and your subscriber creates the new version.
A stronger form avoids a shared standing secret altogether. Product (HashiCorp Vault, major version 2, as documented on 2026-11-18): the database secrets engine "generates database credentials dynamically based on configured roles", revoked when their lease ends; "By default, TTL is 1 hour and max TTL is 24 hours". Vault itself needs to know who is asking, and its documented answers are the same federation idea: the jwt auth method validates OIDC or JWT tokens with bound_audiences that "must exactly match", and the Kubernetes auth method checks a service account token through the TokenReview API.
"Keyless rotation" is the name for the end state: the credential that reaches the cloud is minted per session and expires on its own, so there is nothing to rotate by hand. The remaining rotations are the ones a vendor forces on you (the roof key), and those run through the secrets manager with an overlap, as API keys describes. Signing secrets for webhooks rotate in a different way, with two valid secrets during the change; that is on External SaaS and webhooks.
What this is not. SPIFFE identities between services and mTLS are on Workload identity. Private endpoints and egress control around these services are on Private environments. Rotation and revocation as operations, under pressure, are on Operations.
Failure mode: the key in the pipeline#
Follow the ticket's design as a labelled mistake. The access key goes into a CI variable so the pipeline can deploy, and into the runtime's environment so the service can read the vendor secret. Product (GitHub Actions secure use, as documented on 2026-11-18): "Any user with write access to your repository has read access to all secrets configured in your repository." Every contributor, and every workflow change they can make, can now reach the key. The key has no expiry, and its permissions grew over two years because each new need was added to the one identity that already worked.
When the key leaks, through a log line or a compromised dependency in the pipeline, the attacker holds the assessment service's cloud identity from anywhere, with no sign-in step. Revoking it breaks the pipeline and the service at once, which is exactly why nobody revoked it during the review. The fix is the design above: the runtime's attached identity for the service, federation for the pipeline, one secret per permission, and no key to revoke.
Architecture choice#
| Situation | Simplest credible option | Grow when | Alternatives |
|---|---|---|---|
| Service on the same cloud as its resources | Attached identity (role, service account, managed identity) with one-resource permissions | Several services share an identity | Separate identity per service and environment |
| CI deploying to a cloud | OIDC federation with sub bound to a protected environment | Many repositories deploy | Per-environment roles; reusable workflows |
| Workload in another cloud or on premises | Workload identity federation from its own identity provider | No identity provider exists there | Certificate-based federation (IAM Roles Anywhere, Google X.509 provider) |
| Vendor offers only an API key | Key in a secrets manager, read by one identity | Vendor offers OAuth or signed requests | See External SaaS and webhooks |
| Database credentials | Managed rotation in the secrets manager | Many short-lived jobs need access | Dynamic credentials from Vault; Vault static roles with scheduled rotation |
This site's recommendation: one cloud identity per workload and per environment; permissions written against single resources; federation for everything that runs outside the cloud; no user-managed keys; and the business decision in the service, on the record, whatever the cloud identity is.
Security notes#
Security note. Require IMDSv2 on every instance, and keep the hop limit at its default of 1 unless a container genuinely needs more.
Security note. A federation trust with no condition, or a sub condition with a wildcard over an organization, lets any matching repository assume the role. Bind it to the repository and the protected environment.
Production pitfall. GitHub, GitLab SaaS and HCP Terraform use one issuer URL for all their customers, as Google's federation guide notes. A trust that checks only the issuer trusts every customer of that CI service; add a repository owner condition, by numeric id.
Security note. Session policies and permissions boundaries can only narrow a role; AWS documents that session policies cannot "grant more permissions" and that SCPs and RCPs grant none. Use them as ceilings, not as grants.
Monday checklist#
- List every long-lived cloud key (AWS access keys, Google service account keys, Azure client secrets) with owner and last use; plan each one's replacement by an attached or federated identity.
- Check that no two services share a cloud identity, and that each identity can read only its own secrets.
- Require IMDSv2 on all instances; search application code for user-controlled URLs that the server fetches.
- Review every federation trust: issuer, audience,
subor attribute condition, numeric ids where offered. - Confirm the GitHub
id-token: writepermission appears only in jobs that deploy, and those jobs use protected environments. - Check the Google organization policy for service account key creation and upload, and inventory keys that predate it.
Exercises#
- The assessment service's role allows
secretsmanager:GetSecretValueon*. The secret has no resource policy. Who can read the roof vendor key?
AnswerThe service, and every secret is exposed to it
Only identities whose policies allow it, but this role can read every secret in the account. Narrow the resource to the one secret's ARN, and review other roles with the same wildcard.
- A federation trust for GitHub matches
repo:octo-org/*. A contributor opens a pull request from a fork. Can the fork's workflow deploy?
AnswerBind to an environment instead
The wildcard accepts any ref of any repository in the organization, including pull_request subjects, depending on how workflows run. Bind the sub to environment:production of one repository, with required reviewers on that environment.
- Does the assessment service's cloud identity let it decide which underwriter may see roof data?
AnswerNo: that is the policy decision point's job
The cloud identity proves which workload is asking for the secret. Whether the agent acting for u-uw-w1 may read the assessment for SUB-1004 is a business decision on the record, made before the key is used.
Advanced perspective#
Role chaining, session limits and who did itTemporary credentials still need an audit trail back to a person or pipeline
Temporary credentials solve leakage but can blur attribution: CloudTrail shows the role, not the job that took it on. AWS documents three tools for that. RoleSessionName appears in the assumed-role ARN and in CloudTrail; SourceIdentity "persists across chained role sessions" and can be required with sts:SourceIdentity; and the web identity response includes SubjectFromWebIdentityToken, the token's sub, which lands in CloudTrail (so keep personal data out of it). Set a session name that carries the pipeline run or the workload instance.
Chaining (a role assuming another role) has a documented limit: "Role chaining limits your AWS CLI or AWS API role session to a maximum of one hour." Designs that hop through several accounts must refresh within that hour. Session policies passed at assume time can only narrow: "The resulting session's permissions are the intersection of the role's identity-based policy and the session policies."
Third parties and the confused deputyExternalId, source conditions and cross-account trust
When a vendor's service needs to act in your cloud account (for example to deliver roof reports into a bucket), the vendor assumes a role you created. The risk is a confused deputy: another customer of the same vendor tricks the vendor into using your role. AWS documents ExternalId for this: the trusting account requires an id so "only someone with the ID can assume the role, rather than everyone in the account". For AWS services acting on your resources, Secrets Manager's documentation recommends the aws:SourceArn and aws:SourceAccount condition keys to avoid the same problem.
Cross-account access on AWS needs both sides: the requester's identity policy and the resource's policy must allow. Google's equivalent is a grant on the resource to a principal from another project or a federated principalSet; Azure's is a role assignment for a service principal from another tenant or a federated credential. In every case, add the vendor to the third-party access review on External SaaS and webhooks.
Federation pitfalls in practiceShared issuers, mutable names, mapping mistakes
Three mistakes recur. First, trusting an issuer that many tenants share without a tenant condition: Google's guide warns that GitHub, GitLab SaaS and HCP Terraform use a single issuer URL across all organizations and shows a condition such as assertion.repository_owner=='ORGANIZATION'; numeric owner ids are stronger than names. Second, matching on names that can be reused: GitHub's immutable sub for repositories created after 15 July 2026 removes that risk by default for new repositories; older ones keep the name-based form unless they opt in. Third, mapping too little: Google says that at minimum google.subject should map to assertion.sub, and an attribute condition should restrict which identities in a pool may act at all.
Entra adds two documented limits worth knowing before design: federated credentials must match issuer, subject and audience case-sensitively, and only the first 100 signing keys from an external identity provider are stored. Managed identities used as federated credentials on an app have a limit of 20.
Is secret zero really gone?Trust moved to the platform, not removed
Workload identity does not remove trust; it moves it to the platform's control plane and to whoever can change identity attachments, trust policies and federation conditions. An administrator who can attach the assessment service's identity to a new workload, or add a sub to the deploy role's trust, can read the vendor key without ever seeing a credential. Those administrative permissions become the new crown jewels.
So the governance work shifts: review who can create roles and trust policies, who can attach service accounts to workloads, who can grant the Workload Identity User role, who can assign managed identities, and who can edit federation conditions. On Azure the Key Vault guidance makes the same point about its own control plane: a user with Contributor on a vault "can grant themselves access to the data plane by setting a Key Vault access policy". Treat those permissions as privileged access (see Privileged access).
In one breath#
On every large cloud, a workload can reach cloud APIs with no stored key: the platform attaches an identity (an AWS role, a Google service account, an Azure managed identity), a local endpoint or token service hands out credentials that expire, and workloads outside the cloud, including CI, exchange their own identity provider's token through federation. Permissions sit on the identity, on the resource, or both, depending on the cloud, and a review reads every place. The cloud identity proves which workload is asking for the vendor key; it never decides which underwriter may see which submission.
The assessment service now reads the roof vendor key with its own cloud identity, and nothing in its deployment can leak a cloud credential. But the vendor relationship runs in both directions: the assessment service calls the vendor, and the vendor calls back when a roof report is ready. An inbound request from the internet claiming to be the vendor needs its own proof, and an outbound call to the vendor needs its own credential and limits. Those calls across company lines are the subject of External SaaS and webhooks.