CCNA Troubleshooting Questions

The latency spikes are caused by gp2 storage burst credit exhaustion. The 500 GB gp2 volume has a baseline of 1,500 IOPS, but the workload spikes to 5,000 IOPS every 15 minutes, rapidly consuming burst credits. Migrating to gp3 provides a baseline of 3,000 IOPS and 125 MB/s throughput without relying on burst credits, thus eliminating the credit exhaustion issue.

Option A (read replica) does not resolve the primary instance's write IOPS spikes. Option B (larger instance) does not address storage IOPS limitations; CPU and connections are already normal. Option D (scale storage to 1,000 GB) would increase the gp2 baseline to 3,000 IOPS and provide more burst credits, but gp3 offers a simpler, more cost-effective solution with consistent performance and no credit-based throttling.

Hot keys or uneven partition access patterns can cause throttling even if overall provisioned capacity appears sufficient. Option A is wrong because DynamoDB Accelerator (DAX) is an in-memory cache that reduces read load, but it does not directly fix capacity exceeded errors; misconfiguration might cause cache misses but not ProvisionedThroughputExceededException. Option B is wrong because Global Tables replication does not cause throttling on the source table; conflicts are handled by last-writer-wins.

Option C is wrong because increasing capacity units multiple times without resolving the underlying access pattern suggests the issue is not simply insufficient capacity.

A low cache hit ratio and high cache miss ratio indicate that the cache is not storing data that is frequently requested. The most likely cause is that the Time-To-Live (TTL) for cache keys is set too short, causing data to be evicted before it can be reused. Option A is incorrect because read replicas improve read scalability but do not directly affect cache hit ratio.

Option B is incorrect because write capacity is not relevant for a caching layer that primarily serves reads. Option C is incorrect: while high CPU utilization can cause latency, it would not specifically cause low cache hits and high misses.

Consolidating many small files into fewer, larger files reduces the overhead of opening and processing numerous small files during the COPY command. Redshift performs better with larger files (e.g., 64 MB to 1 GB) because it can parallelize the load across slices more efficiently. Option A is incorrect because the MANIFEST option helps with specifying files but does not address the root cause of many small files.

Option B is incorrect because JSON format typically increases parsing overhead compared to CSV. Option D is incorrect because changing the distribution style to ALL does not improve COPY performance; it affects query performance after data is loaded.

Running ANALYZE updates the table statistics used by the query planner, allowing it to make informed decisions about index usage. Without updated statistics, the planner may still choose sequential scans even after indexes are created. Option A is incorrect because increasing maintenance_work_mem speeds up index creation but does not affect query planning.

Option B is incorrect because decreasing random_page_cost might make indexes more attractive, but it is a global setting that could have unintended consequences and does not address the root cause of stale statistics. Option D is incorrect because disabling sequential scans (enable_seqscan=off) forces index usage but can lead to suboptimal plans, especially if the index is not the most efficient access method.

With on-demand capacity, throttling often results from hot partitions. The CloudWatch metric 'ThrottledRequests' helps detect throttling, and reviewing 'SystemErrors' can indicate partition-level errors, aiding in identifying hot partitions. Option B is incorrect because auto scaling is only supported for provisioned capacity mode, not on-demand.

Option C is incorrect because enabling DAX can reduce read load but does not address the root cause of throttling due to hot partitions; it is not a troubleshooting step. Option D is incorrect because switching to provisioned capacity and increasing RCUs is a remediation action, not a troubleshooting action.

Reducing the backup retention period reduces the amount of storage consumed by automated backup data, while still allowing point-in-time recovery for the duration of the retention period. Option A is incorrect because changing the instance class does not affect storage consumption. Option C is incorrect because deleting manual snapshots does not reduce the automated backup storage that is likely causing the unexpected filling, and manual snapshots are not necessary for point-in-time recovery.

Option D is incorrect because disabling automated backups eliminates point-in-time recovery capability.

Enabling DynamoDB Accelerator (DAX) caches read results from the DynamoDB table, reducing the number of reads that consume read capacity units (RCUs). When the table has a GSI, reads that use the GSI also consume RCUs from the index. DAX can cache both base table and index reads, thereby lowering overall read consumption.

Option A is incorrect because increasing write capacity does not affect read consumption. Option C is incorrect because changing the sort key does not directly reduce read capacity usage. Option D is incorrect because a local secondary index (LSI) uses the same partition key and does not help reduce read consumption from a GSI.

