Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

The option Deploy suitable AWS Storage Gateway File Gateway where protocol support matches addresses a separate condition: on-prem Linux servers need low-latency SMB/NFS-like file cache backed by AWS storage. File Gateway caches files while backing objects in S3. The actual requirement is a global remote team needs a shared managed Windows file service. Recommended corrective action: Use FSx for Windows File Server in suitable region/network design. Managed SMB replaces custom Windows file servers.

For the alternative failure a backup administrator needs a virtual tape library backed by cloud archival storage, the control Use AWS Storage Gateway Tape Gateway for compatible tape-backup software is relevant: tape Gateway exposes virtual tapes backed by AWS storage. Here the evidence instead is a global remote team needs a shared managed Windows file service. The selected technical mechanism is Use FSx for Windows File Server in suitable region/network design: managed SMB replaces custom Windows file servers.

Use AWS DataSync tasks targeting EFS solves a different operational problem where a data center must migrate millions of files efficiently into an EFS filesystem. DataSync transfers files with managed verification and scheduling. It does not directly address a global remote team needs a shared managed Windows file service. The case calls for Use FSx for Windows File Server in suitable region/network design, since managed SMB replaces custom Windows file servers.

Use manifests/events/catalog partitions instead of full repeated bucket scans would help if batch ETL lists a bucket's entire content for every hourly run. Indexed or event-driven discovery reduces listing overhead. That is not the symptom described here: a compute fleet fetches hundreds of independent objects serially and has low throughput. The matching response is Parallelize bounded S3 requests and reuse HTTP connections, because concurrent requests improve aggregate S3 throughput.

For the alternative failure a frequently accessed object is served in full for every partial-data request, the control Use Range GET requests when only byte subsets are needed is relevant: range requests avoid downloading irrelevant bytes. Here the evidence instead is a compute fleet fetches hundreds of independent objects serially and has low throughput. The selected technical mechanism is Parallelize bounded S3 requests and reuse HTTP connections: concurrent requests improve aggregate S3 throughput.

The competing option Switch to a suitable append/log service or redesign object writes would be useful when many clients try to append to one S3 object like a database log. Object PUT semantics differ from mutable record append. The present issue is a compute fleet fetches hundreds of independent objects serially and has low throughput; it is more directly addressed by Parallelize bounded S3 requests and reuse HTTP connections. Concurrent requests improve aggregate S3 throughput.

For the alternative failure many clients try to append to one S3 object like a database log, the control Switch to a suitable append/log service or redesign object writes is relevant: object PUT semantics differ from mutable record append. Here the evidence instead is a frequently accessed object is served in full for every partial-data request. The selected technical mechanism is Use Range GET requests when only byte subsets are needed: range requests avoid downloading irrelevant bytes.

Convert to compressed partitioned Parquet for analytical reads solves a different operational problem where analytics query scans uncompressed JSON files but needs only a few columns. Columnar formats reduce bytes scanned. It does not directly address a frequently accessed object is served in full for every partial-data request. The case calls for Use Range GET requests when only byte subsets are needed, since range requests avoid downloading irrelevant bytes.

The competing option Use manifests/events/catalog partitions instead of full repeated bucket scans would be useful when batch ETL lists a bucket's entire content for every hourly run. Indexed or event-driven discovery reduces listing overhead. The present issue is a frequently accessed object is served in full for every partial-data request; it is more directly addressed by Use Range GET requests when only byte subsets are needed. Range requests avoid downloading irrelevant bytes.

Convert to compressed partitioned Parquet for analytical reads solves a different operational problem where analytics query scans uncompressed JSON files but needs only a few columns. Columnar formats reduce bytes scanned. It does not directly address many clients try to append to one S3 object like a database log. The case calls for Switch to a suitable append/log service or redesign object writes, since object PUT semantics differ from mutable record append.

The competing option Use Range GET requests when only byte subsets are needed would be useful when a frequently accessed object is served in full for every partial-data request. Range requests avoid downloading irrelevant bytes. The present issue is many clients try to append to one S3 object like a database log; it is more directly addressed by Switch to a suitable append/log service or redesign object writes. Object PUT semantics differ from mutable record append.

The option Use manifests/events/catalog partitions instead of full repeated bucket scans addresses a separate condition: batch ETL lists a bucket's entire content for every hourly run. Indexed or event-driven discovery reduces listing overhead. The actual requirement is many clients try to append to one S3 object like a database log. Recommended corrective action: Switch to a suitable append/log service or redesign object writes. Object PUT semantics differ from mutable record append.

The competing option Convert to compressed partitioned Parquet for analytical reads would be useful when analytics query scans uncompressed JSON files but needs only a few columns. Columnar formats reduce bytes scanned. The present issue is batch ETL lists a bucket's entire content for every hourly run; it is more directly addressed by Use manifests/events/catalog partitions instead of full repeated bucket scans. Indexed or event-driven discovery reduces listing overhead.

The option Parallelize bounded S3 requests and reuse HTTP connections addresses a separate condition: a compute fleet fetches hundreds of independent objects serially and has low throughput. Concurrent requests improve aggregate S3 throughput. The actual requirement is batch ETL lists a bucket's entire content for every hourly run. Recommended corrective action: Use manifests/events/catalog partitions instead of full repeated bucket scans. Indexed or event-driven discovery reduces listing overhead.

Use Range GET requests when only byte subsets are needed would help if a frequently accessed object is served in full for every partial-data request. Range requests avoid downloading irrelevant bytes. That is not the symptom described here: batch ETL lists a bucket's entire content for every hourly run. The matching response is Use manifests/events/catalog partitions instead of full repeated bucket scans, because indexed or event-driven discovery reduces listing overhead.

