Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

Use an ALB with path-based listener rules would help if requests need routing by URL path to different container target groups. ALB routes at HTTP Layer 7. That is not the symptom described here: a target group continuously marks healthy instances unhealthy due to the wrong port. The matching response is Correct target-group health-check port/protocol and threshold settings, because health checks control available targets.

For the alternative failure TLS/TCP clients require fast stable IP-based ingress, the control Choose NLB with the matching transport protocol listener is relevant: nLB supports Layer-4 connection routing. Here the evidence instead is a target group continuously marks healthy instances unhealthy due to the wrong port. The selected technical mechanism is Correct target-group health-check port/protocol and threshold settings: health checks control available targets.

Use ALB capabilities that support WebSocket HTTP connections solves a different operational problem where a custom HTTP service needs WebSocket support and cookie-related routing. ALB handles HTTP upgrade flows. It does not directly address a target group continuously marks healthy instances unhealthy due to the wrong port. The case calls for Correct target-group health-check port/protocol and threshold settings, since health checks control available targets.

For the alternative failure a Lambda function reaches the concurrency limit during a flash sale, the control Set appropriate reserved/provisioned concurrency and request a quota increase if needed is relevant: concurrency is limited by function and regional quotas. Here the evidence instead is cold-start initialization delays breach a stringent latency SLA. The selected technical mechanism is Evaluate provisioned concurrency for latency-sensitive Lambda aliases: provisioned concurrency keeps execution environments ready.

Use RDS Proxy and reuse database connections where supported solves a different operational problem where a function opens new database connections on every invocation and exhausts RDS. RDS Proxy reduces backend connection churn. It does not directly address cold-start initialization delays breach a stringent latency SLA. The case calls for Evaluate provisioned concurrency for latency-sensitive Lambda aliases, since provisioned concurrency keeps execution environments ready.

The competing option Move the long-running step to Step Functions plus ECS/Batch would be useful when a Lambda application exceeds the maximum invocation duration. Lambda is not suitable for multi-hour single invocations. The present issue is cold-start initialization delays breach a stringent latency SLA; it is more directly addressed by Evaluate provisioned concurrency for latency-sensitive Lambda aliases. Provisioned concurrency keeps execution environments ready.

Use RDS Proxy and reuse database connections where supported solves a different operational problem where a function opens new database connections on every invocation and exhausts RDS. RDS Proxy reduces backend connection churn. It does not directly address a CPU-heavy Lambda function has low assigned memory and executes slowly. The case calls for Increase Lambda memory allocation and measure duration/CPU tradeoffs, since lambda compute entitlement scales with configured memory.

The competing option Set appropriate reserved/provisioned concurrency and request a quota increase if needed would be useful when a Lambda function reaches the concurrency limit during a flash sale. Concurrency is limited by function and regional quotas. The present issue is a CPU-heavy Lambda function has low assigned memory and executes slowly; it is more directly addressed by Increase Lambda memory allocation and measure duration/CPU tradeoffs. Lambda compute entitlement scales with configured memory.

The option Evaluate provisioned concurrency for latency-sensitive Lambda aliases addresses a separate condition: cold-start initialization delays breach a stringent latency SLA. Provisioned concurrency keeps execution environments ready. The actual requirement is a CPU-heavy Lambda function has low assigned memory and executes slowly. Recommended corrective action: Increase Lambda memory allocation and measure duration/CPU tradeoffs. Lambda compute entitlement scales with configured memory.

Use RDS Proxy and reuse database connections where supported solves a different operational problem where a function opens new database connections on every invocation and exhausts RDS. RDS Proxy reduces backend connection churn. It does not directly address a Lambda application exceeds the maximum invocation duration. The case calls for Move the long-running step to Step Functions plus ECS/Batch, since lambda is not suitable for multi-hour single invocations.

The competing option Evaluate provisioned concurrency for latency-sensitive Lambda aliases would be useful when cold-start initialization delays breach a stringent latency SLA. Provisioned concurrency keeps execution environments ready. The present issue is a Lambda application exceeds the maximum invocation duration; it is more directly addressed by Move the long-running step to Step Functions plus ECS/Batch. Lambda is not suitable for multi-hour single invocations.

