Question 1
An API vendor limits a collector to twenty simultaneous calls, and synchronized retries after HTTP 429 cause repeated throttling. Which TWO client controls address both problems? Choose TWO.
- Exponential backoff with jitter
- DynamoDB adaptive capacity
- RDS Proxy connection pooling
- Kinesis on-demand capacity
- Client-side concurrency limit
Explanation
Correct Answers
A:Backoff and jitter distribute API retries in time after throttling responses or transient errors; in this scenario, delay retries exponentially and introduce randomized timing so the external service can recover rather than receiving a synchronized retry storm.
E:A semaphore or worker cap bounds simultaneous API requests sent by an ingestion job; for the additional requirement of keeping API requests below a known in-flight limit, limit in-flight calls independently of retry delays, keeping concurrency within the contractual service capacity.
Incorrect Answers
B:DynamoDB adaptive capacity can redistribute available throughput to heavily accessed partitions within service limits; the current need is for preventing synchronized retries after a shared API quota is exhausted, not mitigating uneven partition access within a DynamoDB table.
C:RDS Proxy pools application database connections and reduces connection churn against supported databases; this can support protecting a relational database from short-lived connection bursts, but would not address the need for preventing synchronized retries after a shared API quota is exhausted.
D:Kinesis on-demand mode adjusts stream capacity without manually planning shard counts for typical demand patterns; this helps with absorbing variable streaming ingestion demand without shard planning, not preventing synchronized retries after a shared API quota is exhausted.
Question 2
Team-owned data pipeline roles need access decisions based on matching principal and resource `team` tags instead of maintaining one policy per project. Which authorization model fits?
- Cross-account bucket policy
- IAM ABAC with principal tags
- S3 access point policy
- Lake Formation LF-Tag based access
- Session tag authorization
- IAM RBAC role assignment
Explanation
Correct Answer
B:Attribute-based access control compares principal and resource attributes through supported IAM condition keys; in this scenario, use principal/resource tag conditions where supported, with governance for tag assignment to avoid privilege escalation.
Incorrect Answers
A:An S3 bucket resource policy can allow a designated external account or role to access selected objects; it would target authorizing direct read access from another AWS account, while the question is about mapping ETL roles to same-team tagged resources.
C:S3 access points offer distinct access controls and network policies for shared S3 datasets; the current need is for mapping ETL roles to same-team tagged resources, not exposing one bucket to applications with different data-access boundaries.
D:LF-Tag authorization grants governed table access based on metadata classifications and expressions; this can support authorizing lake assets by governed data classification, but would not address the need for mapping ETL roles to same-team tagged resources.
E:Session tags can carry approved attributes in assumed-role sessions for ABAC decisions; this helps with propagating per-session team attributes to authorization rules, not mapping ETL roles to same-team tagged resources.
F:Role-based access control groups permissions according to job functions or workload responsibilities; although useful for giving production operators a stable predefined permission set, it leaves the need for mapping ETL roles to same-team tagged resources unmet.
Question 3
An Athena dataset consists of ten million tiny Parquet objects even though total bytes are moderate. Which maintenance technique fits?
- Avoiding overpartitioned Spark output
- Columnar encoding dictionary
- Sorting output by query predicates
- S3 object compaction
Explanation
Correct Answer
D:Compaction combines many small analytic files into fewer appropriately sized objects; in this scenario, compact objects without losing required partitions and update table metadata so engines enumerate fewer files.
Incorrect Answers
A:Excessive Spark partitions can create scheduling overhead and tiny output objects on low-volume workloads; the current need is for reducing excessive query task overhead, not tuning parallel output granularity to data volume.
B:Dictionary encoding can efficiently represent repeated low-cardinality values in columnar storage formats; this can support compressing repeated categorical attributes efficiently, but would not address the need for reducing excessive query task overhead.
C:Sorting records on frequently filtered fields can improve locality and block skipping for some engines; this helps with increasing pruning efficiency inside large files, not reducing excessive query task overhead.
Question 4
An ETL join has most tasks complete quickly but one reducer runs twenty minutes on one customer ID. What diagnosis fits?
- Spark shuffle skew investigation
- Data type casting validation
- Executor memory tuning
- Glue error log inspection
Explanation
Correct Answer
A:Spark stage metrics can reveal straggler tasks and imbalanced shuffle partitions in a join; in this scenario, inspect per-task shuffle sizes and key frequencies, then apply skew handling rather than simply raising driver memory.
Incorrect Answers
B:Explicit type validation and casting prevent malformed input strings from corrupting typed transformations; the current need is for finding a slow join caused by one hot key, not handling unexpected nonnumeric values in a numeric column.
C:Spark executor memory and partition size affect whether large tasks spill or fail from memory pressure; this can support addressing executor out-of-memory errors on large partitions, but would not address the need for finding a slow join caused by one hot key.
D:Glue job failures produce execution logs that distinguish syntax, credentials, schema and runtime failures; this helps with locating the precise failing operation in Glue, not finding a slow join caused by one hot key.
Question 5
A DataBrew analyst must first measure missing-field patterns and then apply repeatable normalization of country names and whitespace. Which TWO DataBrew capabilities meet both steps? Choose TWO.
- Glue DataBrew recipe
- Lambda event-driven preprocessing
- SageMaker Unified Studio data exploration
- DataBrew profiling job
- Glue Spark preprocessing job
Explanation
Correct Answers
A:DataBrew recipes apply documented preparation steps such as normalizing and cleaning tabular fields; in this scenario, a repeatable DataBrew recipe records preparation steps and can be used in jobs to produce standardized datasets.
D:A DataBrew profile job measures dataset properties including value patterns, completeness and distributions; for the additional requirement of inspecting quality problems before deciding cleaning rules, profile the dataset first to obtain evidence about field distributions and invalid data, then design cleaning rules.
Incorrect Answers
B:Lambda can perform small validation or normalization tasks when an object-arrival event is received; although useful for normalizing small files immediately after landing, it leaves the need for letting analysts prepare messy CSV columns without writing Spark code unmet.
C:Unified Studio provides a governed collaborative environment for exploring and preparing datasets; it would target preparing datasets in a shared analytics project, while the question is about letting analysts prepare messy CSV columns without writing Spark code.
E:Glue Spark jobs transform larger datasets with joins, repartitioning and schema mapping; the current need is for letting analysts prepare messy CSV columns without writing Spark code, not preparing large multi-file datasets for analytics.
Question 6
A function must decompress a few gigabytes locally before uploading its output, but the default scratch space is too small. Which capacity can increase?
- Distributed partitioned compute
- Lambda /tmp ephemeral storage
- Lambda Amazon EFS mount
- Graph traversal algorithm
Explanation
Correct Answer
B:Lambda provides configurable temporary /tmp storage local to an execution environment; in this scenario, configure a sufficient ephemeral storage size and clean temporary files; it is not a shared durable filesystem.
Incorrect Answers
A:Distributed processing partitions data so workers handle portions in parallel and combine results as needed; although useful for parallelizing a large aggregation beyond one machine, it leaves the need for buffering intermediate files during one function execution unmet.
C:Lambda can mount an EFS file system through access points from appropriately networked functions; its benefit is sharing persistent files among multiple Lambda executions; that is different from buffering intermediate files during one function execution.
D:Graph traversal explores connected vertices and edges to follow relationships or dependencies; the current need is for buffering intermediate files during one function execution, not following lineage dependencies between datasets.
Question 7
Fraud and recommendation services must independently replay the same click events after temporary outages. Which ingestion service best fits?
- DynamoDB Streams
- Amazon MSK
- Amazon Data Firehose
- Amazon Kinesis Data Streams
Explanation
Correct Answer
D:A data stream retains ordered records in shards for applications that read at their own pace; in this scenario, separate consumer checkpoints allow either service to resume without forcing the other to keep pace; configure adequate stream retention.
Incorrect Answers
A:DynamoDB Streams exposes item-level changes made to a DynamoDB table for downstream processors; although useful for reacting to inserts and updates of table items, it leaves the need for keeping a replayable clickstream for independent consumers unmet.
B:Amazon MSK runs managed Apache Kafka brokers while retaining Kafka client and topic semantics; it would target migrating existing Kafka producers without rewriting clients, while the question is about keeping a replayable clickstream for independent consumers.
C:Firehose buffers streaming records and delivers them to configured analytics destinations; its benefit is continuously depositing events into an S3 data lake; that is different from keeping a replayable clickstream for independent consumers.
Question 8
An archive migration contains petabytes but receives new data only once per month. Which data characteristic dominates capacity planning?
- High-volume batch architecture
- Data veracity validation
- Schema-flexible variety handling
- High-velocity streaming architecture
Explanation
Correct Answer
A:Volume describes the total quantity of data that must be stored and processed; in this scenario, emphasize volume in storage layout, transfer throughput and batch parallelism; ingestion frequency alone is not the main constraint.
Incorrect Answers
B:Veracity concerns trustworthiness and reliability of incoming information rather than its quantity or speed; the current need is for scaling storage and parallelism for terabytes of historical data, not checking suspicious and conflicting source records.
C:Variety covers multiple structures and types including relational rows, JSON, images and free text; this can support ingesting incompatible structured and unstructured formats, but would not address the need for scaling storage and parallelism for terabytes of historical data.
D:Velocity describes how rapidly data arrives and how quickly it needs to be handled; this helps with coping with millions of events arriving per second, not scaling storage and parallelism for terabytes of historical data.
Question 9
The audit team already collects management events in a CloudTrail Lake event data store and wants SQL analysis of that history. The on-call engineer also needs ad hoc aggregations across current Lambda CloudWatch log groups. Which TWO query tools best fit the separate stores? Choose TWO.
- CloudWatch Logs Insights query
- CloudTrail Lake SQL query
- OpenSearch Service indexed audit exploration
- Athena over S3 CloudTrail logs
- CloudWatch Logs subscription forwarding
Explanation
Correct Answers
A:Logs Insights performs interactive filtered searches and aggregations over CloudWatch application log groups; for the additional requirement of counting application exception types in Lambda logs, search the relevant log groups and parse structured fields to summarize exception frequency quickly.
B:CloudTrail Lake supports SQL-based analysis over events collected in event data stores; in this scenario, query an appropriately populated event data store using SQL and control analyst access to the queryable event history.
Incorrect Answers
C:OpenSearch can index log documents to support interactive search and visualization; the current need is for investigating account activity with structured SQL, not searching repeated substrings across a large normalized log index.
D:Athena can query CloudTrail files in S3 after defining compatible schemas and partitions; this can support joining archived API logs with lake reference datasets, but would not address the need for investigating account activity with structured SQL.
E:Subscription filters can deliver matching CloudWatch log events to downstream processing destinations; this helps with streaming application audit records to a central pipeline, not investigating account activity with structured SQL.
Question 10
An audit needs GetObject activity for specific confidential buckets, not only bucket configuration changes. Which events should be recorded?
- CloudTrail management-event records
- CloudTrail log file integrity validation
- CloudTrail S3 object data events
- CloudTrail organization trail
Explanation
Correct Answer
C:CloudTrail can capture selected S3 object-level APIs as data events when explicitly configured; in this scenario, enable the required S3 data-event selection on a trail or event data store with suitable scope and retention.
Incorrect Answers
A:Management events track AWS control-plane actions such as PutBucketPolicy and CreateRole; it would target finding who changed resource permissions, while the question is about identifying who downloaded restricted data-lake objects.
B:Trail log file integrity validation provides digest files that can help detect tampering of delivered log files; its benefit is proving stored audit logs were not silently altered; that is different from identifying who downloaded restricted data-lake objects.
D:An organization trail can collect supported management activity centrally for accounts in an AWS Organization; this can support covering many accounts with one audit policy, but would not address the need for identifying who downloaded restricted data-lake objects.