DVA-C01 AWS Certified Developer Associate Exam Questions and Answers

Use a DynamoDB query operation with the key attributes of user_id and sport_name and order the results based on the score attribute.

Create a global secondary index with a partition key of sport_name and a sort key of score, and get the results

Use a DynamoDB scan operation to retrieve scores and user_id based on sport_name, and order the results based on the score attribute.

Create a local secondary index with a primary key of sport_name and a sort key of score and get the results based on the score attribute.

Add the signature to an HTTP header that is named Authorization

Add the signature to a session cookie

Add the signature to an HTTP header that 15 named Authentication

Add the signature to a query string parameter that is named X-Amz-Signature

Add the signature to an HTTP header that is named WWW-Authenticate

Immutable updates are not supported for Java-based applications

The account has reached its on-demand instance limit

Immutable updates are only supported for m4 large and larger instance types.

The developer must also modify the ebextensions/immutable-updates config file to enable immutable updates

Upload and deploy the new application version in the Elastic Beanstalk console

Use the eb init CLI command to deploy a new version '

Terminate the current Elastic Beanstalk environment and create a new one

Modify the ebextensions folder to add a source option to services

Deploy the application to AWS Elastic Beanstalk. Migrate the database to an Amazon RDS Multi-AZ DB instance

Create an Amazon Machine Image (AMI) that contains the application code. Create an Auto Scaling group that is based on

the AMI Integrate the Auto Scaling group with an Application Load Balancer for the web servers. Migrate the database to a MySQL instance that runs on an Amazon EC2 instance.

Deploy the application to AWS Elastic Beanstalk. Migrate the database to a MySQL instance that runs on an Amazon EC2

instance.

Create an Amazon Machine Image (AMI) that contains the application code. Create an Auto Scaling group that is based on

the AMI. Integrate the Auto Scaling group with an Application Load Balancer for the web servers. Migrate the database to an Amazon RDS Multi-AZ DB Instance

Obtain the request identifier from the Lambda context object Architect the application to write logs to the console.

Obtain the request identifier from the Lambda event object Architect the application to write logs to a file

Obtain the request identifier from the Lambda event object Architect the application to write logs to the console

Obtain the request identifier from the Lambda context object Architect the application to write logs to a file.

Modify the Lambda function execution role's permissions to include the new role

Change the Lambda function execution role to be the new role

Assume the new role in the Lambda function when accessing the table

Store the access key and the secret key for the new role and use them when accessing the table

Enable throttling for the API Gateway stage. Set a value for both the rate and burst capacity. If a registered user chooses a larger package, create a stage for them, adjust the values, and share the new URL with them.

Set up Amazon CloudWatch API logging in API Gateway Create a filter based on the user and requestTime fields and create an alarm on this filter Write an AWS Lambda function to analyze the values and requester information, and respond accordingly Set up the function as the target for the alarm If a registered user chooses a larger package, update the Lambda code with the values.

Enable Amazon CloudWatch metrics for the API Gateway stage Set up CloudWatch alarms based off the Count metric and the ApiName, Method, Resource, and Stage dimensions to alerts when request rates pass the threshold Set the alarm action to Deny If a registered user chooses a larger package create a user-specific alarm and adjust the values

Set up a default usage plan, specify values for the rate and burst capacity, and associate it with a stage, if a registered user chooses a larger package, create a custom plan with the appropriate values and associate the plan with the user

Provision a Redic cluster in Amazon ElasticCache and save the session data in the cluster

Create a session table in Amazon Redshift and save the session data in the database table.

Enable session stickness in the existing Network Load Balancer and manage the session data in the container.

Use an Amazon S3 bucket as data store and save the session data in the bucket.

GetFederationToken

GetCallerIdentity

GetSessionToken

DecodeAutherizationMessage

Text Description automatically generated

Text, letter Description automatically generated

Text Description automatically generated

Enable CORS in the API Gateway method settings.

Use a Lambda proxy integration to return HTTP codes and headers.

Enable API Gateway error pass-through.

Return the value in the header X-Amzn-ErrorType.