Increase Lambda memory allocation and measure duration/CPU tradeoffs would help if a CPU-heavy Lambda function has low assigned memory and executes slowly. Lambda compute entitlement scales with configured memory. That is not the symptom described here: a Lambda application exceeds the maximum invocation duration. The matching response is Move the long-running step to Step Functions plus ECS/Batch, because lambda is not suitable for multi-hour single invocations.

The option Move the long-running step to Step Functions plus ECS/Batch addresses a separate condition: a Lambda application exceeds the maximum invocation duration. Lambda is not suitable for multi-hour single invocations. The actual requirement is a Lambda function reaches the concurrency limit during a flash sale. Recommended corrective action: Set appropriate reserved/provisioned concurrency and request a quota increase if needed. Concurrency is limited by function and regional quotas.

Evaluate provisioned concurrency for latency-sensitive Lambda aliases would help if cold-start initialization delays breach a stringent latency SLA. Provisioned concurrency keeps execution environments ready. That is not the symptom described here: a Lambda function reaches the concurrency limit during a flash sale. The matching response is Set appropriate reserved/provisioned concurrency and request a quota increase if needed, because concurrency is limited by function and regional quotas.

For the alternative failure a function opens new database connections on every invocation and exhausts RDS, the control Use RDS Proxy and reuse database connections where supported is relevant: rDS Proxy reduces backend connection churn. Here the evidence instead is a Lambda function reaches the concurrency limit during a flash sale. The selected technical mechanism is Set appropriate reserved/provisioned concurrency and request a quota increase if needed: concurrency is limited by function and regional quotas.

Move the long-running step to Step Functions plus ECS/Batch would help if a Lambda application exceeds the maximum invocation duration. Lambda is not suitable for multi-hour single invocations. That is not the symptom described here: a function opens new database connections on every invocation and exhausts RDS. The matching response is Use RDS Proxy and reuse database connections where supported, because rDS Proxy reduces backend connection churn.

For the alternative failure a CPU-heavy Lambda function has low assigned memory and executes slowly, the control Increase Lambda memory allocation and measure duration/CPU tradeoffs is relevant: lambda compute entitlement scales with configured memory. Here the evidence instead is a function opens new database connections on every invocation and exhausts RDS. The selected technical mechanism is Use RDS Proxy and reuse database connections where supported: rDS Proxy reduces backend connection churn.

Evaluate provisioned concurrency for latency-sensitive Lambda aliases solves a different operational problem where cold-start initialization delays breach a stringent latency SLA. Provisioned concurrency keeps execution environments ready. It does not directly address a function opens new database connections on every invocation and exhausts RDS. The case calls for Use RDS Proxy and reuse database connections where supported, since rDS Proxy reduces backend connection churn.

For the alternative failure a Kubernetes service has enough replicas but nodes are fully scheduled, the control Enable appropriate EKS node auto-provisioning or autoscaler is relevant: pod scheduling needs available node capacity. Here the evidence instead is an ECS service's tasks are saturated even while the ASG EC2 hosts have spare room. The selected technical mechanism is Adjust service desired count and target-tracking scaling metrics: task scaling governs application replica count.

Increase task memory sizing after measuring working-set demand solves a different operational problem where a Fargate task's memory limit repeatedly causes OOM kills. Container memory limits determine possible OOM termination. It does not directly address an ECS service's tasks are saturated even while the ASG EC2 hosts have spare room. The case calls for Adjust service desired count and target-tracking scaling metrics, since task scaling governs application replica count.

The competing option Configure readiness checks, grace periods and health-based deployment would be useful when a rollout sends traffic to tasks before warmup completes. Healthy target admission must match app readiness. The present issue is an ECS service's tasks are saturated even while the ASG EC2 hosts have spare room; it is more directly addressed by Adjust service desired count and target-tracking scaling metrics. Task scaling governs application replica count.

For the alternative failure a rollout sends traffic to tasks before warmup completes, the control Configure readiness checks, grace periods and health-based deployment is relevant: healthy target admission must match app readiness. Here the evidence instead is a Fargate task's memory limit repeatedly causes OOM kills. The selected technical mechanism is Increase task memory sizing after measuring working-set demand: container memory limits determine possible OOM termination.

