CCNA Troubleshooting Questions

Enabling DynamoDB auto scaling allows the table to dynamically adjust write capacity based on actual traffic, which helps reduce throttling during failover when secondary region traffic increases. Option A is incorrect because switching to on-demand capacity mode may reduce throttling but is more expensive and not the most direct fix for capacity limits; auto scaling provides a more cost-effective solution. Option C is incorrect because disabling global tables would stop cross-region replication, defeating the purpose of multi-region disaster recovery.

Option D is incorrect because increasing write capacity of only the secondary region to 20000 may lead to over-provisioning and cost, while auto scaling provides a more efficient and automated solution to handle varying load.

The 'ResourceNotFoundException' indicates the table was not found. The command output lists tables in a specific region. If the table exists in another region, it will not appear.

Additionally, DynamoDB table names are case-sensitive. Option A correctly identifies these as the most likely causes. Option B is incorrect because a table not in ACTIVE state would generate a different error.

Option C is unlikely because the describe command uses the table name, not the ARN. Option D is incorrect because the describe command succeeded (returned a list), but the specific table was not found due to region or case mismatch.

High throttling on write requests often results from uneven partition key distribution, creating hot partitions. Option A is correct: examining the partition key value distribution helps identify hot partitions. Option E is correct: reviewing CloudWatch metrics for WriteThrottleEvents and ConsumedWriteCapacityUnits helps identify throttled write requests and analyze capacity usage.

Options B, C, and D are incorrect: DAX is a read cache and does not affect write throughput; changing to provisioned capacity or increasing read capacity units does not resolve write throttling caused by hot partitions.

The IAM policy includes an explicit Deny statement that specifically denies the DeleteDBInstance action on the production-db instance. In IAM, an explicit Deny overrides any Allow, so even if other statements allow DeleteDBInstance, this Deny prevents the deletion. Option B is incorrect because the policy does allow DeleteDBInstance on other resources, so the issue is not a lack of general permissions.

Option C is incorrect because the policy includes Allow on DescribeDBInstances. Option D is incorrect because the policy does not restrict CreateDBInstance; the problem is specific to deletion of production-db.

DynamoDB Streams can be directly integrated with AWS Lambda, enabling automatic invocation of a Lambda function for each stream record in near real-time. This is the natural choice for processing stream records without additional services. Option A (Amazon Kinesis Data Firehose) is used to load streaming data into data stores, not to invoke Lambda.

Option B (Amazon SQS) is a message queue service; DynamoDB Streams does not directly integrate with SQS, and Lambda would still be needed to poll or process. Option C (AWS Step Functions) orchestrates workflows but does not directly trigger from DynamoDB Streams without Lambda.

Reducing the max_connections value in the DB parameter group and rebooting the instance will limit the number of concurrent connections, preventing the database from being overwhelmed. This is the fastest way to mitigate the spike while preserving application availability. Option A is wrong because terminating all connections and restarting the database would disrupt the application.

Option B is wrong because modifying the security group does not affect the number of connections, only the allowed sources. Option C is wrong because increasing the instance size may take time to provision and does not immediately address the connection spike.

(DirtyBufferFlushRate) is correct because it indicates the rate at which dirty (modified) buffers are flushed from memory to disk, directly contributing to disk writes and I/O. Option D (WriteOps) is correct as it measures the number of write operations performed on disk, a direct contributor to disk I/O. Option E (PhysicalReads) is correct because it represents read operations that actually hit the disk (i.e., cache misses), contributing to disk I/O.

Options B (NetworkThroughput) and C (LogicalReads) are incorrect: NetworkThroughput relates to network traffic, not disk I/O; LogicalReads are reads satisfied from the buffer pool (memory), not disk.

Increasing provisioned read capacity to 2000 RCU would directly address the read throttling, and implementing DAX caching would offload read traffic, reducing the load on the DynamoDB table. Option A is incorrect because decreasing write capacity does not free up read capacity; DynamoDB provisioned capacity for reads and writes is independent. Option B is incorrect because increasing the auto scaling target utilization to 90% would actually cause scaling to trigger at a higher utilization, potentially leading to more throttling, not less.

Option C is incorrect because DynamoDB does not use storage types like GP2; that is a concept for Amazon EBS volumes, not applicable to DynamoDB.

A suboptimal partition key can cause a hot partition, leading to throttling even when overall table capacity is not exhausted. Option E is correct because DynamoDB auto scaling has a lag in provisioning capacity; pre-warming by manually increasing write capacity before a spike can prevent throttling. Option A is incorrect because DynamoDB Streams offloads data but does not increase write capacity.

Option B is incorrect because global tables replicate data across regions but do not resolve local hot partitions or capacity lag. Option D is incorrect because reducing read capacity does not increase write capacity.