Set object retention on the files. Use the AWS software development kit (SDK) to restore the object before subsequent requests. Provide the bucket's URL.

Use the AWS software development kit (SDK) to generate a presigned URL. Provide the presigned URL.

Set a bucket policy that restricts access after a period of time. Provide the bucket's S3 URL.

Configure static web hosting on the S3 bucket. Provide the bucket's web URL.

Grant the Lambda function's execution role permissions to upload logs to Amazon CloudWatch Logs. Implement a CloudWatch Logs Insights query that selects the number of unique customers for orders with order quantity equal to 0 and groups the results in 1-day periods. Add the CloudWatch Logs Insights query to a CloudWatch dashboard.

Use Amazon Athena to query AWS CloudTrail API logs for API calls. Implement an Athena query that selects the number of unique customers for orders with order quantity equal to 0 and groups the results in 1 -day periods. Add the Athena query to an Amazon CloudWatch dashboard.

Configure the Lambda function to send events to Amazon EventBridge. Create an EventBridge rule that groups the number of unique customers for orders with order quantity equal to 0 in 1 -day periods. Add a CloudWatch dashboard as the target of the rule.

Turn on custom Amazon CloudWatch metrics for the DynamoDB stream of the DynamoDB table. Create a CloudWatch alarm that groups the number of unique customers for orders with order quantity equal to 0 in 1-day periods. Add the CloudWatch alarm to a CloudWatch dashboard.

Create a separate CloudFormation template for each EC2 instance type in the list

In the Resources section of the CloudFormation template, create resources for each EC2 instance type in the list.

In the CloudFormation template, create a separate parameter for each EC2 instance type in the list.

In the CloudFormation template, create a parameter with the list of EC2 instance types as AllowedValues

A global secondary index (GSI) with Product ID as the partition key and Product Rating as the sort key

A global secondary index (GSI) with Product ID as the partition key and Review ID as the sort key

A local secondary index (LSI) with Product ID as the partition key and Product Rating as the sort key

A local secondary index (LSI) with Review ID as the partition key and Product ID as the sort key

Add local secondary indexes (LSIs) for the trading data

Store the trading data in Amazon S3, and use S3 Transfer Acceleration.

Add retries with exponential backoff for DynamoDB queries.

Use DynamoDB Accelerator (DAX) to cache the trading data

Create a new Elastic Beanstalk environment that connects to the DB instance.

Create a new DB instance from a snapshot of the previous DB instance.

Use the Elastic Beanstalk CLI to decouple the DB instance.

Use the AWS CLI to decouple the DB instance.

Modify the current Elastic Beanstalk environment to connect to the DB instance.

Revise the request content in the application code.

Use the AWS SDK for Java to interact with AWS APIs.

Scale out the application so that more instances of the application are running.

Add additional logging to the application code.

Associate different AWS Lambda functions to an API Gateway target endpoint

Create different stages in API Gateway, then associate API Gateway with aws Lambda

Create aliases and versions In AWS Lambda.

Tag the AWS Lambda functions with different names

Add a print statement to standard out for each alert and the number of occurrences

Add a call to the PutMetncData API operation Pass an array for alerts and the number of occurrences in the Values and Counts fields with a namespace of "Lambda/AlertCounts"

Add a call to the PutMetncAlarm API operation Pass an array of alerts in the metrics member with the namespace of "Lambda/AlertCounts"

Add a call to the PutDashboard API operation Pass an array of alerts in the metrics member with the namespace of "Lambda/AlertCounts"

Change the Auto Scaling group to six desired instances

Change the deployment policy to traffic splitting Specify an evaluation time of 1 hour.

Change the deployment policy to rolling with additional batch Specify a batch size of 1

Change the deployment policy to rolling Specify a batch size of 2.

An Amazon ElastiCache for Redis cluster

A second Amazon EBS volume

The web server’s primary disk

An Amazon EC2 instance dedicated to session data

Call the Getltem operation first to confirm that the record does not exist. Then call Putltem

Enable the TTL attribute on the DynamoDB table.

Implement a conditional put by using the attribute_exists(transactionlD) condition expression.

