Question 480
An Amazon OpenSearch Service log cluster writes event indices continuously. The cluster has already corrected its shard count and heap pressure, but large active indices keep growing beyond their planned 40-GiB per-index target, and old read-only indices should transition to a cooler tier and then expire automatically. Which control provides repeatable index lifecycle actions?
- Increase the number of primary shards for every existing index without setting a rollover or retention policy.
- Use an Index State Management policy with a write alias and supported rollover, tier-transition and deletion actions based on index age or size.
- Enable OpenSearch snapshot creation exclusively and assume backups automatically update the write alias and delete every old index.
- Move old indexes into UltraWarm manually once, without configuring any rollover conditions or future deletion policy for the growing write index.
Explanation
Correct Answer
B:Index State Management supports lifecycle policies such as rollover, warm/cold migration and deletion when age or size conditions are met.
Incorrect Answers
A:Adding shards alone does not schedule rollover, move read-only indexes across tiers or apply retention-based index deletion.
C:Snapshots protect data but do not substitute for index write alias rollover and active index lifecycle policies.
D:A one-time tier move may lower costs for eligible old data, but it does not automate requested future rollover, tier changes and retention-based deletion.
Question 481
An ECS application has an application-level memory leak that appears only after hours of normal traffic. Standard CPU autoscaling makes more leaking tasks and does not stop memory exhaustion. Which operational change identifies the correct remediation target?
- Increase ECS task memory allocation every time heap usage rises but omit process allocation profiling and leak diagnosis.
- Set a memory-based ECS Service Auto Scaling policy that adds replicas as a leaking task fills up, but never fix the leaked object references.
- Profile and repair heap retention, then set realistic container memory limits and alerts based on working-set growth.
- Add CPU-only task scaling and assume more copies of the leaking service eliminate per-task heap growth.
Explanation
Correct Answer
C:A leak is retained memory over time, so code-level memory profiling and bounds address the source instead of multiplying affected replicas.
Incorrect Answers
A:More memory can extend survival but does not determine or eliminate the code path retaining heap objects over time.
B:Memory-driven horizontal scaling is not a root-cause remedy when every new task reproduces the application heap leak.
D:New tasks reproduce the same leak; task count growth does not correct retained objects in the process.
Question 482
An RDS MySQL read replica consistently lags the writer during large DDL and batch updates. Application users require read-after-write for critical account balances but tolerate stale data for reports. What routing change preserves correctness?
- Add replica instances and increase read-replica capacity while continuing to direct strictly consistent balance checks to asynchronous readers.
- Keep balance-sensitive reads on the writer and route only lag-tolerant reporting queries to replicas with monitored delay.
- Send all balance checks to the lagging reader and assume replication order guarantees immediate visibility of writes.
- Enable longer replica retention and replay windows but allow lagging replica reads to authorize critical financial transfers.
Explanation
Correct Answer
B:Replica lag means asynchronous reads may be stale, so consistency-sensitive data needs writer routing or an explicit consistency mechanism.
Incorrect Answers
A:More replicas may serve reports but cannot guarantee read-after-write consistency for a just-committed balance on asynchronous copies.
C:Asynchronous replicas cannot guarantee that the latest committed account update is visible at every read.
D:Replay retention does not make asynchronous replicas immediately consistent; the routing must honor transactional freshness.
Question 483
An Amazon API Gateway REST API is overwhelmed by repeated requests for non-sensitive, publicly cacheable product descriptions. The backend returns identical data for a short interval and latency traces show backend integration time dominates. What managed cache should be assessed?
- Enable a higher REST API burst throttle limit without caching the identical product GET responses, while the backend integration time remains the bottleneck.
- Enable a correctly scoped API Gateway REST API stage cache with appropriate cache keys and TTL for eligible GET responses.
- Cache all authenticated POST payment submissions under one key regardless of customer or request body.
- Configure a Lambda authorizer cache for valid identity decisions and assume this caches the public product-description GET integration response.
Explanation
Correct Answer
B:Caching identical eligible responses at API Gateway can reduce integration calls and latency when keying and freshness are controlled.
Incorrect Answers
A:Higher accepted request concurrency can worsen repeated origin reads and is not a response-cache mechanism.
C:Payment commands are not interchangeable cacheable GET data and could cause incorrect or unsafe responses.
D:Authorizer caching avoids repeated authentication evaluation; it does not cache the product descriptions returned by the backend integration.
Question 484
An EFS-backed machine learning feature service shows sustained throughput throttling while its clients run parallel model loads. The mount targets are healthy and the workload needs sustained high throughput rather than brief bursts. What storage capability should be reviewed?
- Measure EFS throughput mode and choose appropriately supported elastic or provisioned throughput for the sustained workload.
- Change NFS mount options and raise client TCP buffer sizes but never check whether the file system itself exhausted its configured EFS throughput budget.
- Switch the EFS file system to an unsupported higher per-operation IOPS setting as if changing metadata IOPS always increases permitted throughput bandwidth.
- Add EFS replication in another Region while retaining the same congested primary throughput setting and write path.
Explanation
Correct Answer
A:An appropriate EFS throughput mode can provision or scale the filesystem bandwidth required by sustained parallel reads.
Incorrect Answers
B:Client tuning can help certain I/O cases but does not fix a measured filesystem throughput-mode ceiling without EFS capacity analysis.
C:Throughput modes and IOPS behaviors have distinct service constraints; blindly changing operation settings does not address the measured throughput bottleneck.
D:Cross-Region replication is for resilience and does not make the current primary EFS mount serve more active filesystem bandwidth.
Question 485
A team processes daily AWS Glue batch jobs and profiling shows the same dataset is repeatedly transformed from CSV to complex nested structures before any query. The analytics team could store clean intermediate columnar outputs reused by several downstream queries. What optimization is most targeted?
- Enable AWS Glue job bookmarks only while every downstream job still reparses the same raw CSV and reconstructs the same nested dataset.
- Persist validated reusable Parquet intermediate data and have downstream jobs read the prepared columnar partitions.
- Keep reparsing raw CSV in every downstream query and add S3 object versioning only.
- Add AWS Glue crawlers to recatalog the raw CSV schema every hour but keep repeating all transformations in each downstream query.
Explanation
Correct Answer
B:Reusable columnar intermediates avoid repeated expensive parsing and allow engines to scan fewer projected columns.
Incorrect Answers
A:Bookmarks help incremental processing of changed inputs but do not by themselves materialize reusable prepared columnar results for distinct downstream queries.
C:S3 versioning protects object revisions but does not remove repeated CSV parsing costs.
D:Catalog crawlers discover metadata, not the validated reusable transformed dataset or Parquet data layout needed to remove repeated parsing work.
Question 486
A data-science platform repeatedly launches EBS gp3 volumes from the same 8-TiB snapshot in one Availability Zone. Once a volume is fully initialized, it consistently delivers its provisioned throughput and IOPS; only the first full scan after volume creation is unusually slow as previously unwritten snapshot blocks are accessed. What EBS feature can avoid that first-read initialization penalty for supported snapshot and AZ combinations?
- Increase the volume's provisioned throughput even though fully initialized volumes already meet measured throughput targets.
- Enable EBS fast snapshot restore for the source snapshot in the target Availability Zone and plan volume-creation credits and associated charges.
- Enable EBS Multi-Attach on every restored volume so EBS loads all snapshot blocks before its first read.
- Increase the snapshot’s retention period and add snapshot copy jobs without initializing any new EBS volume.
Explanation
Correct Answer
B:Fast snapshot restore prepares supported snapshot-backed volumes to deliver provisioned performance when created, avoiding first-access block-fetch latency.
Incorrect Answers
A:The bottleneck is first-access snapshot initialization, not the already adequate steady-state gp3 throughput.
C:Multi-Attach is a separate supported volume-sharing feature, not a mechanism to preinitialize snapshot-backed blocks or remove first-access I/O latency.
D:Retention and copy operations protect backups but do not automatically give a newly created volume fully initialized, immediate provisioned performance.
Question 487
An application uses ElastiCache for Redis to store product lookups, but CloudWatch shows a low cache hit ratio because keys include a random request ID. Identical product requests consequently bypass cache. What change is most likely to improve cache efficiency?
- Append the timestamp and a new UUID to every Redis key to guarantee that all reads miss.
- Delete the Redis cluster after every request to avoid retaining possibly stale product values.
- Scale out ElastiCache nodes while continuing to use one unique random request ID per logically identical product lookup.
- Normalize cache keys to stable product identifiers, with appropriate namespace, TTL, and invalidation behavior.
Explanation
Correct Answer
D:Stable keys allow equivalent reads to reuse cached product data, while versioning and invalidation prevent stale results.
Incorrect Answers
A:Unique keys defeat cache reuse even when the underlying requested product data is unchanged.
B:Frequent destruction removes the cache and increases origin pressure rather than improving hit rate.
C:A larger cluster can hold more distinct entries but will not make logically identical reads hit the same key when each request changes it.
Question 488
A synchronous Lambda API calls a downstream external API. Execution traces show that opening a new HTTPS connection on each invocation adds a large fraction of observed latency; the remote endpoint permits connection reuse. What code-level tuning should be evaluated?
- Initialize a reusable HTTP client outside the handler and reuse supported connections in warm Lambda execution environments.
- Create a new client and close it for every API call to guarantee the same connection-establishment cost.
- Increase the number of concurrent Lambda environments without reusing the outbound HTTP client within each warm execution environment.
- Increase the Lambda timeout and request retries, preserving the same per-request socket creation and TLS handshake overhead.
Explanation
Correct Answer
A:Connection reuse avoids repeated TLS and TCP setup on warm invocations while preserving correct timeout and error handling.
Incorrect Answers
B:Per-request teardown retains the measured repeated handshake overhead rather than eliminating it.
C:More concurrent environments can add parallel capacity but does not avoid the repeated TLS/HTTP connection setup measured for each invocation.
D:Timeouts and retries do not correct repeatedly opening identical outbound HTTPS connections; safe reuse targets the measured latency.
Question 489
A large Aurora MySQL query performs many joins and creates temporary tables. Performance analysis shows SQL plan errors, missing selective indexes, and far more rows read than returned. Before changing instance classes, what should the database team do?
- Inspect EXPLAIN plans and query metrics, create measured supporting indexes or rewrite joins, and remeasure the workload.
- Add Aurora reader instances before examining an inefficient writer-side transactional join and keep the original SQL predicate and index choices unchanged.
- Disable slow query visibility because execution plans are unrelated to database CPU and I/O.
- Increase the Aurora writer instance size and assume the optimizer will automatically select a better join path without reviewing EXPLAIN or index statistics.
Explanation
Correct Answer
A:Query plan and row-access changes directly address wasted scans and joins rather than blindly increasing hardware capacity.
Incorrect Answers
B:Readers can offload suitable reads but do not automatically repair a poor execution plan for the same specific query or unnecessary row scans.
C:Query visibility and optimizer plans are essential evidence for determining unnecessary relational work.
D:More compute may postpone saturation but does not diagnose or eliminate wasteful joins and missing selective indexes.
Question 490
A Kafka-compatible analytics team polls one MSK topic from a single consumer instance despite having eight independent partitions. Topic lag grows under load and consumer CPU is saturated, but brokers are healthy. Which consumer-side change is most direct?
- Add brokers to the healthy MSK cluster but keep exactly one CPU-saturated application consumer process for all eight available partitions.
- Run additional consumers in the same consumer group up to useful partition parallelism, and test ordering requirements.
- Increase producer batch size alone while maintaining the single consumer handling all partitions and its saturated processing CPU.
- Create twelve consumers in one group for the eight-partition topic and assume all twelve will process an assigned partition simultaneously.
Explanation
Correct Answer
B:Kafka consumer groups can distribute partitions among consumers, increasing processing parallelism without changing topic semantics.
Incorrect Answers
A:More broker-side capacity does not address the measured processing bottleneck in a single consumer instance.
C:Producer batching can change write efficiency but does not add consumer group workers to process existing lagged partitions.
D:Kafka generally assigns each partition to only one active group consumer; extra consumers beyond the partition count are not a useful parallelism increase.
AWS Certified Solutions Architect - Professional SAP-C02 Practice Tests