Enabling the slow query log on RDS for MySQL captures queries that exceed a specified execution time, allowing the developer to identify which queries are slow and analyze their execution plan to find bottlenecks. Option A is wrong because RDS Events are for maintenance and operational notifications, not query performance. Option B is wrong because CloudWatch CPU and memory metrics show overall resource utilization but do not pinpoint specific slow queries.

Option D is wrong because migrating to a larger instance may help but does not directly identify the bottleneck; it addresses symptoms rather than root cause analysis.

Adding nodes increases both compute capacity and storage, addressing high CPU and low disk space. Option E is correct because optimizing sort keys reduces the amount of data scanned per query, which lowers CPU usage and speeds up queries. Option A is incorrect because disabling concurrency scaling would reduce the cluster's ability to handle concurrent queries, increasing wait times.

Option C is incorrect because Multi-AZ is not a feature of Amazon Redshift; it's used for RDS. Option D is incorrect because VACUUM reorganizes data but requires free disk space to operate; with low disk space, it may fail or not help.

Amazon EBS io2 Block Express volumes provide high IOPS and low latency, which can significantly reduce the time required for a secondary node to catch up and become the new primary after a failover. This improves failover reliability and reduces latency spikes. Option B is incorrect: EBS Multi-Attach is designed for shared block storage across multiple instances and is not suitable for MongoDB replica sets; using it could lead to data corruption.

Option C is incorrect: while instance store volumes offer high I/O performance, they are ephemeral; if the instance fails, data is lost, making them unreliable for database workloads. Option D is incorrect: EBS snapshots are for backup and disaster recovery, not for improving failover performance.

Creating Aurora Replicas offloads read-only SELECT queries from the primary instance, reducing CPU utilization on the primary and improving overall read throughput. Option A is incorrect because enabling Multi-AZ with one standby replica provides high availability but does not help with read scaling; the standby is not used for reads. Option B is incorrect because Performance Insights is a monitoring tool that helps identify performance bottlenecks but does not directly reduce CPU utilization.

Option C is incorrect because simply upgrading to a larger instance class may temporarily alleviate the issue but is not cost-effective and does not address the root cause of read-heavy workload imbalance; adding read replicas scales reads horizontally.

Setting the `max_connections` parameter in the RDS parameter group enforces a hard limit at the database level, preventing the database from accepting more than 200 connections. With 20 application instances each using a connection pool of 10, the total intended connections are 200. By setting `max_connections` to 200, any excess connection attempts will be rejected, and the application should handle connection errors with retry logic, preventing the database from being overwhelmed.

Option A is wrong: reducing the Auto Scaling group's desired capacity to 10 instances would reduce the total connection pool to 100, which might temporarily reduce load but is not a scalable solution and does not address the root cause that the application's connection pooling is not being honored. Option C is wrong: migrating to Amazon Aurora MySQL with Auto Scaling does not directly solve the connection pooling issue. Aurora may allow more connections, but the root cause is that the application is opening more connections than configured, and a migration is a costly change that doesn't fix the configuration problem.

Option D is wrong: increasing the SQLAlchemy pool size per instance to 25 would increase the total potential connections to 500 (20 instances × 25), which would worsen the connection spike and exceed the database's maximum, increasing contention and load.

In DynamoDB on-demand capacity mode, throughput scales automatically based on traffic. However, throttling can still occur if a single partition receives more write requests than the partition's maximum throughput capacity (1,000 WCU per partition). This is known as a hot partition, caused by an uneven distribution of write activity across partition keys.

Option A correctly identifies this. Option B is incorrect because on-demand mode does not use provisioned capacity. Option C uses incorrect terminology—there is no 'maximum write capacity units per partition' that the table as a whole can exceed.

Option D is incorrect because DynamoDB does not have a per-region account-level write limit that causes throttling on a single table.

Even with on-demand capacity, each partition has a maximum throughput limit (read/write capacity per partition). When all writes use the same partition key ('tournament_final'), they all go to a single partition, exceeding its limit and causing throttling (ThrottledRequests and ProvisionedThroughputExceededException). The best solution is to redesign the partition key to distribute writes across multiple partitions (e.g., add a suffix like user_id or timestamp).

Option B is incorrect because DAX is a caching layer for reads, not writes; it does not alleviate write throttling. Option C is incorrect because the question does not mention a GSI, and a GSI would not cause this issue on the base table. Option D is incorrect because switching to provisioned capacity does not solve the hot partition problem; the same partition key would still overload a single partition under provisioned capacity.

