Easy ReviewDOP-C02
SDLC Automation124

Reference architectures

Complete multi-service designs that associate and professional exams describe in their scenarios, drawn end to end with the reason behind each piece.

Architecture questions rarely test one service alone. They describe a workload and ask which combination of services meets its availability, security, cost or performance goal. Each section here draws one common design end to end, so you can see where every service sits and why.

Highly available three-tier web application

The classic architecture question describes a web application that must stay up through an Availability Zone failure, scale with traffic, resist attacks and keep its data private. The answer combines a protected edge layer, a load-balanced stateless tier and an encrypted managed database, each placed in at least two zones.

How it works

  1. Route 53 answers for the domain with an alias record that points at CloudFront.
  2. At the edge, Shield Standard absorbs common DDoS attacks, and an AWS WAF web ACL blocks malicious requests. ACM provides and renews the TLS certificates.
  3. CloudFront serves static files from a private S3 bucket through origin access control and forwards dynamic requests to the load balancer.
  4. An Application Load Balancer in public subnets of two zones sends requests to an Auto Scaling group in private subnets of the same zones. A target tracking policy scales the group, and unhealthy instances are replaced.
  5. The app tier keeps no local state: sessions and hot reads live in ElastiCache, durable data in Aurora, encrypted with a KMS key chosen at creation.
  6. Aurora takes writes on the writer and keeps a replica in the other zone for reads and failover.
  7. Each zone has its own NAT gateway for outbound calls, so losing one zone does not cut the other off.
Tier Service What makes it highly available and secure
Edge Route 53, CloudFront, Shield Standard, AWS WAF, ACM Global edge network; attacks filtered before the origin
Static content S3 Private bucket behind OAC
Web and app ALB, EC2 Auto Scaling Two or more AZs; target tracking; unhealthy instances replaced
Session and cache ElastiCache Shared state, so instances are interchangeable
Data Aurora, KMS Storage in three AZs; replica as failover target; encrypted at rest
Decision Choose When
Name at the zone apex Alias record Pointing example.com at CloudFront or an ALB
Block web exploits AWS WAF on CloudFront SQL injection, scripting, rate floods
Reach from app tier to database Security group as source Instances come and go
Scaling policy Target tracking Keep one metric near a target
Egress for private subnets One NAT gateway per AZ Egress must survive an AZ failure

Security groups chain the tiers: the ALB accepts HTTPS, the app tier accepts traffic only from the ALB security group, and the database accepts its port only from the app tier security group.

Exam cues

  • If the question says survive an AZ failure, think ALB and an Auto Scaling group across at least two AZs, because both spread work across zones.
  • If the question says only the app tier may reach the database, think a security group rule that references the app tier security group, because it follows instances as they scale.
  • If the question says private instances keep internet access during an AZ outage, think one NAT gateway per AZ, because a NAT gateway lives in one zone.
  • If the question says keep the S3 origin private behind CloudFront, think origin access control, because only the distribution can read the bucket.
  • If the question says users lose sessions as instances scale in, think ElastiCache or DynamoDB for session state, because the app tier must be stateless.
  • If the question says block SQL injection or request floods, think AWS WAF on CloudFront, because it filters at the edge.
  • If the question says certificates must renew automatically, think ACM.

Remember

  • ALB: subnets in at least two AZs.
  • Aurora: storage copies in three AZs; up to 15 Aurora Replicas.
  • NAT gateway: one per AZ for zone-independent egress.
  • Alias, not CNAME, at the zone apex.
  • Shield Standard is automatic and free; AWS WAF is configured per resource.
  • RDS encryption is set at creation; encrypt later through an encrypted snapshot copy.

Trap: One NAT gateway or one database instance makes the whole design depend on a single zone, even when the web tier spans two. Check every tier, not just compute.

Three-tier web application across two Availability Zones
RegionVPCAvailability Zone AAvailability Zone BAuto Scaling group1234567789101112131313UsersRoute 53alias at apexiCloudFrontedge cacheiAWS WAFweb ACLiACMTLS certificatesiS3 bucketstatic assetsiInternet gatewayattached to VPCAWS KMSkey for data at restiLoad balancerALB, two AZsiNAT gatewaypublic subnet ANAT gatewaypublic subnet BEC2 instancesprivate subnet AiEC2 instancesprivate subnet BElastiCachesessions, readsiAurora writerprivate DB subnet AiAurora Replicaprivate DB subnet BiCloudWatch alarmtarget trackingi
  1. Users look up the domain in Route 53. An alias record at the zone apex returns the CloudFront distribution.

  2. Requests reach a nearby CloudFront edge location, where Shield Standard absorbs common DDoS attacks at no extra cost.

  3. An AWS WAF web ACL on the distribution blocks malicious requests, such as SQL injection, before they reach any origin.

  4. TLS uses certificates that ACM issues and renews, on the distribution and on the load balancer.

  5. Static files come from a private S3 bucket that only the distribution can read, through origin access control in the bucket policy.

  6. Dynamic requests go to the Application Load Balancer, which has nodes in public subnets of two Availability Zones and accepts traffic only from CloudFront.

  7. The load balancer spreads requests across an Auto Scaling group in private subnets of both zones. Only the ALB security group may reach the instances.

  8. Instances keep sessions and cached reads in ElastiCache, so no user is tied to one instance.

  9. Writes go to the Aurora writer, reachable only from the app tier security group. The cluster volume keeps copies of the data in three Availability Zones.

  10. The database is encrypted at rest with a KMS key chosen when it was created.

  11. If the writer or its zone fails, the Aurora Replica in the other zone becomes the writer.

  12. A target tracking policy keeps a metric such as average CPU at its target, adding or removing instances, and the group replaces unhealthy instances in the surviving zone.

  13. Outbound internet calls from each zone use the NAT gateway in that same zone, which sends them out through the internet gateway.

Box details (12)
Route 53

An alias record at the zone apex points example.com at the CloudFront distribution.

CloudFront

Serves cached static content from edge locations and forwards dynamic requests to the load balancer. Shield Standard protects it at no extra cost.

AWS WAF

Rules block SQL injection, cross-site scripting and request floods before they reach the origin.

ACM

Issues and renews the certificates on the distribution and on the load balancer.

S3 bucket

Private bucket. Its policy lets only this distribution read it, through origin access control.

AWS KMS

Chosen when the database is created. An unencrypted database cannot be encrypted in place.

Load balancer

Internet-facing ALB with nodes in a public subnet of each AZ. Its security group accepts HTTPS from CloudFront.

EC2 instances

Stateless app tier. Its security group allows traffic only from the ALB security group.

ElastiCache

Shared session store and read cache, so any instance can serve any user.

Aurora writer

Takes all writes. Its security group allows the database port only from the app tier security group.

Aurora Replica

Serves reads through the reader endpoint and is the failover target if the writer fails.

CloudWatch alarm

Created and managed by the target tracking policy, for example average CPU at 50 percent.

From the AWS docs (17)
  • A Route 53 alias record can point the zone apex, such as example.com, at a CloudFront distribution or other supported AWS resource, which a CNAME record cannot do.
  • CloudFront can send authenticated requests to an S3 origin with origin access control (OAC), so the bucket stays private; AWS recommends OAC over the older origin access identity.
  • An Application Load Balancer needs subnets in at least two Availability Zones.
  • EC2 Auto Scaling replaces instances it finds unhealthy, and a group that spans several Availability Zones can launch instances in another zone when one becomes unavailable.
  • AWS recommends keeping session state in a shared backing store such as ElastiCache, DynamoDB or RDS, so any instance can serve any user and instances can scale without losing sessions.
  • An Aurora cluster volume keeps copies of the data across three Availability Zones in the Region.
  • An Aurora cluster can have up to 15 Aurora Replicas that share the cluster volume and serve reads; placing them in other Availability Zones keeps the cluster highly available.
  • A NAT gateway lives in one Availability Zone; to stay resilient, create one in each zone and route each zone's private subnets to the NAT gateway in the same zone.
  • A security group rule can name another security group as its source, allowing traffic from every instance associated with that group over private IP addresses.
  • AWS WAF is a web application firewall that watches HTTP(S) requests to resources such as CloudFront distributions and API Gateway APIs and allows or blocks them by rules.
  • AWS gives automatic protection against common DDoS attacks such as UDP reflection and SYN floods at no extra cost.
  • Serving traffic through Amazon CloudFront and Amazon Route 53, which run in edge locations, is an AWS best practice for DDoS resilience because attacks are absorbed at the edge.
  • AWS Certificate Manager creates, stores and renews public and private SSL/TLS certificates that protect websites and applications on AWS.
  • ACM certificates are deployed to integrated AWS services such as Elastic Load Balancing and CloudFront.
  • Amazon RDS encrypts DB instances at rest with an AWS KMS key, either the AWS managed key for RDS (the default) or a customer managed key you choose when creating the instance.
  • To encrypt an unencrypted RDS DB instance or change its KMS key, copy a manual snapshot with encryption enabled and restore it, or use a blue/green deployment with an encrypted green environment.
  • Target tracking adjusts group capacity toward a metric target and manages the associated CloudWatch alarms.

Serverless event-driven application

A serverless design answers questions that ask for no servers to manage, cost that follows usage and components that scale on their own. The pieces fit in two halves: a synchronous path that serves the user, and an asynchronous path that does slower work after the response.

How it works

  1. CloudFront serves the web front end from a private S3 bucket through origin access control.
  2. Users sign in with a Cognito user pool. API Gateway checks each token with a user pool authorizer, throttles bursts, and a regional AWS WAF web ACL filters malicious requests.
  3. A Lambda function writes to DynamoDB and publishes an event to EventBridge, then answers the user.
  4. EventBridge rules fan the event out: a Step Functions workflow coordinates multi-step work, and an SQS queue buffers simpler jobs.
  5. A worker function drains the queue at a capped concurrency and reports partial batch failures. Messages that keep failing land in a dead-letter queue, and a CloudWatch alarm on it notifies the team.
  6. X-Ray traces each request across API Gateway, Lambda and DynamoDB.
Need Service Why
Static front end CloudFront and S3 with OAC Edge caching; bucket stays private
Sign-in and API access Cognito user pool authorizer No custom auth code
Request handling API Gateway and Lambda Throttling; scales per request
Web exploit protection Regional AWS WAF on the REST API Filters requests without CloudFront
Data DynamoDB on-demand No capacity planning
Fan-out to many consumers EventBridge Rules per consumer; producer unchanged
Buffer and protect a backend SQS with maximum concurrency Work waits in the queue
Ordered multi-step process Step Functions Retries and visible state
Find slow calls X-Ray with Active tracing Per-request path and timing

Exam cues

  • If the question says the API must not wait for slow downstream work, think publish an event or message and return, because the asynchronous path scales on its own.
  • If the question says many services must react to one event and more will come, think EventBridge rules, because consumers are added without touching the producer.
  • If the question says a downstream system cannot take bursts, think SQS between them with maximum concurrency on the event source mapping, because messages wait instead.
  • If the question says authenticate app users for an API without writing code, think a Cognito user pool authorizer.
  • If the question says coordinate several steps with retries and track each order, think Step Functions.
  • If the question says know when messages fail permanently, think a CloudWatch alarm on the dead-letter queue.

Remember

  • Synchronous path: CloudFront, API Gateway, Lambda, DynamoDB.
  • Asynchronous path: EventBridge for fan-out, SQS for buffering, Step Functions for workflows.
  • Dead-letter queue: same account and Region as its source queue; alarm on ApproximateNumberOfMessagesVisible.
  • AWS WAF can attach to an API Gateway REST API directly.

Trap: Calling every downstream service directly from the API function couples them: one slow consumer slows every request. Put an event bus or a queue between them.

Serverless web front end, API and asynchronous event processing
Region11233455677891011UsersCloudFrontweb front endS3 bucketstatic site, OACiX-RaytracesiCognitouser pooliAWS WAFregional web ACLAPI GatewayREST APIiLambdaorders APIDynamoDBon-demand tableEventBridgeOrderPlacediStep Functionsfulfillment flowSQS queueemail jobsiLambdaworkeriSQS DLQfailed messagesCloudWatch alarmmessages in DLQ
  1. The browser loads the single-page application from CloudFront, which reads a private S3 bucket through origin access control.

  2. The user signs in with a Cognito user pool and receives tokens.

  3. The app calls API Gateway with the token. A Cognito user pool authorizer checks it, and throttling protects the backend.

  4. A regional AWS WAF web ACL on the REST API blocks malicious requests before they reach the function.

  5. A Lambda function stores the order in a DynamoDB table in on-demand mode.

  6. The function publishes an OrderPlaced event to EventBridge and returns at once.

  7. EventBridge rules start a Step Functions workflow for fulfillment and send a copy to an SQS queue.

  8. A worker Lambda function polls the queue and sends the confirmation email. Maximum concurrency caps how far it scales, and partial batch failure reporting retries only the failed messages.

  9. Messages that keep failing move to a dead-letter queue for investigation.

  10. A CloudWatch alarm on the dead-letter queue's visible message count tells the team as soon as anything lands there.

  11. Active tracing sends each request's path through API Gateway, Lambda and DynamoDB to X-Ray, so slow or failing calls show up per request.

Box details (7)
S3 bucket

Holds the single-page application. Only the distribution can read it.

X-Ray

Active tracing on the functions follows each request through API Gateway, Lambda and DynamoDB.