The logs show page corruption and checksum errors, which are classic symptoms of underlying storage corruption in Aurora MySQL. Storage corruption can occur due to hardware failures or software bugs, and Aurora's distributed storage layer can sometimes experience such issues that manifest as corrupted pages. Option B is incorrect because reader lag would show replication delay metrics and possibly 'seconds behind master' warnings, not corruption-related errors.

Option C is incorrect because connection exhaustion would generate errors like 'too many connections' or timeouts, not page corruption. Option D is incorrect because a failed backup restore would typically result in errors during the restore process, not ongoing page corruption after the instance is running.

When DynamoDB auto scaling is enabled, throttling can occur if the table's write capacity demand spikes faster than auto scaling can increase capacity. The 'minimum provisioned capacity' in the auto scaling policy sets a floor for the capacity units. By increasing this minimum, the table starts with a higher base capacity, reducing the likelihood of throttling during predictable peak hours.

Option A is incorrect because DAX is a caching layer for reads, not writes. Option B is incorrect because disabling auto scaling requires manual intervention. Option C is incorrect because table partitioning in DynamoDB is managed automatically based on provisioned capacity; you cannot manually split partitions.

Set up Amazon RDS Proxy. The issue is that Lambda functions create a new connection per invocation, quickly exhausting the connection pool. While the DatabaseConnections metric shows 195 out of 200 max_connections, the Lambda functions are opening connections and not closing them properly, leading to connection exhaustion.

RDS Proxy manages connection pooling, reusing connections across invocations, reducing the number of connections needed. Option A is wrong because reducing provisioned concurrency does not address the underlying connection management issue and may impact application performance. Option B is wrong because increasing max_connections could lead to increased memory usage and potential performance degradation.

Option D is wrong because decreasing max_connections would make the problem worse by reserving fewer slots.

The most likely cause is that the network ACL (NACL) for the private subnet is blocking outbound traffic to the DB instance. Security groups are stateful and allow return traffic automatically, but NACLs are stateless and require explicit rules for both inbound and outbound. If the private subnet's NACL does not allow outbound traffic to the DB instance's subnet on port 3306, the application server cannot initiate the connection.

Options A and B are incorrect because the security group already allows inbound traffic, and instances in public and private subnets within the same VPC can communicate via private IPs. Option D is incorrect; while a DB subnet group is required for RDS, it does not directly affect connectivity once the instance is running.

The most effective action. Using 'Limited LOB mode' in AWS DMS reduces the overhead of replicating large objects by only transferring metadata until the LOB is accessed, and increasing the max LOB size ensures that LOBs fit within a single transaction, preventing fragmentation. Option A is incorrect because disabling Multi-AZ does not directly affect DMS replication performance; Multi-AZ provides high availability but does not impact replication throughput.

Option B, increasing the Aurora instance size, may help if the instance is CPU or memory constrained, but the primary bottleneck in replication is often the handling of large objects, making DMS task configuration more targeted. Option C is incorrect because using a smaller instance would worsen performance, not improve it.

When an Amazon RDS for MySQL instance reaches 100% storage utilization, the most immediate action to prevent it from becoming inaccessible is to modify the DB instance to increase allocated storage. This adds storage capacity and allows normal operations to continue. Option B (snapshot and archive to S3) does not free up storage on the instance.

Option C (deleting old binary logs) can free space but is not guaranteed to free enough and may not be a long-term solution; also, binary logs are needed for replication and point-in-time recovery. Option D (reboot) does not resolve the storage shortage.

On-demand DynamoDB tables have a per-table throughput limit (e.g., 40,000 read/write units per second). When sustained traffic exceeds this limit, requests are throttled. Option B is incorrect because global table replication does not cause throttling; it replicates writes asynchronously.

Option C is incorrect because DynamoDB Accelerator (DAX) is a read cache that reduces latency, but throttling still occurs if the table itself reaches its throughput limit. Option D is incorrect because adaptive capacity automatically handles hot partitions by splitting them; however, the primary cause here is hitting the on-demand throughput limit, not a partition design issue.

Options B and C are correct. A high disk queue depth indicates an I/O bottleneck on the RDS instance. Enabling storage auto scaling (B) allows the storage to automatically scale up when I/O demand increases, which can reduce queue depth.

Increasing provisioned IOPS (C) directly improves the I/O performance by providing more throughput. Option A is incorrect because increasing connections can increase I/O contention, not reduce it. Option D is incorrect because PostgreSQL does not support query caching in the same way as MySQL, and it is not a solution to an I/O bottleneck.