High CPU utilization (90%) and low freeable memory (<100 MB) indicate that the current instance size (db.r5.large) is insufficient for the workload. Scaling up to db.r5.xlarge provides additional CPU and memory resources, directly addressing the performance bottleneck. Option A (adding a read replica) offloads read traffic but does not reduce CPU/memory pressure on the primary writer.

Option B (creating additional indexes) could improve query performance, but the team has verified that no query optimization is possible. Option C (increasing storage volume) improves I/O performance but does not directly affect CPU or memory usage.

Auto-scaling can prevent throttling only if the maximum capacity is set appropriately and traffic patterns are predictable. Option B is correct because if the auto-scaling maximum capacity is set too low, the table cannot scale enough to handle the write demand. Option C is correct because auto-scaling reacts to sustained traffic but cannot instantly accommodate a sudden traffic spike that exceeds the maximum capacity.

Option E is correct because even with auto-scaling, an uneven partition key distribution can cause a single partition to exceed its throughput capacity, leading to throttling. Option A is incorrect; a global secondary index with the same partition key does not inherently cause throttling on the base table. Option D is incorrect because eventually consistent reads affect read capacity, not write capacity, and do not cause write throttling.

Implementing exponential backoff with jitter helps handle throttled requests gracefully by retrying after increasing delays, reducing further load on the table. Option B is correct because increasing the maximum read capacity in the auto scaling configuration allows the table to scale up further (beyond 10,000 RCU) during traffic spikes, preventing throttling. Option E is correct because enabling DynamoDB Accelerator (DAX) caches read requests, offloading the table and reducing the read load that can cause throttling.

Option C is wrong because decreasing the target utilization would cause auto scaling to trigger earlier, but it does not increase the maximum capacity; the table would still be limited to the max capacity set, and the spike might exceed it. Option D is wrong because the issue is read traffic, not write capacity, so increasing write capacity does not address read throttling.

DynamoDB Accelerator (DAX) caches frequently read items, reducing the number of read requests to the table. For a read-once, read-many workload, this significantly lowers read capacity consumption, thus reducing throttling cost-effectively. Option A is incorrect: Enabling auto-scaling for read capacity would help reduce throttling by automatically adjusting capacity, but it does not reduce the number of reads; it increases capacity when needed, which can be more expensive than using DAX.

Option C is incorrect: Switching to On-Demand capacity mode eliminates throttling by paying per request, but for a predictable, high-read workload, this is typically more expensive than provisioned capacity with DAX. Option D is incorrect: Increasing the provisioned read capacity units would reduce throttling, but it increases cost because you pay for higher capacity even during off-peak hours. DAX is more cost-effective as it reduces the required capacity.

High 'WriteLatency' and 'DiskQueueDepth' indicate an I/O bottleneck. Switching to Provisioned IOPS (io1 or io2) provides consistent low-latency I/O performance. Option B is correct: gp2 storage baseline IOPS scales with storage size.

Increasing allocated storage raises the baseline IOPS, which can improve performance. Option C is correct: Low free storage space on gp2 can cause performance degradation because write operations may be throttled. Deleting unnecessary data frees up space and alleviates this issue.

Option D is incorrect: Multi-AZ provides high availability and disaster recovery, not increased I/O capacity. It can add write latency due to synchronous replication. Option E is incorrect: Performance Insights is a monitoring tool for analyzing database performance; it helps identify slow queries but does not directly improve performance.

Therefore, the correct actions are A, B, and C.

Increased latency in DynamoDB can be caused by hot partitions where many requests hit the same partition, leading to throttling even with on-demand capacity if the partition limits are exceeded. Checking CloudWatch metrics for throttled requests and partition metrics helps identify hot partitions. Option A is incorrect because adding a GSI does not improve UpdateItem performance; it only helps query performance.

Option B is incorrect: on-demand mode already handles capacity, and increasing read capacity units does not affect write operations like UpdateItem. Option C is incorrect: disabling conditional writes would break the application's concurrency control and does not guarantee latency reduction; condition evaluation is a fast, internal operation.

Configuring the application to use the cluster endpoint with the Aurora JDBC driver's fast failover feature allows the driver to quickly detect the new writer after a failover and reconnect, significantly reducing the perceived failover time by avoiding DNS propagation delays. Option A is incorrect because increasing the instance class improves performance but does not affect failover speed. Option B is incorrect because backup retention period is unrelated to failover latency.

Option C is incorrect because Aurora MySQL is already Multi-AZ by design; enabling Multi-AZ is not a separate configuration step.

High 'Threads_running' consistently above 200 often indicates queries waiting on locks or I/O. 'Innodb_row_lock_current_waits' directly measures the number of row lock waits, which is a common cause of blocked queries when connection pooling is used. Option B is wrong because 'Queries_per_second' measures throughput, not concurrent active queries. Option C is wrong because 'Slow_queries' counts only queries exceeding a time threshold, not all concurrent queries.

