Tüm alıştırma soruları

An application publishes event messages to an Amazon SNS topic. An Amazon SQS queue named ShippingQueue is subscribed to this topic, and an AWS Lambda function is configured to process messages from this queue. The developer needs to ensure that the ShippingQueue only receives messages where the message attribute shipping_type is set to physical. Additionally, the developer must prevent messages from being processed by multiple concurrent Lambda instances while the function is actively executing. Which TWO configurations should the developer implement?

A developer is designing a REST API in Amazon API Gateway to ingest high-frequency telemetry data from client devices. To minimize latency and operating costs, the API must write incoming JSON payloads directly to an Amazon Kinesis data stream without using an intermediate AWS Lambda function. The client payload is sent as application/json containing a telemetry event. The API Gateway integration must map the payload to the format required by the Kinesis PutRecords API, which expects base64-encoded data. Which two configuration steps must the developer perform to successfully implement this integration? (Select TWO.)

A developer is designing a system where order events must be processed independently by both an inventory management service and a shipping notification service. Each service must receive its own copy of every order event. Which of the following configurations should the developer implement? (Select TWO.)

A developer is designing a message-based integration pattern for an e-commerce platform. Order event messages are published to an Amazon SNS topic, which fans them out to an Amazon SQS queue. A backend worker application polls the SQS queue and processes the events. The developer has two requirements for handling failed messages:

- If the SQS queue is temporarily unreachable or misconfigured (e.g., due to an incorrect IAM policy), any messages that SNS cannot deliver to the SQS queue must be captured for troubleshooting.
- If the backend worker application receives a message from SQS but fails to process it successfully after $3$ attempts, the message must be safely set aside.

Which configuration should the developer implement to satisfy both requirements?

An application uses an AWS Lambda function to process messages from an Amazon SQS standard queue. The Lambda function has its timeout configured to $3$ minutes. During peak traffic, the developer notices that many messages are processed multiple times by parallel Lambda invocations, even though all Lambda executions finish successfully. The SQS queue has a Default Visibility Timeout of $30$ seconds. Which configuration change should the developer make to resolve this issue?

An application publishes transaction events to an Amazon SNS topic. An Amazon SQS standard queue is subscribed to this topic, and an AWS Lambda function processes messages from the queue. The Lambda function's timeout is configured to $30$ seconds. During traffic spikes, some transactions are processed multiple times by different Lambda invocations, causing duplicate database entries. Additionally, the developer wants to ensure that any messages that fail processing $3$ times are automatically moved to a dead-letter queue (DLQ).

Which two actions should the developer take to meet these requirements? (Select TWO.)

A developer is building a REST API using Amazon API Gateway that integrates with an existing AWS Lambda function. The Lambda function expects a JSON payload containing specific keys: `searchCategory` and `maxResults`. However, client applications will send requests containing query string parameters `category` and `limit` (for example, `/items?category=books&limit=10`). The developer wants API Gateway to transform these incoming query string parameters into the required JSON payload structure before invoking the Lambda function.

Which integration approach should the developer implement to meet these requirements?

A developer is building a digital concert ticketing application. The application needs to retrieve ticket status details for a single ticket using the TicketId, which is the partition key of the Amazon DynamoDB table. The developer wants to minimize latency and read capacity consumption. Which approach is the most efficient and cost-effective way to retrieve the ticket details?

A developer is implementing a game state update system where player level-up events are sent to an Amazon SQS queue. An AWS Lambda function is configured to consume messages from the queue and process the updates. The Lambda function has its timeout configured to 50 seconds. The SQS queue has a visibility timeout of 20 seconds. During testing, the developer notices that some level-up events are being processed multiple times by different Lambda invocations. Which configuration change will prevent the duplicate processing of these messages?

A developer is developing an application that retrieves order history for a customer from an Amazon DynamoDB table. The table uses `CustomerId` as the partition key and `OrderTimestamp` as the sort key. Currently, the application retrieves data by fetching all items from the table and filtering them in memory, and the AWS SDK client is initialized using hardcoded AWS access keys. Which two actions should the developer take to resolve these performance and security issues? (Select TWO.)

A developer is implementing an AWS Lambda function that queries an Amazon RDS for PostgreSQL DB instance. The Lambda function is configured to connect to the database using IAM database authentication. To minimize connection overhead and query latency, the developer initializes a database connection pool in the global scope (outside the Lambda handler function) and generates the IAM database authentication token once during this initialization. During initial testing, the Lambda function successfully connects to the RDS instance and retrieves data. However, when the application is left idle and then invoked again after 30 minutes, subsequent invocations fail with database authentication errors. Which action should the developer take to resolve this issue while maintaining optimal database connection management?

