All chapters
  1. Start hereA valid token is not a permission
  2. Foundations · 1Identity and trust primitives: who is calling, and who checks
  3. Foundations · 2People and identity proofing: accounts, passwords and recovery
  4. Foundations · 3Sessions and browser security: cookies, CSRF, XSS and the BFF
  5. Foundations · 4Authenticators and MFA: passwords, passkeys and phishing resistance
  6. Foundations · 5API keys and application credentials: what a key proves
  7. Foundations · 6Tokens: bearer, JWT anatomy, validation and revocation
  8. Foundations · 7OAuth, OpenID Connect and federation: delegation and login
  9. Authorization · 8Authorization from first principles: subject, action, resource, context
  10. Authorization · 9Access control models: RBAC, ABAC, ReBAC and ownership
  11. Authorization · 10The enforcement architecture: PEP, PDP, PIP and PAP
  12. Authorization · 11Policy as code: versions, tests, engines and decision logs
  13. Authorization · 12Tenant and data isolation: one platform, many brokerages
  14. Authorization · 13Identity governance and lifecycle: joiner, mover, leaver
  15. Authorization · 14Privileged access: standing rights, just-in-time elevation and break-glass
  16. Workloads · 15TLS, PKI and certificates: proving a host, and a client
  17. Workloads · 16Workload and service identity: SPIFFE, mTLS and caller allowlists
  18. Workloads · 17API gateways and zero trust: the edge checks, the service decides
  19. Workloads · 18Event-driven identity: Kafka principals, ACLs and replay
  20. Workloads · 19Cloud IAM and secretless deployment: roles, federation and no stored keys
  21. Workloads · 20External SaaS, webhooks and trust: calls that cross company lines
  22. Workloads · 21Private controlled environments: what private networking does and does not secure
  23. AI-native · 22Authenticating to model providers: keys, gateways and cloud IAM
  24. AI-native · 23MCP identity and authorization: discovery is not permission
  25. AI-native · 24RAG and retrieval authorization: only what this caller may read
  26. AI-native · 25Agents as principals and delegates: whose authority is this?
  27. AI-native · 26Agent-to-agent trust: identity, capabilities and forwarded authority
  28. AI-native · 27Coding agents and CI: repository scopes, OIDC and no production keys
  29. Operations · 28Auditing and observability of access: decisions you can prove later
  30. Operations · 29Threat modeling and testing: the negative tests that prove access control
  31. Operations · 30Operational lifecycles: rotation, revocation and outages
  32. Reference · 31Standards, frameworks and products: what each one is, and what it is not
  33. Reference · 32Architecture decision playbooks: choosing an auth strategy
  34. ReferenceGlossary
  35. AboutAbout this site and its sources
Workloads · 19

Cloud IAM and secretless deployment: roles, federation and no stored keys

AWS IAM and STS, Google Cloud service accounts and workload identity federation, Azure managed identities with Entra, CI federation through OIDC, the metadata service, secrets managers and keyless rotation, compared across clouds.

You will understand
How a workload gets cloud permissions with no stored key: the platform vouches for it, and a token service hands out credentials that expire.
You will be able to compare
AWS roles, Google service accounts and Azure managed identities, and where each cloud attaches permissions: to the identity or to the resource.
You will keep apart
The workload's cloud identity, the secret it reads (the roof vendor key) and the business decision the service still makes on the record.

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.

  1. Inside the cloud · attached identity
    1. 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.
    2. 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.
  2. Outside the cloud · federation
    1. workload's own identity provider: A pipeline, an on-premises service or another cloud gets a signed OIDC token from its own provider.
    2. cloud token service exchanges it: The cloud verifies the signature and the configured conditions, then issues a short-lived cloud credential.
  3. Then, on every read
    1. secrets manager checks read on one secret: The secrets manager allows the read only if the identity holds permission on that secret.
    2. 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:

PartWhat it isWho decidesFails how
Workload identityThe assessment service's cloud identity (role, service account or managed identity)The platform team, at deploymentShared identity: another service can read the vendor key
Permission on the secretRead on the one secret roof-vendor, nothing elseThe secrets manager, on each readWildcard resource: every secret readable
The vendor keyThe roof data provider's API key, held in the secrets managerThe assessment service uses it, never returns itKey copied into config, prompt or trace
Business authorizationMay this caller read roof data for SUB-1004?The policy decision point, before the vendor callCloud 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.

QuestionAWSGoogle CloudMicrosoft Azure
The workload's identityIAM role, assumed for temporary credentialsService account, attached or impersonatedManaged identity (system- or user-assigned)
Permissions on the identityIdentity-based policies on the roleNot attached to the identity; granted on resourcesRole assignments name the identity as principal
Permissions on the resourceResource-based policies (inline), on services that support themAllow policy on the resource, inherited from project, folder, organizationRole assignment at resource scope (or above, inherited)
Who may become the identityRole trust policyAttachment to a workload; for federation, the Workload Identity User role plus attribute conditionsSystem-assigned: that resource only; federated credentials for outside workloads
Explicit denyA Deny in any policy wins; SCPs and RCPs grant nothingDeny policiesDeny assignments
Read one secretAllow secretsmanager:GetSecretValue on the secret's ARN, or a resource policy on the secretroles/secretmanager.secretAccessor granted on the one secretKey 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.

  1. Deploy job to GitHub OIDC provider: request ID token (id-token: write). Without id-token: write the token cannot be requested, as GitHub documents.
  2. 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.
  3. Deploy job to Cloud token service: AssumeRoleWithWebIdentity + token. The job presents the token; no cloud key is involved.
  4. Cloud token service to Deploy job: temporary credentials · expire. Issued only if every condition matches. Default duration one hour, as documented.
  5. 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#

SituationSimplest credible optionGrow whenAlternatives
Service on the same cloud as its resourcesAttached identity (role, service account, managed identity) with one-resource permissionsSeveral services share an identitySeparate identity per service and environment
CI deploying to a cloudOIDC federation with sub bound to a protected environmentMany repositories deployPer-environment roles; reusable workflows
Workload in another cloud or on premisesWorkload identity federation from its own identity providerNo identity provider exists thereCertificate-based federation (IAM Roles Anywhere, Google X.509 provider)
Vendor offers only an API keyKey in a secrets manager, read by one identityVendor offers OAuth or signed requestsSee External SaaS and webhooks
Database credentialsManaged rotation in the secrets managerMany short-lived jobs need accessDynamic 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#

  1. 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.
  2. Check that no two services share a cloud identity, and that each identity can read only its own secrets.
  3. Require IMDSv2 on all instances; search application code for user-controlled URLs that the server fetches.
  4. Review every federation trust: issuer, audience, sub or attribute condition, numeric ids where offered.
  5. Confirm the GitHub id-token: write permission appears only in jobs that deploy, and those jobs use protected environments.
  6. Check the Google organization policy for service account key creation and upload, and inventory keys that predate it.

Exercises#

  1. The assessment service's role allows secretsmanager:GetSecretValue on *. 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.

  1. 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.

  1. 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.