Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

The option Mount Amazon EFS across the hosts addresses a separate condition: multiple EC2 Linux hosts need a shared writable filesystem with elastic growth. EFS provides managed elastic NFS sharing. The actual requirement is an external batch process expects FTP/SFTP semantics for files already in S3. Recommended corrective action: Use AWS Transfer Family where suitable. Transfer Family exposes managed file-transfer protocols over S3/EFS backends.

Configure supported Lambda ephemeral storage sizing would help if a team needs temporary file space above the default Lambda /tmp capacity. Lambda ephemeral-storage capacity can be increased within limits. That is not the symptom described here: an external batch process expects FTP/SFTP semantics for files already in S3. The matching response is Use AWS Transfer Family where suitable, because transfer Family exposes managed file-transfer protocols over S3/EFS backends.

Use EBS volumes with appropriate backups solves a different operational problem where stateful EC2 database data requires single-host block filesystem semantics. EBS provides persistent block device storage tied to an AZ. It does not directly address an external batch process expects FTP/SFTP semantics for files already in S3. The case calls for Use AWS Transfer Family where suitable, since transfer Family exposes managed file-transfer protocols over S3/EFS backends.

For the alternative failure a Java service needs several minutes to initialize after new instances launch, the control Configure ASG instance warmup and load-balancer grace handling is relevant: warmup keeps new capacity from skewing scaling measurements. Here the evidence instead is average CPU is low but ALB requests queue under high per-target load. The selected technical mechanism is Use target tracking on appropriate ALB request count per target: request-based scaling reflects HTTP demand better than CPU alone.

Configure scheduled scaling to pre-provision instance capacity solves a different operational problem where a predictable spike occurs at the same weekday hour. Scheduled capacity reduces response delay during known peaks. It does not directly address average CPU is low but ALB requests queue under high per-target load. The case calls for Use target tracking on appropriate ALB request count per target, since request-based scaling reflects HTTP demand better than CPU alone.

The competing option Use EC2 Auto Scaling target tracking on measured CPU utilization would be useful when traffic rises irregularly and CPU correlates with saturation. Target tracking follows resource demand automatically. The present issue is average CPU is low but ALB requests queue under high per-target load; it is more directly addressed by Use target tracking on appropriate ALB request count per target. Request-based scaling reflects HTTP demand better than CPU alone.

For the alternative failure average CPU is low but ALB requests queue under high per-target load, the control Use target tracking on appropriate ALB request count per target is relevant: request-based scaling reflects HTTP demand better than CPU alone. Here the evidence instead is a Java service needs several minutes to initialize after new instances launch. The selected technical mechanism is Configure ASG instance warmup and load-balancer grace handling: warmup keeps new capacity from skewing scaling measurements.

The competing option Use EC2 Auto Scaling target tracking on measured CPU utilization would be useful when traffic rises irregularly and CPU correlates with saturation. Target tracking follows resource demand automatically. The present issue is a Java service needs several minutes to initialize after new instances launch; it is more directly addressed by Configure ASG instance warmup and load-balancer grace handling. Warmup keeps new capacity from skewing scaling measurements.

The option Diagnose database saturation and tune dependent service before adding EC2 addresses a separate condition: instances have plenty of CPU but requests are blocked on a slow shared database. Scaling healthy app instances cannot remove a database bottleneck. The actual requirement is a Java service needs several minutes to initialize after new instances launch. Recommended corrective action: Configure ASG instance warmup and load-balancer grace handling. Warmup keeps new capacity from skewing scaling measurements.

The competing option Configure ASG instance warmup and load-balancer grace handling would be useful when a Java service needs several minutes to initialize after new instances launch. Warmup keeps new capacity from skewing scaling measurements. The present issue is a predictable spike occurs at the same weekday hour; it is more directly addressed by Configure scheduled scaling to pre-provision instance capacity. Scheduled capacity reduces response delay during known peaks.

The option Use target tracking on appropriate ALB request count per target addresses a separate condition: average CPU is low but ALB requests queue under high per-target load. Request-based scaling reflects HTTP demand better than CPU alone. The actual requirement is a predictable spike occurs at the same weekday hour. Recommended corrective action: Configure scheduled scaling to pre-provision instance capacity. Scheduled capacity reduces response delay during known peaks.