Implement a conditional put by using the attribute_not_exists(transactionlD) condition expression.

Store the session state in Amazon ElastiCache

Store the session state in Amazon CloudFront

Store the session state in Amazon S3

Enable session stickiness using elastic load balancers

Enable API caching in Amazon ElastiCache.

Enable an Auto Scaling group on the endpoint service and database.

Create an additional API Gateway and use an Application Load Balancer

Amazon ElastiCache for Memcached with cluster mode enabled

Amazon ElastiCache for Redis with cluster mode enabled

Amazon ElastiCache for Redis with cluster mode disabled

Amazon ElastiCache for Memcached with cluster mode disabled

Configure a unique CodePipelme vanable namespace and vanables as key-value pairs that define each of the variables required in CodeBuild

Configure a CodePipelme environment vanable that contains a JSON document that defines each of the variables required in CodeBuild

Configure an AWS CloudFormation stack set that contains a JSON document that defines each of the variables required in CodeBuild Reference the stack set from CodePipelme

Configure an AWS CodeArtifact repository to store each environment variable Reference CodeArtifact from CodePipelme and CodeBuild

Assign an IAM role to the EC2 instance to allow necessary API calls on behalf of the client.

Implement an exponential backoff algorithm for optimizing the number of API requests made to Amazon EC2.

Increase the overall network bandwidth to handle higher API request rates.

Upgrade to the latest AWS CLI version so that boto3 can handle higher request rates

Create a new attribute that has the Number data type Add a local secondary index (LSI) for this attribute and enable TTL

with an expiration of 48 hours In the application code, set the value of this attribute to the current timestamp for each new item that is being inserted.

Create a new attribute that has the String data type Add a local secondary index (LSI) for this attribute and enable TTL

with an expiration of 48 hours In the application code, set the value of this attribute to the current timestamp for each new item that is being inserted.

Create a new attribute that has the Number data type Enable TTL on the DynamoDB table for this attribute in the

application code set the value of this attribute to the current timestamp plus 48 hours for each new item that is being inserted

Create a new attribute that has the String data type Enable TTL on the DynamoDB table for this attribute In the application

code set the value of this attribute to the current timestamp plus 48 hours for each new item that is being inserted

Place the Lambda function and target group in the same account

Send the request body to the Lambda function with a size less than 1 MB 0

Include the Base64 encoding status status code, status description, and headers in the Lambda function

Enable the multi-value headers on the ALB

Modify the default configuration for the Lambda function to associate it with an Amazon VPC private subnet.

Modify the default network access control list to allow outbound traffic.

Add a NAT Gateway to the VPC.

Modify the default configuration of the Lambda function to associate it with a VPC public subnet.

Add an environmental variable to the Lambda function to allow outbound internet access.

The traces are reaching X-Ray, but the Developer does not have access to view the records.

The X-Ray daemon is not installed on the EC2 instance.

The X-Ray endpoint specified in the application configuration is incorrect.

The instance role does not have “xray:BatchGetTraces” and “xray:GetTraceGraph” permissions.

The instance role does not have “xray:PutTraceSegments” and “xray:PutTelemetryRecords” permissions.

TopicAm

Subject

Destination

Format

Message

Language

Save the secrets in Amazon S3 with AWS KMS server-side encryption, and use a signed URL to access them by using the IAM role from Amazon EC2 instances.

Use the instance metadata to store the secrets and to programmatically access the secrets from EC2 instances.

Use the Amazon DynamoDB client-side encryption library to save the secrets in DynamoDB and to programmatically access the secrets from EC2 instances.

Use AWS SSM Parameter Store to store the secrets and to programmatically access them by using the IAM role from EC2 instances.

Get the instance metadata by retrieving http://169.254.169.254/latest/metadata/.

Get the instance user data by retrieving http://169.254.169.254/latest/userdata/.

Get the application to run IFCONFIG to get the public IP address.

Get the application to run IPCONFIG to get the public IP address.

Subversion

AWS CodeBuild

AWS CodeCommit

AWS CodeStar