Cognito

Signs users in and issues the tokens the API checks.

API Gateway

Checks tokens with a Cognito user pool authorizer and throttles requests before they reach Lambda.

EventBridge

Rules route the event to each consumer. New consumers add a rule, not code in the API.

SQS queue

Buffers work so a slow consumer never slows the API.

Lambda

Event source mapping with maximum concurrency set, and partial batch failure reporting so only failed messages are retried.

From the AWS docs (13)
  • CloudFront can send authenticated requests to an S3 origin with origin access control (OAC), so the bucket that holds a web front end stays private.
  • A REST API in API Gateway can use an Amazon Cognito user pool as its authorizer, as an alternative to IAM permissions or a Lambda authorizer.
  • API Gateway throttling and quotas protect an API from being overwhelmed by too many requests; they apply on a best-effort basis.
  • On-demand is the default and recommended DynamoDB throughput mode for most workloads, with no capacity to plan.
  • EventBridge is a serverless service whose event buses receive events and deliver them to zero or more targets, which keeps producers and consumers loosely coupled.
  • Lambda can process messages from standard and FIFO SQS queues; functions should report partial batch failures so successful messages are not retried.
  • Maximum concurrency on an SQS event source mapping limits how far Lambda scales for that queue.
  • An SQS dead-letter queue receives messages that a source queue could not process successfully, isolating them for debugging; it must be in the same account and Region as the source queue.
  • A CloudWatch alarm on a dead-letter queue's ApproximateNumberOfMessagesVisible metric signals when messages land in it.
  • Step Functions workflows, also called state machines, orchestrate microservices and processes as a series of event-driven steps.
  • AWS WAF protects regional resources including an Amazon API Gateway REST API and an Application Load Balancer.
  • AWS X-Ray collects data about the requests an application serves and provides tools to view and filter it to find issues and optimization opportunities.
  • Lambda Active tracing automatically sends segments for sampled requests.

Multi-Region disaster recovery with warm standby

Disaster recovery questions give a recovery time and a budget, then ask for the cheapest strategy that meets them. Warm standby is the middle ground the exams use most: a second Region already runs the full stack at small size, data replicates continuously, backups are copied there, and DNS moves users over when the primary fails.

How it works

  1. One CloudFormation template, deployed to both Regions through a StackSet, keeps the DR Region identical to production at a smaller size.
  2. A Route 53 health check watches the primary load balancer, and failover routing answers with the primary Region while it is healthy.
  3. Aurora Global Database keeps a read-only cluster in the DR Region, and S3 Cross-Region Replication copies objects to a versioned bucket there.
  4. AWS Backup copies recovery points to a vault in the DR Region, so a restore point survives even when bad data replicates.
  5. When the primary fails its health check, Route 53 answers with the DR Region. The standby takes traffic at once and scales out.
  6. Aurora managed failover promotes the secondary. A planned test uses switchover instead, which loses no data. The global writer endpoint follows the new primary.
Strategy DR Region before the event Recovery
Backup and restore Backups only Slowest: rebuild infrastructure, restore data
Pilot light Data stores running, app servers off Start or deploy app servers, then switch
Warm standby Full stack running at reduced size Takes traffic at once, then scales out
Multi-site active/active Full stack serving traffic Traffic already spread across Regions
Decision Choose When
Planned Region move with no data loss Aurora switchover Tests and maintenance
Region outage Aurora managed failover Primary unavailable; accept possible lost writes
Writes in every Region DynamoDB global tables Multi-active workloads
Restore points in the DR Region AWS Backup copy action Protection against replicated corruption

Exam cues

  • If the question says the cheapest option and hours of downtime are acceptable, think backup and restore, because nothing runs in the DR Region.
  • If the question says data must be live in the DR Region but compute can start after the event, think pilot light.
  • If the question says recover in minutes at reduced cost, think warm standby, because the stack is already running.
  • If the question says writes in every Region, think DynamoDB global tables, because Aurora Global Database writes in one primary Region.
  • If the question says fail DNS over automatically, think Route 53 failover routing with health checks.
  • If the question says a planned Region move with zero data loss, think Aurora switchover; for an outage, managed failover.

Remember

  • Aurora Global Database: one primary Region, up to 10 read-only secondaries.
  • Switchover: RPO zero. Managed failover: can lose writes still replicating.
  • DynamoDB global tables: multi-active, multi-Region.
  • S3 CRR is asynchronous; versioning gives restore points.
  • AWS Backup copy actions put recovery points in another Region.
  • Pilot light cannot serve without action; warm standby can.

Trap: Replication is not a backup. Corruption and deletions replicate too, so keep versioning, point-in-time recovery or AWS Backup copies alongside it.

Warm standby in a second Region with DNS failover
Primary RegionDR Region11233444456778889UsersRoute 53failover routingiHealth checkprimary endpointiALBprimaryAuto Scalingfull capacityAuroraprimary clusteriS3 bucketversionedAWS Backupbackup planiAurorasecondary clusteriAuto Scalingscaled downiALBstandbyS3 bucketreplicaBackup vaultDR copiesCloudFormationStackSeti
  1. Both Regions are deployed from the same CloudFormation template through a StackSet, so the DR Region matches production. Its Auto Scaling group runs at reduced size.

  2. Users resolve the domain in Route 53.

  3. A Route 53 health check probes the primary load balancer, and the failover routing policy answers with the primary record while it is healthy.

  4. The primary Region serves all traffic at full capacity.

  5. Aurora Global Database keeps a read-only secondary cluster synchronized in the DR Region.

  6. S3 Cross-Region Replication copies objects to a versioned bucket in the DR Region.

  7. An AWS Backup plan takes backups and its copy action sends them to a vault in the DR Region, for restores to an earlier point in time.

  8. If the health check fails, Route 53 answers with the DR Region. The standby already serves at reduced size and scales out to production capacity.

  9. Aurora managed failover promotes the secondary cluster to take writes. The global writer endpoint keeps its name and now points to the new primary.

Box details (7)
Route 53

Primary record with a health check, secondary record for the DR Region.

Health check

Probes the primary load balancer. A CloudWatch alarm can notify when its status changes.

Aurora

Takes all writes for the global database. Applications use the global writer endpoint.

AWS Backup

The plan's copy action sends each recovery point to a vault in the DR Region.

Aurora

Read-only until it is promoted by a switchover or failover.

Auto Scaling

Running at reduced size. On failover, raise its capacity to production size.

CloudFormation

One template, a stack instance per Region, so the DR Region matches production.

From the AWS docs (15)
  • AWS groups disaster recovery strategies into four approaches, from low-cost backup and restore to multiple active Regions; active/passive strategies serve traffic from one Region and fail over to another.
  • Warm standby keeps a scaled-down but fully functional copy of production running in another Region, so it can take traffic at reduced capacity at once and recovers faster than pilot light.
  • In pilot light, data stores such as databases and object storage stay running in the DR Region, but the application servers cannot serve requests until more action is taken.
  • CloudFormation can deploy the same infrastructure definition consistently across accounts and Regions, which keeps a DR Region in step with production.
  • A StackSet deploys one template as stacks across selected AWS accounts and Regions; a stack instance associates it with an account and Region.
  • Route 53 health checks support active-passive failover, where the failover routing policy sends traffic to a secondary resource when the primary is unhealthy, and active-active failover with the other routing policies.
  • Route 53 health checks monitor the health of web applications and other resources, and CloudWatch alarms can notify when a health check status changes.
  • An Aurora global database has one primary Region that takes writes and up to 10 read-only secondary Regions that Aurora keeps synchronized.
  • Switchover, formerly managed planned failover, synchronizes the selected secondary before changing primary Region and has RPO zero.
  • Managed failover handles an unplanned outage without waiting for synchronization; asynchronous replication lag can cause lost writes.
  • The global writer endpoint keeps the same name and points to the new primary after switchover or failover; applications must observe the DNS change before resuming writes.
  • S3 Cross-Region Replication copies objects asynchronously to a bucket in another Region, and with versioning you can choose a restore point.
  • AWS Backup can copy supported backups to other Regions on demand or through backup plan copy actions.
  • The first copy to a new Region is full; later copies are generally incremental if the service supports incremental backups.
  • DynamoDB global tables are multi-active and multi-Region, with fast local reads and writes in each replica Region.

Cross-account deployment pipeline

Professional exams separate build tooling from workloads: one tooling account runs the pipeline, and each environment lives in its own account. The design works only when three things line up across accounts: the artifact bucket policy, the KMS key policy and a role in each target account that the pipeline assumes.

How it works

  1. A source action starts CodePipeline in the tooling account, and CodeBuild builds and tests the change.
  2. Artifacts land in the pipeline’s S3 bucket, encrypted with a customer managed KMS key. The bucket policy and the key policy both allow the target accounts.
  3. Each deploy action names the ARN of a role in its target account. That role can read the artifact, use the key and run CloudFormation there.
  4. A manual approval action holds the production stage until an authorized reviewer approves it.
  5. A rollback trigger rolls a failing production update back, and an EventBridge rule reports failed executions.
  6. For a baseline every account needs, a service-managed StackSet with automatic deployment replaces per-account stages.
Piece Lives in Must allow
Artifact bucket Tooling account Target accounts (bucket policy)
Customer managed KMS key Tooling account Target accounts (key policy)
Deploy role Each target account Deploy actions, bucket read, key use
CodeArtifact domain Tooling or shared account Build roles (domain or repository policy)
Decision Choose When
Stop a bad release Manual approval A person must sign off before production
Undo a bad stack update Rollback trigger with an alarm The alarm fires during or after the update
Return to the last good release Stage rollback (V2) A stage failed after a bad change
Same template in every account Service-managed StackSet Baseline for an OU, including new accounts
Production stack action mode CREATE_UPDATE Always; REPLACE_ON_FAILURE is for testing

Exam cues

  • If the question says a pipeline in one account deploys to another, think bucket policy plus customer managed key plus an assumed role in the target account, because all three must allow the cross-account access.
  • If the question says the target account cannot decrypt artifacts, think customer managed KMS key, because cross-account pipelines need one.
  • If the question says the key works in one account but not the other, think key ID or ARN instead of an alias.
  • If the question says a human must sign off before production, think a manual approval action.
  • If the question says the same template must reach every account in an OU, think a service-managed StackSet.
  • If the question says roll back automatically when an alarm fires during a stack update, think a rollback trigger.
  • If the question says notify on failed pipeline executions, think an EventBridge rule on the execution state change event.

Remember

  • Cross-account pipeline: artifact bucket policy, customer managed KMS key, role in each target account.
  • KMS aliases work only in their owning account.
  • Approvers need codepipeline:PutApprovalResult.
  • One artifact bucket per Region where the pipeline runs actions.
  • Service-managed StackSets need Organizations trusted access.
  • Cross-account CodeArtifact: IAM allow plus domain or repository policy allow; sts:GetServiceBearerToken only in IAM.
  • Stage rollback and automatic retry need a V2 pipeline.

Trap: An artifact cannot move directly between two non-pipeline accounts. Every target account reads from the pipeline account’s bucket.

One pipeline in a tooling account deploys to staging and production accounts
Tooling accountStaging accountProduction account1223344556788Git repositorysource actionCodePipelineV2 pipelineiEventBridge ruleexecution FAILEDCodeArtifactpackage repositoryiCodeBuildbuild and testS3 bucketpipeline artifactsiManual approvalbefore productionAWS KMScustomer managed keyiRelease managerPutApprovalResultSNS topicteam alertsDeploy rolestagingCloudFormationstaging stackDeploy roleproductionCloudFormationproduction stackCloudWatch alarmrollback trigger
  1. A commit to the repository starts the pipeline through its source action.

  2. CodeBuild pulls dependencies from CodeArtifact, then builds and tests the change. A caller from another account needs an allow in its own IAM policy and in the domain or repository policy.

  3. The output artifact goes to the pipeline's S3 bucket, encrypted with a customer managed KMS key whose key policy allows the staging and production accounts.

  4. The staging deploy action assumes the role in the staging account by its ARN. That role reads the artifact (bucket policy plus key permission) and runs CloudFormation.

  5. A manual approval action pauses the pipeline. The release manager, who has codepipeline:PutApprovalResult, approves, and the production action assumes the production role.

  6. CloudFormation updates the production stack with the CREATE_UPDATE action mode.

  7. If the rollback trigger alarm enters ALARM during the update or its monitoring period, CloudFormation rolls the whole stack update back.

  8. The failed action stops the revision. EventBridge receives the Pipeline Execution State Change event with state FAILED, and the rule alerts the team through SNS. A V2 pipeline can retry failed actions or roll the stage back.

Box details (4)
CodePipeline

V2 pipelines can retry failed actions and roll a stage back to the last successful execution.

CodeArtifact

The domain policy can limit access to principals in the organization with aws:PrincipalOrgID.

S3 bucket

Bucket policy grants the staging and production accounts read access.

AWS KMS

Key policy allows the target accounts. Actions reference it by key ID or ARN, never by alias.

