CCNA Data Operations and Support Questions

The OutOfMemoryError occurs because each Standard worker has a memory limit of 4 GB. Increasing MaxCapacity to 20 does not increase memory per worker when NumberOfWorkers is explicitly set; it only increases the total DPU allocation but the job still uses 10 workers each with 1 DPU. The correct solution is to change the worker type to G.1X, which provides 2 DPUs (8 GB memory) per worker, effectively doubling the memory per worker and resolving the error.

Option A (increase workers) adds parallelism but does not increase per-worker memory. Option B (reduce workers) decreases parallelism and may aggravate memory pressure. Option D (increase MaxCapacity) is ineffective when NumberOfWorkers is fixed.

The `withErrorThreshold` option on an AWS Glue DynamicFrame allows the ETL job to skip a specified number of corrupt or malformed records without failing. This is the most direct way to handle malformed JSON records in Glue. Option A is incorrect because pre-processing all files is inefficient and may not be feasible for large datasets.

Option B is incorrect because converting to Parquet does not address the issue of malformed JSON within the existing files. Option C is incorrect because AWS Glue Schema Registry validates schema compliance, not individual record malformation; it would reject entire datasets that don't match the schema, not skip malformed records.

Options A and C are correct. Defining appropriate sort keys on frequently filtered columns allows Redshift to use zone maps to skip irrelevant blocks, reducing the amount of data scanned. Defining appropriate distribution keys to collocate data on the same node slices minimizes data shuffling during joins, improving performance.

Option B is incorrect because GROUP BY and DISTINCT are query optimization techniques, not table design practices. Option D is incorrect because resizing the cluster (adding nodes or slices) is an infrastructure change, not a table design practice. Option E is incorrect because using VARCHAR instead of CHAR for fixed-length strings does not directly impact query performance from a table design perspective; it is a data type choice that affects storage but not query performance via sort or distribution design.

Loading data directly from S3 to Redshift using the COPY command eliminates the AWS Glue transformation step, which is the primary bottleneck. The COPY command is optimized for high-speed bulk loads, and performing transformations within Redshift (e.g., using SQL or stored procedures) can often be faster than an external ETL tool. Option A (increasing Glue workers) may help parallelism but does not address the overhead of the Glue job itself.

Option C (S3 Select) reduces the data volume scanned by Glue but still requires the Glue transformation. Option D (columnar storage) is already the default in Redshift and does not reduce the Glue job runtime.

The error 'ERROR: cannot execute INSERT in a read-only transaction' occurs when attempting to write data within a transaction that was opened as read-only. In AWS Glue ETL jobs, if the Spark session is configured with `auto_commit=False` or if the job explicitly starts a read-only transaction (e.g., via `SET TRANSACTION READ ONLY`), any subsequent INSERT operation will fail. Option A correctly identifies this cause.

Option B is incorrect because Redshift clusters do not enter a read-only mode during maintenance; instead, they are briefly unavailable. Option C is incorrect because Glue connections do not have a 'read-only' property; the connection string may set `defaultTransactionIsolation`, but not a read-only flag. Option D is incorrect because the IAM role has necessary permissions per the question stem, and insufficient permissions would produce a different error (e.g., permission denied).

Modifying the job to use a 'query' parameter with a WHERE clause that filters on a timestamp column (the bookmark key) allows AWS Glue to read only the new or modified rows, reducing the amount of data transferred from the database and significantly improving read performance. Option A is wrong because increasing the JDBC 'fetchSize' parameter can improve throughput per connection but does not address the root cause of reading all 10 million rows; it may also cause memory issues if set too high. Option B is wrong because disabling job bookmarks and performing a full refresh would reprocess all data, making the job even slower and defeating the purpose of incremental processing.

Option C is wrong because increasing the number of DPUs adds parallelism but does not reduce the volume of data read; the database can still become a bottleneck when reading the entire table.

When read traffic spikes above the maximum auto-scaling limit of 10,000 RCUs (e.g., to 12,000 RCUs), the table cannot provision enough read capacity units quickly enough. This leads to throttling of requests. The AWS SDKs are designed to retry throttled requests, and under certain conditions, they may fall back to eventually consistent reads to reduce latency, which can return stale data.

This explains why stale data appears even when the application explicitly requests strongly consistent reads. Option B is incorrect: write sharding does not inherently cause read-after-write inconsistencies; DynamoDB's strong consistency guarantees hold if capacity is sufficient. Option C is incorrect: DAX is a caching layer that provides eventual consistency by default; strongly consistent reads bypass DAX and go directly to the table, so DAX is not involved.

Option D is incorrect: global tables replicate data asynchronously, but the statement says the application uses a single table; moreover, reading from a replica region would use eventually consistent reads only if configured, but the question states strongly consistent reads are used.

The EC2 instance is in a private subnet without an internet gateway, so it cannot reach S3 over the internet. A VPC endpoint (Gateway or Interface) for S3 is required for private connectivity. The error log shows a connection timeout, which is consistent with the lack of a VPC endpoint.