Use Amazon Cognito user pools and a custom authorizer to authenticate and authorize users based on JSON Web Tokens.

Build a OpenID token broker with Amazon and Facebook. Users will authenticate with these identify providers and pass the JSON Web Token to the API to authenticate each API call.

Store user credentials in Amazon DynamoDB and have the application retrieve temporary credentials from AWS STS. Make API calls by passing user credentials to the APIs for authentication and authorization.

Use Amazon RDS to store user credentials and pass them to the APIs for authentications and authorization.

HTTP

UDP

SMS

DynamoDB

Named Pipes

Use aws cloudformation compile to base64 encode and embed the source file into a modified

CloudFormation template.

Use aws cloudformation package to upload the source code to an Amazon S3 bucket and produce a

modified CloudFormation template.

Use aws lambda zip to package the source file together with the CloudFormation template and deploy

the resulting zip archive.

Use aws serverless create-package to embed the source file directly into the existing

CloudFormation template.

Use Amazon VPC and keep all resources inside the VPC. and use a VPC link for the S3 bucket with the bucket policy.

Use Amazon Cognito user pools, federate with the SAML provider and use user pool groups with an IAM policy

Use an Amazon Cognito identity pool, federate with the SAML provider, and use an IAM condition key with a value for the cognito-identity.amazonaws com sub variable to grant access to the employees.

Create a unique IAM role for each employee and have each employee assume the role to access the application so they can access their personal data only.

Build the code locally, and then upload the code into the source control system. When a release is needed, run AWS CodePipeline to extract the uploaded build and deploy the resources.

Use the AWS Serverless Application Model (AWS SAM) CLI to build and deploy the application from the developer's local machine with the latest version checked out locally.

Use AWS CodeBuild and AWS CodePipeline to invoke builds and corresponding deployments when configured source controlled branches have pull requests merged into them

Use the Lambda console to upload a .zip file of the application that is created by the AWS Serverless Application Model (AWS SAM) CLI build command.

Create an AWS Lambda function that uses Amazon Simple Email Service (Amazon SES) to send the email notification. Add an Amazon API Gateway to invoke the function. Call the API from the client side when login confirmation is received.

Create an AWS Lambda function that uses Amazon Simple Email Service (Amazon SES) to send the email notification. Add an Amazon Cognito post authentication Lambda trigger for the function.

Create an AWS Lambda function that uses Amazon Simple Email Service (Amazon SES) to send the email notification. Create an Amazon CloudWatch Logs log subscription filter to invoke the function based on the login status.

Configure Amazon Cognito to stream all logs to Amazon Kinesis Data Firehose. Create an AWS Lambda function to process the streamed logs and it send the email notification based on the login status of each user.

Store the configuration data in an encrypted file on the source code bundle. Grant the application access by using IAM policies.

Store the configuration data in AWS Systems Manager Parameter Store. Grant the application access by using IAM policies.

Store the configuration data on an Amazon Elastic Block Store (Amazon EBS) encrypted volume. Attach the EBS volume to an Amazon EC2 instance to provide the application with access to the data.

Store the configuration data in AWS Secrets Manager. Grant the application access by using IAM policies.

The S3 object key only

The S3 object key and the encryption key

The S3 object key and the Amazon Resource Name (ARN) of the AWS Key Management Service (AWS KMS) key

The S3 object key and a randomly salted Hash-based Message Authentication Code (HMAC) value of the encryption key

Send the order ID to an Amazon Simple Notification Service (Amazon SNS) FIFO topic that fans out to one Amazon Simple Queue Service (Amazon SQS) FIFO queue for inventory management and another SQS FIFO queue for payment processing.

Change the Lambda function that generates the order ID to initiate the Lambda function for inventory management. Then initiate the Lambda function for payment processing.

Send the order ID to an Amazon Simple Notification Service (Amazon SNS) topic. Subscribe the Lambda functions for inventory management and payment processing to the topic.

Deliver the order ID to an Amazon Simple Queue Service (Amazon SQS) queue. Configure the Lambda functions for inventory management and payment processing to poll the queue.

Amazon DynamoDB

Amazon Cognito