From the AWS docs (26)
  • A cross-account CodePipeline setup requires access to the artifact bucket and a customer managed KMS key, plus a trusted cross-account role; an artifact cannot pass directly between two non-pipeline accounts.
  • The artifact bucket policy must grant the target account access to the pipeline artifacts.
  • The target action role needs deployment permissions and access to the artifact bucket and encryption key.
  • The cross-account action is configured with the ARN of the target role.
  • KMS aliases are recognized only in their owning account; cross-account actions must identify the key by key ID or ARN.
  • Policy-based cross-account key access requires an allow in the owning key policy and an allow in the caller account IAM policy.
  • A manual approval action pauses an execution until an authorized identity approves or rejects it.
  • An approver needs codepipeline:PutApprovalResult permission on the approval action.
  • A pipeline needs an artifact bucket in its own Region and in every Region where it runs an action.
  • A StackSet deploys one template as stacks across selected AWS accounts and Regions; a stack instance associates it with an account and Region.
  • Service-managed StackSets create the needed roles for accounts managed in AWS Organizations and require trusted access.
  • A caller outside the domain-owner and repository-administrator accounts needs both an identity-policy Allow and a resource-policy Allow for cross-account access.
  • For repository actions, an explicit Allow in either the domain policy or repository policy is sufficient on the resource-policy side.
  • The caller must have sts:GetServiceBearerToken in its identity permissions; a domain policy cannot grant that action.
  • A domain policy can use aws:PrincipalOrgID to limit its grants to principals in the specified organization.
  • Rollback triggers roll back a whole stack create or update operation if a configured alarm enters ALARM during the operation or monitoring period.
  • INSUFFICIENT_DATA alone does not trigger rollback; configure the alarm to treat missing data as breaching if missing metrics should cause an alarm.
  • EventBridge receives separate CodePipeline Pipeline Execution State Change, CodePipeline Stage Execution State Change, and CodePipeline Action Execution State Change detail types.
  • EventBridge rules can route CodePipeline state events to targets such as SNS or Lambda.
  • A failed action prevents its revision from advancing; in stage-locking operation failure releases the stage lock.
  • FAILED_ACTIONS retries failed actions while in-progress actions continue.
  • Stage rollback creates a new execution using a previously successful execution source revisions, variables, and artifacts.
  • Stage rollback and automatic stage retry require V2.
  • CREATE_UPDATE creates a missing stack or updates an existing stack without deleting a failed stack to replace it.
  • REPLACE_ON_FAILURE can delete and recreate a failed stack; AWS recommends it for testing only.
  • Automatic deployment creates StackSet instances for accounts added to the targeted organization or OUs.

Governed multi-account landing zone

Governance questions at the professional level describe dozens of accounts and ask how to keep them consistent, logged and monitored without slowing teams down. The answer is a landing zone: Control Tower on top of Organizations, shared accounts for logs and security tooling, guardrails on OUs, and single sign-on for people.

How it works

  1. Control Tower sets up the landing zone on Organizations, with OUs, shared accounts and controls. Account Factory vends new accounts, and CfCT (or AFT, with Terraform) applies the company’s customizations to each one.
  2. SCPs on OUs set the maximum permissions for member accounts. IAM policies inside each account still grant the actual access.
  3. IAM Identity Center gives people single sign-on, and permission sets define what they get in each account.
  4. An organization trail sends every account’s activity to the central log archive bucket. Since landing zone 4.0, the shared accounts are named CloudTrail Administrator and Aggregator by default (formerly Log Archive and Audit).
  5. A security tooling account is the delegated administrator for GuardDuty and Security Hub CSPM. A Config aggregator gives a read-only compliance view across accounts.
  6. Control Tower reports drift, such as an edited managed SCP, as an EventBridge event in the management account; updating the landing zone repairs it.
Account Holds Why separate
Management Organizations, Control Tower, Identity Center SCPs don’t restrict it, so keep workloads out
CloudTrail administrator (log archive) Organization trail logs Members cannot alter the record
Security tooling (audit, aggregator) Delegated admins for security services Daily security work outside management
Workload accounts Applications, per environment Blast radius and SCP boundaries
Decision Choose When
Vend accounts Account Factory Standard accounts from the console or Service Catalog
Customize new accounts with CloudFormation CfCT Templates and SCPs applied on each lifecycle event
Vend and customize with Terraform AFT Account requests committed to Git
Detect broken governance Drift Detected events A managed SCP, OU or shared account changed
Admin access to a member account OrganizationAccountAccessRole Created by default only in accounts created through Organizations

Exam cues

  • If the question says set up and govern many accounts with guardrails, think Control Tower, because it orchestrates Organizations, controls and Account Factory.
  • If the question says restrict what member accounts can ever do, think SCPs on OUs, because they cap permissions without granting any.
  • If the question says manage a security service for all accounts outside the management account, think delegated administrator.
  • If the question says log every account and members must not disable it, think organization trail.
  • If the question says one read-only compliance view across accounts, think Config aggregator.
  • If the question says apply the same customizations to every new account automatically, think CfCT, or AFT for Terraform.
  • If the question says someone changed a managed SCP or moved a shared account, think Control Tower drift and updating the landing zone.

Remember

  • SCPs never grant access and don’t apply to the management account.
  • Delegated administrator accounts are still subject to SCPs.
  • GuardDuty delegated admin is set per Region, same account in every Region.
  • Organization trails add new accounts automatically.
  • Config aggregators are read-only.
  • AFT is for accounts, not application workloads.
  • Invited accounts have no OrganizationAccountAccessRole until someone creates it.

Trap: Running workloads in the management account defeats the guardrails, because SCPs never restrict that account.

A landing zone that vends, customizes, logs and watches every account
Management accountWorkloads OUCloudTrail administrator accountSecurity tooling account123455666788Control Towerlanding zoneiOrganizationsOUs and SCPsAccount FactoryService CatalogiDrift ruleEventBridgeCfCTcustomizationsiSNS topicplatform teamDevelopmentmember accountNew accountvendediCloudTrailorganization trailS3 bucketcentral log archiveSecurity Hub CSPMdelegated adminiConfig aggregatorread-only viewGuardDutydelegated admini
  1. Control Tower builds the landing zone on Organizations: OUs, shared accounts, preventive controls enforced as SCPs, and detective controls that use Config rules.

  2. SCPs on the Workloads OU cap what any principal in its accounts can do. They never grant access, and they don't restrict the management account.

  3. A team requests an account through Account Factory. Control Tower calls Organizations CreateAccount and applies the baseline and controls; the lifecycle event starts the CfCT pipeline.

  4. CfCT deploys the company's CloudFormation templates, through StackSets, and its SCPs to the new account in manifest order.

  5. The organization trail covers the new account automatically and delivers to the central log archive bucket. Member accounts cannot stop or change it.

  6. The account sends findings to the delegated administrators in the security tooling account. GuardDuty findings flow into Security Hub CSPM, which aggregates them in its home Region.

  7. A Config aggregator collects the account's configuration and compliance data into a read-only, organization-wide view.

  8. If someone edits or detaches a Control Tower managed SCP, Control Tower detects policy drift and sends a Drift Detected event to EventBridge in the management account. A rule alerts the platform team, which repairs it by updating the landing zone.

Box details (6)
Control Tower

Preventive controls are enforced with SCPs and similar policies; detective controls use Config rules.

Account Factory

Control Tower calls Organizations CreateAccount, then applies blueprints and controls. AFT offers the same vending as a Terraform pipeline.

CfCT

Deploys CloudFormation templates through StackSets, and SCPs, in manifest order.

New account

Accounts created through Organizations get OrganizationAccountAccessRole; invited accounts do not.

Security Hub CSPM

Aggregates findings from every account into a home Region.

GuardDuty

Configured in each Region with the same delegated administrator account.

From the AWS docs (30)
  • Control Tower orchestrates AWS services including Organizations, Service Catalog, and IAM Identity Center to set up and govern a multi-account landing zone.
  • AWS Control Tower applies controls (guardrails), which are preventive, detective or proactive rules, to the accounts in its landing zone.
  • Account Factory provides configurable account templates to standardize account provisioning and enrollment.
  • Shared account default names changed with version 4.0 from Log Archive and Audit to CloudTrail Administrator and Aggregator account; names can be customized.
  • An SCP limits the available permissions of principals in member accounts and never grants access.
  • SCPs do not restrict the management account, but delegated administrator member accounts remain subject to them.
  • A delegated administrator is a member account registered to administer a particular supported AWS service for the organization.
  • StackSets, Config, CloudTrail, GuardDuty, Security Hub CSPM, and Backup support service-specific delegated administrators.
  • The GuardDuty delegated administrator and members must be configured in each desired Region, using the same delegated administrator account across Regions.
  • A management account or CloudTrail delegated administrator can create an organization trail covering management and member accounts.
  • Ordinary member-account users cannot modify, delete, or stop organization trails.
  • New organization members are automatically added to an organization trail for logging.
  • IAM Identity Center gives users MFA-protected single sign-on access to their assigned AWS accounts, with identities managed in Identity Center or a SAML 2.0 identity provider.
  • A permission set is a collection of IAM policies used to assign account access in IAM Identity Center.
  • A Config aggregator collects configuration and compliance data from multiple accounts and Regions, one account across Regions, or an organization whose accounts have Config enabled.
  • Aggregators replicate data into a read-only view and cannot mutate source accounts, deploy rules, or push snapshots back to sources.
  • Cross-Region aggregation replicates findings, updates, insights, control compliance statuses, and security scores to a home Region.
  • Service Catalog calls Control Tower; Control Tower first calls Organizations CreateAccount, then applies blueprints and controls.
  • CfCT deploys CloudFormation templates, SCPs, and RCPs to accounts or OUs and integrates with lifecycle events to apply configured customizations to new Account Factory accounts.
  • CfCT deploys CloudFormation resources through StackSets in manifest order; manifest order expresses dependencies.
  • AFT provides a Terraform pipeline for provisioning and customizing Control Tower accounts through account request files committed to Git.
  • AFT is intended for account provisioning and customization, not deployment of application workload resources.
  • Governance drift occurs when managed accounts, OUs, or policies change from the configuration expected by Control Tower.
  • Editing or detaching a Control Tower-managed SCP causes policy drift; updating the landing zone is a documented remediation.
  • Landing zone 4.0 and later sends drift notifications to EventBridge in the management account instead of SNS.
  • The documented drift event uses source aws.controltower and detail-type Drift Detected; a rule can target SNS or Lambda.
  • Accounts created in Organizations receive OrganizationAccountAccessRole by default.
  • Invited accounts do not automatically receive OrganizationAccountAccessRole; it can be created manually.
  • Preventive controls block actions that violate policy and use Organizations SCPs, RCPs, or declarative policies.
  • Detective controls use Config rules to identify resource noncompliance and report it in the dashboard.

Automated security remediation

Remediation questions describe a misconfiguration or a threat and ask for the fastest automatic response with the least custom code. Two paths cover most of them: AWS Config with Systems Manager Automation fixes configuration drift, and EventBridge routes security findings to code or people.

How it works

  1. An AWS Config rule, deployed to every account by an organization conformance pack, evaluates each change.
  2. For noncompliant resources, automatic remediation runs a Systems Manager Automation runbook, using the role in AutomationAssumeRole, and retries up to MaximumAutomaticAttempts.
  3. With the Config integration on, Security Hub CSPM receives the evaluation as a finding. Automation rules can update findings first.
  4. GuardDuty and Security Hub CSPM send findings to EventBridge. A rule matches the pattern and invokes Lambda or SNS, and custom actions let an analyst send one finding on demand.
  5. To act in a workload account, the function assumes a role there whose trust policy names the security account, for example to move an instance to an isolation security group.
  6. A dead-letter queue on each target keeps events that could not be delivered, and Detective helps analysts find the root cause.
Need Use
Revert a misconfiguration automatically Config rule plus automatic remediation (Automation runbook)
Same rules and fixes in every account Organization conformance pack
React to threat findings GuardDuty or Security Hub CSPM finding, then EventBridge, then Lambda or SNS
Analyst-chosen response Security Hub CSPM custom action
Act in another account Lambda assumes a role that trusts the security account
Contain a compromised instance Isolation security group (tracked connections stay open)
Never lose a finding event Dead-letter queue on the rule target
Find the root cause Amazon Detective

Exam cues

  • If the question says fix noncompliant resources automatically with the least effort, think Config automatic remediation with an Automation runbook.
  • If the question says member accounts must not change the rules, think organization conformance pack.
  • If the question says act on every new finding, think an EventBridge rule on the finding pattern.
  • If the question says an analyst selects which findings to act on, think a Security Hub CSPM custom action.
  • If the question says isolate a compromised instance automatically, think EventBridge, Lambda and an isolation security group.
  • If the question says events must not be lost when a target fails, think a dead-letter queue on the target.

Remember

  • Automatic remediation requires AutomationAssumeRole.
  • MaximumAutomaticAttempts defaults to 5 (range 1 to 25).
  • GuardDuty exports new findings in about 5 minutes; updates every 6 hours by default.
  • Automation rules run before EventBridge sees findings.
  • EventBridge retries a target for 24 hours and 185 attempts by default, then drops the event without a DLQ.

Trap: A Config aggregator or Security Hub CSPM only reports problems. Something must act on them: automatic remediation, or an EventBridge rule with a target.