A developer is building a serverless backend for a web application using Amazon API Gateway and AWS Lambda. The API must secure its endpoints by authenticating users against an Amazon Cognito User Pool. The backend Lambda function needs access to the user's Cognito group memberships (claims) as well as the request's HTTP headers and query string parameters. To reduce development time and minimize latency, the developer wants to avoid writing custom authorization code or custom payload mapping logic. Which configuration should the developer implement?

A developer is building an integration where an application publishes messages to an Amazon SNS topic. An Amazon SQS queue is subscribed to the topic, and an AWS Lambda function processes messages from the queue. The messages take approximately $15$ seconds to process. During testing, the developer observes that messages are frequently being processed multiple times, and the Lambda function is running out of database connections. Which of the following actions should the developer take to resolve these issues? (Select TWO.)

A developer is configuring an Amazon API Gateway REST API with a Lambda integration. To manage deployments across different environments, the developer defines a stage variable named $env$ and configures the integration request to dynamically target a Lambda function alias using the format `my-function:${stageVariables.env}`. After deploying the API to a stage where$ env $is set to `prod`, clients receive a$ 500$ Internal Server Error. The API Gateway execution logs show a permission error when attempting to invoke the Lambda function. Which action should the developer take to resolve this issue?

A developer is designing the backend for a multiplayer game where the game session state is stored in an Amazon DynamoDB table. The table structure is defined as follows:
- Partition key: `$GameSessionId$` (String)
- Sort key: `$PlayerId$` (String)
- Attributes: `$Score$` (Number), `$SessionStatus$` (String), `$MatchDetails$` (Map, size $12\text{ KB}$)

The application must support the following requirements:
1. Retrieve the top $10$ highest scores for a specific `$GameSessionId$` in real-time with strong consistency.
2. Every $10\text{ seconds}$, retrieve a list of all active sessions (where `$SessionStatus$` is $\text{"ACTIVE"}$) to display on a public lobby dashboard. The number of active sessions is typically small (fewer than $100$ at any time), but the table contains millions of completed sessions.
3. Minimize provisioned write capacity consumption. Players update their `$Score$` and `$MatchDetails$` frequently (up to $100\text{ writes/sec}$ per session).

Which two configurations should the developer implement to meet these requirements with the lowest latency and cost?

A company is migrating a transaction processing system to AWS. The solution uses an AWS Lambda function that must process events from an Amazon SQS queue, perform a call to an external payment gateway API over the public internet, and save the transaction status to an Amazon DynamoDB table. The Lambda function is configured to run inside private subnets of an Amazon VPC to comply with security requirements. During testing, the function experiences connection timeout errors when trying to reach the payment gateway. Additionally, many SQS messages are being processed multiple times by different Lambda invocations. Which two configuration changes should a developer make to resolve these issues? (Select two.)

A developer is designing an AWS Lambda function that processes incoming images. The function requires a static machine learning model file of $250\text{ MB}$, which is stored in a private Amazon S3 bucket. This model file is read-only and rarely updated. To process the images, the function also needs to write metadata to an Amazon DynamoDB table. The developer wants to optimize the Lambda function's performance by minimizing execution time and avoiding unnecessary API calls during cold starts and warm invocations. Which of the following actions should the developer take to meet these requirements? (Select TWO.)

A developer is implementing a medical imaging pipeline where scan metadata is published to an Amazon SNS topic. An Amazon SQS queue, which is subscribed to the topic, triggers an AWS Lambda function to generate detailed diagnostic reports. The Lambda function has a timeout of $90$ seconds, and a single report can take up to $80$ seconds to generate. During testing, the developer observes that several reports are being generated multiple times for the same scan.

Which configuration change should the developer make to resolve this duplicate processing issue?

An application uses an Amazon SQS standard queue to distribute image processing tasks to EC2 worker instances. Each worker instance takes approximately $15$ seconds to process a single task and then delete the message from the queue. Currently, the SQS queue's visibility timeout is set to $5$ seconds. The developer notices that worker instances are frequently processing the same image tasks multiple times. What should the developer do to resolve this issue?

A developer is building a blogging application where posts are stored in an Amazon DynamoDB table. The table's partition key is AuthorId and the sort key is PostId. The application needs to retrieve all posts written by a specific author that were published within the last 30 days. This operation must minimize latency and read capacity unit (RCU) consumption. Which combination of actions should the developer take to meet these requirements? (Select TWO.)