Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

Configure an EventBridge archive and controlled replay where supported would help if a business wants event replay for a limited audit window. Event archives retain event-bus records for replay. That is not the symptom described here: an integration partner can only push approved events to a shared bus. The matching response is Add an EventBridge resource policy constrained to intended sender principals, because event-bus policies govern cross-account event publishing.

For the alternative failure events with specific account and detail-type values need separate processing, the control Define EventBridge rules that match the required event patterns is relevant: event patterns route only matching records. Here the evidence instead is an integration partner can only push approved events to a shared bus. The selected technical mechanism is Add an EventBridge resource policy constrained to intended sender principals: event-bus policies govern cross-account event publishing.

Use EventBridge event buses and target rule subscriptions solves a different operational problem where a service publishes domain events but must not know subscriber URLs. Producers and consumers stay decoupled through event routing. It does not directly address an integration partner can only push approved events to a shared bus. The case calls for Add an EventBridge resource policy constrained to intended sender principals, since event-bus policies govern cross-account event publishing.

Reference Secrets Manager values through supported ECS secret injection would help if an external secret appears in plain text in the ECS task definition. Task definitions can reference secrets without embedding values. That is not the symptom described here: an ECS service requires per-task CPU and memory capacity without managing EC2 worker nodes. The matching response is Use Amazon ECS on AWS Fargate with appropriate task sizing, because fargate runs container tasks without EC2 fleet management.

Configure supported rolling deployment minimum healthy percent and health checks solves a different operational problem where a container rollout causes a sudden drop in availability from replacing every task at once. Deployment controls preserve healthy capacity during replacement. It does not directly address an ECS service requires per-task CPU and memory capacity without managing EC2 worker nodes. The case calls for Use Amazon ECS on AWS Fargate with appropriate task sizing, since fargate runs container tasks without EC2 fleet management.

The competing option Use independent ECS services and queue-depth-driven scaling would be useful when a busy ingestion worker queue must scale separately from API containers. Service-specific scaling avoids resource coupling. The present issue is an ECS service requires per-task CPU and memory capacity without managing EC2 worker nodes; it is more directly addressed by Use Amazon ECS on AWS Fargate with appropriate task sizing. Fargate runs container tasks without EC2 fleet management.

Reference Secrets Manager values through supported ECS secret injection solves a different operational problem where an external secret appears in plain text in the ECS task definition. Task definitions can reference secrets without embedding values. It does not directly address the app needs an HTTP path router to three independent container services. The case calls for Place services behind an ALB with host/path target-group rules, since aLB request routing separates application components.

The competing option Use independent ECS services and queue-depth-driven scaling would be useful when a busy ingestion worker queue must scale separately from API containers. Service-specific scaling avoids resource coupling. The present issue is the app needs an HTTP path router to three independent container services; it is more directly addressed by Place services behind an ALB with host/path target-group rules. ALB request routing separates application components.

The option Configure supported rolling deployment minimum healthy percent and health checks addresses a separate condition: a container rollout causes a sudden drop in availability from replacing every task at once. Deployment controls preserve healthy capacity during replacement. The actual requirement is the app needs an HTTP path router to three independent container services. Recommended corrective action: Place services behind an ALB with host/path target-group rules. ALB request routing separates application components.

Configure supported rolling deployment minimum healthy percent and health checks solves a different operational problem where a container rollout causes a sudden drop in availability from replacing every task at once. Deployment controls preserve healthy capacity during replacement. It does not directly address a busy ingestion worker queue must scale separately from API containers. The case calls for Use independent ECS services and queue-depth-driven scaling, since service-specific scaling avoids resource coupling.

The competing option Place services behind an ALB with host/path target-group rules would be useful when the app needs an HTTP path router to three independent container services. ALB request routing separates application components. The present issue is a busy ingestion worker queue must scale separately from API containers; it is more directly addressed by Use independent ECS services and queue-depth-driven scaling. Service-specific scaling avoids resource coupling.

The option Use Amazon ECS on AWS Fargate with appropriate task sizing addresses a separate condition: an ECS service requires per-task CPU and memory capacity without managing EC2 worker nodes. Fargate runs container tasks without EC2 fleet management. The actual requirement is a busy ingestion worker queue must scale separately from API containers. Recommended corrective action: Use independent ECS services and queue-depth-driven scaling. Service-specific scaling avoids resource coupling.