Option E is incorrect because Multi-AZ provides high availability but does not directly improve I/O performance.

Increasing the instance size of the target RDS instance provides more CPU and memory resources for the CDC process, allowing it to process more changes per unit time and catch up on lag. Option A is incorrect because disabling supplemental logging on the source Oracle database would prevent the capture of necessary change data, breaking CDC entirely and preventing any catch-up. Option C is incorrect because pausing the CDC task would stop processing changes, allowing the lag to grow further, not catch up.

Option D is incorrect because stopping CDC and performing a full load migration would cause significant downtime, which contradicts the requirement for minimal downtime.

Enabling Enhanced Monitoring at the instance level provides OS-level metrics (CPU, memory, I/O) that can help identify resource bottlenecks causing high write latency on the primary instance. Option A is incorrect because switching to Amazon DynamoDB is a major architectural change, not a troubleshooting step. Option B is incorrect because adding read replicas does not reduce write latency on the primary; replicas handle read traffic, not writes.

Option D is incorrect because while slow query logging can identify poorly performing queries, high write latency may also be caused by OS-level resource contention, which Enhanced Monitoring captures.

(WriteIOPS) is correct because during peak hours, high write IOPS can overwhelm the primary instance's capacity, leading to replication lag or resource exhaustion that triggers a failover. Monitoring WriteIOPS helps identify if the write workload exceeds the instance's limits. Option A (FreeableMemory) is incorrect because low freeable memory can cause performance degradation but is less likely to directly cause failover unless memory is severely exhausted.

Option B (DatabaseConnections) is incorrect because high connection counts can cause performance issues but typically do not directly trigger failovers unless combined with other resource constraints. Option C (ReadLatency) is incorrect because it is a symptom of issues like high read load or replication lag, but not a direct cause of failover; failovers are usually triggered by primary instance failure or unreachability.

In REPEATABLE READ isolation level, InnoDB uses gap locks on non-unique indexes to prevent phantom reads, which can cause lock wait timeouts. Changing to READ COMMITTED eliminates gap locks for non-unique indexes because it only uses row-level locks (no gap locks). This reduces lock contention.

Option A is incorrect: adding an index on transaction_date does not eliminate gap locks if the index is non-unique; gap locks still occur. Option B is incorrect: increasing innodb_lock_wait_timeout only increases the time a transaction waits for a lock, it does not prevent the lock from happening. Option C is incorrect: modifying the partition key does not affect the locking mechanism at the row level.

Enabling the slow query log allows the database specialist to identify long-running or inefficient queries that contribute to high CPU utilization and increased database connections, leading to connection timeouts during peak hours. Option A is incorrect because Enhanced Monitoring provides additional metrics (e.g., OS-level metrics) but does not directly address the root cause of the timeouts; it is useful for deeper analysis but not the primary troubleshooting action. Option C is incorrect because creating a read replica and redirecting read traffic reduces load on the primary for read operations, but the issue likely involves write-intensive or poorly optimized queries affecting the primary; while it might alleviate some load, it is not a direct troubleshooting step to identify the cause.

Option D is incorrect because failing over to the standby instance is for high availability and disaster recovery, not for resolving performance issues; it would restart the database but not fix the underlying queries or resource contention.

The most cost-effective because eventually consistent reads consume half the read capacity units (0.5 RCU for items up to 4 KB) compared to strongly consistent reads (1 RCU). Since items are small (1 KB) and the table uses on-demand capacity, halving RCU consumption directly reduces read costs. Option A: Switching to provisioned capacity with auto scaling adds complexity and may not reduce costs if traffic is unpredictable; on-demand is already suitable for variable workloads.

Option B: Application-level compression would not significantly reduce RCU consumption because items are already under the 4 KB RCU threshold. Option C: Adding DAX introduces additional cost and primarily improves latency, not read cost, as DAX still charges for reads from DynamoDB.

High CPU and high disk space usage on dc2.large nodes are classic signs of queries spilling to disk due to insufficient memory. When there isn't enough memory for query processing, Redshift resorts to writing intermediate results to disk, which increases disk space usage and also causes high CPU as the system manages the spill. Option A is insufficient network bandwidth: network bandwidth issues would typically manifest as increased network throughput or latency metrics, not high CPU and disk usage.