Use EC2 Auto Scaling target tracking on measured CPU utilization would help if traffic rises irregularly and CPU correlates with saturation. Target tracking follows resource demand automatically. That is not the symptom described here: a predictable spike occurs at the same weekday hour. The matching response is Configure scheduled scaling to pre-provision instance capacity, because scheduled capacity reduces response delay during known peaks.

The competing option Configure scheduled scaling to pre-provision instance capacity would be useful when a predictable spike occurs at the same weekday hour. Scheduled capacity reduces response delay during known peaks. The present issue is traffic rises irregularly and CPU correlates with saturation; it is more directly addressed by Use EC2 Auto Scaling target tracking on measured CPU utilization. Target tracking follows resource demand automatically.

The option Diagnose database saturation and tune dependent service before adding EC2 addresses a separate condition: instances have plenty of CPU but requests are blocked on a slow shared database. Scaling healthy app instances cannot remove a database bottleneck. The actual requirement is traffic rises irregularly and CPU correlates with saturation. Recommended corrective action: Use EC2 Auto Scaling target tracking on measured CPU utilization. Target tracking follows resource demand automatically.

For the alternative failure a Java service needs several minutes to initialize after new instances launch, the control Configure ASG instance warmup and load-balancer grace handling is relevant: warmup keeps new capacity from skewing scaling measurements. Here the evidence instead is traffic rises irregularly and CPU correlates with saturation. The selected technical mechanism is Use EC2 Auto Scaling target tracking on measured CPU utilization: target tracking follows resource demand automatically.

The option Configure ASG instance warmup and load-balancer grace handling addresses a separate condition: a Java service needs several minutes to initialize after new instances launch. Warmup keeps new capacity from skewing scaling measurements. The actual requirement is instances have plenty of CPU but requests are blocked on a slow shared database. Recommended corrective action: Diagnose database saturation and tune dependent service before adding EC2. Scaling healthy app instances cannot remove a database bottleneck.

Use target tracking on appropriate ALB request count per target would help if average CPU is low but ALB requests queue under high per-target load. Request-based scaling reflects HTTP demand better than CPU alone. That is not the symptom described here: instances have plenty of CPU but requests are blocked on a slow shared database. The matching response is Diagnose database saturation and tune dependent service before adding EC2, because scaling healthy app instances cannot remove a database bottleneck.

Configure scheduled scaling to pre-provision instance capacity solves a different operational problem where a predictable spike occurs at the same weekday hour. Scheduled capacity reduces response delay during known peaks. It does not directly address instances have plenty of CPU but requests are blocked on a slow shared database. The case calls for Diagnose database saturation and tune dependent service before adding EC2, since scaling healthy app instances cannot remove a database bottleneck.

Use Amazon EKS for the Kubernetes API and orchestration model would help if a workload requires Kubernetes controllers and custom resources. EKS provides managed control-plane APIs for Kubernetes extensions. That is not the symptom described here: a synchronous web request handler completes in seconds and should not require a running web fleet. The matching response is Use Lambda behind API Gateway for bounded synchronous request handling, because lambda plus API Gateway offers request-driven compute and HTTPS routing.

For the alternative failure a portable container app needs task-level scaling without cluster host operations, the control Use ECS services on Fargate is relevant: fargate supplies managed container compute capacity. Here the evidence instead is a synchronous web request handler completes in seconds and should not require a running web fleet. The selected technical mechanism is Use Lambda behind API Gateway for bounded synchronous request handling: lambda plus API Gateway offers request-driven compute and HTTPS routing.

Submit AWS Batch array jobs using job-level retry settings and appropriate compute solves a different operational problem where thousands of independent already-containerized research tasks must run in parallel with isolated retries. Array jobs partition a large batch into separately scheduled units. It does not directly address a synchronous web request handler completes in seconds and should not require a running web fleet. The case calls for Use Lambda behind API Gateway for bounded synchronous request handling, since lambda plus API Gateway offers request-driven compute and HTTPS routing.

For the alternative failure a workload requires Kubernetes controllers and custom resources, the control Use Amazon EKS for the Kubernetes API and orchestration model is relevant: eKS provides managed control-plane APIs for Kubernetes extensions. Here the evidence instead is a service runs a continuous daemon for days with custom OS dependencies. The selected technical mechanism is Use EC2 instances or an appropriate container service rather than Lambda: lambda execution duration is bounded.