The option Use Range GET requests when only byte subsets are needed addresses a separate condition: a frequently accessed object is served in full for every partial-data request. Range requests avoid downloading irrelevant bytes. The actual requirement is analytics query scans uncompressed JSON files but needs only a few columns. Recommended corrective action: Convert to compressed partitioned Parquet for analytical reads. Columnar formats reduce bytes scanned.

For the alternative failure batch ETL lists a bucket's entire content for every hourly run, the control Use manifests/events/catalog partitions instead of full repeated bucket scans is relevant: indexed or event-driven discovery reduces listing overhead. Here the evidence instead is analytics query scans uncompressed JSON files but needs only a few columns. The selected technical mechanism is Convert to compressed partitioned Parquet for analytical reads: columnar formats reduce bytes scanned.

Parallelize bounded S3 requests and reuse HTTP connections solves a different operational problem where a compute fleet fetches hundreds of independent objects serially and has low throughput. Concurrent requests improve aggregate S3 throughput. It does not directly address analytics query scans uncompressed JSON files but needs only a few columns. The case calls for Convert to compressed partitioned Parquet for analytical reads, since columnar formats reduce bytes scanned.

Use AWS Transfer Family where suitable would help if an external batch process expects FTP/SFTP semantics for files already in S3. Transfer Family exposes managed file-transfer protocols over S3/EFS backends. That is not the symptom described here: a Lambda function must persist an uploaded image after invocation ends. The matching response is Store durable uploads in S3 rather than Lambda ephemeral storage, because lambda local storage is scoped to execution environments.

For the alternative failure multiple EC2 Linux hosts need a shared writable filesystem with elastic growth, the control Mount Amazon EFS across the hosts is relevant: eFS provides managed elastic NFS sharing. Here the evidence instead is a Lambda function must persist an uploaded image after invocation ends. The selected technical mechanism is Store durable uploads in S3 rather than Lambda ephemeral storage: lambda local storage is scoped to execution environments.

Configure supported Lambda ephemeral storage sizing solves a different operational problem where a team needs temporary file space above the default Lambda /tmp capacity. Lambda ephemeral-storage capacity can be increased within limits. It does not directly address a Lambda function must persist an uploaded image after invocation ends. The case calls for Store durable uploads in S3 rather than Lambda ephemeral storage, since lambda local storage is scoped to execution environments.

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 a team needs temporary file space above the default Lambda /tmp capacity. The case calls for Configure supported Lambda ephemeral storage sizing, since lambda ephemeral-storage capacity can be increased within limits.

The competing option Store durable uploads in S3 rather than Lambda ephemeral storage would be useful when a Lambda function must persist an uploaded image after invocation ends. Lambda local storage is scoped to execution environments. The present issue is a team needs temporary file space above the default Lambda /tmp capacity; it is more directly addressed by Configure supported Lambda ephemeral storage sizing. Lambda ephemeral-storage capacity can be increased within limits.

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 a team needs temporary file space above the default Lambda /tmp capacity. Recommended corrective action: Configure supported Lambda ephemeral storage sizing. Lambda ephemeral-storage capacity can be increased within limits.

Store durable uploads in S3 rather than Lambda ephemeral storage solves a different operational problem where a Lambda function must persist an uploaded image after invocation ends. Lambda local storage is scoped to execution environments. It does not directly address multiple EC2 Linux hosts need a shared writable filesystem with elastic growth. The case calls for Mount Amazon EFS across the hosts, since eFS provides managed elastic NFS sharing.

The option Configure supported Lambda ephemeral storage sizing addresses a separate condition: a team needs temporary file space above the default Lambda /tmp capacity. Lambda ephemeral-storage capacity can be increased within limits. The actual requirement is multiple EC2 Linux hosts need a shared writable filesystem with elastic growth. Recommended corrective action: Mount Amazon EFS across the hosts. EFS provides managed elastic NFS sharing.

Use EBS volumes with appropriate backups would help if stateful EC2 database data requires single-host block filesystem semantics. EBS provides persistent block device storage tied to an AZ. That is not the symptom described here: multiple EC2 Linux hosts need a shared writable filesystem with elastic growth. The matching response is Mount Amazon EFS across the hosts, because eFS provides managed elastic NFS sharing.

The competing option Mount Amazon EFS across the hosts would be useful when multiple EC2 Linux hosts need a shared writable filesystem with elastic growth. EFS provides managed elastic NFS sharing. The present issue is stateful EC2 database data requires single-host block filesystem semantics; it is more directly addressed by Use EBS volumes with appropriate backups. EBS provides persistent block device storage tied to an AZ.

Use AWS Transfer Family where suitable would help if an external batch process expects FTP/SFTP semantics for files already in S3. Transfer Family exposes managed file-transfer protocols over S3/EFS backends. That is not the symptom described here: stateful EC2 database data requires single-host block filesystem semantics. The matching response is Use EBS volumes with appropriate backups, because eBS provides persistent block device storage tied to an AZ.

For the alternative failure a Lambda function must persist an uploaded image after invocation ends, the control Store durable uploads in S3 rather than Lambda ephemeral storage is relevant: lambda local storage is scoped to execution environments. Here the evidence instead is stateful EC2 database data requires single-host block filesystem semantics. The selected technical mechanism is Use EBS volumes with appropriate backups: eBS provides persistent block device storage tied to an AZ.

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.