Question 370
A source account must reject S3 PutObject requests that omit required server-side encryption headers under the chosen design. What authorization technique helps?
- IAM policy condition key
- IAM permissions boundary
- IAM resource-scoped S3 policy
- IAM explicit deny precedence
Explanation
Correct Answer
A:IAM policy conditions can limit allowed API use based on supported request attributes and context; in this scenario, use supported S3 condition keys in the bucket or identity policy and test actual request headers rather than granting unconditional writes.
Incorrect Answers
B:A permissions boundary limits the maximum effective permissions of a principal even when identity policies allow more; although useful for constraining delegated ETL-role administration, it leaves the need for restricting object writes to approved encryption settings unmet.
C:An IAM identity policy can scope supported S3 operations to specific bucket and object ARN patterns; it would target granting ETL read access to one landing prefix, while the question is about restricting object writes to approved encryption settings.
D:An explicit deny in an applicable policy overrides otherwise allowing IAM statements; its benefit is diagnosing access denied despite an Allow statement; that is different from restricting object writes to approved encryption settings.
Question 371
A new database column must appear in development and production in the same controlled sequence. What practice fits?
- Schema registry compatibility check
- Controlled schema migration version
- Backward-compatible optional column
- Schema-on-read normalization
Explanation
Correct Answer
B:Versioned schema migration scripts make database changes reproducible and reviewable across environments; in this scenario, track migration scripts and their applied versions so application and pipeline releases can coordinate safely.
Incorrect Answers
A:A schema registry can enforce defined compatibility rules for producers and consumers sharing encoded records; it would target blocking incompatible event schema changes during deployment, while the question is about coordinating relational schema changes with ETL releases.
C:Adding an optional column can allow older records and consumers to coexist with newer schema versions; the current need is for coordinating relational schema changes with ETL releases, not introducing a nullable attribute without breaking old data.
D:Schema-on-read applies structure when data is queried or transformed rather than forcing one physical shape at ingestion; this can support retaining unpredictable third-party fields for later curation, but would not address the need for coordinating relational schema changes with ETL releases.
Question 372
A vendor's feed may contain bad records, and production reports must not see partially loaded updates. What load pattern fits?
- Redshift UNLOAD to S3
- Redshift COPY manifest
- Redshift staging table merge
- Redshift COPY from S3
Explanation
Correct Answer
C:Loading into a staging table before a controlled merge separates ingestion from publication of target data; in this scenario, cOPY into staging, validate counts and types, then apply updates within an appropriate transaction or swap strategy.
Incorrect Answers
A:UNLOAD writes Redshift query results to S3 objects for exchange or downstream analysis; its benefit is exporting a curated warehouse query result to the lake; that is different from atomically applying validated changes to warehouse tables.
B:A COPY manifest specifies the exact objects that a load should consume for reproducibility; the current need is for atomically applying validated changes to warehouse tables, not preventing partial object sets during a warehouse load.
D:COPY loads supported data files from S3 into Redshift tables using managed parallel reads; this helps with ingesting a large staged dataset into warehouse tables, not atomically applying validated changes to warehouse tables.
Question 373
Thousands of Lambda invocations open new database connections and exhaust RDS session limits. Which component should be considered?
- Kinesis on-demand capacity
- Exponential backoff with jitter
- DynamoDB adaptive capacity
- Client-side concurrency limit
- RDS Proxy connection pooling
Explanation
Correct Answer
E:RDS Proxy pools application database connections and reduces connection churn against supported databases; in this scenario, pool and reuse connections via RDS Proxy, while separately controlling query load and database capacity.
Incorrect Answers
A:Kinesis on-demand mode adjusts stream capacity without manually planning shard counts for typical demand patterns; its benefit is absorbing variable streaming ingestion demand without shard planning; that is different from protecting a relational database from short-lived connection bursts.
B:Backoff and jitter distribute API retries in time after throttling responses or transient errors; the current need is for protecting a relational database from short-lived connection bursts, not preventing synchronized retries after a shared API quota is exhausted.
C:DynamoDB adaptive capacity can redistribute available throughput to heavily accessed partitions within service limits; this can support mitigating uneven partition access within a DynamoDB table, but would not address the need for protecting a relational database from short-lived connection bursts.
D:A semaphore or worker cap bounds simultaneous API requests sent by an ingestion job; this helps with keeping API requests below a known in-flight limit, not protecting a relational database from short-lived connection bursts.
Question 374
A central lake bucket must expose one prefix to a partner account role without copying data. Which policy layer can grant cross-account resource access?
- Cross-account bucket policy
- S3 access point policy
- Lake Formation LF-Tag based access
- IAM ABAC with principal tags
- IAM RBAC role assignment
- Session tag authorization
Explanation
Correct Answer
A:An S3 bucket resource policy can allow a designated external account or role to access selected objects; in this scenario, add narrowly scoped principal and action statements in the bucket policy and require the caller's effective identity permissions.
Incorrect Answers
B:S3 access points offer distinct access controls and network policies for shared S3 datasets; its benefit is exposing one bucket to applications with different data-access boundaries; that is different from authorizing direct read access from another AWS account.
C:LF-Tag authorization grants governed table access based on metadata classifications and expressions; the current need is for authorizing direct read access from another AWS account, not authorizing lake assets by governed data classification.
D:Attribute-based access control compares principal and resource attributes through supported IAM condition keys; this can support mapping ETL roles to same-team tagged resources, but would not address the need for authorizing direct read access from another AWS account.
E:Role-based access control groups permissions according to job functions or workload responsibilities; this helps with giving production operators a stable predefined permission set, not authorizing direct read access from another AWS account.
F:Session tags can carry approved attributes in assumed-role sessions for ABAC decisions; although useful for propagating per-session team attributes to authorization rules, it leaves the need for authorizing direct read access from another AWS account unmet.
Question 375
A preparation stage must join terabytes of customer records and write partitioned Parquet to the curated lake. Which engine is appropriate?
- DataBrew profiling job
- Lambda event-driven preprocessing
- Glue DataBrew recipe
- SageMaker Unified Studio data exploration
- Glue Spark preprocessing job
Explanation
Correct Answer
E:Glue Spark jobs transform larger datasets with joins, repartitioning and schema mapping; in this scenario, run managed Spark transformations in Glue, selecting workers and file layout based on volume and shuffle cost.
Incorrect Answers
A:A DataBrew profile job measures dataset properties including value patterns, completeness and distributions; the current need is for preparing large multi-file datasets for analytics, not inspecting quality problems before deciding cleaning rules.
B:Lambda can perform small validation or normalization tasks when an object-arrival event is received; this can support normalizing small files immediately after landing, but would not address the need for preparing large multi-file datasets for analytics.
C:DataBrew recipes apply documented preparation steps such as normalizing and cleaning tabular fields; this helps with letting analysts prepare messy CSV columns without writing Spark code, not preparing large multi-file datasets for analytics.
D:Unified Studio provides a governed collaborative environment for exploring and preparing datasets; although useful for preparing datasets in a shared analytics project, it leaves the need for preparing large multi-file datasets for analytics unmet.
Question 376
Lambda runtime logs must be forwarded continuously to a central security processor rather than queried only when needed. What feature fits?
- OpenSearch Service indexed audit exploration
- CloudTrail Lake SQL query
- CloudWatch Logs subscription forwarding
- CloudWatch Logs Insights query
- Athena over S3 CloudTrail logs
Explanation
Correct Answer
C:Subscription filters can deliver matching CloudWatch log events to downstream processing destinations; in this scenario, configure subscription delivery to a supported central destination with filter expressions and target permissions.
Incorrect Answers
A:OpenSearch can index log documents to support interactive search and visualization; its benefit is searching repeated substrings across a large normalized log index; that is different from streaming application audit records to a central pipeline.
B:CloudTrail Lake supports SQL-based analysis over events collected in event data stores; the current need is for streaming application audit records to a central pipeline, not investigating account activity with structured SQL.
D:Logs Insights performs interactive filtered searches and aggregations over CloudWatch application log groups; this helps with counting application exception types in Lambda logs, not streaming application audit records to a central pipeline.
E:Athena can query CloudTrail files in S3 after defining compatible schemas and partitions; although useful for joining archived API logs with lake reference datasets, it leaves the need for streaming application audit records to a central pipeline unmet.
Question 377
A worker may crash after writing output but before acknowledging its source batch. What design prevents duplicate business rows?
- SQS dead-letter queue
- Idempotent processing checkpoint
- Multi-AZ dependent services
- SQS ChangeMessageVisibility heartbeat
- Step Functions retry with backoff
Explanation
Correct Answer
B:Durable checkpoints plus idempotent sink writes limit duplicate effects after task retries; in this scenario, use stable source identifiers and committed processing state so retrying a batch does not apply the same logical updates twice.
Incorrect Answers
A:A dead-letter queue collects messages that repeatedly fail processing after configured receive attempts; the current need is for making a restarted pipeline safe to replay, not isolating permanently failing messages for investigation.
C:Using supported multi-AZ data services can reduce interruption from a single Availability Zone failure; this helps with keeping stateful dependencies available during one AZ outage, not making a restarted pipeline safe to replay.
D:The SQS ChangeMessageVisibility API can dynamically extend the invisibility period of an in-flight message as a variable-length task proceeds; although useful for extending SQS visibility for a task whose running time varies widely, it leaves the need for making a restarted pipeline safe to replay unmet.
E:State machine Retry rules can handle selected errors with intervals and exponential backoff; it would target recovering from transient downstream API failures, while the question is about making a restarted pipeline safe to replay.
Question 378
Twenty batch jobs post completed-object keys and worker Lambdas should share the backlog without direct producer-to-worker calls. What architecture helps?
- Separate registered stream consumers
- Kinesis partition key design
- SQS standard queue fan-in
- Kafka consumer groups
- Kinesis enhanced fan-out
Explanation
Correct Answer
C:A standard SQS queue buffers messages from multiple producers for a pool of competing worker consumers; in this scenario, send notifications into one standard queue and scale consumers based on backlog, handling at-least-once delivery idempotently.
Incorrect Answers
A:Applications can register distinct Kinesis stream consumers to obtain their own enhanced fan-out paths; its benefit is creating separately managed read identities for independent applications; that is different from decoupling many asynchronous producers from workers.
B:A Kinesis partition key determines shard assignment and per-key ordering for records; the current need is for decoupling many asynchronous producers from workers, not spreading heavy producer traffic across shards.
D:Kafka consumer groups divide topic partitions among members within a group while different groups read independently; this helps with scaling workers for one Kafka subscription, not decoupling many asynchronous producers from workers.
E:Enhanced fan-out gives registered consumers dedicated throughput for a Kinesis Data Streams shard; although useful for isolating high-throughput independent stream readers, it leaves the need for decoupling many asynchronous producers from workers unmet.
Question 379
A Lambda data-quality controller must execute a SQL query against an Athena table and wait for success. Which API fits?
- Glue job start API
- Step Functions Glue run-job integration
- Redshift Data API execution
- Athena StartQueryExecution
- EMR step submission
Explanation
Correct Answer
D:Athena APIs can start SQL queries and return query execution IDs for polling results; in this scenario, start an Athena query with an approved workgroup and output location, then inspect execution state before consuming results.
Incorrect Answers
A:The Glue StartJobRun API launches a configured ETL job and returns a run identifier for tracking; although useful for starting Glue ETL from an application workflow, it leaves the need for running a governed S3 SQL check from code unmet.
B:A Step Functions Glue service integration can start a job and wait for its run to finish; it would target coordinating downstream steps after a Glue job completes, while the question is about running a governed S3 SQL check from code.
C:The Redshift Data API can submit SQL statements to compatible Redshift environments using authorized calls; its benefit is invoking warehouse SQL without maintaining a persistent client connection; that is different from running a governed S3 SQL check from code.
E:EMR steps run specified data-processing tasks such as Spark jobs on a compatible cluster; this can support launching Spark processing on an existing EMR cluster, but would not address the need for running a governed S3 SQL check from code.
Question 380
A critical S3 replication workflow needs measurable replication latency commitments rather than best-effort timing. What feature should be evaluated?
- DynamoDB global tables
- RDS Multi-AZ deployment
- S3 Replication Time Control
- S3 same-Region replication
- S3 cross-Region replication
Explanation
Correct Answer
C:S3 Replication Time Control provides an SLA-backed replication-time target and metrics for eligible replication rules; in this scenario, configure RTC on the relevant replication rule and monitor replication latency metrics for eligible objects.
Incorrect Answers
A:Global tables replicate DynamoDB table items across selected AWS Regions for multi-Region application access; its benefit is providing regional writes and resilient access to key-value data; that is different from monitoring time-bounded cross-Region replication.
B:An RDS Multi-AZ deployment can provide a synchronized standby or multi-node configuration for availability; the current need is for monitoring time-bounded cross-Region replication, not maintaining database availability through a single-AZ outage.
D:Same-Region Replication copies eligible objects between buckets within one Region for supported uses; this helps with maintaining a second bucket copy without crossing residency boundaries, not monitoring time-bounded cross-Region replication.
E:Cross-Region Replication asynchronously copies eligible objects between buckets in different AWS Regions; although useful for protecting approved datasets with a second-Region object copy, it leaves the need for monitoring time-bounded cross-Region replication unmet.