Configuration Mechanics & Cross-Account Patterns

A companion module to the core service guides — this one deliberately skips "what does the service do" and goes straight to "what does the actual configuration look like." SCS-C02 scenario questions frequently describe a partially-built setup (a trust policy, a route table, a rotation Lambda, an SCP) and ask you to spot the missing piece. That skill requires having seen the literal artifact, not just the concept. Every topic here is also examined through a cross-account lens, since AWS disproportionately tests configuration mechanics at account boundaries.

Cross-cutting — Identity, Data Protection, Infrastructure Protection, Governance Preventive — correct configuration prevents the incident Detective — misconfiguration recognition from a described symptom
4
Secrets Manager rotation lifecycle steps
sub / aud
IRSA trust policy condition keys
RAM
Primary cross-account infra-sharing mechanism
2
Layers needed for cross-account KMS-encrypted secret access

The Core Mental Model — Six Configurations, One Exam Skill

Read the Artifact, Not Just the Label
How to use this module

Each configuration below is written as "what has to be true, in order, before it works" — the same order AWS expects you to mentally check when a scenario says a configuration failed partway through. Cross-Account Patterns then re-synthesizes all six by mechanism, since recognizing WHICH cross-account mechanism a requirement calls for is itself a tested skill, independent of the underlying service.

Core Configuration Mechanics

AD Connector — Prerequisites & Ports High — frequently tested
VPC networkingTwo subnets, two different AZs (redundant proxy ENIs)
ConnectivityVPN or Direct Connect to on-prem AD, low latency required
Service accountDelegated on-prem AD permissions — NOT Domain Admin
DNSAt least 2 DNS servers supplied at setup (normally your DCs)
Ports to DCs53 (DNS), 88 (Kerberos), 123 UDP (NTP), 135+ephemeral (RPC), 389 (LDAP), 445 (SMB), 464 (Kerberos pw change), 3268/3269 (Global Catalog)
  • Structural limit: AD Connector is a 1:1 proxy to a SINGLE domain — no transitive trust. Multiple domains/forests in the requirement automatically disqualifies it.
  • "Password resets work inconsistently, but login succeeds" → check port 464 specifically, not general connectivity.
  • "Login is slow/times out" → check VPN/DX latency, not IAM or AD Connector configuration — it does zero caching, every request is a live round trip.
AWS Managed Microsoft AD — Trust Relationship Setup
  1. Deploy AWS Managed Microsoft AD into a VPC (2 subnets, 2 AZs).
  2. Create a conditional forwarder in AWS-side DNS pointing to your on-prem domain, and a matching one in on-prem DNS pointing back.
  3. Establish the trust relationship: choose one-way (only one domain trusts the other) or two-way (full mutual trust).
  4. Trust password must match on both sides at creation time.
  5. Same port set as AD Connector must be open — bidirectionally if the trust is two-way.
⚠️ Exam trap — trust direction

A one-way trust where "on-prem trusts AWS" lets on-prem users authenticate into AWS resources — but does NOT let AWS-side identities reach into on-prem, and vice versa. A scenario describing a trust "already established" in the wrong direction is a common distractor; recognizing that a trust EXISTING isn't the same as it existing in the needed direction is the tested skill.

Raw SAML — IAM Trust Policy + Claim Rules (AssumeRoleWithSAML)

Used standalone (custom apps not going through Identity Center) or as the mechanical foundation Identity Center automates for you.

  1. Obtain the external IdP's SAML metadata XML (signing certificate, entity ID, SSO URL).
  2. Create an IAM SAML Identity Provider object, uploading that metadata.
  3. Create an IAM role with a trust policy scoped to that provider:
IAM role trust policy
{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Principal": {
      "Federated": "arn:aws:iam::ACCOUNT_ID:saml-provider/ProviderName"
    },
    "Action": "sts:AssumeRoleWithSAML",
    "Condition": {
      "StringEquals": {
        "SAML:aud": "https://signin.aws.amazon.com/saml"
      }
    }
  }]
}
  1. On the IdP side (e.g. ADFS), configure a relying party trust for AWS and issue claim rules:
    • NameID — the user identifier
    • https://aws.amazon.com/SAML/Attributes/Role → IAM role ARN + SAML provider ARN, comma-separated
    • https://aws.amazon.com/SAML/Attributes/RoleSessionName → typically email or UPN
    • https://aws.amazon.com/SAML/Attributes/SessionDuration (optional) → seconds, capped by the role's max session duration