Option B is CPU bottleneck: while CPU is high, the simultaneous high disk usage suggests the root cause is memory spilling, not CPU exhaustion alone. Adding compute nodes would not address the memory spilling if the workload is memory-intensive; instead, increasing the node size or using a different instance type with more memory per node would help. Option C is WLM queue: WLM queue waits would be visible in CloudWatch metrics like 'WLMQueueLength' or 'QueryWaitTime', not in CPU or disk usage.

Enabling Performance Insights provides visibility into which SQL queries are consuming CPU resources. Option E is correct because reviewing the slow query log helps identify queries with long execution times that may be causing high CPU. Option B is incorrect because disabling Multi-AZ does not help investigate CPU utilization; it reduces availability but not CPU.

Option C is incorrect because increasing the query cache size is a tuning action, not an investigative step, and may not address the root cause. Option D is incorrect because increasing the DB instance class is a scaling fix, not an investigation method.

Amazon RDS Event Notifications for 'failover' events are delivered within seconds, meeting the 30-second requirement. Subscribing to SNS topics ensures near real-time notification. Option B is wrong because the 'DatabaseConnections' metric with a 1-minute evaluation period introduces a delay of up to 1 minute, exceeding the 30-second threshold.

Option C is wrong because Enhanced Monitoring provides OS-level metrics every second but does not directly indicate a failover event. Option D is wrong because CloudTrail logs API calls with a typical delay of several minutes, not suitable for sub-minute detection.

Options A and C are correct. DatabaseConnections directly shows the number of concurrent connections to the RDS instance, helping monitor connection count. BurstBalance indicates whether the instance has exhausted its I/O burst credits; if it drops, I/O performance degrades and can cause connection timeouts.

Option B (NetworkTransmitThroughput) measures network traffic, not connections. Option D (SwapUsage) tracks memory swapping, which is not a standard RDS metric and does not directly relate to connection timeouts. Option E (ReadLatency) measures I/O read latency, which can affect performance but is not a primary metric for high connection count or connection timeouts.

Even with on-demand capacity, DynamoDB can throttle write requests if the write traffic exceeds the table's previous peak traffic by more than double. On-demand capacity is designed to handle traffic spikes up to double the previous peak within a 30-minute window. If the spike surpasses that threshold, throttling may occur.

Option B correctly identifies this cause. Option A is incorrect because on-demand mode does not use provisioned capacity. Option C is incorrect because adaptive capacity is a feature of provisioned mode, not on-demand.

Option D, an AWS Health event, could cause issues but is not the most likely given normal operation.

The Multi-AZ DB cluster deployment for Amazon RDS includes two readable standby instances. By routing read traffic to these standbys, the load on the primary is reduced, which can decrease read latency without additional compute costs since the standbys are already provisioned. Option A is incorrect because increasing allocated storage primarily improves I/O throughput for sequential operations but may not significantly reduce latency for many small random reads.

Option B is incorrect because Performance Insights is a monitoring tool that helps identify performance bottlenecks but does not directly reduce read latency. Option D is incorrect because increasing the instance size (e.g., from db.r5.large to db.r5.xlarge) would incur additional compute costs.

The 'AuroraBinlogReplicaLag' metric measures the lag between the writer and a reader when using binary log replication. A high value indicates that the reader is not applying changes from the writer quickly enough, causing read latency. This is typically because the reader instance is not keeping up with the write workload from the writer.

Option A is incorrect because Aurora storage is shared and not the cause of replication lag. Option C is incorrect; while an undersized reader can contribute to lag, the primary cause is the reader not keeping pace with writes, not necessarily size. Option D is incorrect because parameter groups affect settings but not replication lag directly.

Enabling RDS Proxy reduces connection churn by pooling database connections, which decreases the number of concurrent transactions competing for locks, thereby reducing lock contention. Option A is incorrect because adding read replicas does not address write lock contention on the writer instance. Option B is incorrect although increasing instance size can help with CPU, it does not directly reduce lock contention and may even exacerbate it by allowing more transactions.

Option D is incorrect because reducing the maximum number of connections can actually increase contention per connection as the same workload is funneled through fewer connections.

Creating a read replica offloads read queries from the primary DB instance, reducing read latency and CPU utilization without requiring application changes. Option B is incorrect because disabling Multi-AZ removes the standby instance, reducing availability and not addressing read latency. Option C is incorrect because increasing the instance class may improve performance but does not specifically offload read traffic; read replicas are more targeted for read-heavy workloads.

Option D is incorrect because the instance already has Multi-AZ enabled; enabling it again has no effect and does not reduce read latency.