AWS Builder Center
Designing Secure Workload Identity on AWS Without Long-Lived Credentials

Designing Secure Workload Identity on AWS Without Long-Lived Credentials

Learn how to design workload identity on AWS using IAM roles, temporary credentials, OIDC federation, Amazon EKS Pod Identity, and IAM Roles Anywhere across AWS-native, Kubernetes, CI/CD, hybrid, and multi-cloud environments.

Cloud Security Engineer | AWS User Group Leader | AWS Community Builder
Modern workloads rarely operate within a single security boundary.
An application may run on Amazon EC2, AWS Lambda, Amazon ECS, Amazon EKS, a CI/CD platform, an on-premises server, or another cloud provider while still requiring access to AWS resources.
In this environment, the security question should no longer be:
Where should I store the AWS access key?
A better question is:
How can the workload prove its identity and obtain short-lived AWS credentials only when required?
This is the foundation of workload identity.
A well-designed workload identity architecture replaces persistent credentials with:
  • A verifiable workload identity
  • An explicit trust relationship
  • Short-lived credentials
  • Least-privilege authorization
  • Auditable access



1. Workforce Identity and Workload Identity

The first architectural distinction is between human identity and machine identity.

Workforce identity

Workforce identities represent people such as developers, administrators, platform engineers, and security engineers.
A typical enterprise access path is:
User
|
v
Enterprise Identity Provider
|
v
AWS IAM Identity Center
|
v
AWS Account / Role
|
v
AWS Resources


Workload identity

Workload identities represent software:
Application
CI/CD Pipeline
Kubernetes Pod
Lambda Function
EC2 Workload
External Cloud Workload
On-Premises Application

These workloads should authenticate using their own identities rather than credentials belonging to a human operator.
A generic workload identity flow looks like:
+-------------------+
| Workload |
+---------+---------+
|
| Identity assertion
v
+-------------------+
| Identity Authority|
+---------+---------+
|
| Trust validation
v
+-------------------+
| AWS STS / IAM |
+---------+---------+
|
| Temporary credentials
v
+-------------------+
| IAM Role |
+---------+---------+
|
| Authorization
v
+-------------------+
| AWS Resources |
+-------------------+

This creates an important separation:
Authentication
Who is this workload?

+

Authorization
What can this workload access?

Both must be designed correctly.



2. Prefer AWS-Native Identity for AWS Workloads

When a workload already runs on AWS, use the identity mechanism provided by the compute platform whenever possible.
Workload
Identity mechanism
Amazon EC2
IAM role through an instance profile
AWS Lambda
Execution role
Amazon ECS
Task IAM role
Amazon EKS
EKS Pod Identity or IRSA
The application can then obtain temporary credentials dynamically through the AWS SDK credential provider chain.
Application
|
| AWS SDK
v
Temporary IAM Credentials
|
v
AWS Service

The application therefore does not need credentials such as:
AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY

stored in source code, configuration files, container images, or application secrets.
The security benefit is not simply that the secret is stored somewhere safer.
The better outcome is that there is no long-lived AWS secret to distribute in the first place.



3. Use Workload-Level Identity on Amazon EKS

Kubernetes introduces another important security boundary.
A worker node can host workloads belonging to multiple applications and namespaces. Applications should therefore not rely on broad permissions assigned to the node whenever workload-level identity is available.
A stronger design is:
Amazon EKS
|
+----------+----------+
| |
Namespace A Namespace B
| |
ServiceAccount A ServiceAccount B
| |
IAM Role A IAM Role B
| |
v v
Amazon S3 Amazon DynamoDB

With Amazon EKS Pod Identity, IAM permissions can be associated with Kubernetes service accounts so that Pods receive temporary credentials for the corresponding IAM role.
The security boundary becomes closer to the application:
Cluster
|
Namespace
|
Service Account
|
Workload
|
IAM Role

This is preferable to:
Multiple Applications
|
v
Worker Node Role
|
v
Broad AWS Permissions

