Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

Right-size to memory-optimized EC2 if memory pressure dominates would help if a large in-memory analytical cache spills to disk on undersized general-purpose hosts. Memory-optimized instances reduce spill overhead. That is not the symptom described here: oversized EBS bandwidth is purchased though storage throughput is far lower. The matching response is Select an instance size matching measured network and EBS bandwidth, because instance type choice should reflect actual I/O requirements.

For the alternative failure a GPU instance runs a simple CPU-only scheduled script, the control Replace it with suitable CPU instances or Lambda is relevant: gPU capacity is unnecessary for CPU-only tasks. Here the evidence instead is oversized EBS bandwidth is purchased though storage throughput is far lower. The selected technical mechanism is Select an instance size matching measured network and EBS bandwidth: instance type choice should reflect actual I/O requirements.

Use general-purpose EC2 instances sized to observed demand solves a different operational problem where a general web tier has balanced modest CPU and memory requirements. Balanced families suit common mixed workloads. It does not directly address oversized EBS bandwidth is purchased though storage throughput is far lower. The case calls for Select an instance size matching measured network and EBS bandwidth, since instance type choice should reflect actual I/O requirements.

For the alternative failure app containers run much larger task CPU/memory than observed, the control Right-size ECS task definitions from metrics is relevant: task allocation determines Fargate billing. Here the evidence instead is a small team maintains Kubernetes clusters for simple stateless containers and wants less admin overhead. The selected technical mechanism is Use Amazon ECS/Fargate where Kubernetes APIs are not required: simpler orchestration reduces cluster operations.

Use EKS rather than rebuilding operator features in ECS solves a different operational problem where several teams require Kubernetes custom operators and portable manifests. Kubernetes requirements justify EKS operational complexity. It does not directly address a small team maintains Kubernetes clusters for simple stateless containers and wants less admin overhead. The case calls for Use Amazon ECS/Fargate where Kubernetes APIs are not required, since simpler orchestration reduces cluster operations.

The competing option Trigger Lambda or Batch with EventBridge Scheduler would be useful when a service uses an EC2 host exclusively to run one hourly job. Event-driven compute removes idle host cost. The present issue is a small team maintains Kubernetes clusters for simple stateless containers and wants less admin overhead; it is more directly addressed by Use Amazon ECS/Fargate where Kubernetes APIs are not required. Simpler orchestration reduces cluster operations.

Use Amazon ECS/Fargate where Kubernetes APIs are not required solves a different operational problem where a small team maintains Kubernetes clusters for simple stateless containers and wants less admin overhead. Simpler orchestration reduces cluster operations. It does not directly address several teams require Kubernetes custom operators and portable manifests. The case calls for Use EKS rather than rebuilding operator features in ECS, since Kubernetes requirements justify EKS operational complexity.

The competing option Right-size ECS task definitions from metrics would be useful when app containers run much larger task CPU/memory than observed. Task allocation determines Fargate billing. The present issue is several teams require Kubernetes custom operators and portable manifests; it is more directly addressed by Use EKS rather than rebuilding operator features in ECS. Kubernetes requirements justify EKS operational complexity.

The option Trigger Lambda or Batch with EventBridge Scheduler addresses a separate condition: a service uses an EC2 host exclusively to run one hourly job. Event-driven compute removes idle host cost. The actual requirement is several teams require Kubernetes custom operators and portable manifests. Recommended corrective action: Use EKS rather than rebuilding operator features in ECS. Kubernetes requirements justify EKS operational complexity.

Right-size ECS task definitions from metrics solves a different operational problem where app containers run much larger task CPU/memory than observed. Task allocation determines Fargate billing. It does not directly address a service uses an EC2 host exclusively to run one hourly job. The case calls for Trigger Lambda or Batch with EventBridge Scheduler, since event-driven compute removes idle host cost.

The competing option Use EKS rather than rebuilding operator features in ECS would be useful when several teams require Kubernetes custom operators and portable manifests. Kubernetes requirements justify EKS operational complexity. The present issue is a service uses an EC2 host exclusively to run one hourly job; it is more directly addressed by Trigger Lambda or Batch with EventBridge Scheduler. Event-driven compute removes idle host cost.