⚠️ Diagnosing failures by symptom

"Valid assertion received, but sts:AssumeRoleWithSAML is denied" → the trust policy's Principal or SAML:aud Condition is misconfigured — not the IdP.
"User authenticates but lands with the wrong/no permissions" → the IdP-side Role attribute claim rule is mapping to the wrong role ARN — not an AWS-side problem.

IAM Identity Center + External SAML IdP + SCIM
  1. Identity Center → Settings → Identity Source → External Identity Provider.
  2. Identity Center generates its own SP metadata (an ACS URL and Audience/Issuer value) — give this to the external IdP.
  3. Upload the external IdP's metadata (SSO URL, issuer, certificate) into Identity Center.
  4. Map attributes — typically email → Identity Center Subject/username.
  5. SCIM (optional, heavily tested): enable automatic provisioning; Identity Center generates a SCIM endpoint URL + bearer token, entered into the IdP's provisioning app config. User/group create, update, and de-provision then sync automatically.
The single most important trap in this whole topic

Identity Center supports only ONE identity source at a time. Switching sources does NOT migrate existing users/groups or permission set assignments — assignments are tied to identity references in the specific store. Best-practice timing: choose the identity source BEFORE creating any users/groups in the built-in directory.

IRSA — OIDC Provider + Trust Policy + Annotation
  1. Associate an IAM OIDC identity provider with the cluster (registers the cluster's unique OIDC issuer URL, https://oidc.eks.REGION.amazonaws.com/id/CLUSTER_ID, as a trusted IdP in IAM).
  2. Create an IAM role with a trust policy scoped to that specific provider AND a specific namespace/service account pair:
IRSA trust policy
{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Principal": {
      "Federated": "arn:aws:iam::ACCOUNT_ID:oidc-provider/oidc.eks.REGION.amazonaws.com/id/CLUSTER_ID"
    },
    "Action": "sts:AssumeRoleWithWebIdentity",
    "Condition": {
      "StringEquals": {
        "oidc.eks.REGION.amazonaws.com/id/CLUSTER_ID:sub":
          "system:serviceaccount:NAMESPACE:SERVICE_ACCOUNT_NAME",
        "oidc.eks.REGION.amazonaws.com/id/CLUSTER_ID:aud": "sts.amazonaws.com"
      }
    }
  }]
}
  1. Annotate the Kubernetes service account with the role ARN:
Service account annotation (YAML)
apiVersion: v1
kind: ServiceAccount
metadata:
  name: my-service-account
  namespace: default
  annotations:
    eks.amazonaws.com/role-arn: arn:aws:iam::ACCOUNT_ID:role/my-role
⚠️ The scoping trap

The :sub condition is what restricts the role to ONE namespace + service-account pair. A wildcarded or mismatched :sub value is the classic "why can every pod in the cluster assume this role" root cause — it's a trust-policy misconfiguration, not an RBAC or network issue.

EKS Pod Identity — Agent-Based Association (No OIDC Config)
  1. Install the EKS Pod Identity Agent add-on on the cluster.
  2. Create an IAM role with a simple trust policy — no cluster-specific issuer URL needed:
Pod Identity trust policy
{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Principal": { "Service": "pods.eks.amazonaws.com" },
    "Action": ["sts:AssumeRole", "sts:TagSession"]
  }]
}
  1. Create the association (no service-account annotation required):
CLI — create association
aws eks create-pod-identity-association \
  --cluster-name CLUSTER \
  --namespace NAMESPACE \
  --service-account SERVICE_ACCOUNT \
  --role-arn arn:aws:iam::ACCOUNT_ID:role/my-role
  • Because the association lives as external metadata rather than a service-account annotation, changing the role requires NO pod restart — a frequently tested operational advantage over IRSA.