Config fixes drift with Automation, and findings trigger a cross-account response
Workload accountSecurity tooling account1223455667789S3 bucketpublic access openedAWS Configmanaged ruleiAutomationremediation runbookiIsolation roletrusts security accountEC2 instancecompromisedSecurity Hub CSPMdelegated adminiDetectiveinvestigationEventBridge rulefinding patternSNS topicsecurity teamLambdaresponse functionGuardDutydelegated adminSQS DLQundelivered events
  1. An organization conformance pack from the security account puts the Config rule and its remediation in every member account. A change makes the bucket noncompliant, and the rule evaluates it as NON_COMPLIANT.

  2. Automatic remediation starts a Systems Manager Automation runbook with the noncompliant resource ID, which reverts the setting. Failed attempts retry up to the configured maximum.

  3. With the Config integration on, the rule's evaluation also becomes a finding in Security Hub CSPM.

  4. GuardDuty detects suspicious activity from the EC2 instance and creates a finding in the delegated administrator account.

  5. GuardDuty and Security Hub CSPM send their findings to EventBridge.

  6. An EventBridge rule matches the finding pattern, alerts the security team through SNS and invokes a Lambda response function.

  7. The function assumes the isolation role in the workload account, whose trust policy names the security account's role, and moves the instance to an isolation security group. Connections already tracked stay open.

  8. Analysts investigate the root cause in Detective, which links up to a year of activity to the GuardDuty finding.

  9. If EventBridge cannot deliver to a target after its retries, or the error is not retryable, the event goes to a dead-letter queue instead of being dropped.

Box details (3)
AWS Config

Deployed with an organization conformance pack from the security account, so member accounts cannot change it.

Automation

Runs with the role in AutomationAssumeRole and receives the noncompliant resource ID as a parameter.

Security Hub CSPM

Automation rules can update findings before EventBridge sees them.

From the AWS docs (21)
  • Config remediation runs a managed or custom Systems Manager Automation document defining the corrective actions.
  • Automatic remediation starts configured corrective actions for resources reported as noncompliant.
  • Automatic Config remediation requires a value for AutomationAssumeRole.
  • A remediation parameter can use a static value or dynamically receive the noncompliant resource ID.
  • MaximumAutomaticAttempts is the maximum failed automatic-remediation attempts, defaults to 5, and accepts 1 through 25.
  • An organization conformance pack deploys Config rules and remediation actions together across member accounts.
  • Member accounts cannot modify the underlying organization conformance pack rules and remediation actions.
  • Activate the AWS Config integration to ingest managed and custom Config rule evaluations as CSPM findings through EventBridge.
  • EventBridge patterns filter finding attributes and invoke targets such as Lambda functions and SNS topics.
  • Create a custom action in CSPM and match its ARN in an EventBridge rule; ARN means Amazon Resource Name.
  • CSPM automation rules update findings before EventBridge rules receive and evaluate them.
  • GuardDuty retains findings for 90 days and exports active findings to EventBridge; new active findings are exported within about 5 minutes.
  • New GuardDuty findings are sent to EventBridge near real time; updates to existing findings default to 6 hours and can be set to 15 minutes or 1 hour.
  • AWS recommends isolating a potentially compromised EC2 instance with a dedicated security group and removing its other security groups.
  • Changing security groups does not terminate existing tracked connections on an EC2 instance.
  • A cross-account AssumeRole caller needs sts:AssumeRole permission on the target role ARN.
  • The target role trust policy must trust the caller or its account for cross-account AssumeRole.
  • Amazon Detective helps investigate security findings and suspicious activity by collecting log data and building visualizations to find the root cause.
  • Detective keeps up to a year of historical event data and links activity to GuardDuty findings.
  • By default, EventBridge retries delivering an event to a target for 24 hours and up to 185 times with exponential backoff and jitter; after that the event is dropped.
  • A dead-letter queue, a standard SQS queue set on a rule target, keeps events that could not be delivered so they can be processed later; errors such as missing permissions to the target go there without retries.

Canary release with automatic rollback

Release questions ask how to ship a change to a small share of users, watch it and undo it automatically if it misbehaves. With Lambda or ECS, CodeDeploy does the traffic shifting, hooks run the checks, and a CloudWatch alarm on the deployment group triggers the rollback.

How it works

  1. The pipeline starts a CodeDeploy deployment. For Lambda, the AppSpec names the alias, the current version and the target version.
  2. The BeforeAllowTraffic hook runs a validation function before the new version gets traffic.
  3. A canary configuration moves a first share of traffic, waits, then moves the rest. Linear moves equal shares at equal intervals.
  4. A CloudWatch alarm on the new version’s errors is attached to the deployment group. With automatic rollback on alarm, CodeDeploy stops and redeploys the last known good revision as a new deployment.
  5. For ECS, the same pattern shifts an Application Load Balancer between task sets, with an optional test listener first.
Configuration How traffic moves Fits
Canary One increment, then the rest after a wait Fast check on real traffic
Linear Equal increments at equal intervals Gradual ramp with time to watch
All-at-once Everything in one step Speed over safety
Decision Choose When
Lambda behind API Gateway CodeDeploy shifting the alias The integration targets the alias
ECS behind an ALB CodeDeploy blue/green with a test listener Testers reach the new task set first
Undo a bad release Alarm on the deployment group, rollback on alarm Errors rise during the shift
Test with no real traffic Synthetics canary Low or no traffic during the release
Tell people about failures Deployment group triggers to SNS Failure and Rollback events

Exam cues

  • If the question says send a small percentage first and the rest later, think a canary deployment configuration.
  • If the question says increase traffic gradually in equal steps, think linear.
  • If the question says roll back automatically when errors rise, think a CloudWatch alarm on the deployment group plus automatic rollback on alarm.
  • If the question says test before any traffic, think the BeforeAllowTraffic hook (or the ECS test listener).
  • If the question says test an endpoint even when there is no traffic, think a CloudWatch Synthetics canary.
  • If the question says notify on failed or rolled back deployments, think deployment group triggers to SNS.

Remember

  • LambdaCanary10Percent5Minutes: 10 percent, then 90 percent five minutes later.
  • The CodeDeploy service role must be able to read CloudWatch alarms.
  • A rollback is a new deployment with a new ID.
  • Stopping a Lambda deployment by hand without rollback can leave the alias on two versions.

Trap: Attaching an alarm alone does not revert anything. Automatic rollback on alarm must be configured too.

CodeDeploy shifts a Lambda alias in a canary and rolls back on an alarm
Region12344445677Lambdavalidation hookiCodeDeploycanary 10% 5 miniCodePipelinedeploy stageSynthetics canaryevery minuteiCloudWatch alarmerrors on new versionClientsHTTPSAPI Gatewayintegration on aliasLambda aliasliveVersion 190% during canaryVersion 210% canary
  1. The pipeline's deploy stage starts a CodeDeploy deployment whose AppSpec names the alias, the current version and the target version.

  2. The BeforeAllowTraffic hook validates the new version before it gets any traffic.

  3. CodeDeploy points 10 percent of the alias at version 2, waits five minutes, then shifts the rest.

  4. Clients call API Gateway, whose integration targets the alias, so requests split between the two versions while the canary runs.

  5. A Synthetics canary calls the API every minute, so problems show up even when real traffic is low.

  6. A CloudWatch alarm watches the new version's errors.

  7. If the alarm fires, CodeDeploy stops the deployment and rolls back to version 1 as a new deployment, and the Failure and Rollback triggers notify the team through SNS.

Box details (3)
Lambda

Runs at BeforeAllowTraffic and AfterAllowTraffic and reports success or failure to CodeDeploy.

CodeDeploy

The deployment group has the alarm attached, automatic rollback on alarm turned on, and SNS triggers for Failure and Rollback events.

Synthetics canary

Scripted checks run even with no customer traffic and publish metrics in the CloudWatchSynthetics namespace.

From the AWS docs (21)
  • Canary shifts traffic in an initial increment and moves the remainder after a waiting interval.
  • Linear shifts traffic in equal increments separated by equal time intervals.
  • All-at-once moves all traffic to the replacement in one step.
  • CodeDeployDefault.LambdaCanary10Percent5Minutes shifts 10 percent first and the remaining 90 percent five minutes later.
  • Lambda AppSpec identifies a function alias, current version, and target version for traffic shifting.
  • Lambda deployment validation functions run at BeforeAllowTraffic and AfterAllowTraffic.
  • CodeDeploy can stop deployments when an attached CloudWatch alarm reaches its threshold.
  • Automatic rollback on alarm thresholds must be configured to redeploy the last known good revision when an attached alarm activates.
  • CodeDeploy rollback redeploys a previous revision as a new deployment with a new deployment ID.
  • A CodeDeploy service role authorizes operations on target resources, publishing SNS notifications, and reading CloudWatch alarms.
  • CodeDeploy ECS canary and linear traffic shifting can use an Application Load Balancer.
  • The optional ECS test listener reaches the replacement before production traffic shifts.
  • Manually stopping a Lambda deployment without rollback can leave its alias referencing two versions and cause later deployments to fail.
  • Synthetics canaries run scripted endpoint and user-flow checks without requiring customer traffic.
  • Canaries can run once or on a schedule as often as once per minute using cron or rate expressions.
  • Canaries publish metrics in the CloudWatchSynthetics namespace.
  • CodeDeploy deployment group triggers publish event notifications to an SNS topic and its subscribers, including email recipients.
  • Failure and Rollback are supported deployment event types for CodeDeploy SNS notification triggers.
  • Linux script output is in /opt/codedeploy-agent/deployment-root/<group-id>/<deployment-id>/logs/scripts.log; agent activity is in /var/log/aws/codedeploy-agent/codedeploy-agent.log.
  • EC2 blue/green AllowTraffic failures without deployment log errors are typically caused by incorrectly configured load balancer health checks.
  • Stage variables can substitute a Lambda function name, version or alias in an integration URI.

Centralized multi-account observability

Operations questions at the professional level spread a workload across many accounts and ask how one team sees it all and keeps the logs. Two mechanisms do the work: CloudWatch cross-account observability for live viewing and alarms, and CloudWatch Logs subscriptions for a durable copy in a log archive account.

How it works

  1. A monitoring account owns a sink. Each source account creates a link to it, allowed by the sink policy.
  2. The monitoring account builds dashboards, runs Logs Insights queries across accounts and creates alarms on source-account metrics.
  3. Subscription filters, per log group or account level, send matching log events to a logical destination in the log archive account.
  4. The destination passes events to Data Firehose, which delivers them to an S3 bucket with Object Lock; Athena and Quick Sight query it there.
  5. The CloudWatch agent adds OS metrics and log files from EC2, and log groups are encrypted with a symmetric KMS key.
Decision Choose When
OS metrics from EC2 CloudWatch agent Memory, disk, log files
One view of many accounts OAM sink and links Dashboards, queries and alarms across accounts
Central, undeletable log archive Subscription to a destination, Firehose, S3 Object Lock Retention and audit
Search logs as they arrive Subscription with a Lambda path to OpenSearch Full-text search
Query the archive Athena and Quick Sight SQL and dashboards on S3
Detect a silent source Alarm treating missing data as breaching Heartbeat metrics
Process log events in near real time Subscription to Kinesis Data Streams or Lambda Custom processing per event

Exam cues

  • If the question says one console for metrics, logs and traces from many accounts, think cross-account observability, because links share data without copying it.
  • If the question says query logs from several accounts at once, think Logs Insights in the monitoring account.
  • If the question says central long-term log storage from many accounts, think subscription filters to a logical destination with Firehose and S3.
  • If the question says every log group including new ones, think an account-level subscription filter.
  • If the question says EC2 memory or disk metrics, think the CloudWatch agent.
  • If the question says logs must never be deleted during retention, think S3 Object Lock in compliance mode.
  • If the question says alert when metrics stop arriving, think treat missing data as breaching.

Remember

  • One sink per Region per account; a source shares with up to five monitoring accounts.
  • No extra charge for shared logs and metrics; the first trace copy is free.
  • Log group and logical destination share a Region.
  • Subscription targets: Kinesis Data Streams, Data Firehose, Lambda.

Trap: Cross-account observability works within a Region. Each Region needs its own sink and links.

Workload accounts link telemetry to a monitoring account and stream logs to a locked archive
Workload account AWorkload account BMonitoring accountLog archive account122345566778CloudWatch agentEC2 memory, disk, logsiCloudWatchmetrics, logs, tracesiLog groupKMS key, subscriptioniCloudWatchmetrics, logs, tracesLog groupsubscription filterOAM sinkcross-account link targetiCloudWatchdashboards and alarmsiSNS topicon-call teamLogs destinationaccess policyiData Firehosedelivery streamS3 bucketObject LockiError prefixfailed recordsQuick SightdashboardsAthenaSQL on archive
  1. On EC2, the CloudWatch agent collects guest OS metrics such as memory and disk, plus log files, which basic monitoring does not include.

  2. Each workload account creates a link to the monitoring account's sink, sharing the telemetry types the sink policy accepts.

  3. In the monitoring account, dashboards and Logs Insights queries span all linked accounts in the Region.

  4. Alarms in the monitoring account watch source-account metrics and notify the on-call team through SNS.

  5. Log groups are encrypted with a KMS key. A subscription filter on each log group, or one account-level filter, sends matching events to a logical destination in the log archive account.

  6. The destination hands events to Data Firehose, which delivers them to an S3 bucket whose Object Lock retention keeps them from being deleted.

  7. Athena queries the archive in place, and Quick Sight builds dashboards on those queries.

  8. Records Firehose cannot deliver or process go to an error prefix in S3 instead of being lost.

Box details (7)
CloudWatch agent

Collects guest OS metrics, such as memory and disk space, and log files.