The competing option Use independent ECS services and queue-depth-driven scaling would be useful when a busy ingestion worker queue must scale separately from API containers. Service-specific scaling avoids resource coupling. The present issue is a container rollout causes a sudden drop in availability from replacing every task at once; it is more directly addressed by Configure supported rolling deployment minimum healthy percent and health checks. Deployment controls preserve healthy capacity during replacement.

The option Use Amazon ECS on AWS Fargate with appropriate task sizing addresses a separate condition: an ECS service requires per-task CPU and memory capacity without managing EC2 worker nodes. Fargate runs container tasks without EC2 fleet management. The actual requirement is a container rollout causes a sudden drop in availability from replacing every task at once. Recommended corrective action: Configure supported rolling deployment minimum healthy percent and health checks. Deployment controls preserve healthy capacity during replacement.

For the alternative failure an external secret appears in plain text in the ECS task definition, the control Reference Secrets Manager values through supported ECS secret injection is relevant: task definitions can reference secrets without embedding values. Here the evidence instead is a container rollout causes a sudden drop in availability from replacing every task at once. The selected technical mechanism is Configure supported rolling deployment minimum healthy percent and health checks: deployment controls preserve healthy capacity during replacement.

Use independent ECS services and queue-depth-driven scaling would help if a busy ingestion worker queue must scale separately from API containers. Service-specific scaling avoids resource coupling. That is not the symptom described here: an external secret appears in plain text in the ECS task definition. The matching response is Reference Secrets Manager values through supported ECS secret injection, because task definitions can reference secrets without embedding values.

For the alternative failure the app needs an HTTP path router to three independent container services, the control Place services behind an ALB with host/path target-group rules is relevant: aLB request routing separates application components. Here the evidence instead is an external secret appears in plain text in the ECS task definition. The selected technical mechanism is Reference Secrets Manager values through supported ECS secret injection: task definitions can reference secrets without embedding values.

Configure supported rolling deployment minimum healthy percent and health checks solves a different operational problem where a container rollout causes a sudden drop in availability from replacing every task at once. Deployment controls preserve healthy capacity during replacement. It does not directly address an external secret appears in plain text in the ECS task definition. The case calls for Reference Secrets Manager values through supported ECS secret injection, since task definitions can reference secrets without embedding values.

Define readiness checks and safe rolling update thresholds would help if a single pod restart causes dropped client connections during rolling updates. Readiness gates remove unready pods from service traffic. That is not the symptom described here: a Kubernetes deployment needs application pod replicas to rise with utilization. The matching response is Configure Horizontal Pod Autoscaler with appropriate metrics, because hPA scales pods based on resource or custom metrics.

For the alternative failure container tasks must run without administering Kubernetes clusters, the control Use ECS/Fargate for a simpler orchestration model when Kubernetes APIs are unnecessary is relevant: purpose-built ECS can reduce orchestration complexity. Here the evidence instead is a Kubernetes deployment needs application pod replicas to rise with utilization. The selected technical mechanism is Configure Horizontal Pod Autoscaler with appropriate metrics: hPA scales pods based on resource or custom metrics.

The competing option Use Amazon EKS rather than building an unmanaged master control plane would be useful when the app requires a managed Kubernetes control plane with workload portability. EKS runs the managed Kubernetes API control plane. The present issue is a Kubernetes deployment needs application pod replicas to rise with utilization; it is more directly addressed by Configure Horizontal Pod Autoscaler with appropriate metrics. HPA scales pods based on resource or custom metrics.

Configure Horizontal Pod Autoscaler with appropriate metrics solves a different operational problem where a Kubernetes deployment needs application pod replicas to rise with utilization. HPA scales pods based on resource or custom metrics. It does not directly address nodes run out of schedulable resources after pods scale out. The case calls for Configure supported EKS node scaling with managed node groups or Karpenter, since cluster capacity must follow workload pod growth.