Option A is incorrect because the bucket's region is us-west-2 as specified, and the bucket exists (DNS resolves). Option C is incorrect because the error is a timeout, not a 404 (bucket not found). Option D is incorrect because the error is a connection timeout, not an access denied (403), so IAM permissions are not the issue.

The most likely cause is that the S3 bucket has a bucket policy that denies access or does not explicitly grant access to the IAM role. Even if the IAM policy attached to the role allows S3 actions, a bucket policy can override it with an explicit deny or by not granting access to the role. Option A is incorrect because the s3:GetObject operation does not require s3:ListBucket permission.

Option C is incorrect because SSE-KMS is not mentioned and would require specific kms:Decrypt permission, but it is not the most likely cause. Option D is incorrect because the EC2 instance's private IP is within the 10.0.0.0/8 VPC range, and the public IP is irrelevant for in-VPC communication.

To protect against accidental deletion of objects in Amazon S3, three effective measures are: creating a bucket policy that explicitly denies the s3:DeleteObject action (option B), enabling versioning (option D), and enabling MFA Delete (option E). Option B ensures that no principal can delete objects unless an explicit allow overrides it. Option D preserves all object versions, allowing recovery of deleted objects.

Option E requires multi-factor authentication for deletion operations, adding an extra security layer. Option A (server access logging) is for auditing, not prevention. Option C (lifecycle policy to Glacier) does not prevent deletion; it transitions objects to cheaper storage but objects can still be deleted by lifecycle rules or manually.

Increasing the size of the DMS replication instance provides more CPU and memory, which can process and apply changes faster, thereby reducing latency in ongoing replication. Option B is incorrect because decreasing the batch size and batch apply timeout would likely increase latency by reducing the efficiency of batch writes. Option C is incorrect because changing the target endpoint to Amazon S3 is not relevant; the target is Aurora MySQL, and migrating to S3 would not resolve latency issues for the current setup.

Option D is incorrect because enabling CDC from binary logs is not applicable; the source is Oracle, which uses redo logs, not binary logs. Additionally, CDC is already used in ongoing replication from Oracle.

The correct answer. Parquet is a columnar storage format that allows Athena to read only the columns needed for a query, reducing I/O and improving performance. Combined with effective partitioning, it enables partition pruning, which further limits the data scanned.

CSV files are row-based and require full scans, even with partitioning. Option A is incorrect because Athena is serverless and users cannot increase nodes; resources are managed automatically. Option C is incorrect: JSON is also row-based and verbose, making it even slower than CSV.

Option D is incorrect because larger CSV files still lead to full scans; Parquet's columnar nature is more impactful than file size.

A, B, and C are correct. A: Setting the number of Glue workers to match the number of shards ensures optimal parallelism and resource utilization. B: Ensuring sufficient shards in Kinesis Data Streams is essential to handle the expected record rate and avoid throttling.

C: Configuring checkpointing in AWS Glue streaming jobs prevents data loss and allows resumption from the last checkpoint on failure. D (batch window) is not appropriate for streaming pipelines as it introduces latency and is more suited for batch processing. E (converting to Avro) is a general data optimization but not a critical consideration specifically for Glue streaming with Kinesis.

AWS Glue is the correct choice because it provides managed ETL (extract, transform, load) capabilities and can be scheduled to run daily. Glue jobs can directly read CSV files from S3 and write to a Redshift table that already exists. Option A (correct) accurately identifies AWS Glue for this automated data movement task.

Option B (Amazon Athena) is wrong because Athena is an interactive query service, not an ETL scheduler; it cannot autonomously move data on a schedule. Option C (Amazon EMR) is wrong because while EMR can handle such tasks, it requires provisioning a cluster, managing lifecycle, and more configuration than needed for a simple daily copy—Glue is simpler and more cost-effective for this use case. Option D (Amazon Kinesis Data Analytics) is wrong because it is designed for processing streaming data in real time, not for batch copying of CSV files.

The current cluster uses a single dc2.large node with only 160 GB SSD, which is nearly full. Replacing it with a single ds2.xlarge node provides 2 TB HDD storage, offering a significant capacity increase at a lower cost per GB compared to other options. Option A is wrong because switching to RA3 nodes introduces managed storage with higher costs and is unnecessary for this capacity need.

Option C is wrong because scaling to a single dc2.8xlarge node provides 2.56 TB SSD but is more expensive than the ds2.xlarge option. Option D is wrong because adding another dc2.large node only doubles the storage to 320 GB, which may not be sufficient and still leaves the cluster with limited SSD capacity, while also increasing CPU and memory unnecessarily.

Combining S3 Block Public Access prevents unintended public exposure, and Amazon Macie automatically discovers, classifies, and protects sensitive PII. Option A is incorrect because S3 Transfer Acceleration speeds up uploads but does not protect data; versioning helps with accidental deletion but not confidentiality or access control. Option B is incorrect because SSE-KMS only provides encryption at rest, not comprehensive protection against misconfigurations or authorized access to PII.

Option C is incorrect because CloudWatch Logs monitor and audit access but do not prevent exposure or classify data; MFA Delete protects against accidental deletion but not against data leaks.