Use Lambda behind API Gateway for bounded synchronous request handling solves a different operational problem where a synchronous web request handler completes in seconds and should not require a running web fleet. Lambda plus API Gateway offers request-driven compute and HTTPS routing. It does not directly address a service runs a continuous daemon for days with custom OS dependencies. The case calls for Use EC2 instances or an appropriate container service rather than Lambda, since lambda execution duration is bounded.

The option Use ECS services on Fargate addresses a separate condition: a portable container app needs task-level scaling without cluster host operations. Fargate supplies managed container compute capacity. The actual requirement is a service runs a continuous daemon for days with custom OS dependencies. Recommended corrective action: Use EC2 instances or an appropriate container service rather than Lambda. Lambda execution duration is bounded.

Submit AWS Batch array jobs using job-level retry settings and appropriate compute solves a different operational problem where thousands of independent already-containerized research tasks must run in parallel with isolated retries. Array jobs partition a large batch into separately scheduled units. It does not directly address a portable container app needs task-level scaling without cluster host operations. The case calls for Use ECS services on Fargate, since fargate supplies managed container compute capacity.

The competing option Use EC2 instances or an appropriate container service rather than Lambda would be useful when a service runs a continuous daemon for days with custom OS dependencies. Lambda execution duration is bounded. The present issue is a portable container app needs task-level scaling without cluster host operations; it is more directly addressed by Use ECS services on Fargate. Fargate supplies managed container compute capacity.

The option Use Lambda behind API Gateway for bounded synchronous request handling addresses a separate condition: a synchronous web request handler completes in seconds and should not require a running web fleet. Lambda plus API Gateway offers request-driven compute and HTTPS routing. The actual requirement is a portable container app needs task-level scaling without cluster host operations. Recommended corrective action: Use ECS services on Fargate. Fargate supplies managed container compute capacity.

The option Submit AWS Batch array jobs using job-level retry settings and appropriate compute addresses a separate condition: thousands of independent already-containerized research tasks must run in parallel with isolated retries. Array jobs partition a large batch into separately scheduled units. The actual requirement is a workload requires Kubernetes controllers and custom resources. Recommended corrective action: Use Amazon EKS for the Kubernetes API and orchestration model. EKS provides managed control-plane APIs for Kubernetes extensions.

Use Lambda behind API Gateway for bounded synchronous request handling would help if a synchronous web request handler completes in seconds and should not require a running web fleet. Lambda plus API Gateway offers request-driven compute and HTTPS routing. That is not the symptom described here: a workload requires Kubernetes controllers and custom resources. The matching response is Use Amazon EKS for the Kubernetes API and orchestration model, because eKS provides managed control-plane APIs for Kubernetes extensions.

For the alternative failure a portable container app needs task-level scaling without cluster host operations, the control Use ECS services on Fargate is relevant: fargate supplies managed container compute capacity. Here the evidence instead is a workload requires Kubernetes controllers and custom resources. The selected technical mechanism is Use Amazon EKS for the Kubernetes API and orchestration model: eKS provides managed control-plane APIs for Kubernetes extensions.

Use Lambda behind API Gateway for bounded synchronous request handling would help if a synchronous web request handler completes in seconds and should not require a running web fleet. Lambda plus API Gateway offers request-driven compute and HTTPS routing. That is not the symptom described here: thousands of independent already-containerized research tasks must run in parallel with isolated retries. The matching response is Submit AWS Batch array jobs using job-level retry settings and appropriate compute, because array jobs partition a large batch into separately scheduled units.

For the alternative failure a portable container app needs task-level scaling without cluster host operations, the control Use ECS services on Fargate is relevant: fargate supplies managed container compute capacity. Here the evidence instead is thousands of independent already-containerized research tasks must run in parallel with isolated retries. The selected technical mechanism is Submit AWS Batch array jobs using job-level retry settings and appropriate compute: array jobs partition a large batch into separately scheduled units.

Use EC2 instances or an appropriate container service rather than Lambda solves a different operational problem where a service runs a continuous daemon for days with custom OS dependencies. Lambda execution duration is bounded. It does not directly address thousands of independent already-containerized research tasks must run in parallel with isolated retries. The case calls for Submit AWS Batch array jobs using job-level retry settings and appropriate compute, since array jobs partition a large batch into separately scheduled units.