Queue asynchronous side effects and return quickly would help if an event handler spends most time waiting for an unneeded synchronous downstream action. Decoupling removes avoidable request-time resource occupation. That is not the symptom described here: a service uses an EC2 host exclusively to run one hourly job. The matching response is Trigger Lambda or Batch with EventBridge Scheduler, because event-driven compute removes idle host cost.

The competing option Right-size ECS task definitions from metrics would be useful when app containers run much larger task CPU/memory than observed. Task allocation determines Fargate billing. The present issue is an event handler spends most time waiting for an unneeded synchronous downstream action; it is more directly addressed by Queue asynchronous side effects and return quickly. Decoupling removes avoidable request-time resource occupation.

The option Trigger Lambda or Batch with EventBridge Scheduler addresses a separate condition: a service uses an EC2 host exclusively to run one hourly job. Event-driven compute removes idle host cost. The actual requirement is an event handler spends most time waiting for an unneeded synchronous downstream action. Recommended corrective action: Queue asynchronous side effects and return quickly. Decoupling removes avoidable request-time resource occupation.

Use Amazon ECS/Fargate where Kubernetes APIs are not required would help if a small team maintains Kubernetes clusters for simple stateless containers and wants less admin overhead. Simpler orchestration reduces cluster operations. That is not the symptom described here: an event handler spends most time waiting for an unneeded synchronous downstream action. The matching response is Queue asynchronous side effects and return quickly, because decoupling removes avoidable request-time resource occupation.

The option Use Amazon ECS/Fargate where Kubernetes APIs are not required addresses a separate condition: a small team maintains Kubernetes clusters for simple stateless containers and wants less admin overhead. Simpler orchestration reduces cluster operations. The actual requirement is app containers run much larger task CPU/memory than observed. Recommended corrective action: Right-size ECS task definitions from metrics. Task allocation determines Fargate billing.

Use EKS rather than rebuilding operator features in ECS would help if several teams require Kubernetes custom operators and portable manifests. Kubernetes requirements justify EKS operational complexity. That is not the symptom described here: app containers run much larger task CPU/memory than observed. The matching response is Right-size ECS task definitions from metrics, because task allocation determines Fargate billing.

For the alternative failure an event handler spends most time waiting for an unneeded synchronous downstream action, the control Queue asynchronous side effects and return quickly is relevant: decoupling removes avoidable request-time resource occupation. Here the evidence instead is app containers run much larger task CPU/memory than observed. The selected technical mechanism is Right-size ECS task definitions from metrics: task allocation determines Fargate billing.

Tune scaling around real workload demand and performance objectives would help if an autoscaling group runs too many hosts because scaling targets use an unrelated metric. Misaligned scaling signals cause excess capacity. That is not the symptom described here: cost Explorer shows a consistent compute floor across the past year. The matching response is Match eligible committed Savings Plans to measured baseline usage, because commitments suit predictable long-running usage.

Use On-Demand baseline and keep Spot for tolerant background services solves a different operational problem where spot interruption reports show frequent failures in a time-critical API tier. Critical synchronous APIs should not depend on interruptible sole capacity. It does not directly address cost Explorer shows a consistent compute floor across the past year. The case calls for Match eligible committed Savings Plans to measured baseline usage, since commitments suit predictable long-running usage.

The competing option Enforce scheduled stop/scale-in with environment exceptions would be useful when a dev-test environment runs 24/7 without any activity overnight. Nonproduction scheduling cuts unused compute hours. The present issue is cost Explorer shows a consistent compute floor across the past year; it is more directly addressed by Match eligible committed Savings Plans to measured baseline usage. Commitments suit predictable long-running usage.

For the alternative failure a dev-test environment runs 24/7 without any activity overnight, the control Enforce scheduled stop/scale-in with environment exceptions is relevant: nonproduction scheduling cuts unused compute hours. Here the evidence instead is spot interruption reports show frequent failures in a time-critical API tier. The selected technical mechanism is Use On-Demand baseline and keep Spot for tolerant background services: critical synchronous APIs should not depend on interruptible sole capacity.

