DVA-C02 Troubleshooting and Optimization Practice Test 2 — 15 Questions

Question 1

An AWS Lambda function that processes messages from an SQS queue is experiencing throttling (TooManyRequestsException). The function has reserved concurrency set to 100. The SQS queue has a redrive policy configured with maxReceiveCount of 5. CloudWatch metrics show that the function's concurrent executions occasionally spike to 100, and throttling occurs. The function execution time averages 2 seconds. What is the most effective way to reduce throttling?

Accepted Answer

Increase the batch size of the SQS event source mapping. Increasing the batch size allows the Lambda function to process more messages per invocation, reducing the number of concurrent executions needed to handle the same message volume. Since the function already spikes to its reserved concurrency of 100, processing more messages per batch lowers the invocation rate and thus reduces throttling without requiring additional concurrency.

Answer

Increase the reserved concurrency of the Lambda function

Answer

Decrease the batch window of the event source mapping

Answer

Add a dead-letter queue (DLQ) for the Lambda function

Question 2

A developer deployed an AWS Lambda function that is invoked by an Amazon SQS queue. The function is configured with a batch size of 10 and a timeout of 30 seconds. CloudWatch metrics show that the function's Duration is consistently around 28 seconds, but occasionally spikes to 35 seconds causing timeouts. The function makes a synchronous HTTP call to an external API. Which approach will MOST effectively prevent timeouts while maximizing throughput?

Accepted Answer

Use async HTTP calls with a callback. Option A is correct because using async HTTP calls with a callback prevents the Lambda function from blocking on the synchronous HTTP request. This allows the function to process the batch of 10 messages concurrently, reducing the overall execution time below the 30-second timeout even when individual API calls occasionally take longer. By not waiting for each response sequentially, the function maximizes throughput and avoids timeouts.

Answer

Increase the function's timeout to 60 seconds

Answer

Reduce the batch size to 5

Answer

Increase the SQS visibility timeout to 60 seconds

Question 3

A developer is troubleshooting slow response times in a serverless application. The application consists of an Amazon API Gateway REST API that invokes an AWS Lambda function, which then writes data to an Amazon DynamoDB table with on-demand capacity. The function also calls an external API for enrichment. The developer observes that the API Gateway integration latency is high, but the Lambda function duration is low. What is the most likely cause?

Accepted Answer

The API Gateway request/response payload size is large, increasing transfer time.. Option D is correct because high API Gateway integration latency combined with low Lambda duration indicates that the delay is occurring in the data transfer between API Gateway and Lambda, not within the function itself. A large request/response payload increases the network transfer time over the HTTPS connection, which is measured as part of integration latency but not reflected in the function's billed duration.

Answer

The Lambda function is experiencing cold starts due to low invocation frequency.

Answer

The DynamoDB on-demand capacity is throttling requests.

Answer

The external API call is adding network latency due to its geographic location.

Question 4

A developer is troubleshooting an AWS Lambda function that is triggered by an S3 event. The function occasionally fails with a timeout error. CloudWatch logs show that the timeout occurs during the processing of large files. The function has a memory setting of 128 MB and a timeout of 3 seconds. The developer wants to process large files without modifying the code. Which parameter should the developer adjust first?

Accepted Answer

Increase the function's memory. Increasing the function's memory is the correct first step because Lambda allocates CPU proportionally to memory, and more CPU reduces processing time for CPU-bound tasks like decompressing or parsing large files. This directly addresses the timeout by making the function complete faster, without requiring code changes. The current 128 MB setting is the minimum, which provides the least CPU, so even a modest increase can significantly reduce execution time.

Answer

Increase the function's timeout

Answer

Increase the function's reserved concurrency

Answer

Increase the S3 event notification batch size

Question 5

A developer is troubleshooting performance issues in an application that uses Amazon ElastiCache for Redis. The application experiences periodic latency spikes during peak hours. The developer checks CloudWatch metrics and sees that the 'Evictions' metric is consistently high and the 'CacheHitRate' metric is low. The cluster uses a single cache.t3.small node. Which action will most likely improve the cache hit rate and reduce latency?

Accepted Answer

Use a larger instance type. The correct answer is D because the symptoms—high evictions and low cache hit rate—indicate that the single cache.t3.small node is running out of memory. Using a larger instance type increases the available memory, allowing more data to be cached, reducing evictions, and improving the cache hit rate. This directly addresses the root cause of memory pressure without changing the cluster architecture or data expiration behavior.

Answer

Increase the number of replicas

Answer

Enable cluster mode and add more shards

Answer

Increase the TTL of cached items

Question 6