The competing option Use Amazon EKS rather than building an unmanaged master control plane would be useful when the app requires a managed Kubernetes control plane with workload portability. EKS runs the managed Kubernetes API control plane. The present issue is nodes run out of schedulable resources after pods scale out; it is more directly addressed by Configure supported EKS node scaling with managed node groups or Karpenter. Cluster capacity must follow workload pod growth.

The option Define readiness checks and safe rolling update thresholds addresses a separate condition: a single pod restart causes dropped client connections during rolling updates. Readiness gates remove unready pods from service traffic. The actual requirement is nodes run out of schedulable resources after pods scale out. Recommended corrective action: Configure supported EKS node scaling with managed node groups or Karpenter. Cluster capacity must follow workload pod growth.

The competing option Configure Horizontal Pod Autoscaler with appropriate metrics would be useful when a Kubernetes deployment needs application pod replicas to rise with utilization. HPA scales pods based on resource or custom metrics. The present issue is a single pod restart causes dropped client connections during rolling updates; it is more directly addressed by Define readiness checks and safe rolling update thresholds. Readiness gates remove unready pods from service traffic.

The option Use Amazon EKS rather than building an unmanaged master control plane addresses a separate condition: the app requires a managed Kubernetes control plane with workload portability. EKS runs the managed Kubernetes API control plane. The actual requirement is a single pod restart causes dropped client connections during rolling updates. Recommended corrective action: Define readiness checks and safe rolling update thresholds. Readiness gates remove unready pods from service traffic.

Use ECS/Fargate for a simpler orchestration model when Kubernetes APIs are unnecessary would help if container tasks must run without administering Kubernetes clusters. Purpose-built ECS can reduce orchestration complexity. That is not the symptom described here: a single pod restart causes dropped client connections during rolling updates. The matching response is Define readiness checks and safe rolling update thresholds, because readiness gates remove unready pods from service traffic.

The competing option Use ECS/Fargate for a simpler orchestration model when Kubernetes APIs are unnecessary would be useful when container tasks must run without administering Kubernetes clusters. Purpose-built ECS can reduce orchestration complexity. The present issue is the app requires a managed Kubernetes control plane with workload portability; it is more directly addressed by Use Amazon EKS rather than building an unmanaged master control plane. EKS runs the managed Kubernetes API control plane.

Configure supported EKS node scaling with managed node groups or Karpenter would help if nodes run out of schedulable resources after pods scale out. Cluster capacity must follow workload pod growth. That is not the symptom described here: the app requires a managed Kubernetes control plane with workload portability. The matching response is Use Amazon EKS rather than building an unmanaged master control plane, because eKS runs the managed Kubernetes API control plane.

For the alternative failure a single pod restart causes dropped client connections during rolling updates, the control Define readiness checks and safe rolling update thresholds is relevant: readiness gates remove unready pods from service traffic. Here the evidence instead is the app requires a managed Kubernetes control plane with workload portability. The selected technical mechanism is Use Amazon EKS rather than building an unmanaged master control plane: eKS runs the managed Kubernetes API control plane.

The option Configure supported EKS node scaling with managed node groups or Karpenter addresses a separate condition: nodes run out of schedulable resources after pods scale out. Cluster capacity must follow workload pod growth. The actual requirement is container tasks must run without administering Kubernetes clusters. Recommended corrective action: Use ECS/Fargate for a simpler orchestration model when Kubernetes APIs are unnecessary. Purpose-built ECS can reduce orchestration complexity.

Use Amazon EKS rather than building an unmanaged master control plane would help if the app requires a managed Kubernetes control plane with workload portability. EKS runs the managed Kubernetes API control plane. That is not the symptom described here: container tasks must run without administering Kubernetes clusters. The matching response is Use ECS/Fargate for a simpler orchestration model when Kubernetes APIs are unnecessary, because purpose-built ECS can reduce orchestration complexity.

Configure Horizontal Pod Autoscaler with appropriate metrics solves a different operational problem where a Kubernetes deployment needs application pod replicas to rise with utilization. HPA scales pods based on resource or custom metrics. It does not directly address container tasks must run without administering Kubernetes clusters. The case calls for Use ECS/Fargate for a simpler orchestration model when Kubernetes APIs are unnecessary, since purpose-built ECS can reduce orchestration complexity.