Amazon ElastiCache

Application Load Balancer

Amazon Simple Queue Service (Amazon SQS)

Create a CloudFront origin access identity (OAI). Associate the OAI with the CloudFront distribution. Modify the S3 bucket policy to allow access from only the OAI. Create an alias in Route 53 that points the website domain to the S3 bucket.

Create a CloudFront origin access identity (OAI). Associate the OAI with the CloudFront distribution. Modify the S3 bucket policy to allow access from only the OAI. Update the Route 53 records to point the website domain to the CloudFront domain name.

Block public access in the S3 bucket policy. Configure CloudFront to use the S3 bucket endpoint. Create an alias in Route 53 that points the website domain to the S3 bucket.

Block public access in the S3 bucket policy. Configure CloudFront to use the S3 bucket endpoint. Create an alias in Route 53 that points the website domain to the CloudFront domain name.

Configure the ALB to use the X.509 certificate by using the AWS Management Console.

Configure each EC2 instance to use the same X.509 certificate by using the AWS Management Console.

Export the root key of the X.509 certificate to an Amazon S3 bucket. Configure each EC2 instance to use the same X.509 certificate from the S3 bucket.

Export the root key of the X.509 certificate to an Amazon S3 bucket. Configure the ALB to use the X.509 certificate from the S3 bucket.

Use the Amazon CloudWatch Synthetics canary functionality to call the API and check the responses and duration of the request.

Use a custom health check in the API that queries hosts to check the duration of the request.

Implement a custom AWS Lambda function with an Amazon EventBridge event to periodically call the API and check the responses and duration of the request.

Use the built-in API Gateway metrics to monitor the average duration of the API response.

Add a listener rule to the listener to return a fixed response if the Authorization header is missing. Set the fixed response to 401 Unauthorized.

Create an authentication action for the listener rules of the ALB. Set the rule action type to authenticate-cognito Set the OnUnauthenticatedRequest field to "deny."

Create an Amazon API Gateway API. Configure all API methods to be forwarded to the ALB endpoint. Create an authorizer of the COGNITO_USER_POOLS type. Configure every API method to use that authorizer.

Create a new target group that includes an AWS Lambda function target that validates the Authorization header by using Amazon Cognito. Associate the target group with the listener.

Configure a high-resolution CloudWatch alarm.

Set up a custom CloudWatch dashboard.

Use Amazon CloudWatch Logs Insights.

Change to a default CloudWatch metric.

VPC Flow Logs

Amazon Route 53 logs

AWS Systems Manager Agent logs

Amazon CloudWatch agent logs

Use the EC2 instances to make the API calls to the payment API

Use Amazon Simple Queue Service (Amazon SQS) with API Gateway and the Lambda function to asynchronously call the payment API

Increase the API Gateway timeout duration to match the payment API time

Increase the Lambda function's memory to increase the network bandwidth and increase the speed of the payment API calls

Use the Amazon CloudWatch API to write timestamps to a custom CloudWatch metric Use the CloudWatch console to analyze the resulting data

Use the AWS X-Ray API to write trace data into X-Ray from strategic places within the code Use the Amazon CloudWatch console to analyze the resulting data

Use the AWS X-Ray API to write trace data into X-Ray from strategic places within the code. Use the X-Ray console to analyze the resulting data

Use the Amazon CloudWatch API to write timestamps to a custom CloudWatch metric Use the AWS X-Ray console to analyze the resulting data

Rewrite the application to be cloud native and to run on AWS Lambda where the logs can be reviewed in Amazon CloudWatch.

Set up centralized logging by using Amazon Elasticsearch Service (Amazon ES), Logstash, and Kibana

Scale down the application to one larger EC2 instance where only one instance is recording logs.

Install the unified Amazon CloudWatch agent on the EC2 instances. Configure the agent to push the application logs to CloudWatch.

Grant the CloudFormation execution role S3 list and get permissions Add a bucket policy to Amazon S3 with the Pnncipal of "AWS": [account numbers].

Grant the CloudFormation execution role S3 get permissions Add a bucket policy to Amazon S3 with the Principal of "".