because compromising one workload should not automatically expose permissions required by unrelated applications.



4. Federate External Workloads with OIDC

Not every workload runs inside AWS.
Examples include:
  • GitHub Actions
  • External CI/CD platforms
  • Kubernetes clusters outside AWS
  • SaaS automation
  • Applications running in another cloud
For platforms that support OpenID Connect (OIDC), AWS can establish trust with the external identity provider.
A typical flow is:
External Workload
|
| OIDC JWT
v
OIDC Identity Provider
|
v
AWS STS
AssumeRoleWithWebIdentity
|
v
Temporary AWS Credentials
|
v
IAM Role
|
v
AWS Resources

Instead of provisioning an IAM user and distributing an access key, the external workload presents an identity token.
AWS evaluates that identity against the IAM role's trust policy and, when allowed, issues temporary credentials.
The security model changes from:
Access is granted because
the workload possesses a secret.

to:
Access is granted because
the workload can prove an approved identity.

This is especially valuable for CI/CD and multi-cloud architectures.



5. The IAM Trust Policy Is a Security Boundary

Federation by itself does not guarantee strong isolation.
Consider an OIDC provider serving many workloads:
OIDC Provider
|
+--- Project A
|
+--- Project B
|
+--- Project C

If an IAM role trusts the provider too broadly, unrelated workloads may be able to assume the same role.
Trust should therefore be constrained using identity-provider claims whenever possible.
Examples include:
Issuer
Audience
Subject
Organization
Repository
Branch
Environment
Tenant
Project
Namespace
Service Account

Conceptually:
Identity Provider
|
v
Tenant
|
v
Project
|
v
Workload
|
v
IAM Role

The objective is simple:
Trust the smallest workload identity scope that satisfies the requirement.
For example, a deployment role intended for one production pipeline should not implicitly trust every repository or workload managed by the same identity provider.



6. Multi-Cloud Workload Identity

Multi-cloud environments demonstrate why this model matters.
Consider an application running outside AWS that needs to write objects to Amazon S3.
A traditional architecture might look like:
External Cloud
|
v
Secret Manager
|
AWS Access Key
|
v
Amazon S3

This introduces an entire credential-management lifecycle:
Create
|
Distribute
|
Store
|
Protect
|
Rotate
|
Monitor
|
Revoke

With federation:
External Workload Identity
|
| Identity token
v
AWS STS
|
| Temporary credentials
v
IAM Role
|
v
Amazon S3

The trust decision is based on the workload identity rather than possession of a reusable AWS credential.
For multi-cloud environments, this can significantly reduce secret distribution and credential-rotation dependencies.



7. Use IAM Roles Anywhere for PKI-Based Workloads

OIDC is not always available.
Organizations may still operate applications on:
  • On-premises virtual machines
  • Bare-metal servers
  • Private data centers
  • Legacy middleware
  • PKI-enabled infrastructure
For these environments, AWS IAM Roles Anywhere provides another workload identity pattern.
On-Premises Workload
|
| X.509 Certificate
v
Enterprise PKI
|
v
IAM Roles Anywhere
|
v
Temporary AWS Credentials
|
v
IAM Role
|
v
AWS Resources

The main building blocks include:
Trust Anchor
+
Profile
+
IAM Role

The certificate establishes the workload identity, while IAM controls authorization to AWS resources.
This enables external workloads to use temporary AWS credentials without requiring persistent IAM user access keys.



8. Selecting the Appropriate Pattern

A practical decision framework is:
Environment
Recommended starting point
Amazon EC2
Instance profile
AWS Lambda
Execution role
Amazon ECS
Task role
Amazon EKS
EKS Pod Identity or IRSA
GitHub Actions
OIDC federation
External CI/CD
OIDC federation where supported
External Kubernetes
OIDC federation
Workload in another cloud
Workload identity federation
On-premises with PKI
IAM Roles Anywhere
Legacy application without federation support
Long-lived credential as an exception
A useful architectural preference is:
AWS-native workload identity
|
v
OIDC federation
|
v
Certificate-based federation
|
v
Long-lived credentials