The competing option Enable appropriate EKS node auto-provisioning or autoscaler would be useful when a Kubernetes service has enough replicas but nodes are fully scheduled. Pod scheduling needs available node capacity. The present issue is a Fargate task's memory limit repeatedly causes OOM kills; it is more directly addressed by Increase task memory sizing after measuring working-set demand. Container memory limits determine possible OOM termination.

The option Increase task CPU resources and benchmark throughput addresses a separate condition: a container processes CPU-bound requests but task CPU is set very low. Task CPU allocations affect processing capacity. The actual requirement is a Fargate task's memory limit repeatedly causes OOM kills. Recommended corrective action: Increase task memory sizing after measuring working-set demand. Container memory limits determine possible OOM termination.

Configure readiness checks, grace periods and health-based deployment solves a different operational problem where a rollout sends traffic to tasks before warmup completes. Healthy target admission must match app readiness. It does not directly address a Kubernetes service has enough replicas but nodes are fully scheduled. The case calls for Enable appropriate EKS node auto-provisioning or autoscaler, since pod scheduling needs available node capacity.

The option Adjust service desired count and target-tracking scaling metrics addresses a separate condition: an ECS service's tasks are saturated even while the ASG EC2 hosts have spare room. Task scaling governs application replica count. The actual requirement is a Kubernetes service has enough replicas but nodes are fully scheduled. Recommended corrective action: Enable appropriate EKS node auto-provisioning or autoscaler. Pod scheduling needs available node capacity.

Increase task CPU resources and benchmark throughput would help if a container processes CPU-bound requests but task CPU is set very low. Task CPU allocations affect processing capacity. That is not the symptom described here: a Kubernetes service has enough replicas but nodes are fully scheduled. The matching response is Enable appropriate EKS node auto-provisioning or autoscaler, because pod scheduling needs available node capacity.

The competing option Adjust service desired count and target-tracking scaling metrics would be useful when an ECS service's tasks are saturated even while the ASG EC2 hosts have spare room. Task scaling governs application replica count. The present issue is a container processes CPU-bound requests but task CPU is set very low; it is more directly addressed by Increase task CPU resources and benchmark throughput. Task CPU allocations affect processing capacity.

The option Increase task memory sizing after measuring working-set demand addresses a separate condition: a Fargate task's memory limit repeatedly causes OOM kills. Container memory limits determine possible OOM termination. The actual requirement is a container processes CPU-bound requests but task CPU is set very low. Recommended corrective action: Increase task CPU resources and benchmark throughput. Task CPU allocations affect processing capacity.

Enable appropriate EKS node auto-provisioning or autoscaler would help if a Kubernetes service has enough replicas but nodes are fully scheduled. Pod scheduling needs available node capacity. That is not the symptom described here: a container processes CPU-bound requests but task CPU is set very low. The matching response is Increase task CPU resources and benchmark throughput, because task CPU allocations affect processing capacity.

The option Increase task memory sizing after measuring working-set demand addresses a separate condition: a Fargate task's memory limit repeatedly causes OOM kills. Container memory limits determine possible OOM termination. The actual requirement is a rollout sends traffic to tasks before warmup completes. Recommended corrective action: Configure readiness checks, grace periods and health-based deployment. Healthy target admission must match app readiness.

Adjust service desired count and target-tracking scaling metrics would help if an ECS service's tasks are saturated even while the ASG EC2 hosts have spare room. Task scaling governs application replica count. That is not the symptom described here: a rollout sends traffic to tasks before warmup completes. The matching response is Configure readiness checks, grace periods and health-based deployment, because healthy target admission must match app readiness.

Increase task CPU resources and benchmark throughput solves a different operational problem where a container processes CPU-bound requests but task CPU is set very low. Task CPU allocations affect processing capacity. It does not directly address a rollout sends traffic to tasks before warmup completes. The case calls for Configure readiness checks, grace periods and health-based deployment, since healthy target admission must match app readiness.