Use a service-based link to grant the Lambda function S3 list and get permissions by explicitly adding the S3 bucket's account number in the resource

Use a service-based link to grant the Lambda function S3 get permissions and add a Resource of "*" to allow access to the S3 bucket.

Deploy the application in a single Elastic Beanstalk environment

Deploy each component in a separate Elastic Beanstalk environment

Use multiple Elastic Beanstalk environments for the HTTP component but one environment for the background task component

Use multiple Elastic Beanstalk environments for the background task component but one environment tor the HTTP component

Configure an AWS CloudTrail trail to deliver log files to an Amazon S3 bucket

Ensure that the Lambda functions write log messages to stdout and stderr

Enable an AWS CloudTrail trail for the Lambda function

Ensure that the execution role for the Lambda function has access to write to Amazon CloudWatch Logs.

Use the Amazon CloudWatch metric for Lambda errors to create a CloudWatch alarm.

Redeploy the function within the default VPC

Increase the function's memory.

Redeploy the function by using Lambda layers

Increase the function's reserved concurrency

www.myawsbucket.ap-northeast-1.amazonaws.com

myawsbucket.s3-website-ap-northeast-1.amazonawscom

myawsbucket.amazonaws.com

myawsbucket.tokyo.amazonaws.com

Rolling

All at once

Rolling with an additional batch

Immutable

Use parallel scans while limiting the rate

Use sequential scans

Increase read capacity units during the scan operation

Change consistency to eventually consistent during the scan operation

Create an IAM user with access credentials that are distributed with the mobile app to sign the requests

Distribute the AWS root account access credentials with the mobile app to sign the requests

Request temporary security credentials using web identity federation to sign the requests

Establish cross account access between the mobile app and the DynamoDB table to sign the requests

Add database retries to effectively use RDS with vertical scaling

Use RDS with multi-AZ deployment

Add a connection string to use an RDS read replica for read queries

Add a connection string to use a read replica on an EC2 instance.

Use Cognito federated identities.

Use a Cognito user pool.

Use Cognito Sync.

Use Cognito events.

starRating

reviewID

comment

productID

Use s3:x-amz-acl as a condition in the S3 bucket policy.

Use Amazon RDS with default encryption.

Use aws:SecureTransport as a condition in the S3 bucket policy.

Turn on S3 default encryption for the S3 bucket.

Use an identity provider to securely authenticate with the application.

Create an AWS Lambda function to create an IAM user when a user accesses the application.

Create credentials using AWS KMS and apply these credentials to users when using the application.

Use Amazon Cognito to associate unauthenticated users with an IAM role that has limited access to resources.

Specify the Developer’s IAM access key ID and secret access key as parameters for each CLI command.

Run the aws configure CLI command, and provide the Developer’s IAM access key ID and secret access key.

Specify the Developer’s IAM user name and password as parameters for each CLI command.

Use the Developer’s IAM role when making the CLI command.

DynamoDB uses a pessimistic locking model

DynamoDB uses optimistic concurrency control

DynamoDB uses conditional writes for consistency

DynamoDB restricts item access during reads

DynamoDB restricts item access during writes

Deploy the X-Ray SDK with the application and use X-Ray annotation.

Install the X-Ray daemon and instrument the application code.

Install the X-Ray daemon and configure it to forward data to Amazon CloudWatch Events.

Deploy the X-Ray SDK with the application and instrument the application code.

Use the Elastic Beanstalk CLI to disassociate the database.

Use the AWS CLI to disassociate the database.

Change the deployment policy to disassociate the database.

Recreate a new Elastic Beanstalk environment without Amazon RDS.

Create a separate codePipline pipline to run unit tests.

Update the AWS codeBuild build specification to include a phase for running unit tests.

Install the AWS CodeDeploy agent on an Amazon EC2 instance to run unit tests.

Create a testing branch in AWS CodeCommit to run unit tests.

Batch all the writes, and perform the write operations when no or few reads are being performed.

Create a global secondary index with a minimum set of projected attributes.

Implement exponential backoffs in the application.