CloudWatch

Owns a link to the monitoring account's sink.

Log group

Encrypted with a symmetric KMS key; a key policy condition can limit the key to this log group.

OAM sink

Its sink policy allows the organization to create links and limits the shared telemetry types.

CloudWatch

One Logs Insights query can span log groups in several source accounts. Alarms set to treat missing data as breaching fire when a source goes silent.

Logs destination

Same Region as the sending log groups. Its access policy lists the sender accounts.

S3 bucket

Compliance-mode retention keeps each log version from being deleted during its retention period.

From the AWS docs (25)
  • CloudWatch cross-account observability shares operational data between source and monitoring accounts within a Region.
  • A sink is the attachment point managed by a monitoring account.
  • A source account manages a link connecting it to a monitoring account sink.
  • Each account supports one sink per Region, and each source account can share with up to five monitoring accounts.
  • A sink resource policy grants selected accounts or an organization permission to create links and can restrict shared resource types.
  • A monitoring account can run one Logs Insights query across log groups in multiple source accounts.
  • A cross-account observability monitoring account can create alarms watching source-account metrics.
  • Cross-account observability adds no extra cost for logs, metrics, or Application Signals; the first trace copy is free.
  • Subscriptions deliver matching new CloudWatch log events to Kinesis Data Streams, Data Firehose, or Lambda for processing.
  • The cross-account recipient creates a target, a delivery role, a logical destination, and an access policy; senders reference the destination ARN in subscription filters.
  • The source log group and logical destination must share a Region; the destination target resource can be in a different Region.
  • A CloudWatch Logs subscription can send logs to Firehose for delivery to S3.
  • An account-level subscription applies to all log groups unless selection criteria limit which groups are included.
  • The CloudWatch agent collects guest operating system metrics and log files from EC2 and on-premises servers.
  • Use the CloudWatch agent to collect guest memory and disk space metrics beyond EC2 basic monitoring.
  • CloudWatch Logs log group encryption supports only symmetric KMS keys.
  • The kms:EncryptionContext:aws:logs:arn condition can restrict key use to a specific log group.
  • Object Lock compliance retention protects saved log versions from deletion during their retention period.
  • CloudWatch Logs can stream log events to OpenSearch through a Lambda subscription delivery path.
  • Non-retryable destination errors can disable a subscription for up to 10 minutes, during which logs are skipped.
  • breaching treats missing data as violating the threshold.
  • notBreaching treats missing data as within the threshold.
  • Firehose backup configuration includes an S3 backup bucket, bucket prefix, and error output prefix for failed data.
  • Athena runs standard SQL directly on data in S3; it is serverless, so you pay only for the queries you run.
  • Quick Sight can use Athena, Redshift, OpenSearch Service and S3 as data sources for dashboards.

Multi-Region active-active with automated failover

Professional resilience questions ask for more than a standby Region: both Regions serve users, data replicates in both directions, and failover is automatic, tested and safe to trigger. The design combines CloudFront origin groups for static content, Route 53 latency routing for dynamic traffic, DynamoDB global tables for data and ARC routing controls for a deliberate Region switch.

How it works

  1. S3 Cross-Region Replication and a DynamoDB global table copy data to both Regions.
  2. CloudFront serves static content and fails over between buckets through an origin group.
  3. Route 53 latency records with Evaluate Target Health send users to the closest healthy Region.
  4. ARC routing controls move all traffic on purpose, through the health checks linked to each Region’s records.
  5. FIS experiments test the failover, with CloudWatch alarms as stop conditions.
Decision Choose When
Writes in every Region DynamoDB global tables (MREC) Eventual consistency between Regions is acceptable
Latest write everywhere Global tables in MRSC mode Strong reads in every Region; one account
Static content failover CloudFront origin group Primary origin returns an error status
Send users to the closer Region Route 53 latency with Evaluate Target Health Active-active traffic
Deliberate Region switch ARC routing controls Operators decide, DNS follows
Prove failover works FIS experiment with stop conditions Before an incident, in pre-production first
Track RTO and RPO targets Resilience Hub resiliency policy Assess an application against objectives

Exam cues

  • If the question says writes in multiple Regions, think DynamoDB global tables.
  • If the question says static content must survive a Region failure, think S3 replication plus a CloudFront origin group.
  • If the question says route users to the lowest latency Region and skip unhealthy ones, think Route 53 latency records with Evaluate Target Health.
  • If the question says a reliable manual switch between Regions, think ARC routing controls.
  • If the question says test failover safely, think AWS FIS with stop conditions.

Remember

  • MREC: last writer wins. MRSC: strong reads everywhere, empty table, one account.
  • Origin group failover status codes: 400, 403, 404, 416, 429, 500, 502, 503, 504.
  • Cache hits never touch the origin group.
  • ARC routing controls do not measure health.

Trap: Replication is not a test. Until a fault injection experiment has moved traffic, nobody knows whether failover works.

Two Regions serve traffic, replicate data, and fail over by DNS and origin groups
Region ARegion B11223334444567UsersworldwideCloudFrontorigin groupiRoute 53latency recordsiARCrouting controlsiFIS teststop on alarmS3 bucketstatic assetsALBRegion AApp tierAuto ScalingDynamoDBglobal table replicaS3 bucketCRR replicaALBRegion BApp tierAuto ScalingDynamoDBglobal table replicai
  1. S3 Cross-Region Replication copies static assets to Region B, and a DynamoDB global table keeps a replica in each Region.

  2. CloudFront serves static content from its cache, going to the Region A bucket on a miss.

  3. Route 53 latency records send each user to the closer healthy Region, so both Regions serve traffic.

  4. In each Region, the load balancer sends requests to the app tier, which reads and writes its local DynamoDB replica.

  5. Before relying on failover, an FIS experiment injects a fault into Region A's app tier. A CloudWatch alarm as stop condition ends the experiment if the impact goes too far.

  6. If the Region A bucket returns a configured error status, the CloudFront origin group retries the request on the Region B bucket.

  7. To move all traffic, operators turn Region A's ARC routing control Off and Region B's On. The linked Route 53 health checks change, and DNS sends everyone to Region B.

Box details (4)
CloudFront

The origin group pairs the Region A bucket as primary and the Region B bucket as secondary, with chosen failover status codes.

Route 53

Latency aliases with Evaluate Target Health skip a Region whose records are unhealthy.

ARC

Switches that change Route 53 health checks. They do not probe health themselves. Safety rules can require at least one Region to stay On.

DynamoDB

Every replica takes reads and writes. In the default MREC mode, concurrent updates resolve by last writer wins.

From the AWS docs (21)
  • Global tables provide managed replication across Regions and every replica can serve reads and writes.
  • MREC replicates asynchronously and resolves concurrent item updates by latest internal timestamp, called last writer wins.
  • MRSC synchronously replicates a write to at least one other Region before success; strong reads at any replica return the latest item.
  • Conversion to MRSC requires an empty table and additional replicas cannot be added later.
  • Global tables support same-account and multi-account configurations; MRSC supports same-account configurations only.
  • Applications can shift traffic to another global table replica if application processing is interrupted in a Region.
  • An origin group contains a primary and a secondary origin and must be selected by a cache behavior.
  • Selectable failover status codes are 400, 403, 404, 416, 429, 500, 502, 503 and 504.
  • CloudFront serves a cache hit without contacting the origin group.
  • Route 53 latency routing compares configured Regions using measurements collected over time between users and AWS data centers. An endpoint outside AWS can have substantially different latency, even when it is near an AWS Region.
  • Latency aliases can point to regional groups of weighted records; Evaluate Target Health lets Route 53 leave a Region with no healthy records and try another Region.
  • ARC routing controls are On or Off switches that change Route 53 health checks associated with application DNS records.
  • Switching the primary routing control Off and a standby control On changes associated health checks to reroute DNS traffic to the standby application replica.
  • A routing control does not probe endpoint health or measure response time; its configured state controls the associated health check.
  • An assertion safety rule rejects a routing control state update unless its configured conditions remain true, such as at least one control remaining On.
  • An ARC routing control cluster provides five redundant regional endpoints for getting and updating routing control states.
  • S3 Cross-Region Replication copies objects asynchronously to a bucket in another Region, and with versioning you can choose a restore point.
  • FIS injects real faults into real AWS resources so teams can observe workload behavior; AWS recommends planning and pre-production experiments before production.
  • An FIS experiment template defines actions, targets, stop conditions, and an IAM experiment role.
  • A stop condition uses a CloudWatch alarm to stop an FIS experiment when workload performance crosses an unacceptable threshold.
  • A resiliency policy sets recovery time and recovery point objectives for application, infrastructure, Availability Zone and Region disruptions.

Golden image pipeline with immutable rollout

Image questions ask how to give every server the same tested base, patch it regularly and roll changes out without touching running instances. The professional answer is an image factory: Image Builder bakes and tests a golden AMI on a schedule, distribution hands each account its own copy, and Auto Scaling replaces instances with an instance refresh.

How it works

  1. An Image Builder pipeline runs the recipe’s build and test components on a schedule.
  2. Tests run on a new instance launched from the built image, and nothing is distributed unless they pass.
  3. Distribution copies the AMI to each workload account and Region, and writes its ID to Parameter Store.
  4. A new launch template version picks up the AMI, and an instance refresh replaces instances in batches.
  5. CodeDeploy deploys the application on top, and Systems Manager reports inventory and patch compliance between images.
Decision Choose When
Patch servers Replace with a new AMI (immutable) Repeatable, tested, rollback by version
Patch servers Patch Manager in place (mutable) Between image releases
Speed up launch Bake software into the AMI Long installs slow scaling
Environment settings Bootstrap at launch Values differ per environment
Give accounts the image Distribution copy Account must own its copy
Roll out the image Instance refresh Replace running instances in batches

Exam cues

  • If the question says build and test AMIs automatically on a schedule, think EC2 Image Builder.
  • If the question says always launch the latest AMI without editing IDs, think a Parameter Store parameter written by distribution.
  • If the question says replace running instances with a new AMI, think instance refresh.
  • If the question says immutable infrastructure, think new instances from a new image rather than changes to running ones.
  • If the question says report installed software and patch compliance, think Systems Manager Inventory and Compliance.

Remember

  • Image Builder stages: Build, Test, Distribution, in order.
  • A copied AMI belongs to the destination account; a shared AMI only allows launching, in its Region.
  • Instance refresh: 90 percent minimum healthy by default; auto rollback off by default.
  • Rollback cannot restore a template that uses a Parameter Store AMI alias.

Trap: Updating the launch template changes nothing on running instances. Only new instances, or an instance refresh, pick up the new AMI.

Image Builder bakes and tests an AMI, shares it, and Auto Scaling replaces instances with it
Image factory accountWorkload account12345566789Image recipebase and componentsImage Builderscheduled pipelineiSNS topicbuild statusBuild instancebuild and testiInspectorAMI scanningGolden AMItestedCodeDeployapp revisionsSystems Managerinventory and patchingiAMI copyowned by workloadAuto Scalinginstance refreshiParameter Storelatest AMI IDLaunch templatenew version
  1. The image recipe selects a base image and the build and test components. The pipeline runs on a schedule or when started.

  2. The build stage launches an instance and runs the components; the test stage launches a new instance from the result and runs the tests.

  3. Only an image that passes every test becomes the golden AMI.

  4. Inspector scans the AMI for operating system and language package vulnerabilities.

  5. Distribution copies the AMI to the workload account and Regions, so that account owns its copy, and writes the new AMI ID to a Parameter Store parameter.

  6. A new launch template version uses the new AMI, and an instance refresh replaces the group's instances in batches.

  7. CodeDeploy deploys application revisions onto the instances that the golden AMI started.

  8. Between image releases, Systems Manager Inventory and Patch Manager report what each instance runs and whether it meets the patch baseline.

  9. If a build or test step fails, nothing is distributed. The build status goes to the SNS topic, and clearing Terminate instance on failure keeps the failed instance for troubleshooting.

Box details (4)
Image Builder

Runs the Build, Test and Distribution stages in order; each starts only after the previous one succeeds.

Build instance

Testing launches a new instance from the image built in the previous stage.

Systems Manager

Inventory collects software metadata; Compliance reports patch status against the patch baseline between image releases.

Auto Scaling

Replaces instances in batches, keeping at least 90 percent healthy by default.