Option D is wrong because 'Threads_connected' shows the number of open connections, not necessarily active queries; with connection pooling, many connections may be idle.

The issue is throttling on write requests despite consumed capacity below provisioned. This indicates a hot partition where one partition receives more writes than its limit (1000 WCU per partition). Option A (add random suffix to partition key) distributes writes across partitions, preventing any single partition from exceeding its limit.

Option C (increase write capacity units) can increase the number of partitions, thereby distributing the load and potentially raising the per-partition limit. Option B is incorrect because DAX is a read cache and does not affect write throughput. Option D (Global Tables) does not resolve throttling and may add latency.

Option E (removing sort key) does not address partition hotness.

The condition 'dynamodb:LeadingKeys' applies only to Query and Scan operations when the condition key is used to restrict partition key values. However, the condition 'ForAllValues:StringEquals' requires that all leading keys in the request match the specified value. For a Scan operation without a specific partition key, the condition cannot be satisfied, leading to denial.

Option A is incorrect because the resource ARN includes the table name, so it is valid. Option B is incorrect because the policy allows Scan action. Option C is incorrect because the condition is on LeadingKeys, not on the table.

The 'Connection timed out' error suggests the packet is being dropped at the network layer, likely by a network ACL. Since the security group allows inbound on port 3306, the next step is to check the network ACL associated with the RDS instance's subnet. Network ACLs are stateless, so they must allow both inbound traffic on port 3306 and outbound traffic on ephemeral ports for the response.

Option B is incorrect because a timed out error occurs before the TCP handshake completes, so DNS resolution is not the issue. Option C is incorrect because an internet gateway and public route are irrelevant if both instances are in the same VPC or connected privately. Option D is incorrect because the security group for the EC2 instance can be stateful and typically allows outbound traffic by default; the timeout is not caused by missing outbound rules on the EC2 side.

Amazon RDS allows you to modify the allocated storage for a DB instance dynamically without downtime; the change takes effect during the next maintenance window or can be applied immediately. Option A is incorrect because migrating from gp2 to gp3 changes the storage type but does not increase the storage capacity. Option B is incorrect because adding a read replica does not increase storage on the primary instance; it only offloads read traffic.

Option C is incorrect because while you can restore a snapshot to a larger instance, this process involves downtime and is not as straightforward as modifying the storage directly.

Resize the cluster to a larger node type or add more nodes. RA3 nodes use managed storage with a local cache, and a 'Disk Full' error typically indicates that the local cache or the overall storage limit for the cluster is exhausted. Resizing adds more local cache and increases the total managed storage capacity, resolving the disk full error.

Option A is incorrect because disabling concurrency scaling does not free up disk space; it only affects query concurrency. Option B is incorrect because VACUUM reclaims space from deleted rows, but it requires temporary disk space; if the disk is already full, VACUUM may fail or not help. Option D is incorrect because Redshift Spectrum allows querying data directly from S3 without loading it into Redshift, but it does not resolve a disk full error on the Redshift cluster itself.

Options A (connect_timeout) and B (max_allowed_packet) are correct because a low connect_timeout can cause connections to abort if not completed within the time limit, and a low max_allowed_packet can cause large queries to fail, resulting in aborted connections. Option C is incorrect because query_cache_type affects caching, not connection handling. Option D is incorrect because binlog_retention_hours is for binary log retention, unrelated to connections.

Option E is incorrect because max_connections limits the total number of simultaneous connections but does not directly cause aborted connections; excessive connection attempts might be due to other issues.

'ConsumedWriteCapacityUnits' shows the actual write capacity used, helping to determine if provisioned capacity is exceeded, which leads to throttling. Option B is correct because 'WriteThrottleEvents' directly indicates the number of throttled write requests. Option C is incorrect because 'ThrottledWriteRequests' is not a valid CloudWatch metric for DynamoDB; the correct metric for throttled writes is 'WriteThrottleEvents'.

Option D is incorrect because 'ReadThrottleEvents' pertains to read throttling, not writes. Option E is incorrect because 'SuccessfulRequestLatency' measures latency, not throttling events.

Offloading SELECT queries to the read replica reduces CPU utilization on the primary instance because read replicas can handle read traffic independently. Option A is incorrect: failing over to the standby instance does not reduce CPU load—the standby is only for high availability and becomes the new primary, still handling the same workload. Option B is incorrect: increasing the DB instance size would help but is not the best first step; it involves scaling costs and potential downtime, whereas using a read replica is more efficient and cost-effective for read-heavy workloads.

Option C is incorrect: converting the read replica to a Multi-AZ standby would make it a synchronous replica for failover, not for offloading reads, so it would not reduce CPU on the primary.