Cross-Account Chaining — targetRoleArn (Pod Identity only)
MechanismSpecify both roleArn (same-account) and targetRoleArn (different account) in the association
What happensEKS automatically performs a second AssumeRole hop into the target account's role — no custom STS chaining code needed in the application
PrerequisiteThe target role's trust policy must trust the source role's ARN as Principal
⚠️ IRSA has no equivalent

IRSA has no native cross-account chaining feature — reaching another account requires the application itself to call AssumeRole a second time against a manually configured cross-account trust. A requirement for "simplest cross-account workload identity" is a strong signal toward Pod Identity over IRSA specifically because of this gap.

The Four-Step Rotation Lambda Contract

Secrets Manager invokes the SAME rotation Lambda four times, passing a different Step parameter each call:

1 — createSecret

Generate a new secret value; store it as a new version labeled AWSPENDING

↓
2 — setSecret

Apply the AWSPENDING value to the target service (e.g. change the DB user's password)

↓
3 — testSecret

Validate the AWSPENDING credential actually works (test login/connection)

↓
4 — finishSecret

Move the AWSCURRENT label to the AWSPENDING version; the old AWSCURRENT becomes AWSPREVIOUS

Why this staged design matters

Because the live credential change (step 2) only affects the PENDING version, and the atomic cutover (step 4) is the only step that changes what "current" means, a failure at any step before finishSecret leaves the currently-active credential untouched — rotation can safely retry without locking anyone out.

Alternating-Users Strategy (RDS)

Two DB users (clone A / clone B) alternate roles each rotation. Whichever user is NOT currently active gets its password rotated and tested; the currently-active user's credential is never touched mid-rotation. Contrast with single-user rotation, which briefly changes the password on the live user — a rotation failure there can cause a short connectivity gap that alternating-users avoids.

Prerequisites Often Missed
NetworkingRotation Lambda needs network reachability to the target (same VPC or routed VPC, correct security group ingress)
IAM (Lambda execution role)secretsmanager:GetSecretValue, PutSecretValue, UpdateSecretVersionStage, DescribeSecret
KMS (if CMK-encrypted)Add kms:Decrypt / kms:GenerateDataKey — not needed for the default AWS-managed key
⚠️ "Rotation Lambda times out"

This symptom points at VPC/security-group misconfiguration far more often than IAM — verify network reachability to the target database before assuming a permissions problem.

Cross-Account Secret Access — Two Layers Required

Sharing a secret across accounts requires BOTH of the following — missing either one causes a denial that looks identical from the requester's side:

  1. The secret's own resource-based policy grants the specific principal ARN in the other account secretsmanager:GetSecretValue.
  2. If the secret is encrypted with a customer-managed KMS key, that key's key policy must ALSO grant the same cross-account principal decrypt permissions.
⚠️ Mirrors the KMS multi-layer authorization pattern

"Account B can see the secret exists but GetSecretValue fails" is almost always the KMS key policy layer missing — the secret's resource policy alone is not sufficient when a CMK is involved.

Rule Statement Building Blocks
Rate-based statement with a scope-down statement
{
  "RateBasedStatement": {
    "Limit": 2000,
    "AggregateKeyType": "IP",
    "ScopeDownStatement": {
      "ByteMatchStatement": {
        "FieldToMatch": { "UriPath": {} },
        "PositionalConstraint": "STARTS_WITH",
        "SearchString": "/login",
        "TextTransformations": [{ "Priority": 0, "Type": "NONE" }]
      }
    }
  }
}
  • Limit is requests per 5-minute window, per aggregation key (IP by default).
  • ScopeDownStatement narrows WHICH requests count toward the limit — here, only requests to /login — so the rate limit doesn't apply site-wide.
  • IP set reference statements point at a pre-created IPSet resource by ARN.
  • AND / OR / NOT statements nest other statements to build compound logic.
  • Label matching — managed rule groups emit labels on matching requests; a later custom rule can use a LabelMatchStatement to act only when an earlier rule already flagged the request, enabling "block only if managed-rule-flagged AND matches custom condition" logic.
Priority & Evaluation Order

Rules in a Web ACL evaluate strictly in ascending priority order (0 first). WAF stops at the first TERMINATING action — Block, Allow, CAPTCHA, Challenge. Count is non-terminating — evaluation continues past it.

⚠️ Priority number, not rule "importance," decides the outcome

Placing an Allow rule at a LOWER priority number than a Block rule, for overlapping traffic, means the Allow wins and the Block never triggers — regardless of which rule "seems" more important. This is a recurring scenario pattern: "traffic that should be blocked is getting through" almost always traces to priority ordering, not a broken rule.

WCU capacity is consumed by every rule in the Web ACL continuously — regardless of whether that rule ever actually matches traffic.

Cross-Account — AWS Firewall Manager WAF Policy
PrerequisiteAWS Organizations + a designated Firewall Manager administrator account
Policy definesRule groups (fixed priority — insert first or last relative to account-level custom rules), a resource scope (tag/type/OU/account list), and whether member accounts may add their own additional rules
Auto-remediationApplies automatically to any new in-scope resource, even one just created in a member account — with no action from that account's admin
⚠️ Member accounts cannot opt out of a mandatory FM policy

A common wrong assumption: that a member-account admin retains override authority. When a Firewall Manager policy is set to mandatory enforcement, it does not — enforcement is centralized at the Organization level by design.

Association vs. Propagation — Two Independent Settings
AssociationWhich ONE TGW route table an attachment USES to route its OWN outbound traffic
PropagationWhich route table(s) an attachment's routes get ADVERTISED INTO — i.e. who can reach it
Default TGWSingle default route table, all attachments auto-associated AND auto-propagated — full mesh connectivity
Segmented designDisable default association/propagation; build custom route tables per segment (e.g. a prod table that only propagates from prod VPCs)
The hub-and-spoke inspection pattern this enables

An attachment can propagate its routes into a route table it is NOT associated with. Spoke VPCs associate with a "spoke" route table; a separate "inspection" route table receives propagation from everything, forcing all inter-spoke traffic through a central firewall VPC before it can reach its destination.

The Classic "Why Can't VPC A Reach VPC C" Trap

VPC A's attachment is associated with Route Table 1. VPC C's routes are propagated only into Route Table 2. Both are attached to the same TGW — but Route Table 1 has no route to VPC C's CIDR, because propagation never happened into the table VPC A actually uses.

Fix

Propagate VPC C's attachment into Route Table 1 as well (or add a static route) — attaching to the same TGW is necessary but not sufficient for connectivity.

Cross-Account — Sharing a TGW via RAM
  1. TGW owner creates a Resource Access Manager (RAM) resource share, specifying which accounts (or the whole Organization) may attach.
  2. The participant account creates its OWN VPC attachment to the shared TGW.
  3. The participant CANNOT see or modify the TGW's route tables, association, or propagation settings — and cannot see other participants' attachments unless the owner explicitly grants that visibility.
⚠️ Attaching ≠ automatic connectivity

A participant account assumes that attaching to a shared TGW grants full connectivity by default. It does not — the OWNING account still decides whether that new attachment gets associated/propagated anywhere. Without owner action, the participant's VPC is attached but reaches nothing.

SCP Fundamentals
  • SCPs are JSON documents attached to an OU or account in AWS Organizations.
  • They NEVER grant permissions — they set a permissions CEILING. Effective permission = intersection of the SCP ceiling and whatever the account's own IAM policies grant.
  • The default FullAWSAccess SCP stays attached even when you add a custom Deny-only SCP — a Deny always wins regardless of any Allow elsewhere, so no matching Allow statement is needed for a Deny SCP to take effect.
Deny-With-Exception (Break-Glass) Pattern
Deny an action for everyone except one specific role
{
  "Version": "2012-10-17",
  "Statement": [{
    "Sid": "DenyLeavingOrgExceptBreakGlass",
    "Effect": "Deny",
    "Action": "organizations:LeaveOrganization",
    "Resource": "*",
    "Condition": {
      "StringNotEquals": {
        "aws:PrincipalArn": "arn:aws:iam::ACCOUNT_ID:role/BreakGlassAdmin"
      }
    }
  }]
}

The StringNotEquals condition is the mechanism — deny X unless the calling principal matches a specific admin/break-glass role ARN. This exact shape recurs across many unrelated-looking SCP scenario questions.

Region-Lockdown Pattern
Deny everything outside approved Regions, excluding global services
{
  "Effect": "Deny",
  "NotAction": [
    "iam:*", "organizations:*", "sts:*",
    "support:*", "cloudfront:*", "route53:*"
  ],
  "Resource": "*",
  "Condition": {
    "StringNotEquals": {
      "aws:RequestedRegion": ["us-east-1", "eu-west-1"]
    }
  }
}

NotAction + Deny, combined with aws:RequestedRegion, is the standard region-lockdown shape. Global services (IAM, Organizations, STS, Support, CloudFront, Route 53) must be excluded via NotAction since they don't operate in a single Region — omitting this exclusion list is the most common broken version of this SCP shown in exam scenarios.

Cross-Account — aws:PrincipalOrgID in Resource Policies

Used inside a resource-based policy (S3 bucket policy, KMS key policy, SNS/SQS policy) to allow access from ANY principal within your own Organization — including accounts created in the future — without listing account IDs individually.

Condition keyScope
aws:PrincipalOrgIDEntire Organization, current and future accounts, single condition
aws:PrincipalAccountOne specific account only
Explicit account ID listOnly the accounts listed — does not auto-include new accounts
Layering reminder

SCPs constrain identity-side actions; Resource Control Policies (RCPs) constrain what a resource's own resource-based policy can grant, regardless of identity permissions. A request must clear EVERY applicable layer — identity policy, SCP, and (for resource-based access) the resource policy and RCP — with any explicit Deny anywhere overriding all Allows.

Cross-Account Patterns — Synthesis

Recognizing WHICH cross-account mechanism a requirement calls for is a tested skill independent of the underlying service. Five mechanisms cover almost every cross-account scenario on the exam.

1 — AWS Resource Access Manager (RAM)

Shares actual infrastructure resources for the receiving account to ATTACH TO or USE — not administer. Covers: Transit Gateway, subnets in a shared VPC, License Manager configurations, Route 53 Resolver rules.

Key trait

The owning account retains full administrative control (route tables, association/propagation, subnet-level NACLs). The participant gets usage rights only.

2 — Resource-Based Policies + Principal

Grants cross-account access to a SPECIFIC resource without RAM: S3 bucket policies, KMS key policies, Secrets Manager resource policies, SNS/SQS policies, Lambda resource policies.

Key trait — always two-sided

Both the resource policy AND (if the caller is using an IAM identity, not a service) an identity-side policy in the calling account must allow the action. When a CMK is involved (Secrets Manager, S3 with a customer-managed key), the key policy is a THIRD layer that must independently allow the cross-account principal.

3 — IAM Role Trust Policy Chaining (Cross-Account AssumeRole)

For compute/workload identity crossing an account boundary: classic cross-account IAM roles, Pod Identity's targetRoleArn, or a SAML/OIDC federation flow that issues credentials scoped to a role in a specific account.

Key trait

The TARGET role's trust policy must explicitly list the SOURCE role/principal ARN. IRSA has no built-in chaining — it requires the application to perform a second, manually configured AssumeRole itself.

4 — Organization-Wide Policy Attachment

SCPs, RCPs, and Firewall Manager policies apply org-wide from a single management-account (or FM-delegated-admin) action — no per-account trust setup needed.

Key trait

SCPs/RCPs only CONSTRAIN, never grant. Firewall Manager policies, by contrast, actively PUSH and enforce configuration into member accounts — member admins cannot opt out of a mandatory policy. Don't confuse the two: one is a ceiling, the other is a mandatory push.

5 — aws:PrincipalOrgID / aws:PrincipalOrgPaths

The "trust my whole org, not a fixed account list" condition key pattern — usable inside resource policies or SCPs, automatically covering future accounts without manual updates.

Mechanism Map — Which Topic Uses Which Mechanism

Configuration topicCross-account mechanismWho retains control
SAML / external IdP → Identity CenterTrust chaining (SAML assertion → specific account's role)Identity Center admin defines permission sets per account
EKS Pod IdentityTrust chaining via targetRoleArnTarget account's role trust policy
Secrets ManagerResource policy + KMS key policy (two-sided)Secret owner account
WAFOrganization-wide push (Firewall Manager) — NOT RAM, NOT a resource policyFM administrator account — mandatory on members
Transit GatewayRAM (share the attachment point only)TGW owner keeps route tables, association, propagation
SCP / bucket / key policiesOrg-wide attachment + aws:PrincipalOrgIDManagement account (SCP) / resource owner account (policy)

Decision Tree — Which Mechanism Does This Requirement Need?

Does the other account need to ATTACH TO shared infrastructure?

(a VPC, a TGW, a Resolver rule) → RAM

↓
Does the other account need to READ/CALL one specific resource?

(a bucket, a key, a secret, a queue) → Resource-based policy (check for a CMK layer too)

↓
Does a WORKLOAD in one account need to ACT AS an identity in another?

→ IAM role trust policy chaining (AssumeRole)

↓
Does EVERY account in the org need the SAME constraint or policy, centrally enforced?

→ SCP/RCP (ceiling, never grants) or Firewall Manager (mandatory push)

⚠️ The single most common cross-account exam trap

Assuming ONE mechanism grants access when the real requirement needs TWO layers. Cross-account + a customer-managed KMS key is the repeat offender: the resource-side grant (bucket policy, secret policy, DynamoDB stream policy) is necessary but not sufficient — the KMS key policy must independently name the same cross-account principal, or decryption fails even though the resource-level grant looks completely correct.

AWS Exam Thinking

Requirement → Keywords → Expected Answer → why every distractor fails.

Federate a single existing on-prem AD domain into Identity Center with zero data duplication
single domainno duplicationproxy
Expected Answer

AD Connector as the identity source

DistractorWhy it's wrong
AWS Managed Microsoft ADStands up a new directory and requires a trust relationship — more than a single-domain, no-duplication need calls for
Migrate users into the built-in directoryDuplicates identity data, breaking the explicit "no duplication" requirement
A new EKS workload needs scoped AWS permissions with the simplest cross-account setup, no OIDC provider configuration
new EKS workloadcross-accountsimplest setup
Expected Answer

EKS Pod Identity with targetRoleArn

DistractorWhy it's wrong
IRSA + manual cross-account AssumeRole in application codeRequires OIDC provider setup AND custom chaining logic — exactly the overhead the requirement rules out
Broad node instance roleGrants every pod on the node the same permissions, violating least privilege and providing no cross-account path at all
Account B needs to read a secret owned by Account A, encrypted with Account A's customer-managed KMS key
cross-account secretCMK-encrypted
Expected Answer

Update BOTH the secret's resource policy AND the KMS key policy to grant Account B's principal

DistractorWhy it's wrong
Update only the secret's resource policyLeaves the KMS decrypt step denied — GetSecretValue will fail even though the secret-level grant looks correct
Switch the secret to the AWS-managed keyRemoves the org's ability to control the key policy independently, a poor security trade just to sidestep the second layer
Legitimate traffic to a specific path is being blocked despite a correctly-written Allow rule for it
WAFAllow rule not applying
Expected Answer

Check rule priority — a lower-numbered Block rule for overlapping traffic is winning first

DistractorWhy it's wrong
The Allow rule's statement syntax must be brokenA correctly-written rule at the wrong priority produces exactly this symptom — syntax isn't the first thing to check
WCU budget must be exceededExceeding WCU changes cost, not which rule wins evaluation order
Two VPCs attached to the same Transit Gateway cannot reach each other
TGWno connectivity
Expected Answer

Check propagation — one VPC's routes likely aren't propagated into the route table the other VPC is associated with

DistractorWhy it's wrong
Assume the TGW attachment itself failedBoth being attached to the same TGW is necessary but not sufficient — association/propagation is the far more common root cause
Check security groups firstSGs matter, but the described symptom (total unreachability across a TGW) is a routing question first
Every account in a 200-account Organization must be blocked from operating outside two approved Regions, except for global services
SCPregion lockdownorg-wide
Expected Answer

Deny SCP with NotAction excluding global services, Condition on aws:RequestedRegion

DistractorWhy it's wrong
Deny SCP without excluding IAM/Organizations/STS/Support via NotActionBreaks global services that don't operate in a single Region — the most common broken version of this pattern
Apply the restriction via 200 individual IAM policiesDoesn't scale and isn't centrally enforced the way an org-wide SCP is
A bucket policy should allow read access from any current or future account in the Organization, without listing account IDs
cross-accountfuture accountsno account list
Expected Answer

aws:PrincipalOrgID condition key in the bucket policy

DistractorWhy it's wrong
List every current account ID explicitlyDoesn't auto-include future accounts, violating the stated requirement
aws:PrincipalAccountScopes to a single account only, not the whole Organization
A member account's admin wants to exclude their own resources from a mandatory Firewall Manager WAF policy
Firewall Managermandatory enforcement
Expected Answer

Not possible under mandatory enforcement — only the FM administrator account can change scope

DistractorWhy it's wrong
The member account can disable the policy locallyContradicts the deliberate design of mandatory FM enforcement — member accounts cannot opt out

Best Practices & Common Exam Traps

Best Practices

Must Know
  • AD Connector = single domain, proxy, no duplication. AWS Managed Microsoft AD = new domain + trust, needed for multiple domains/forests.
  • IRSA trust policy scoping lives in the :sub condition key — Pod Identity removes this requirement entirely via agent-based association.
  • Secrets Manager rotation is a 4-step contract: createSecret → setSecret → testSecret → finishSecret, with AWSPENDING/AWSCURRENT/AWSPREVIOUS staging.
  • WAF evaluates rules in strict priority order; Count is non-terminating, everything else stops evaluation.
  • TGW association (what a VPC uses) and propagation (who it's visible to) are independent settings — the top cause of "attached but unreachable."
  • SCPs/RCPs only constrain; they never grant. A Deny anywhere always wins.
Good Practice
  • Choose an Identity Center identity source BEFORE creating any users/groups in the built-in directory.
  • Prefer Pod Identity over IRSA for new EKS workloads, especially any needing cross-account access via targetRoleArn.
  • Use the alternating-users rotation strategy for RDS credentials where connectivity continuity during rotation failure matters.
  • Test new WAF rules in Count mode before switching to Block.
  • Use aws:PrincipalOrgID in resource policies instead of maintaining explicit account-ID allowlists.
Advanced Practice
  • Build hub-and-spoke TGW inspection architectures using propagation-without-association to force traffic through a central firewall VPC.
  • Layer SCP deny-with-exception patterns for break-glass roles rather than leaving any principal permanently exempt.
  • Audit CMK key policies specifically whenever a cross-account resource-based-policy grant "looks right but doesn't work."

Common Exam Traps

⚠️ "The resource policy grants access, so it should work"

Ignoring the KMS key policy layer whenever a CMK is involved — the single most repeated cross-account trap across Secrets Manager, S3, and DynamoDB streams scenarios.

⚠️ "They're attached to the same TGW/Organization, so they must be connected/covered"

Attachment ≠ connectivity (TGW propagation). Membership ≠ enforcement (an SCP must actually be attached to the right OU/account, not just exist somewhere in the Organization).

⚠️ Treating IRSA and Pod Identity as interchangeable in cross-account scenarios

Only Pod Identity has native targetRoleArn chaining. A scenario emphasizing "simplest cross-account setup" for EKS is a strong signal toward Pod Identity specifically, not just "workload identity" generically.

⚠️ Assuming a rule's semantic "importance" determines WAF outcome

Only priority number and terminating/non-terminating action type determine outcome — not which rule seems more critical to a human reader.

Flashcards

Click to reveal answer
1 / 24
Mark:   Score: 0/0

Practice Quiz — 10 Questions

SCS-C02 scenario style, Easy → Specialty, cross-account emphasis throughout. Select an answer to reveal the explanation.

out of 10 correct