From the AWS docs (26)
  • An Image Builder recipe selects the base image and build and test components; components contain installation, configuration, or test instructions.
  • Pipelines can run on a schedule or be started manually.
  • Image Builder workflow stages run in the order Build, Test and Distribution; a stage starts after the previous included stage succeeds.
  • AMI testing launches a new EC2 instance from the image created during the build stage.
  • Image Builder distributes an image only after all configured tests succeed.
  • Infrastructure configuration selects instance types, subnet and security groups, an S3 application-log location and an SNS build-status notification topic.
  • The Image Builder console selects Terminate instance on failure by default; clearing it retains a failed instance for troubleshooting.
  • AMI distribution settings can copy images to other Regions and target accounts or grant launch permission to accounts, organizations and organizational units.
  • Cross-account Image Builder distribution delivers an AMI that the destination account can launch or modify.
  • AMI launch sharing retains ownership, permits launching rather than modifying the shared AMI, and is limited to the AMI Region.
  • Image Builder distribution can write an output AMI ID into a Systems Manager Parameter Store parameter.
  • AMIs are Region-specific and can be copied to another Region.
  • Inspector scans owned AMIs for operating system and programming language package vulnerabilities using their backing EBS snapshots, without launching instances.
  • A new launch template applies to new instances; existing instances keep their original configuration until replaced, for example by instance refresh.
  • An instance refresh replaces group instances using an updated launch template or instance configuration.
  • Without an instance maintenance policy, instance refresh defaults to a minimum healthy percentage of 90 percent.
  • Instance refresh auto rollback is disabled by default.
  • Rollback cannot restore a launch template using an AMI alias from Systems Manager Parameter Store.
  • An in-place CodeDeploy EC2 deployment updates the application revision on existing instances.
  • An immutable deployment starts a new server set with the new configuration or application version.
  • Prebaking embeds application components in an AMI and can reduce instance startup work.
  • Bootstrapping installs or customizes software at instance launch; large downloads and complex setup can slow deployment and scaling.
  • Inventory collects metadata such as application versions, file attributes, network configuration, Windows updates, services and tags rather than file contents.
  • Inventory resource data sync continuously updates a central S3 bucket as new collected inventory data is discovered.
  • Systems Manager Compliance reports current patch, association and custom compliance data.
  • Patch baselines define rules and explicit lists for approving or rejecting patches.

Container delivery pipeline with blue/green on ECS

Container delivery questions combine three repositories (code, packages, images) with a release that must be tested before customers see it and undo itself when it fails. The professional design runs one pipeline: build with dependencies from CodeArtifact, push an immutable image to ECR, scan it, test it, then let CodeDeploy shift ECS traffic from blue to green.

How it works

  1. CodeBuild pulls dependencies from CodeArtifact, builds the image and pushes it to ECR with immutable tags.
  2. An InspectorScan action stops the pipeline when the image has too many findings.
  3. A test action invokes Lambda, or CodeBuild, for integration tests.
  4. CodeDeployToECS creates the green task set, the test listener exposes it to the AfterAllowTestTraffic hook, then production traffic shifts.
  5. An alarm on the green task set rolls traffic back to blue.
Decision Choose When
Tags that never move ECR tag immutability Releases must match tested images
Stop vulnerable images InspectorScan action with thresholds Gate inside the pipeline
Test before customers Blue/green with a test listener ECS behind an ALB
Simple rolling update ECS deploy action and circuit breaker No test traffic needed
Kubernetes New Deployment, then switch the Service selector Workload runs on EKS
Long multi-step tests Step Functions invoke action Tests need a workflow

Exam cues

  • If the question says images must not be overwritten, think ECR tag immutability.
  • If the question says fail the pipeline on vulnerable images, think the InspectorScan action.
  • If the question says test the new ECS version before production traffic, think CodeDeploy blue/green with a test listener.
  • If the question says a Lambda test action never finishes, think PutJobSuccessResult or PutJobFailureResult.
  • If the question says roll back a failed rolling ECS deployment, think the deployment circuit breaker.

Remember

  • Standard ECS action: imagedefinitions.json. CodeDeployToECS: task definition template, AppSpec, imageDetail.json.
  • AfterAllowTestTraffic runs after the test listener reaches the green task set.
  • The blue task set stays until the termination wait ends, so rollback is fast.

Trap: The ECS deployment circuit breaker belongs to ECS rolling updates. A CodeDeploy blue/green deployment rolls back through its own alarms and settings.

Build, scan and test an image, then shift ECS traffic to a green task set
RegionVPC11223455677789Git repositorysource actionCodePipelinerelease pipelineCodeBuilddocker buildiECRimmutable tagsiInspectorScanimage scan actioniLambdaintegration testsiCodeArtifactdependenciesCodeDeployECS blue/greeniLambdaAfterAllowTestTrafficClientsHTTPSALBprod and test listenersCloudWatch alarmgreen errorsBlue task setoriginalGreen task setreplacement
  1. A commit starts the pipeline, and CodeBuild builds the container image.

  2. The build pulls dependencies from CodeArtifact with an authorization token and pushes the image to an ECR repository with immutable tags.

  3. An InspectorScan action scans the pushed image and fails the pipeline if findings exceed its thresholds.

  4. A test action invokes a Lambda function that runs integration tests and reports success or failure back to the pipeline.

  5. The CodeDeployToECS action reads imageDetail.json, registers a new task definition and creates the green task set behind the load balancer.

  6. The test listener sends traffic to the green task set, and the AfterAllowTestTraffic hook validates it before customers see it.

  7. CodeDeploy shifts production traffic from the blue task set to the green one, all at once, in a canary or linearly.

  8. A CloudWatch alarm watches the green task set's errors.

  9. If the alarm fires, CodeDeploy rolls traffic back to the blue task set, which stays running until the termination wait ends.

Box details (5)
CodeBuild

Local Docker layer caching needs a Linux environment in privileged mode.

ECR

Enhanced scanning uses Inspector for OS and language packages.

InspectorScan

Fails when findings exceed the critical, high, medium or low thresholds.

Lambda

Reports back with PutJobSuccessResult or PutJobFailureResult.

CodeDeploy

CodeDeployToECS takes a task definition template, an AppSpec file and imageDetail.json.

From the AWS docs (22)
  • CodeBuild can provide Build or Test actions that run buildspec commands in a build container.
  • A Lambda pipeline action must call PutJobSuccessResult or PutJobFailureResult with the job ID to report completion.
  • The CodePipeline event passed to Lambda includes temporary artifact credentials and must not be logged in full.
  • StepFunctions is an Invoke action that starts a state machine, a workflow defined as states and transitions.
  • Local Docker layer cache reuses image layers and requires Linux and privileged mode.
  • A caller outside the domain-owner and repository-administrator accounts needs both an identity-policy Allow and a resource-policy Allow for cross-account access.
  • Package managers use a CodeArtifact authorization token obtained with AWS credentials to publish or consume packages.
  • IMMUTABLE prevents overwriting image tags; a push using an existing immutable tag returns ImageTagAlreadyExistsException.
  • Enhanced scanning uses Amazon Inspector for operating system and programming language package vulnerabilities.
  • InspectorScan is a managed compute CodePipeline action that scans source dependencies or container images for vulnerabilities.
  • CriticalThreshold, HighThreshold, MediumThreshold, and LowThreshold are finding counts beyond which the scan action fails.
  • An ECR source produces an output artifact containing imageDetail.json with the image URI.
  • CodeDeployToECS uses a task definition template, an AppSpec file, and imageDetail.json image input for dynamic image replacement.
  • An ECS standard deploy action consumes imagedefinitions.json by default; the configured filename can be changed.
  • Lambda deployments shift traffic between function versions, and ECS deployments shift traffic between original and replacement task sets.
  • The optional ECS test listener reaches the replacement before production traffic shifts.
  • ECS AfterAllowTestTraffic runs after the test listener sends traffic to the replacement task set.
  • After an ECS deployment, the original task set is terminated according to the configured wait.
  • Automatic rollback on alarm thresholds must be configured to redeploy the last known good revision when an attached alarm activates.
  • The ECS deployment circuit breaker detects rolling deployments that cannot reach a stable running state.
  • With rollback enabled, the circuit breaker chooses the most recent COMPLETED deployment.
  • For blue/green in Kubernetes, create a new Deployment alongside the existing version, test its Pods, and change the Service selector to direct traffic to it.

Event-driven operations across accounts

Operations questions at the professional level describe something happening in an account, such as a scheduled change, an API call or a failed job, and ask how to detect it centrally and respond without people watching consoles. The design forwards events from every account to a central bus, where rules notify, track and fix.

How it works

  1. A rule on each account’s default bus forwards events to a central bus in the operations account.
  2. AWS Health events and CloudTrail API call events arrive on the default bus of the account they concern.
  3. Central rules notify through SNS, open OpsItems in OpsCenter, start Automation runbooks or invoke Lambda.
  4. Responses act in member accounts through an execution role that trusts the operations account.
  5. Automation status events report failed runs, so nothing is silently dropped.
Decision Choose When
One place for every account’s events Central event bus with a resource policy Many accounts, one operations team
Health events for the whole organization Organizational view, delegated administrator Rules alone see only their account
React to API calls AWS API Call via CloudTrail events A trail with logging is on
Track and resolve issues OpsCenter OpsItems Context, deduplication and runbooks
Fix across accounts Automation with an execution role per account Same runbook in many accounts and Regions
Know when a fix failed Rule on Automation Failed or TimedOut Every automated response

Exam cues

  • If the question says react to scheduled maintenance or service events, think AWS Health events in EventBridge.
  • If the question says react when someone calls a specific API, think AWS API Call via CloudTrail events.
  • If the question says collect events from many accounts, think a central event bus with a resource policy.
  • If the question says operational work items with context and runbooks, think OpsCenter.
  • If the question says alert when an automated fix fails, think Automation status events in EventBridge.

Remember

  • Health events reach EventBridge at least once, only for the rule’s own account.
  • API call events need a trail; read-only events need ENABLED_WITH_ALL_CLOUDTRAIL_MANAGEMENT_EVENTS.
  • No third hop: cross-account events are not forwarded again.

Trap: An EventBridge rule in the management account does not see member accounts’ events by default. Forward them from each account, or use the service’s organization feature.

Member accounts forward Health and API events to a central bus that notifies, tracks and fixes
Member accountOperations account1223344555677EC2 instancescheduled changeAWS Healthaccount eventCloudTrailAWS API CalliDefault event busforwarding ruleiSecurity groupingress openedExecution roletrusts operationsOpsCenterOpsItemiSNS topicon-call teamCentral event busresource policyiAutomationresponse runbooksFailure ruleFailed, TimedOut
  1. In every member account, a rule on the default bus forwards matching events to the central bus in the operations account, whose resource policy allows the organization.

  2. AWS Health announces a scheduled change for an EC2 instance and delivers the event to the member account's default bus at least once.

  3. When someone opens a security group, the call reaches the same bus as an AWS API Call via CloudTrail event, which needs a trail with logging on.

  4. Central rules alert the on-call team through SNS and open an OpsItem that collects the event's context.

  5. For the Health event, a rule starts an Automation runbook, which works in the member account through an execution role that trusts the operations account.

  6. For the API call, another rule starts a runbook that uses the same role to remove the ingress rule.

  7. If the runbook ends Failed or TimedOut, its status event matches a failure rule that updates OpsCenter, so the work is not lost.

Box details (4)
CloudTrail

API call events need a trail with logging on. Read-only events need the rule state ENABLED_WITH_ALL_CLOUDTRAIL_MANAGEMENT_EVENTS.

Default event bus

The rule's target is the central bus, with an IAM role for the cross-account delivery.

OpsCenter

Deduplication stops a second OpsItem while a matching one is open. OpsItems can run Automation runbooks.

Central event bus

Its resource policy allows the organization to send events. Events received from another account are not forwarded to a third.

From the AWS docs (21)
  • AWS Health gives ongoing visibility into resource performance and the availability of AWS services and accounts, through events that explain how changes might affect applications.
  • AWS Health account-specific events concern an account and its resources.
  • Public events describe regional service availability and are not specific to an account.
  • EventBridge can send events from a rule in one account to a receiving bus in another account.
  • The receiving bus resource policy must allow the sender account or organization.
  • Cross-account event-bus targets created after March 2, 2023 require an IAM role; older targets without one are unaffected.
  • An event received from another account is not forwarded onward to a third account.
  • A rule on an event bus compares arriving events with a pattern and sends matching events to its targets.
  • CloudTrail-derived EventBridge events require a trail with logging enabled.
  • EventBridge uses AWS API Call via CloudTrail for API calls and AWS Console Signin via CloudTrail for sign-in attempts.
  • EventBridge rules in ENABLED state match CloudTrail write management events.
  • Read-only management events require EventBridge rule state ENABLED_WITH_ALL_CLOUDTRAIL_MANAGEMENT_EVENTS, including both forwarding and destination rules when forwarding.
  • OpsCenter centralizes investigation and resolution of operational work items called OpsItems.
  • CloudWatch alarms entering ALARM and EventBridge rules can create OpsItems automatically; users can also create them manually.
  • OpsCenter can run Systems Manager Automation runbooks to help resolve an OpsItem.
  • If the matching OpsItem is open or in progress, deduplication prevents creation of another matching item.
  • Automation execution status changes are sent to EventBridge, so a rule on Failed or TimedOut can notify an SNS topic.
  • Systems Manager Automation can run from a central account across target AWS accounts, organizational units and Regions.
  • AWS-SystemsManager-AutomationAdministrationRole belongs in the central account and permits assuming target execution roles.
  • AWS Health delivers events to EventBridge at least once, and rules can send them to targets such as Lambda, SQS or SNS, for example when EC2 instances are scheduled for updates.
  • An EventBridge rule receives AWS Health events only for its own account; events for other accounts in an organization need the organizational view with delegated administrator access.

Flashcards

tap to flip
Answer

·

All 124 cards as a list

A web application on EC2 must survive the loss of an Availability Zone with no manual action. Which combination of load balancer and compute settings fits?

An Application Load Balancer with subnets in at least two AZs, in front of an Auto Scaling group that spans the same AZs.

The group replaces unhealthy instances and launches in the surviving zone.

A three-tier application on EC2 must let only the web tier reach the database tier, even as instances are added and removed. How should the database security group be written?

Allow the database port with the app tier security group as the source, not IP ranges.