Prefer flexible Compute Savings Plans over narrow instance-family commitments solves a different operational problem where a service frequently changes regions and instance types due to expansion. Flexible commitments accommodate changing deployment footprints. It does not directly address spot interruption reports show frequent failures in a time-critical API tier. The case calls for Use On-Demand baseline and keep Spot for tolerant background services, since critical synchronous APIs should not depend on interruptible sole capacity.

The competing option Match eligible committed Savings Plans to measured baseline usage would be useful when cost Explorer shows a consistent compute floor across the past year. Commitments suit predictable long-running usage. The present issue is spot interruption reports show frequent failures in a time-critical API tier; it is more directly addressed by Use On-Demand baseline and keep Spot for tolerant background services. Critical synchronous APIs should not depend on interruptible sole capacity.

Use On-Demand baseline and keep Spot for tolerant background services solves a different operational problem where spot interruption reports show frequent failures in a time-critical API tier. Critical synchronous APIs should not depend on interruptible sole capacity. It does not directly address a dev-test environment runs 24/7 without any activity overnight. The case calls for Enforce scheduled stop/scale-in with environment exceptions, since nonproduction scheduling cuts unused compute hours.

The competing option Tune scaling around real workload demand and performance objectives would be useful when an autoscaling group runs too many hosts because scaling targets use an unrelated metric. Misaligned scaling signals cause excess capacity. The present issue is a dev-test environment runs 24/7 without any activity overnight; it is more directly addressed by Enforce scheduled stop/scale-in with environment exceptions. Nonproduction scheduling cuts unused compute hours.

Match eligible committed Savings Plans to measured baseline usage would help if cost Explorer shows a consistent compute floor across the past year. Commitments suit predictable long-running usage. That is not the symptom described here: a dev-test environment runs 24/7 without any activity overnight. The matching response is Enforce scheduled stop/scale-in with environment exceptions, because nonproduction scheduling cuts unused compute hours.

The competing option Tune scaling around real workload demand and performance objectives would be useful when an autoscaling group runs too many hosts because scaling targets use an unrelated metric. Misaligned scaling signals cause excess capacity. The present issue is a service frequently changes regions and instance types due to expansion; it is more directly addressed by Prefer flexible Compute Savings Plans over narrow instance-family commitments. Flexible commitments accommodate changing deployment footprints.

Match eligible committed Savings Plans to measured baseline usage would help if cost Explorer shows a consistent compute floor across the past year. Commitments suit predictable long-running usage. That is not the symptom described here: a service frequently changes regions and instance types due to expansion. The matching response is Prefer flexible Compute Savings Plans over narrow instance-family commitments, because flexible commitments accommodate changing deployment footprints.

For the alternative failure spot interruption reports show frequent failures in a time-critical API tier, the control Use On-Demand baseline and keep Spot for tolerant background services is relevant: critical synchronous APIs should not depend on interruptible sole capacity. Here the evidence instead is a service frequently changes regions and instance types due to expansion. The selected technical mechanism is Prefer flexible Compute Savings Plans over narrow instance-family commitments: flexible commitments accommodate changing deployment footprints.

The option Enforce scheduled stop/scale-in with environment exceptions addresses a separate condition: a dev-test environment runs 24/7 without any activity overnight. Nonproduction scheduling cuts unused compute hours. The actual requirement is an autoscaling group runs too many hosts because scaling targets use an unrelated metric. Recommended corrective action: Tune scaling around real workload demand and performance objectives. Misaligned scaling signals cause excess capacity.

For the alternative failure cost Explorer shows a consistent compute floor across the past year, the control Match eligible committed Savings Plans to measured baseline usage is relevant: commitments suit predictable long-running usage. Here the evidence instead is an autoscaling group runs too many hosts because scaling targets use an unrelated metric. The selected technical mechanism is Tune scaling around real workload demand and performance objectives: misaligned scaling signals cause excess capacity.

Prefer flexible Compute Savings Plans over narrow instance-family commitments solves a different operational problem where a service frequently changes regions and instance types due to expansion. Flexible commitments accommodate changing deployment footprints. It does not directly address an autoscaling group runs too many hosts because scaling targets use an unrelated metric. The case calls for Tune scaling around real workload demand and performance objectives, since misaligned scaling signals cause excess capacity.