Question 340
A Redshift join becomes slow after a new fact table is added, and analysts suspect poor distribution choices. What tool helps?
- Athena scanned-data metrics
- Kinesis shard throughput metrics
- Glue Spark stage metrics
- Redshift EXPLAIN plan
Explanation
Correct Answer
D:EXPLAIN shows a planned Redshift query strategy, including joins, scans and potential data movement; in this scenario, inspect the query plan for redistribution and scan behavior before changing sort or distribution layouts.
Incorrect Answers
A:Athena query execution statistics report the volume of data scanned and runtime behavior; it would target explaining a sudden rise in query cost, while the question is about identifying costly redistribution in warehouse SQL.
B:Stream shard metrics reveal write or read throughput saturation and throttling within shard limits; its benefit is diagnosing write throttling on a hot partition key; that is different from identifying costly redistribution in warehouse SQL.
C:Spark task and stage metrics reveal shuffle size, skew, spill and slow executors; the current need is for identifying costly redistribution in warehouse SQL, not identifying why one Spark stage dominates the run.
Question 341
A partner API returns 500 records per page and may time out after page 18. What practice limits duplicates and missed pages?
- Secrets Manager for API tokens
- Lambda scheduled API poller
- API Gateway with Lambda
- Checkpointed API pagination
Explanation
Correct Answer
D:A durable cursor or page token enables an ingestion process to resume an API listing incrementally; in this scenario, persist the last successfully committed cursor together with idempotent writes so retries resume from a known boundary.
Incorrect Answers
A:Secrets Manager stores API credentials and can support rotation workflows for supported secrets; it would target managing third-party API credentials without embedding them in code, while the question is about resuming paginated ingestion after partial failures.
B:Lambda code can invoke third-party REST APIs on a schedule when network access is available; its benefit is polling a vendor API at bounded intervals; that is different from resuming paginated ingestion after partial failures.
C:API Gateway accepts HTTPS requests and can invoke Lambda for backend request processing; the current need is for resuming paginated ingestion after partial failures, not exposing a managed HTTPS entry point for ingested events.
Question 342
Users want fast free-text and faceted search across millions of support documents. Which store is designed for this access pattern?
- Amazon MemoryDB for Redis
- Aurora PostgreSQL pgvector HNSW index
- Amazon ElastiCache cache
- Amazon OpenSearch Service search index
Explanation
Correct Answer
D:OpenSearch Service supports full-text search and search-oriented indexing of documents; in this scenario, index document fields into OpenSearch and query them with search APIs, rather than scanning raw objects per request.
Incorrect Answers
A:MemoryDB offers a durable Redis-compatible in-memory database for low-latency key-value access; the current need is for enabling relevance-ranked keyword search over ingested articles, not combining Redis-compatible operations with a durable primary database.
B:Aurora PostgreSQL with supported pgvector functionality can index embeddings for approximate similarity search; this can support finding similar embeddings within relational application data, but would not address the need for enabling relevance-ranked keyword search over ingested articles.
C:ElastiCache provides managed in-memory caching to accelerate access to data stored durably elsewhere; this helps with caching read-heavy reference values without changing the source of truth, not enabling relevance-ranked keyword search over ingested articles.
Question 343
A finance team drops CSV archives in S3 once each month and requires a repeatable Spark transformation over all new files. Which approach is appropriate?
- AWS Glue JDBC connection
- AWS DMS full load
- Amazon AppFlow
- S3 object batch processing with Glue
Explanation
Correct Answer
D:Glue batch ETL processes stored S3 objects when a scheduled job runs against their paths; in this scenario, a scheduled Glue job reads the object dataset in batches and writes transformed output; no low-latency stream is necessary.
Incorrect Answers
A:Glue can read JDBC-backed sources through a connection with network and credential settings; it would target extracting scheduled rows from a private relational database, while the question is about reprocessing a monthly collection of stored flat files.
B:AWS DMS can copy existing database tables as an initial migration or replication phase; its benefit is taking a one-time baseline of source tables; that is different from reprocessing a monthly collection of stored flat files.
C:AppFlow transfers data between supported SaaS applications and AWS destinations with managed connectors; the current need is for reprocessing a monthly collection of stored flat files, not importing CRM objects from a supported SaaS application.
Question 344
A Spark transformation writes millions of one-kilobyte Parquet files, and listing and planning overhead dominates queries. What output change helps?
- Compression-aware partitioned Parquet
- Apache Avro for row-oriented exchange
- Apache Parquet output
- JSON preservation for variable schema
Explanation
Correct Answer
A:Compression and sensible file sizing improve Parquet read efficiency without creating countless tiny files; in this scenario, coalesce or compact outputs into reasonably sized Parquet objects while maintaining query-relevant partition boundaries.
Incorrect Answers
B:Avro serializes row-oriented records with schema-based encoding suitable for data interchange; although useful for exchanging schema-described records across heterogeneous consumers, it leaves the need for avoiding a data lake filled with tiny output objects unmet.
C:Parquet stores column-oriented data with encoding and compression suitable for selective analytics; it would target reducing scan bytes for repeated analytic queries, while the question is about avoiding a data lake filled with tiny output objects.
D:JSON can preserve nested and changing attributes that are awkward in a rigid flat-row schema; its benefit is preserving semi-structured event attributes during initial landing; that is different from avoiding a data lake filled with tiny output objects.
Question 345
A new subnet NACL allows TCP 5432 inbound but JDBC clients still time out because ephemeral return traffic is denied. What should be checked?
- Private VPC endpoint policy
- Database security-group ingress
- Network ACL rule order
- Glue worker security-group egress
Explanation
Correct Answer
C:Network ACLs are stateless subnet controls with numbered allow and deny rules evaluated in order; in this scenario, ensure both directions and relevant ephemeral port ranges are allowed in the stateless NACL without overly broad exposure.
Incorrect Answers
A:VPC endpoint policies can restrict supported API actions and resource access through a particular endpoint; it would target limiting S3 API access through a specific gateway endpoint, while the question is about debugging return traffic dropped at a subnet boundary.
B:A VPC security group can restrict database listener access by source security group and destination port; its benefit is permitting only Glue ETL workers to reach RDS over TCP; that is different from debugging return traffic dropped at a subnet boundary.
D:Security-group egress rules govern which destinations Glue worker ENIs may contact; this can support allowing a job to initiate approved outbound database connections, but would not address the need for debugging return traffic dropped at a subnet boundary.
Question 346
A daily bulk replacement collides with interactive reporting sessions and causes lock waits during business hours. What operational adjustment helps?
- Relational isolation-level selection
- Redshift lock monitoring
- Partitioned load scheduling
- Shorter database transaction
Explanation
Correct Answer
C:Loading separate table partitions at coordinated intervals can reduce contention with user-facing operations; in this scenario, schedule and stage the load around critical queries, with atomic publication where appropriate and short final transactions.
Incorrect Answers
A:Transaction isolation controls the concurrency anomalies a database transaction permits under its engine semantics; this can support choosing consistency guarantees for simultaneous source updates, but would not address the need for avoiding bulk-load conflicts with live warehouse queries.
B:Redshift system views and query monitoring expose sessions waiting on resource or transaction locks; this helps with diagnosing warehouse query waits caused by locks, not avoiding bulk-load conflicts with live warehouse queries.
D:Reducing transaction length releases row and table locks sooner in conventional relational engines; it would target limiting lock contention from long-running batch updates, while the question is about avoiding bulk-load conflicts with live warehouse queries.
Question 347
A platform executes Spark jobs around the clock with custom libraries and stable compute utilization. Which compute arrangement may fit?
- Provisioned Redshift cluster
- EMR persistent cluster
- Athena on-demand SQL
- Redshift Serverless
- Lambda short execution
Explanation
Correct Answer
B:A persistent EMR cluster can run continuing workloads with custom node and framework configurations; in this scenario, keep appropriately sized EMR capacity running and tune autoscaling and software controls, accepting cluster management responsibility.
Incorrect Answers
A:Provisioned Redshift compute provides explicit sizing and reservations for more predictable warehouse workloads; this can support optimizing sustained analytics demand under stable capacity, but would not address the need for maintaining specialized continuously running Spark infrastructure.
C:Athena can query data in S3 without administering a persistent warehouse cluster; although useful for serving occasional lake SQL queries with variable demand, it leaves the need for maintaining specialized continuously running Spark infrastructure unmet.
D:Redshift Serverless runs warehouse workloads without manually managing provisioned clusters; it would target running variable warehouse SQL workloads with less infrastructure management, while the question is about maintaining specialized continuously running Spark infrastructure.
E:Lambda charges for invoked execution and suits bounded tasks under platform runtime constraints; its benefit is handling sporadic lightweight event transformations without idle servers; that is different from maintaining specialized continuously running Spark infrastructure.
Question 348
Queries filter first by tenant_id and then by created_at, but the current index seldom gets used. What should be evaluated?
- Relational composite index order
- S3 partition cardinality
- Parquet compression codec
- Redshift distribution key choice
Explanation
Correct Answer
A:The order of columns in a composite B-tree index affects which query predicates can use its leading keys; in this scenario, design an index with columns ordered for selective query patterns and verify plans, avoiding unnecessary index maintenance overhead.
Incorrect Answers
B:Partitioning by extremely high-cardinality fields can create excessive small partitions and metadata overhead; although useful for avoiding millions of tiny lake partitions, it leaves the need for optimizing multi-column predicates in an operational database unmet.
C:A compression codec changes encoded data size and decompression trade-offs for columnar lake files; it would target reducing bytes stored and scanned for Parquet files, while the question is about optimizing multi-column predicates in an operational database.
D:Redshift distribution style influences where rows reside and how much data moves during joins; its benefit is reducing redistribution for frequent large-table joins; that is different from optimizing multi-column predicates in an operational database.
Question 349
Two systems record the same event in local time without offsets, and the merged sequence is inconsistent. What normalization is required?
- Time zone normalization
- Deduplication across sources
- Stable join key
- Late-arriving dimension handling
Explanation
Correct Answer
A:Normalizing timestamps to a common time basis prevents false ordering across systems using different zones; in this scenario, convert source timestamps with known time zones to a consistent standard such as UTC before sequence-sensitive joins.
Incorrect Answers
B:Entity deduplication uses an agreed business key and conflict-resolution rule across integrated sources; its benefit is merging duplicate customer updates from two systems; that is different from correlating event timestamps from multiple geographic sources.
C:Joining data from separate systems requires a trustworthy key that identifies the same entity on each side; the current need is for correlating event timestamps from multiple geographic sources, not preventing incorrect joins across customer feeds.
D:Late-arriving dimensions require a defined strategy for facts received before their lookup rows; this can support loading facts that precede their dimension records, but would not address the need for correlating event timestamps from multiple geographic sources.
Question 350
A Step Functions pipeline ends in FAILED, and operators need the sequence of completed and retried states. Where should they inspect?
- Glue conditional trigger
- Step Functions execution history
- Airflow dependency trigger rule
- EventBridge Scheduler flexible time window
- Airflow task retry policy
Explanation
Correct Answer
B:Step Functions maintains execution event history for supported workflows and helps locate failed states; in this scenario, examine execution history and per-state inputs and errors while considering appropriate sensitive-data logging controls.
Incorrect Answers
A:Glue conditional triggers can start downstream jobs when designated upstream jobs or crawlers reach configured states; the current need is for tracing the precise failure transition in a workflow, not running a publish job only after upstream Glue success.
C:Airflow trigger rules determine when a downstream task may run relative to upstream task states; this helps with ensuring a cleanup task runs after upstream failures, not tracing the precise failure transition in a workflow.
D:Flexible time windows let a scheduled invocation occur within a configured interval instead of at an exact instant; although useful for spreading noncritical batch launches to avoid thundering herds, it leaves the need for tracing the precise failure transition in a workflow unmet.
E:Airflow tasks support retry counts and delays within a DAG's execution schedule; it would target retrying a transiently failing DAG task, while the question is about tracing the precise failure transition in a workflow.