This is not an absolute hierarchy. The correct mechanism depends on platform capabilities and the threat model.
However, long-lived credentials should generally be treated as an exception rather than the default design.



9. Federation Does Not Replace Least Privilege

Workload identity primarily addresses:
Authentication
+
Credential lifecycle

It does not automatically solve authorization.
A workload using temporary credentials with:
{
"Effect": "Allow",
"Action": "*",
"Resource": "*"
}

still has excessive privileges.
A stronger architecture combines:
Workload Identity
|
v
Restricted Trust Policy
|
v
Temporary Credentials
|
v
Least-Privilege IAM Policy
|
v
Resource-Level Controls
|
v
Organization Guardrails

Depending on the architecture, additional controls may include:
  • IAM identity policies
  • Resource-based policies
  • Permissions boundaries
  • AWS Organizations service control policies
  • Attribute-based access control
  • VPC endpoint policies
  • IAM Access Analyzer
A security review should therefore evaluate two separate questions:
Who can assume this role?
and
What can the role do after it is assumed?



10. Design Workload Identity for Observability

Identity should also be observable.
Security teams should be able to answer:
Which workload assumed this role?

Which identity was presented?

Why did AWS trust that identity?

What permissions were available?

Which resources were accessed?

Was the activity expected?

Relevant telemetry includes:
  • AWS STS role assumptions
  • Failed role-assumption attempts
  • IAM role trust-policy changes
  • IAM policy modifications
  • OIDC provider changes
  • IAM Roles Anywhere configuration changes
  • Unexpected role sessions
  • Access from unexpected workloads or environments
AWS CloudTrail should form part of the audit foundation, with relevant identity events integrated into centralized security monitoring where appropriate.



11. Common Anti-Patterns

Long-lived access keys embedded in applications

This introduces persistent credentials that must be distributed, protected, rotated, and revoked.

Access keys stored permanently in CI/CD secrets

Moving an access key into a secret store protects storage but does not eliminate the long-lived credential.
Where federation is supported, credentials should be obtained dynamically.

One IAM role shared across unrelated workloads

This increases blast radius and reduces attribution.

Broad OIDC trust policies

Trusting an identity provider is not the same as trusting a specific workload.
Trust policies should validate workload-specific identity context.

Kubernetes workloads inheriting broad node permissions

Infrastructure identity and application identity should be separated.

Federation with excessive IAM permissions

Short-lived credentials reduce credential persistence; they do not make excessive authorization safe.

Human credentials used by applications

Human and machine identities have different lifecycle, governance, and audit requirements and should remain separate.



12. A Practical Security Model

A robust workload identity architecture can be summarized as:
Verifiable Workload Identity
|
v
Explicit Trust Relationship
|
v
Short-Lived Credentials
|
v
Least-Privilege Authorization
|
v
Centralized Auditability

Each layer addresses a different security question:
Layer
Question
Identity
Who is the workload?
Trust
Why should AWS trust it?
Credentials
How long does access remain valid?
Authorization
What can it access?
Observability
Can the activity be attributed and investigated?



Conclusion

Workload identity is fundamentally a trust architecture problem, not a secret-storage problem.
The traditional model is:
Possession of a credential
=
Identity

A stronger model is:
Verifiable workload identity
|
v
Explicit trust
|
v
Temporary credentials
|
v
Least-privilege access

AWS provides several mechanisms for implementing this model across different environments:
  • IAM roles for AWS-native workloads
  • Amazon EKS Pod Identity and IRSA for Kubernetes
  • OIDC federation for external workloads and CI/CD
  • IAM Roles Anywhere for certificate-based workloads outside AWS
The implementation differs by platform, but the architectural objective remains consistent:
Establish a verifiable machine identity, restrict the trust relationship, issue temporary credentials, and authorize only the minimum required access.
When reviewing an architecture that depends on a permanently stored AWS access key, the first question should therefore be:
Can this workload authenticate using its own identity instead?
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article