The rule then covers every instance in that group, whatever its address.

Private EC2 instances in two Availability Zones share one NAT gateway in AZ A. What happens to internet access from AZ B if AZ A fails, and what is the fix?

AZ B loses outbound internet access. Create one NAT gateway per AZ and route each zone's private subnets to the NAT gateway in the same zone.

A company serves static images from an S3 bucket through CloudFront and wants the bucket closed to direct public access. What should it configure?

Origin access control (OAC) on the distribution, and a bucket policy that allows only that distribution. Block Public Access can stay on.

A three-tier web application uses Aurora and needs a database that keeps serving after an Availability Zone failure, with read capacity in the other zone. Which design fits?

An Aurora cluster with an Aurora Replica in another AZ. The replica serves reads and is the failover target, and the cluster volume already keeps copies in three AZs.

The domain example.com must point at a CloudFront distribution. Why does the team use a Route 53 alias record instead of a CNAME?

A CNAME is not allowed at the zone apex. An alias record can point example.com at the distribution.

Users of an Auto Scaling web tier are logged out whenever an instance is terminated. Which change fits a highly available three-tier design?

Move session state to a shared store such as ElastiCache (or DynamoDB), so any instance can serve any user.

A web application behind CloudFront receives SQL injection attempts and bursts of requests from a few IP addresses. What should block them before they reach the origin?

An AWS WAF web ACL on the CloudFront distribution, with rules for SQL injection and request rates.

A company wants baseline DDoS protection for a public web application without paying for an extra service. What does it get, and which front end helps?

Shield Standard protects every customer automatically at no extra cost. Serving through CloudFront and Route 53 absorbs attacks at edge locations.

A web application needs HTTPS certificates on CloudFront and on its Application Load Balancer that renew without manual work. Which service fits?

AWS Certificate Manager (ACM): it issues and renews certificates and deploys them to integrated services such as CloudFront and Elastic Load Balancing.

An Amazon RDS DB instance was created without encryption, and compliance now requires encryption at rest. Can the team turn it on in place?

No. Copy a manual snapshot with encryption enabled and restore it (or use a blue/green deployment with an encrypted green environment). The KMS key is chosen at creation.

An Auto Scaling group behind an ALB should keep average CPU near 50 percent as traffic changes, without hand-built alarms. Which scaling policy fits?

A target tracking policy on average CPU with a target of 50. It adjusts capacity and manages its own CloudWatch alarms.

A serverless REST API in API Gateway must accept only users who signed in to the company's web app, with no custom authorization code. Which option fits?

A Cognito user pool authorizer on the API. Users sign in to the user pool and send its token with each request.

An order API on Lambda must notify billing, email and analytics services, and new consumers keep being added. How can the API stay unchanged as consumers grow?

Publish an event to an EventBridge event bus and give each consumer its own rule and target.

The producer never calls consumers directly.

A Lambda function that consumes an SQS queue calls a legacy database that fails under more than 20 parallel connections. How can the team cap the load without slowing the API that fills the queue?

Set maximum concurrency on the SQS event source mapping. Messages wait in the queue instead of reaching the database all at once.

Some messages in an SQS queue fail processing every time and are retried again and again. Which feature isolates them for debugging?

An SQS dead-letter queue. Messages that fail repeatedly move there for debugging. It must be in the same account and Region as the source queue.

A serverless order flow must charge a card, reserve stock and ship, with retries and a visible state per order. Which service coordinates the steps?

AWS Step Functions. A workflow (state machine) runs each step and shows where every execution is.

A new serverless application on DynamoDB has unpredictable traffic and no capacity estimate. Which throughput mode fits?

On-demand, the default and recommended mode for most workloads. There is no capacity to plan.

A serverless API in API Gateway (REST) receives SQL injection attempts. Can AWS WAF protect it directly, without CloudFront in front?

Yes. A regional AWS WAF web ACL can be associated with an API Gateway REST API.

Failed order messages pile up in an SQS dead-letter queue for days before anyone notices. What should the team add?

A CloudWatch alarm on the dead-letter queue's ApproximateNumberOfMessagesVisible metric, so the team is notified as soon as messages arrive.

Some requests through API Gateway and Lambda are slow, and the team must see which downstream call causes it, request by request. What fits?

AWS X-Ray with Active tracing on the Lambda functions, which records each sampled request's path and timing.

A Lambda function processes SQS messages in batches of ten. When one message fails, all ten are retried. How can only the failed message be retried?

Report partial batch failures from the function, returning only the failed message IDs, so successful messages are not processed again.

A company needs its application to keep answering requests within minutes of a Region failure, at lower cost than running two full Regions. Which DR strategy fits?

Warm standby: a scaled-down but fully working copy runs in the DR Region, takes traffic at once and scales out.

In the DR Region, the databases are replicated and running but no application servers can serve traffic until they are started. Which strategy is this, and how does warm standby differ?

Pilot light. Warm standby keeps the application running at reduced capacity, so it handles traffic immediately.

Traffic must go to the primary Region and switch to a DR Region automatically when the primary endpoint is unhealthy. Which Route 53 configuration fits?

Failover routing (active-passive) with a health check on the primary record and a secondary record for the DR Region.

An Aurora MySQL database must be readable in a second Region and promotable there during a regional outage. Which feature fits?

Aurora Global Database: one primary Region for writes and up to 10 read-only secondary Regions kept in sync.

A multi-Region application must accept writes in every Region with low local latency. Which database feature fits better than Aurora Global Database?

DynamoDB global tables, which are multi-active: every replica Region takes reads and writes. An Aurora global database writes only in its primary Region.

A DR plan replicates S3 objects to another Region, but a bad batch job just overwrote thousands of objects, and the overwrites replicated too. What protects against this?

Versioning on the buckets, so earlier versions can be restored. Replication alone copies corruption as well.

How can a team keep the DR Region's infrastructure identical to production as production changes?

Define it once in CloudFormation and deploy the same template to both Regions (and accounts), for example with a StackSet.

A company runs a planned DR test that moves its Aurora global database to the DR Region and must lose no data. Which operation fits?

Switchover (formerly managed planned failover): it synchronizes the secondary before changing the primary Region, with RPO zero.

The primary Region of an Aurora global database is down. The team runs managed failover. Can recent writes be lost?

Yes. Managed failover does not wait for synchronization, so writes still in asynchronous replication can be lost. Only a switchover guarantees RPO zero.

After an Aurora global database fails over to the DR Region, must the application change the database hostname it writes to?

No, if it uses the global writer endpoint: the name stays the same and points to the new primary. The application must pick up the DNS change before writing again.

Besides live replication, a company needs point-in-time backups of its databases stored in the DR Region, in case corrupted data replicates. What fits?

An AWS Backup plan with a copy action to a vault in the DR Region. The first copy is full; later copies are generally incremental.

A CodePipeline pipeline in a central tooling account must deploy CloudFormation stacks into separate staging and production accounts. Which pieces does the design need?

An S3 artifact bucket whose policy grants the target accounts, a customer managed KMS key that allows them, and a role in each target account that the deploy action assumes by ARN.

A cross-account CodePipeline deploy fails because the production account cannot decrypt artifacts encrypted with the default AWS managed S3 key. What should change?

Encrypt the artifact bucket with a customer managed KMS key whose key policy allows the production account. Cross-account pipelines need a customer managed key.

A cross-account CodePipeline action references the artifact encryption key by its alias, and the target account cannot use it. Why?

KMS aliases resolve only in their owning account. Reference the key by key ID or ARN.

In a cross-account CodePipeline design, which permissions does the role in the target account need?

Permissions to deploy (for example CloudFormation), plus read access to the artifact bucket and use of the encryption key. The bucket policy and key policy must also allow that account.

A pipeline must not update the production account until a release manager reviews the staging result. What fits, and what permission does the reviewer need?

A manual approval action before the production stage. The reviewer needs codepipeline:PutApprovalResult on that action.

A pipeline in us-east-1 adds a deploy action that runs in eu-west-1. What artifact storage does it need?

An artifact bucket in each Region where it runs actions: its own Region and eu-west-1.

A baseline CloudFormation template must reach every account in an organizational unit, including accounts created later, without creating roles by hand. What fits better than one pipeline stage per account?

A service-managed StackSet targeting the OU. It creates the needed roles through Organizations trusted access and deploys one template across accounts and Regions.

CodeBuild in a tooling account must pull packages from a CodeArtifact domain owned by a shared services account. What has to allow the request?

An allow in the CodeBuild role's IAM policy and in the domain or repository policy. The IAM policy must also allow sts:GetServiceBearerToken, which a domain policy cannot grant.

A CloudFormation deployment should undo itself if the application's error rate alarm fires during the update or shortly after. What fits?

A rollback trigger with that CloudWatch alarm and a monitoring period. If the alarm enters ALARM, CloudFormation rolls back the whole update.

The team must be alerted whenever any execution of a CodePipeline pipeline fails. What fits with no polling?

An EventBridge rule matching the CodePipeline Pipeline Execution State Change event with state FAILED, targeting an SNS topic.

A production stage of a V2 pipeline failed after a bad change. How can the team return the stage to the last good release without a new commit?

Use stage rollback, which starts a new execution with the source revisions and artifacts of a previously successful execution. Failed actions can also be retried.

A CloudFormation deploy action in production uses REPLACE_ON_FAILURE. Why is that risky?

It can delete and recreate a failed stack; AWS recommends it for testing only. Production uses CREATE_UPDATE.

Accounts added to an OU later must receive the baseline stack without anyone running a deployment. Which StackSet setting fits?

Automatic deployment on a service-managed StackSet targeting the OU, which creates stack instances for accounts added to it.

A company needs a governed multi-account AWS environment with preventive and detective guardrails and standardized account vending. Which service fits?

AWS Control Tower: it sets up a landing zone on Organizations, applies controls (guardrails) and creates accounts through Account Factory.

An SCP on the Workloads OU allows only approved Regions. A developer in a member account still cannot launch EC2 in an approved Region. Why, and does the SCP restrict the management account?

An SCP only limits permissions; the developer still needs an IAM policy that grants the action. SCPs do not restrict the management account.

A security team must run GuardDuty and Security Hub CSPM for every account without working in the management account. What should be configured?

Register a security tooling account as the delegated administrator for each service. For GuardDuty, set it up in every Region with the same account. SCPs still apply to that account.

API activity in every account, including accounts created later, must be logged to one bucket, and member account admins must not be able to stop it. What fits?

An organization trail created from the management account or a CloudTrail delegated administrator. New members join it automatically, and members cannot modify or stop it.

An auditor wants one read-only view of AWS Config compliance across all accounts. A team proposes a Config aggregator to also turn on recording and deploy rules in member accounts. Will that work?

No. An aggregator only collects data already recorded and shows it read-only. Recording and rules must be deployed separately, for example with conformance packs or StackSets.

Engineers need one MFA-protected sign-in to reach the accounts they are assigned, with a standard set of permissions in each. What fits?

IAM Identity Center with permission sets assigned per account.

Security Hub CSPM is enabled in several Regions, and the team wants all findings and security scores in one Region. What should it configure?

Cross-Region aggregation with a home Region, which receives findings, updates, insights and scores from the linked Regions.

Every new account must arrive with the company's network baseline, IAM roles and SCPs, without manual steps after Account Factory creates it. What fits?

Customizations for Control Tower (CfCT), which reacts to the account's lifecycle event and deploys templates through StackSets, plus SCPs, in manifest order. AFT does the same as a Terraform pipeline.

A team plans to deploy its application stacks through Account Factory for Terraform (AFT) because it already provisions their accounts. Is that the intended use?

No. AFT is meant for account provisioning and customization, not for deploying application workloads. Use a deployment pipeline for those.

An administrator detached a Control Tower managed SCP from an OU. How does the platform team find out, and how is it repaired?

Control Tower detects policy drift and, from landing zone 4.0, sends a Drift Detected event to EventBridge in the management account; a rule can alert through SNS. Updating the landing zone repairs it.

An account joined the organization by invitation. The management account's admins try to assume OrganizationAccountAccessRole in it and fail. Why?

Only accounts created through Organizations get that role by default. For an invited account, create the role manually.

An S3 bucket that becomes public must be fixed automatically within minutes, using AWS managed tooling with no custom servers. What design fits?

An AWS Config rule with automatic remediation that runs a Systems Manager Automation runbook, passing the noncompliant resource ID as a parameter.

Automatic remediation on an AWS Config rule fails to save. The runbook and parameters are set. What is commonly missing?

The AutomationAssumeRole value: automatic remediation requires a role for the Automation runbook to run with.

A security team must deploy the same Config rules and remediations to every member account, and account admins must not be able to change them. What fits?

An organization conformance pack. It deploys rules and remediation actions together, and member accounts cannot modify them.

A team wants a Lambda function to run automatically whenever a high-severity Security Hub CSPM or GuardDuty finding appears. What should it build?

An EventBridge rule whose pattern matches the finding attributes, with the Lambda function (and an SNS topic if people must know) as targets.

Analysts want to choose a Security Hub CSPM finding in the console and send it to a ticketing workflow on demand, not for every finding. What fits?

A Security Hub CSPM custom action, matched by its ARN in an EventBridge rule that targets the workflow.

An EventBridge rule triggers on GuardDuty findings, but changes to an existing finding arrive hours later. Why, and what can change it?