Load balance the reads to the table using an Application Load Balancer.

Invoke the Encrypt API passing the plaintext data that must be encrypted, then reference the customer managed key ARN in the KeyId parameter

Invoke the GenerateRandom API to get a data encryption key, then use the data encryption key to encrypt the data

Invoke the GenerateDataKey API to retrieve the encrypted version of the data encryption key to encrypt the data

Invoke the GenerateDataKey API to retrieve the plaintext version of the data encryption key to encrypt the data

Security groups

Amazon Elastic Container Registry (Amzon ECR)

Container agent

Task definition

Use an Amazon Cognito user pool with SAML as the resource server

Use Amazon Cognito Identity pools with a SAML identity provider as one of the authentication providers

Use the AWS IAM service to provide the sign-up and sign-in functionality.

Use Amazon CloudFront signed URLs to connect with the SAML identity provider

Store the database credentials as encrypted parameters in AWS Systems Manager Parameter Store Obtain the credentials from Systems Manager when the Lambda function needs to connect to the database

Store the database credentials in AWS Secrets Manager Let Secrets Manager handle the rotation of the credentials, as required

Store the database credentials in an Amazon S3 bucket that has a restrictive bucket policy for the Lambda role only when accessing the credentials Use AWS KMS to encrypt the data

Create a policy with rds-db connect access to the database and attach it to the role assigned to the Lambda function

Write a script that deletes old records; schedule the scripts as a cron job on an Amazon EC2 instance.

Add an attribute with the expiration time; enable the Time To Live feature based on that attribute.

Each day, create a new table to hold session data; delete the previous day’s table.

Add an attribute with the expiration time; name the attribute ItemExpiration.

Make sure Amazon RDS is Multi-AZ so it can better absorb increased traffic.

Create an RDS Read Replica and direct all read traffic to the replica.

Implement Amazon ElastiCache in front of Amazon RDS to buffer the write traffic.

Use Amazon DynamoDB instead of Amazon RDS to buffer the read traffic.

Create an IAM user with read-only permissions for the S3 bucket Temporarily store the user credentials in the Amazon EBS volume of the EC2 instance

Create an IAM user with read-only permissions for the S3 bucket. Temporarily store the user credentials in the user data of the EC2 instance.

Create an EC2 service role with read-only permissions for the S3 bucket Attach the role to the EC2 instance

Create an S3 service role with read-only permissions for the S3 bucket Attach the role to the EC2 instance

Create an Amazon RDS instance, then implement session handling at the application level to leverage a database inside the RDS database instance for session data storage

Implement a shared file system solution across the underlying Amazon EC2 instances, then implement session handling at the application level to leverage the shared file system for session data storage

Create an Amazon ElastiCache Memcached cluster, then implement session handling at the application level to leverage the cluster for session data storage

Create an Amazon DynamoDB table, then implement session handling at the application level to leverage the table for session data storage

Retrieve the messages from the queue using long polling every 20 seconds.

Reduce the size of the messages by compressing them before sending.

Retrieve the messages from the queue using short polling every 10 seconds.

Reduce the size of each message payload by sending it in two parts.

Use an X-Version header to denote which version is being called and pass that header to the Lambda function(s)

Create an API Gateway Lambda authorizer to route API clients to the correct API version

Create an API Gateway resource policy to isolate versions and provide context to the Lambda function(s)

Deploy the API versions as unique stages with unique endpoints and use stage variables to provide further context

First split the files to make them smaller, then process with synchronous RequestResponse Lambda invocations.

Make synchronous RequestResponse Lambda invocations and process the files one by one.

Make asynchronous Event Lambda invocations and process the files in parallel.

First join all the files, then process it all at once with an asynchronous Event Lambda invocation.

Amazon SQS

Amazon Cognito

Amazon Kinesis

Amazon SNS

Amazon ElastiCache

Define an array that includes the environment variables under the environment parameter within the service definition

Define an array that includes the environment variables under the environment parameter within the task definition

Define an array that includes the environment variables under the entrypoint parameter within the task definition

Define in array that includes the environment variables under the entryPoint parameter within the service definition