S3 Storage Lens provides cost-effective analytics including last access date and object age, enabling identification of objects not accessed for 90 days without scanning all objects or incurring high costs. Option A is less suitable because S3 Inventory creates daily lists but requires additional Athena queries, adding complexity and cost. Option B is incorrect because S3 Select is designed for querying object content, not metadata; applying it to millions of objects would be highly inefficient and costly.

Option C is incorrect because analyzing S3 server access logs would involve storing and querying large volumes of log data, which is costly and impacts performance, and it logs all requests rather than providing a direct last access timestamp.

The Glue job intermittently fails with AccessDenied when accessing the S3 bucket because the bucket policy restricts access to requests originating from a specific VPC endpoint. Although the Glue job runs in a VPC, it does not automatically route S3 traffic through the VPC endpoint; it may use the internet or a different endpoint. The intermittent success occurs when requests happen to come from the allowed endpoint.

To resolve this, ensure the Glue job's VPC configuration includes a VPC endpoint for S3, and update the bucket policy to allow access from that endpoint. Option B is incorrect because a NAT gateway would route traffic through the internet, which may be denied by the bucket policy. Option C is incorrect because the Lambda function's IAM role does not affect the Glue job's access.

Option D is incorrect because the error is about reading from the input bucket, not writing to the output bucket, and the IAM role already has the necessary S3 permissions.

The current cluster has limited memory per node (16 GB). By switching to memory-optimized instances like r5.xlarge (32 GB), each node has double the memory, reducing the chance of OOM. This is more cost-effective than adding more nodes because the total memory per node increases without increasing the number of instances.

Option A is wrong because increasing the number of nodes adds more memory but also more cost; it might be more expensive than using fewer, larger nodes. Option C is wrong because it's generally not recommended to increase spark.executor.memory beyond the physical memory; it could cause YARN to kill containers. Option D is wrong because Parquet is already efficient; changing to a different format may not solve memory issues.

Options A and D are correct. Increasing the number of shards in the stream increases the write capacity, reducing the 'WriteProvisionedThroughputExceeded' metric. Implementing a random prefix for the partition key helps distribute data writes evenly across all shards, preventing hot shards.

Option B is incorrect because reducing the data retention period does not affect write throughput; it only changes how long data is stored. Option C is incorrect because decreasing the number of shards would reduce write capacity, potentially worsening the issue. Option E is incorrect because enabling enhanced fan-out increases read capacity, not write capacity.

Using S3 event notifications to send events to an SQS queue decouples the file upload from processing. Lambda can then poll the queue in batches, processing multiple events per invocation. This improves reliability by allowing retries and scalability by handling spikes in file arrivals without timing out.

Option A is incorrect because AWS Batch is designed for long-running batch jobs, not event-driven processing triggered by S3 events. Option B is incorrect because SNS is push-based and can still overwhelm Lambda, leading to timeouts. Option C is incorrect because increasing Lambda timeout and memory only postpones the problem without addressing the root cause of scaling and reliability.

Partition pruning allows Athena to read only the partitions that match the WHERE clause, significantly reducing the amount of data scanned. Option A is correct because filtering on partition columns is the most effective way to minimize scanned data. Option B is incorrect because Parquet is a columnar format that already compresses well and reduces scan compared to CSV with GZIP.

Option C is incorrect because S3 Intelligent-Tiering optimizes storage costs, not query scan costs. Option D is incorrect because adding more partition columns does not reduce scan unless the query filters on them, and may increase metadata overhead.

Using 'Full LOB mode' ensures that large objects are migrated without truncation, parallel threads improve throughput, and 'BatchApply' applies changes in batches to maintain transactional consistency. Option A is incorrect because 'Limited LOB mode' can truncate LOB data if the size exceeds the configured maximum, leading to data loss. Option B is incorrect because merely enabling 'Full LOB mode' without parallel threads and 'BatchApply' may not handle large volumes efficiently, potentially causing inconsistency under heavy load.

Option C is incorrect because truncating target tables and restarting the task is a destructive approach that does not resolve the underlying migration issues and can cause data loss or downtime.

The CSV classifier's 'Quote symbol' setting must match the files. If the files do not use quotes, but the classifier expects a quote symbol (e.g., double quotes), the classifier may fail to match, causing the crawler to fall back to default behavior and treat the header row as data. Option B is wrong because a varying number of columns would cause schema issues, not header misrecognition.

Option C is wrong because the delimiter is unrelated to header detection; a custom delimiter can be set separately. Option D is wrong because case of header text does not affect the crawler's ability to recognize headers.

If the incoming data rate is low, the buffer interval (60 seconds) expires before the buffer size (5 MB) is reached, causing small objects. Option B is incorrect because S3 event notifications do not split objects; they are triggered by events but do not affect object size. Option C is incorrect because S3 lifecycle policies transition objects to Glacier, which does not affect object size during delivery.

Option D is incorrect because GZIP compression reduces the object size after batching, but the buffer interval can still trigger delivery before the buffer is full, so it is not the most likely explanation.