A developer is troubleshooting a DynamoDB table that is experiencing high write throttling (ProvisionedThroughputExceededException) on certain days. The table has provisioned write capacity of 1000 WCU. The table has a partition key of 'user_id' which is a UUID. The table is accessed by multiple services. CloudWatch metrics show that the WriteThrottleEvents are spiking during specific hours, and the ConsumedWriteCapacityUnits often reaches 1000. What is the most likely cause of the throttling?

Accepted Answer

The provisioned write capacity is insufficient to handle the traffic spikes.. The correct answer is B because the ConsumedWriteCapacityUnits consistently reaches the provisioned 1000 WCU during specific hours, and WriteThrottleEvents spike at those same times. This indicates that the provisioned capacity is insufficient to handle peak traffic, causing requests to be throttled. The partition key (UUID) is well-distributed, so a hot partition is unlikely.

Answer

The partition key is not distributed evenly, causing a hot partition.

Answer

The table does not have DynamoDB Accelerator (DAX) enabled.

Answer

The table is configured with eventual consistency, which throttles writes.

Question 7

A developer is troubleshooting an AWS Lambda function that writes items to an Amazon DynamoDB table. The function frequently fails with ProvisionedThroughputExceededException. The table has provisioned write capacity of 500 write capacity units (WCUs). The function has reserved concurrency of 10, and each invocation writes 10 items of approximately 1 KB each. There are no other writers to the table. What is the most likely cause of the throttling?

Accepted Answer

The function is writing to a single partition key, causing hot partition throttling. The most likely cause is that the function is writing to a single partition key, creating a 'hot partition' that exceeds the 1,000 WCU per-partition limit (or 3,000 WCU for burst capacity) even though the table's total provisioned capacity of 500 WCU is not exhausted. DynamoDB distributes throughput across partitions based on the partition key; if all writes target the same key, they are throttled at the partition level regardless of table-level capacity.

Answer

The function's reserved concurrency is too high, causing excessive write requests

Answer

The table's read capacity is insufficient, causing write throttling

Answer

The function is exceeding the DynamoDB item size limit of 400 KB

Question 8

A developer is monitoring an AWS Lambda function that processes events from an Amazon Kinesis stream. The function's CloudWatch metrics show high IteratorAge and the function is often throttled. The function's batch size is 100, maximum record age is 60s, and reserved concurrency is 100. The Kinesis stream has 10 shards, each with 5000 records/sec. Which action is most effective to reduce the IteratorAge and throttle rate?

Accepted Answer

Increase the number of shards. The high IteratorAge indicates that the Lambda function is falling behind in processing records from the Kinesis stream. Throttling occurs because the function's reserved concurrency of 100 is insufficient to handle the total throughput of 10 shards × 5000 records/sec = 50,000 records/sec. Increasing the number of shards (option B) directly increases the parallelism of the stream, allowing more Lambda invocations to run concurrently (up to the reserved concurrency limit) and reducing the backlog, thereby decreasing IteratorAge and throttle rate.

Answer

Increase the batch size to 1000

Answer

Decrease the maximum record age

Answer

Increase the function's memory and CPU allocation

Question 9

A developer is troubleshooting an Amazon API Gateway REST API that returns 504 Gateway Timeout errors for certain requests. The backend is a Lambda function that performs a resource-intensive operation that occasionally takes up to 30 seconds. API Gateway has a default integration timeout of 29 seconds. The developer cannot reduce the execution time. What should the developer do to resolve the timeout issue?

Accepted Answer

Refactor the Lambda function to use asynchronous invocation, return a 202 immediately, and have the client poll for results.. Option B is correct because it decouples the client from the long-running Lambda execution. By invoking the Lambda asynchronously, the API Gateway can return a 202 Accepted response immediately, well within the 29-second integration timeout. The client then polls a separate endpoint (e.g., using a presigned S3 URL or a DynamoDB status record) to retrieve the final result, completely sidestepping the timeout limitation.

Answer

Increase the API Gateway integration timeout to 30 seconds.

Answer

Enable API Gateway caching to avoid repeated calls.

Answer

Use multiple Lambda functions to parallelize processing.

Question 10

A developer is troubleshooting an application that uses Amazon ElastiCache for Redis to improve performance. The application periodically experiences high latency during peak hours. The developer checks the ElastiCache metrics and sees that the 'Evictions' metric is consistently high and the 'CacheHitRate' metric is low. The cluster has a single node with a cache.t3.small instance type. Which action will most likely improve the cache hit rate and reduce latency?

Accepted Answer

Scale up to a larger node type (e.g., cache.t3.medium) to increase available memory.. The high 'Evictions' and low 'CacheHitRate' metrics indicate that the Redis node is running out of memory, forcing it to evict keys to make room for new data. Scaling up to a larger node type (cache.t3.medium) increases the available memory, allowing more data to be cached and reducing evictions, which directly improves the cache hit rate and reduces latency.

