AWS Identity and Access Management
AWS Identity and Access Management (IAM) controls who can do what across an AWS account. It defines users, roles, and policies that grant or deny specific API actions on specific resources, forming the authorization layer for every AWS service.
itCloud computing | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — AWS Identity and Access Management
IAM controls who can make which AWS request under which conditions. That is the whole thing. Every console click, CLI command, SDK call, and service-to-service operation is an API request, and IAM is the authorization layer that decides whether to accept it.
Before IAM existed, every API call used root credentials. That was the problem. IAM replaced it with identities — users, roles, and temporary sessions — and policies that describe what each identity may do. The core evaluation model has not changed since 2011: a request is implicitly denied unless an applicable policy produces an allow, and any applicable explicit deny overrides that allow.
The part that surprises most people is how many policy layers participate in that decision. An identity-based policy grants permissions to a user or role. A resource-based policy grants permissions to a named principal on a resource. A permissions boundary caps what identity-based policies can grant. A session policy narrows one temporary session. Service control policies set organization-level guardrails. Resource control policies do the same for resources. A single API call can be evaluated against all six layers, and the interaction is not always intuitive.
The mental model that survives first contact with production is: follow one request. A principal uses credentials to ask an AWS service to perform an action on a resource. AWS builds a request context — the principal, the action, the resource, the time, the network path, the tags, the Region — and evaluates every policy that applies. The result is allow or deny. When access surprises you, the answer is never in one policy document. It is in the interaction between the layers, and the debugging path starts with identifying which layer caused the denial.
Least privilege is not a policy you write once. It is a process: define the task, write the narrowest evidence-backed policy, validate before deployment, test both allowed and denied paths, observe real activity through CloudTrail, review Access Analyzer findings, and remove unused permissions. The first policy you write will be too broad. That is expected, not a failure. The question is whether you close the gap before or after something goes wrong.
The three things worth remembering: temporary credentials are the default design target for both people and workloads; explicit deny always wins; and IAM tells you how access should be decided while CloudTrail gives you evidence about requests that actually occurred. You need both for sound operations.
Start with the request model in the reference tab if you want the evaluation logic in detail. The cheatsheet is the fastest way to identify which policy type does which job. And if you are debugging an unexpected deny, the field notes describe the policy-layer interactions that most troubleshooting guides skip.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html
Supports
- IAM controls authentication and authorization for AWS resources
- AWS evaluates permissions when a principal makes a request
- IAM is eventually consistent and policy changes can take time to propagate
- https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html
Supports
- Human users should use federation and temporary credentials
- Workloads should use temporary credentials through IAM roles
- Least privilege, multi-factor authentication, conditions, Access Analyzer, credential review, and permission guardrails are recommended practices
- https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html
Supports
- An IAM role is an assumable identity without standard long-term credentials
- Assuming a role produces temporary credentials for a role session
- Roles support delegation, cross-account access, workloads, and AWS services
- IAM users are reserved for use cases that federation and roles do not support
- https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html
Supports
- An IAM user group collects IAM users and can receive identity-based policies
- An IAM user group is not a principal and cannot be used as the Principal in a resource-based policy
- https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html
Supports
- AWS Security Token Service issues temporary security credentials
- Temporary credentials expire and support roles, federation, delegation, and cross-account access
- Temporary credentials avoid distributing long-term credentials to supported applications
- https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html
Supports
- IAM Identity Center connects workforce users to AWS accounts and applications
- An organization instance centrally assigns workforce permissions across multiple AWS accounts
- IAM Identity Center can connect an external identity provider or manage users directly
- https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
Supports
- Policies define permissions and most use JSON documents
- Identity-based policies grant permissions to identities and resource-based policies grant permissions to named principals
- Permissions boundaries, session policies, SCPs, RCPs, and VPC endpoint policies have distinct limiting roles
- A role trust policy is a common resource-based policy
- https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html
Supports
- IAM policy statements use elements including Effect, Principal, Action, Resource, and Condition
- Policy element support varies by AWS service and action
- IAM and Access Analyzer provide policy validation capabilities
- https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html
Supports
- Policy conditions compare request-context keys with values using condition operators
- Context-key and operator support varies by service, action, resource, and data type
- https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html
Supports
- Identity-based and resource-based policies can combine permissions for same-account requests
- Permissions boundaries and organization policies restrict effective permissions
- An explicit deny overrides an allow
- https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic_policy-eval-denyallow.html
Supports
- Requests are implicitly denied unless the evaluation produces an allow
- Any applicable explicit deny produces a final denial
- Resource-based policy behavior depends on the exact principal type named in the policy
- Session policies and permissions boundaries participate in applicable request evaluation
- https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html
Supports
- Cross-account access requires authorization in both the trusted and trusting accounts
- A role trust policy permits external principals to assume the role
- The role permissions policy controls what resulting temporary credentials can access
- https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html
Supports
- A permissions boundary caps permissions for an IAM user or role
- A permissions boundary does not grant permissions on its own
- Effective permissions depend on the intersection of grants and applicable limits
- https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html
Supports
- SCPs limit maximum available permissions for IAM users and roles in member accounts
- SCPs do not grant permissions
- Identity policies cannot restore actions excluded by an applicable SCP
- https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html
Supports
- Access Analyzer can analyze external, internal, and unused access
- Access Analyzer validates policies and supports custom policy checks
- Access Analyzer can generate policies from CloudTrail access activity
- https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-generation.html
Supports
- Access Analyzer generates policy templates from CloudTrail activity
- Policy generation has documented action-level and data-event coverage limits
- Generated policies require review and refinement
- https://docs.aws.amazon.com/IAM/latest/UserGuide/root-user-best-practices.html
Supports
- The root user has complete account access and should be used only for required tasks
- Root credentials, account recovery mechanisms, and multi-factor authentication require protection
- AWS recommends avoiding root access keys and using temporary credentials for routine access
- https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html
Supports
- CloudTrail records actions by users, roles, and AWS services as events
- Events cover console, command-line, software development kit, and API activity
- Event history, trails, and CloudTrail Lake provide different recording and analysis paths
- https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html
Supports
- AWS publishes service-by-service actions, resource types, and condition keys for policy authoring
- Resource-level and condition-key support must be checked for the target service and action