New findings export in about 5 minutes, but updates to existing findings default to every 6 hours. Set the frequency to 15 minutes or 1 hour.

A Security Hub CSPM automation rule suppresses some findings, and an EventBridge rule should only see the remaining ones. Does the order work?

Yes. Automation rules update findings before EventBridge rules receive and evaluate them.

A GuardDuty finding shows an EC2 instance in a workload account talking to a known malicious host. A Lambda function in the security account must contain it automatically. What design fits?

An EventBridge rule on the finding invokes Lambda, which assumes a role in the workload account (its trust policy names the security account's role) and moves the instance to a dedicated isolation security group.

After a compromised instance is moved to an isolation security group with no rules, the attacker's existing session keeps working. Why?

Changing security groups does not end connections that are already tracked. Isolation stops new connections; existing ones need other action.

The Lambda target of a security EventBridge rule was down for a day, and some findings never triggered a response. How should the rule be configured?

Add a dead-letter queue to the target. EventBridge retries for up to 24 hours and 185 attempts by default, then drops the event unless a DLQ keeps it.

An EventBridge rule's target role lost permission to invoke the function. Will EventBridge retry for 24 hours?

No. Errors such as missing permissions are not retried; the event goes straight to the DLQ if one is configured, or is lost.

After containment, analysts must find the root cause of a GuardDuty finding using months of related activity. Which service fits?

Amazon Detective, which builds visualizations from log data and links up to a year of history to GuardDuty findings.

A Lambda function update must reach 10 percent of requests first and then everyone if nothing breaks, with no custom traffic code. What fits?

A CodeDeploy deployment with a canary configuration such as CodeDeployDefault.LambdaCanary10Percent5Minutes, shifting the function's alias from the current to the target version.

How do CodeDeploy canary, linear and all-at-once deployments differ?

Canary: one first increment, then the rest after a wait.

Linear: equal increments at equal intervals.

All-at-once: everything in one step.

A canary deployment must undo itself if the new version's error rate rises during the shift. What must the CodeDeploy deployment group have?

A CloudWatch alarm on the error metric attached to the deployment group, with automatic rollback on alarm turned on, so CodeDeploy redeploys the last known good revision.

An alarm is attached to a CodeDeploy deployment group and fires during a canary, but the previous version is not redeployed. What was missed?

Automatic rollback on alarm was not configured. Without it, the alarm can stop the deployment, but CodeDeploy does not redeploy the last known good revision.

Before any user traffic reaches a new Lambda version in a CodeDeploy deployment, a smoke test must pass. Where does it run?

In a validation Lambda function on the BeforeAllowTraffic hook. AfterAllowTraffic can check again after the shift.

After an automatic CodeDeploy rollback, a team searches for the original deployment ID to see the rollback. Where is it?

A rollback is a new deployment with a new ID that redeploys the previous revision.

An Amazon ECS service behind an Application Load Balancer needs a canary release, with testers reaching the new task set before customers. What fits?

A CodeDeploy ECS blue/green deployment with a canary configuration on the ALB and an optional test listener that reaches the replacement before production traffic shifts.

A new API version gets almost no traffic at night, so a canary deployment's error alarm may never see a failure. How can the team keep testing the endpoint?

A CloudWatch Synthetics canary that calls the endpoint on a schedule, as often as once per minute, without needing customer traffic. Its metrics can feed the alarm.

The release team must get an email whenever a CodeDeploy deployment fails or rolls back. What fits?

A deployment group trigger for the Failure and Rollback events, publishing to an SNS topic with email subscribers.

An EC2 in-place CodeDeploy deployment fails during a lifecycle script. Where should the team look first on a Linux instance?

The script output in scripts.log under the deployment's folder in /opt/codedeploy-agent/deployment-root, and the agent log in /var/log/aws/codedeploy-agent. The CloudWatch agent can collect them centrally.

An EC2 blue/green deployment fails at AllowTraffic, and the deployment logs show no errors. What is the usual cause?

Load balancer health checks that are configured incorrectly, so the new instances never pass.

An operations team wants one CloudWatch console to view metrics, logs and traces from 30 workload accounts in the same Region, without copying data. What fits?

CloudWatch cross-account observability: a monitoring account owns a sink, and each source account creates a link to it.

Every new account in an organization must be able to link to a central CloudWatch monitoring account, sharing only metrics and logs. How is that allowed?

A sink policy on the monitoring account's sink that grants the organization permission to create links and restricts the shared resource types.

During an incident, an engineer must search application logs from five accounts with one query. What does cross-account observability allow?

A single Logs Insights query in the monitoring account across log groups in multiple source accounts. Alarms there can also watch source-account metrics.

A team plans a second sink in the same Region of its monitoring account, and wants one source account to share with eight monitoring accounts. Are both possible?

No. Each account has one sink per Region, and a source account can share with up to five monitoring accounts.

Logs from many accounts must land in one S3 bucket in a log archive account for years. What CloudWatch Logs design fits?

Subscription filters in each account sending to a logical destination in the archive account, backed by Data Firehose that delivers to S3.

A cross-account CloudWatch Logs subscription fails because the logical destination is in us-east-1 and the log group is in eu-west-1. What is the rule?

The log group and the logical destination must be in the same Region. The destination's target, such as a Firehose stream, can be in another Region.

A team wants every log group in an account, including new ones, streamed to a central destination without adding a filter per group. What fits?

An account-level subscription filter, which covers all log groups unless selection criteria narrow it.

Dashboards must show memory and disk usage of EC2 instances, which basic monitoring lacks. What has to be installed?

The CloudWatch agent, which collects guest OS metrics and log files. Its metrics are billed as custom metrics.

Archived logs must be impossible to delete, even by an administrator, for seven years. Which S3 feature fits?

S3 Object Lock in compliance mode with a retention period, which protects each log version from deletion until it ends.

A team encrypts a CloudWatch Logs log group with an asymmetric KMS key, and it fails. Why?

Log group encryption supports only symmetric KMS keys. A key policy condition on kms:EncryptionContext:aws:logs:arn can limit the key to one log group.

An application's logs must be searchable in OpenSearch Service as they arrive. Which CloudWatch Logs feature delivers them?

A subscription filter with a Lambda delivery path to OpenSearch. Subscriptions also feed Kinesis Data Streams, Data Firehose or Lambda.

An alarm must fire when a workload stops sending its heartbeat metric altogether. How should missing data be treated?

As breaching, so missing data counts as violating the threshold. With notBreaching, silence would look healthy.

Auditors want SQL queries and dashboards over years of archived logs in S3 without loading them anywhere. What fits?

Athena to query the files in place, and Quick Sight dashboards with Athena as the data source.

An application must accept writes in two Regions at once with local latency, and the data must survive the loss of either Region. Which database feature fits?

DynamoDB global tables: every replica takes reads and writes. In the default MREC mode, replication is asynchronous and concurrent updates resolve by last writer wins.

A multi-Region DynamoDB application needs strong reads that always return the latest write, in any Region. What fits, and what are the limits?

A global table in MRSC mode, which replicates each write to another Region before succeeding. It needs an empty table, cannot add replicas later and works in one account.

Static assets served by CloudFront from an S3 bucket in one Region must keep working if that bucket fails. What fits?

Replicate the bucket to another Region and use a CloudFront origin group with the two buckets as primary and secondary, failing over on chosen status codes such as 500, 502, 503 or 504.

During a test, the primary origin of a CloudFront origin group is down, yet some requests never reach the secondary. Why?

Cache hits are served without contacting the origin group at all; failover only happens on requests that go to the origin.

A company wants a dependable, operator-triggered way to move all traffic from one Region to another, without editing DNS records during an incident. What fits?

ARC routing controls: On/Off switches that change Route 53 health checks tied to each Region's records, with a highly available cluster of endpoints.

Does an ARC routing control notice by itself that a Region is unhealthy?

No. It does not probe endpoints; its state decides the health check result. Detection comes from alarms or people, and safety rules can stop every control from being turned Off.

A team must prove that its multi-Region failover works, with a safe way to stop if customers are affected. What fits?

An AWS FIS experiment template with actions, targets and a stop condition on a CloudWatch alarm, run in pre-production first.

Route 53 latency records point to two Regions. How does Route 53 avoid sending users to a Region whose endpoints are down?

Use alias records with Evaluate Target Health, so Route 53 leaves a Region with no healthy records and answers with another Region.

A company wants a hardened, tested AMI rebuilt every week with the latest patches, and only images that pass tests may be used. What fits?

An EC2 Image Builder pipeline on a schedule, with a recipe of build and test components. It distributes an image only after all tests succeed.

Workload accounts in several Regions must launch the golden AMI and own their copy. How should Image Builder deliver it?

Distribution settings that copy the AMI to the target accounts and Regions. A copied AMI belongs to the destination account; launch sharing would only allow launching, in one Region.

Teams always want the newest golden AMI in their launch templates without editing AMI IDs by hand. What fits?

Have Image Builder distribution write the AMI ID to a Parameter Store parameter that launch templates and pipelines read.

A new launch template version with the new AMI is set as default, but running instances still use the old AMI. How are they replaced safely?

Start an instance refresh, which replaces instances in batches, keeping 90 percent healthy by default. A new template only affects new instances.

An instance refresh must roll back automatically, but the launch template takes its AMI from a Parameter Store alias. Will rollback work?

No. Auto rollback is off by default, and it cannot restore a launch template that uses a Parameter Store AMI alias; it needs a numbered previous template version.

What is the difference between patching instances in place and replacing them with a new golden AMI?

In place is mutable: existing servers change. A new AMI rolled out by instance refresh is immutable: new servers start from a tested image, and baking cuts launch time compared with bootstrapping.

Security needs to know which software versions run on every instance and whether each meets the patch baseline, across accounts. What fits?

Systems Manager Inventory with a resource data sync to a central S3 bucket, plus Compliance for patch status against the patch baseline.

Every new golden AMI must be checked for known package vulnerabilities before teams adopt it. Which service scans the AMI?

Amazon Inspector, which scans owned AMIs for operating system and programming language package vulnerabilities.

Release images must never be overwritten after they are pushed, so a tag always points to the image that was tested. What fits?

Tag immutability on the ECR repository. A push that reuses an existing tag fails with ImageTagAlreadyExistsException.

A pipeline must stop when a new container image has more than zero critical vulnerabilities, with no custom scanning code. What fits?

A CodePipeline InspectorScan action in ECRImageScan mode with a CriticalThreshold; the action fails when findings exceed it.

A pipeline invokes a Lambda function to run integration tests, and the stage hangs until it times out. What is the function missing?

It must report back with PutJobSuccessResult or PutJobFailureResult and the job ID. It should also never log the full event, which holds artifact credentials.

Which input files does the CodePipeline CodeDeployToECS action need, compared with the standard ECS deploy action?

CodeDeployToECS needs a task definition template, an AppSpec file and imageDetail.json. The standard ECS action reads imagedefinitions.json.

QA must test a new ECS version through the production load balancer before any customer traffic reaches it. What fits?

CodeDeploy blue/green with a test listener; the AfterAllowTestTraffic hook validates the replacement task set before the production shift.

An ECS service uses rolling updates, not CodeDeploy. How can a deployment that never stabilizes roll back automatically?

Turn on the deployment circuit breaker with rollback; it returns to the most recent COMPLETED deployment.

How is a blue/green release done for a workload on Amazon EKS?

Create a new Deployment next to the current one, test its Pods, then change the Service selector to send traffic to the new version.

Events from 50 accounts must reach one operations account for central rules and responses. How?

In each account, a rule on the default bus targets a central event bus in the operations account, with an IAM role. The central bus resource policy allows the sender accounts or the organization.

The central operations bus forwards events to a security account bus, but events that came from member accounts never arrive there. Why?

EventBridge does not forward an event received from another account on to a third account. Send it from the source account directly.

A rule in the management account should catch AWS Health events for every member account, but it only sees its own. What is needed?

AWS Health's organizational view with delegated administrator access. A rule on its own receives Health events only for its account.

An EventBridge rule should react when someone calls AuthorizeSecurityGroupIngress, but nothing matches. What must exist?

A CloudTrail trail with logging on, because API calls arrive as AWS API Call via CloudTrail events. Read-only calls also need the rule state ENABLED_WITH_ALL_CLOUDTRAIL_MANAGEMENT_EVENTS.

Operational issues from alarms and events must become tracked work items with context and one-click runbooks, without duplicates. What fits?

Systems Manager OpsCenter: alarms and EventBridge rules create OpsItems, deduplication blocks repeats while one is open, and OpsItems can run Automation runbooks.

The team must know when an Automation runbook started by an event fails or times out. What fits?

Automation sends execution status changes to EventBridge; a rule on Failed or TimedOut notifies SNS or opens an OpsItem.

One runbook must run from a central account against instances in many accounts and Regions. What makes that possible?

Systems Manager Automation multi-account and multi-Region execution: the central AutomationAdministrationRole assumes an execution role in each target account.

What is the difference between AWS Health public events and account-specific events?

Public events describe a service's regional availability for everyone; account-specific events concern your account and its resources, such as a scheduled change for an instance.

You finished every topic of DOP-C02!

Your badge turned gold. Next step: book the exam on AWS. Once you pass, add yourself to Who passed.

Share

Share that you finished this certification

I finished every topic of AWS Certified DevOps Engineer - Professional (DOP-C02) on Easy Review. Come study too!