Answer

Enable cluster mode and distribute data across multiple shards to reduce memory pressure.

Answer

Change the eviction policy to 'allkeys-lfu' to better manage which keys are evicted.

Answer

Add a read replica for the Redis cluster to offload read traffic.

Question 11

An AWS Lambda function processes messages from an Amazon SQS queue and writes results to an Amazon DynamoDB table. The function is configured with a reserved concurrency of 5 and a batch size of 10. CloudWatch metrics show high throttling and a growing queue backlog. The function's execution time averages 1 second per message. What is the MOST effective action to reduce throttling while improving throughput?

Accepted Answer

Increase the reserved concurrency to 20.. The Lambda function is throttling because its reserved concurrency of 5 limits it to 5 concurrent executions. With a batch size of 10 and 1-second execution time, the function can process at most 5 * 10 = 50 messages per second. Increasing reserved concurrency to 20 allows 20 concurrent executions, raising throughput to 200 messages per second, which directly reduces throttling and clears the backlog.

Answer

Increase the batch size to 100.

Answer

Decrease the reserved concurrency to 2.

Answer

Increase the provisioned write capacity of the DynamoDB table.

Question 12

A developer is debugging an issue where an Amazon S3 bucket policy is not allowing cross-account access for a user from another AWS account. The bucket policy grants access to the other account's root user. The IAM user in the other account has an IAM policy that allows s3:GetObject on the bucket. When the user tries to download an object, they get an Access Denied error. What is the most likely cause?

Accepted Answer

The bucket is encrypted with SSE-KMS and the user does not have kms:Decrypt permission. The most likely cause is that the bucket is encrypted with SSE-KMS. When an S3 bucket uses AWS KMS customer master keys (CMKs) for server-side encryption, the bucket policy granting access to the root user of the other account is not sufficient. The IAM user in the other account must also have explicit kms:Decrypt permission on the KMS key, because S3 GetObject calls require decrypting the object before returning it. Without this KMS permission, the request fails with Access Denied even though the S3 bucket policy and IAM policy appear correct.

Answer

The bucket policy does not specify the user's ARN

Answer

The object's ACL is set to private

Answer

The IAM policy does not include s3:ListBucket

Question 13

A developer has deployed an AWS Lambda function that is triggered by an Amazon S3 event. The function processes image files and stores metadata in an Amazon DynamoDB table. CloudWatch metrics show that the function's error count has increased. The developer checks CloudWatch Logs and sees errors related to insufficient memory. The function is configured with 128 MB of memory. What should the developer do to resolve the errors?

Accepted Answer

Increase the function's memory to 256 MB or higher.. The error is caused by insufficient memory, which directly impacts the CPU and execution resources allocated to the Lambda function. Increasing the memory allocation to 256 MB or higher provides more CPU throughput and memory, resolving the out-of-memory errors without requiring code changes.

Answer

Increase the function's timeout to 30 seconds.

Answer

Reduce the size of the images being uploaded to S3.

Answer

Move the DynamoDB write operation to an asynchronous invocation.

Question 14

A developer is troubleshooting an AWS Lambda function that processes streaming data from Amazon Kinesis Data Streams. The function processes records in batches. The developer notices that the function often experiences high latency even though the average invocation rate is well below the account concurrency limit. Which action would MOST effectively reduce latency?

Accepted Answer

Use provisioned concurrency for the function.. Provisioned concurrency pre-warms a specified number of execution environments, eliminating cold starts and ensuring that the function can handle sudden bursts of traffic without latency spikes. Since the function processes streaming data from Kinesis and experiences high latency despite low average concurrency, the issue is likely cold starts or initialization overhead, which provisioned concurrency directly mitigates.

Answer

Increase the batch size for the Kinesis event source mapping.

Answer

Enable reserved concurrency for the function.

Answer

Increase the number of shards in the Kinesis data stream.

Question 15

A developer is monitoring an AWS Lambda function that is triggered by an Amazon SQS queue. The function's CloudWatch metrics show a high number of throttles. The function has a reserved concurrency of 10 and the SQS queue has a large backlog of messages. The function processes each message in about 2 seconds and has a timeout of 60 seconds. Which action will most effectively reduce the throttles and increase throughput?

Accepted Answer

Increase the reserved concurrency of the Lambda function to 50. The high throttles indicate that the Lambda function's reserved concurrency of 10 is insufficient to handle the incoming messages from the SQS queue. By increasing reserved concurrency to 50, you allow more concurrent executions, which reduces throttling and increases throughput. The function's 2-second processing time and 60-second timeout are not the bottleneck; the concurrency limit is.

Answer

Increase the batch size in the SQS event source mapping to 100

Answer

Increase the function timeout to 120 seconds

Answer

Decrease the reserved concurrency to 5