Use the AWS CLI to retrieve the IAM group.

Query Amazon EC2 metadata for in-line IAM policies.

Request a token from AWS STS, and perform a describe action.

Perform a get action using the –-dry-run argument.

Validate the IAM role policy with the IAM policy simulator.

The EC2 instance will only be able to list the S3 buckets

The EC2 instance will only be able to list the contents of one S3 bucket at a time

The EC2 instance will be able to perform all actions on any S3 bucket

The EC2 instance will not be able to perform any S3 action on any S3 bucket.

Enable Amazon EBS volume encryption with an AWS KMS .. configuration so that all storage attached to the Lambda function is encrypted.

Set up the Lambda function with a role and key policy to access an AWS KMS CMK Use the CMK to generate a data key used to encrypt all data prior to writing to /tmp storage

Use OpenSSL to generate a symmetric encryption key on Lambda startup Use this key to encrypt the data prior to writing to /tmp

Use an on-premises hardware security module (HSM) to generate keys where the Lambda function requests a data key from the HSM and uses that to encrypt data on all requests to the function

Store the credentials in a configuration file and commit it to the GIT repository.

Store the credentials in AWS Secrets Manager and enable automatic secret rotation.

Store the credentials using Amazon RDS and enable automatic rotation

Store the credentials in code and handle credentials rotation within the application.

Update the Lambda function's execution role to include the missing permissions

Update the Lambda function's resource policy to include the missing permissions

Include an 1AM policy document at the root of the deployment package and redeploy the Lambda function.

Redeploy the Lambda function using an account with access to the AdministratorAccess policy

Change the encryption type to customer-provided keys.

Configure the SJ bucket to use an S3 Bucket Key for SSE-KMS

Use S3 bucket policies to limit the principals who can create objects

Use a custom policy to limit the number of AWS KMS calls that are allowed

Create a global secondary index (GSl) with the Year attribute as the sort key. Create a Lambda function to return the results from a new method in the API.

Design a Lambda function that scans the DynamoDB table and filters the results for the Phase 1 items. Invoke the function from a new method in the API.

Use a DynamoDB stream to send items that are filtered by Year to a new DynamoDB table. Invoke a Lambda function from a new method in the API.

Set up an Amazon CloudFront distribution. Create a Lambda@Edge function to filter the items that are returned from the API request.

After successful login, submit a Cognito request for user tokens. When redirecting to the welcome screen, provide the identity token in the Authorization header of the request. Extract the user name from the given_name claim and the user's universally unique identifier (UUID) from the sub claim inside the identity token. Use the UUID as the key to store and retrieve the previous login information from the database.

After successful login, submit a Cognito request for user tokens. When redirecting to the welcome screen, provide the access token in the Authorization header of the request. Extract the user name from the given_name claim and the user's universally unique identifier (UUID) from the sub claim inside the access token. Use the UUID as the key to store and retrieve the previous login information from the database.

After successful login, submit a Cognito request for user tokens. When redirecting to the welcome screen, provide the identity token in the Authorization header of the request. Extract the user name from the given_name claim and the user's universally unique identifier (UUID) from the iss claim inside the identity token. Use the UUID as the key to store and retrieve the previous login information from the database.

After successful login, submit a Cognito request for user tokens. When redirecting to the welcome screen, provide the access token in the Authorization header of the request. Extract the user name from the given name claim and the user's universally unique identifier (UUID) from the iss claim inside the access token. Use the UUID as the key to store and retrieve the previous login information from the database.

Contact AWS Support to request an AWS KMS rate limit increase.

Perform error retries with exponential backoff in the application code.

Contact AWS Support to request a S3 rate limit increase.

Import a customer master key (CMK) with a larger key size.

Use more than one customer master key (CMK) to encrypt S3 data

Implement the user login page as an asynchronous Lambda function.

Use Amazon ElastiCache for MemCached to cache user data.

Use Amazon Application Load Balancer to load balance the traffic to the website.

Call the database asynchronously so the code can continue executing.

Batch login requests from hundreds of users together as a single read request to the database.

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

Use the AWS:: Include transform in CloudFormation to provide the log group's name to the application.

Pass the log group's name to the application in the user data section of the CloudFormation template.

Use the CloudFormation template's Mappings section to specify the log group's name for the application.

Pass the log group's Amazon Resource Name (ARN) as an environment variable to the Lambda function.

The API operation cannot access the encryption key

The HTTP Content-Length header is missing.

The object exceeds the maximum object size that is allowed.

The S3 bucket exceeds the maximum storage capacity that is allowed

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

Create a custom AWS CloudFormation public registry extension Reference a GitHub repository that hosts the open-source modules m the extension Configure Formation to scan the repository once each day Write an AWS Serverless Application Model (AWS SAM) template to redeploy the three Lambda functions upon a scan notification change.

Create an Amazon CloudFront distribution with an Amazon S3 bucket as the origin Upload the patched modules to Amazon S3 when needed Modify each Lambda function to download the patched modules from the CloudFront distribution during the cold start.

Launch an Amazon EC2 instance Host a private open-source module registry on the EC2 instance Upload the modified open-source modules to the private registry when needed. Modify each Lambda function deployment script to download the modules from the private registry Redeploy the three new Lambda functions.

Create a Lambda layer with the open-source modules Modify all three Lambda functions to depend on the layer Remove the open-source modules from each Lambda function Patch the Lambda layer with the modified open-source modules when needed Update the Lambda functions to reference the new layer version

Create a cross-account role and call the AssumeRole API operation

Create a user in the Example Corp account and provide the access keys

Create a user in the Example Corp account and provide the credentials

Create a cross-account role and call the AssumeRoleWithWebldentity API operation

Use Amazon ElastiCache to cache query results

Scale the ECS cluster to contain more ECS instances

Add read capacity units (RCUs) to the DB instance.

Modify the ECS task definition to increase the task memory

Managed policy

Trust policy

Inline policy

Service control policy (SCP)

Install the missing module and specify the current directory as the target Create a ZIP file to include all files under the current directory, and upload the ZIP file.

Install the missing module in a lib directory Create a ZIP file to include all files under the lib directory, and upload the ZIP file as a dependency file

In the Lambda code invoke a Linux command to install the missing modules under the /usr/lib directory

In the Lambda console, create a LD_LIBRARY_PATH environment and specify the value for the system library path.

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

Enable cross-origin resource sharing (CORS) on the S3 bucket

Enable cross-origin resource sharing (CORS) for the method in API Gateway

Add the Access-Control-Request-Method header to the request

Add the Access-Control-Request-Headers header to the request

Execute an AWS Lambda function in response to the S3 object creation events that creates an Amazon DynamoDB record for every object with the Customer ID as the partition key and the Server ID as the sort key Retrieve all the records using the Customer ID and Server ID attributes

Execute an AWS Lambda function in response to the S3 object creation events that creates an Amazon Redshift record for every object with the Customer ID as the partition key and TS-Server as the sort key Retrieve all the records using the Customer ID and TS-Server attributes

Execute an AWS Lambda function in response to the S3 object creation events that creates an Amazon DynamoDB record for every object with the Customer ID as the partition key and TS-Server as the sort key Retrieve all the records using the Customer ID and TS-Server attributes

Execute an AWS Lambda function in response to the S3 object creation events that creates an Amazon Redshift record for every object with the Customer ID as the partition key and the Server ID as the sort key. Retrieve all the records using the Customer ID and Server ID attributes.

Configure the services to use Amazon Cognito.

Configure the ALB to use Amazon Cognito

Configure the services to use AWS Security Token Service (AWS STS) with the OpenID Connect IdP.

Configure the Amazon ECS cluster to use AWS Security Token Service (AWS STS) with the OpenID Connect IdP

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"

Create an IAM permission policy attached to the role that allows access to DynamoDB Add a trust policy to the role that allows DynamoDB to assume the role Attach a permissions policy to the development group in AWS IAM that allows developers to use the IAM GetRole and IAM PassRole permissions for the role

Create an IAM permissions policy attached to the role that allows access to DynamoDB Add a trust policy to the role that allows Amazon EC2 to assume the role Attach a permissions policy to the development group in AWS IAM that allows developers to use the IAM PassRole permission for the role

Create an IAM permission policy attached to the role that allows access to Amazon EC2 Add a trust policy to the role that allows DynamoDB to assume the role Attach a permissions policy to the development group in AWS IAM that allows developers to use the IAM PassRole permission for the role

Create an IAM permissions policy attached to the role that allows access to DynamoDB Add a trust policy to the role that allows Amazon EC2 to assume the role Attach a permissions policy to the development group in AWS IAM that allows developers to use the iam GetRole permission for the role.

Sending custom metrics using the CLI is not supported

The developer needs to use the put-metric-data command.

The developer must use a unified CloudWatch agent to publish custom metrics

The code is not running on an Amazon EC2 instance

Use AWS Elastic Beanstalk for application deployment and select an all-at-once update policy.

Use AWS Elastic Beanstalk for application deployment and select a rolling deployment policy.

Deploy the Docker container on an Amazon EC2 instance in an Auto Scaling group and configure a health check on the EC2 instance

Deploy the Docker container using AWS Lambda and enable Amazon CloudWatch monitoring

Implement retries with exponential backoff

Use a PutRecord API instead of PutRecords

Reduce the frequency and/or size of the requests

Use Amazon SNS instead of Kinesis.

Reduce the number of KCL consumers.

The file must be a JSON-formatted file named appspec.json.

The file must be a YAML-formatted file named appspec.yml

The file must be stored in AWS CodeBuikJ and referenced from the application's source code.

The file must be placed in the root of the directory structure of the application's source code.

The file must be stored in Amazon S3 and referenced from the application's source code.

Turn on the trusted code option in AWS CodeDeploy. Add the CodeDeploy digital certificate to the Lambda package before deploying the package to Lambda

Define the code signing configuration in the Lambda console Use AWS Signer to digitally sign the Lambda package before deploying the package to Lambda

Link Lambda to AWS Key Management Service (AWS KMS) in the Lambda console. Use AWS KMS to digitally sign the Lambda package before deploying the package to Lambda.

Set the KmsKeyArn property of the Lambda function to the Amazon Resource Name (ARN) of a trusted key before deploying the package to Lambda.

Configure security groups to allow access lo Systems Manager.

Create an interface VPC endpoint for Systems Manager.

Use an internet gateway from inside the VPC.

Create a gateway VPC endpoint for Systems Manager.

Perform a DynamoDB Query operation with the Id. If the price is >= 600, perform an Updateltem operation to update the price.

Perform a DynamoDB Updateltem operation with a condition expression of "Price >= 600".

Perform a DynamoDB Updateltem operation with a condition expression of "ProductCategory IN <{"S": "Sporting Goods"}) and Price = 600".

1. Build the SAM template in Amazon EC2.

2. Package the SAM template to Amazon EBS storage.

3. Deploy the SAM template from Amazon EBS.

1. Build the SAM template locally.

2. Package the SAM template onto Amazon S3.

3. Deploy the SAM template from Amazon S3.

1. Build the SAM template locally.

2. Deploy the SAM template from Amazon S3.

3. Package the SAM template for use.

1. Build the SAM template locally.

2 Package the SAM template from AWS CodeCommit.

Enable sticky sessions on the ALB target group.

Create an Amazon DynamoDB table. Configure the application to use the DynamoDB table to store session state such as login status.

Create an Amazon Elastic Block Store (Amazon EBS) volume. Use EBS Multi-Attach to attach the volume to all instances in the Auto Scaling group. Configure the application to use the volume to store session state such as login status.

Enable deregistration delay on the ALB target group.

Partition key on the office identifier and sort key on the employee name

Partition key on the employee name and sort key on the office identifier

Partition key on the employee name

Partition key on the office identifier

Issue the aws lambda update-function-code CLI command with the -zip-file fileb://my-function.zip parameter

Upload the build artifact to Amazon S3.

Issue the aws cloudformation package CLI command.

Issue the aws lambda update-function-code CLI command with the -s3-bucket and -s3-key parameters.

Issue the aws lambda update-function-code CLI command with a parameter that points to the source code in AWS CodeCommit.

Create an Amazon Cognito authonzer in API Gateway and specify the Amazon Cognito user pool.

Create an AWS Lambda authorizer in API Gateway and specify the Amazon Cognito user pool.

Specify the authofizer in the GET method section of API Gateway and redeploy the API.

Use Amazon Cognito user pools to make and authenticate the request to API Gateway.

Create an Amazon Cognito authorizer in API Gateway and specify the Amazon Cognito identity pool.

Use S3 Batch Operations to invoke an AWS Lambda function to create new variants of the photos with the required dimensions and resolutions. Cr........dynamic CloudFront origin that automatically maps the request of each device to the corresponding photo variant.

Use S3 Batch Operations to invoke an AWS Lambda function to create new variants of the photos with the required dimensions and resolutions. Cre;..... Lambda@Edge function to route requests to the corresponding photo variant by using request headers.

Create a Lambda@Edge function that optimizes the photos upon request and returns the photos as a response. Change the CloudFront TTL cache policy to the maximum value possible.

Create a Lambda@Edge function that optimizes the photos upon request and returns the photos as a response. In the same function, store a copy to processed photos on Amazon S3 for subsequent requests.

Import users from a .csv file.

Add an OpenID Connect (OIDC) identity provider to the user pool.

Import users from a .json file.

Import users with a user migration AWS Lambda trigger.

Create an Amazon S3 bucket. Use the s3 sync command to upload the files to the S3 bucket.

Create an Amazon Elastic Block Store (Amazon E8S) volume. Upload the files to the volume. Attach the volume to the EC2 instances.

Create an Amazon Elastic File System (Amazon EFS) file system. Use AWS DataSync to transfer the files to Amazon EFS.

Create an Amazon Elastic File System (Amazon EFS) file system. Mount the EFS file system from the legacy application. Copy the files to the EFS mount.

Set up an all-at-once deployment in Elastic Beanstalk. Run tests in parallel with multiple CodeBuild actions.

Set up a rolling update in Elastic Beanstalk. Run tests in serial with a single CodeBuild action.

Set up an immutable update in Elastic Beanstalk. Run tests in serial with a single CodeBuild action.

Set up a traffic-splitting deployment in Elastic Beanstalk. Run tests in parallel with multiple CodeBuild actions.

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.

Deploy the API Gateway REST API to all the required AWS accounts. Use the same custom domain name for all the gateway endpoints so that a single SCM webhook can be used for all events from all accounts.

Deploy the API Gateway REST API to all the receiver AWS accounts Create as many SCM webhooks as the number of AWS accounts.

Grant permission to the central AWS account for EventBridge to access the receiver AWS accounts. Add an EventBridge event bus on the receiver AWS accounts as the targets to the existing EventBridge rule

Convert the API Gateway type from REST API to HTTP API

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.

Configure the Lambda function with a larger amount of memory.

Configure an increase in the Lambda function's timeout value.

Configure the SOS queue's delivery delay value to be greater than the maximum time it takes to call the third-party API.

Configure the SOS queue's visibility timeout value to be greater than the maximum time it takes to call the third-party API.

Store the data objects on an Amazon RDS DB instance. Cache the data objects in memory by using Amazon ElastiCache.

Store the data objects on Amazon EC2 instances behind an Application Load Balancer. Use session affinity (sticky sessions) for each user's shopping cart.

Store the data objects in Amazon S3 buckets. Cache the data objects by using Amazon CloudFront with the maximum TTL.

Store the data objects in Amazon DynamoDB tables. Cache the data objects by using DynamoDB Accelerator (DAX).

SSE with Amazon S3 managed keys (SSE-S3)

SSFE with AWS KMS managed keys (SSE KMS)

SSE with AWS Secrets Manager

SSE with customer provided encryption keys

AWS IAM

Amazon Cognito identity pools

Amazon Cognito user pools

AWS Directory Service

Use Amazon CloudFront with signed URLs for Amazon S3

Create a dedicated Amazon CloudFront Distribution for each customer

Use Amazon CloudFront with AWS Lambda@Edge

Use Amazon API Gateway and AWS Lambda to control access to an S3 bucket

CloudFormation serverless intrinsic functions

AWS serverless express

An AWS serverless application model

A CloudFormation serverless plugin

AWS Certificate Manager (ACM)

AWS Systems Manager Parameter Store

AWS Trusted Advisor

AWS KMS

Amazon GuardDuty

Create a high-resolution custom Amazon CloudWatch metric for user activity data, then publish data every 30 seconds

Create a high-resolution custom Amazon CloudWatch metric for user activity data, then publish data every 5 seconds

Create a standard-resolution custom Amazon CloudWatch metric for user activity data, then publish data every 30 seconds

Create a standard-resolution custom Amazon CloudWatch metric for user activity data, then publish data every 5 seconds

Rolling update

Immutable update

User data

ebextensions

Set up hardware VPN tunnels to a VPC and access S3 through a VPC endpoint

Set up Client-Side Encryption with an AWS KMS-Managed Customer Master Key

Set up Server-Side Encryption with AWS KMS-Managed Keys

Transfer the data over an SSL connection

Set up Server-Side Encryption with S3-Managed Keys

Use the default AWS KMS customer master key for S3 in the Lambda function code.

Use the S3 managed key and call the GenerateDataKey API to encrypt the file.

Use the GenerateDateKey API, then use that data key to encrypt the file in the Lambda function code.

Use a custom KMS customer master key created for S3 in the Lambda function code.

Amazon DynamoDB to store MFA session data, and Amazon SNS to send MFA codes

Amazon Cognito with MFA

AWS Directory Service

AWS IAM with MFA enabled

Store photos on an EBS volume of the web server

Remove public read access and use signed URLs with expiry dates.

Use CloudFront distributions for static content.

Block the IPs of the offending websites in Security Groups.

Even though the Swagger import was successful, resource creation failed afterwards

There is a propagation delay of several minutes in creating API Gateway resources after import

The developer needs to restart the API Gateway stage after import in order to apply the changes.

The developer needs to create a new deployment after import in order to deploy the changes

Configure First in First out (FIFO) delivery in a standard Amazon SQS queue to process requests.

Use an SQS FIFO queue to process requests

Use the SetOrder attribute to ensure sequential request processing

Convert the standard queue to a FIFO queue by renaming the queue to use the fifo suffix.

Configure the Amazon EC2 instance fleet to use encrypted EBS volumes for storing data

Add logic to write all data to an encrypted Amazon S3 bucket

Add a custom encryption algorithm to the application that will encrypt and decrypt all data

Create a new Amazon Machine Image (AMI) with an encrypted root volume and store the data to ephemeral disks.

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.

dynaracdb:DeleteItem

dynamodb:GetItem

dynamcdb:Putltem

dynamodb:Updateltem

dynamcdb:Getltem

dynamodb:DescribeTable

dynamcdb:GetRecords

dynamcdb:Putltem

dynamodb:updateTable

dynamodb:Updateltem

dynamodb:Getltem

dynamodb:Putltem

Configure an ECS task IAM role for the application to use

Refactor the application to call AWS STS AssumeRole based on an instance role

Configure AWS access key/secret access key environment variables with new credentials

Configure the credentials file with a new access key/secret access key

Implement dead-letter queues to capture invocation errors

Add an event source from Amazon API Gateway to the Lambda function

Implement error handling within the application code

Contact AWS Support to increase the concurrent execution limits

Configure cross-account roles in each audited account. Write code in Account A that assumes those roles

Use S3 cross-region replication to communicate among accounts, with Amazon S3 event notifications to trigger Lambda functions

Deploy an application in each audited account with its own role. Have Account A authenticate with the application

Create an IAM user with an access key in each audited account. Write code in Account A that uses those access keys

Copy the documents to a separate S3 bucket that has a lifecycle policy for deletion after 15 minutes

Create a presigned S3 URL using the AWS SDK with an expiration time of 15 minutes

Use server-side encryption with AWS KMS managed keys (SSE-KMS) and download the documents using HTTPS

Modify the S3 bucket policy to only allow specific users to download the documents Revert the change after 15 minutes.

Upload the object using the multi-part upload API.

Upload the object over an AWS Direct Connect connection.

Contact AWS Support to increase the object size limit.

Upload the object to another AWS region.

1 Build the SAM template in Amazon EC2

2 Package the SAM template to Amazon EBS storage

3. Deploy the SAM template from Amazon EBS.

1 Build the SAM template locally

2 Package the SAM template onto Amazon S3

3. Deploy the SAM template from Amazon S3.

1 Build the SAM template locally

2. Deploy the SAM template from Amazon S3.

3 Package the SAM template for use

1 Build the SAM template locally

2 Package the SAM template from AWS CodeCommit.

3 Deploy the SAM template to CodeCommit

Store the source code in an Amazon S3 bucket Configure AWS CodePipeline to start whenever a file in the bucket changes

Store the source code in an encrypted Amazon EBS volume Configure AWS CodePipeline to start whenever a file in the volume changes

Store the source code in an AWS CodeCommit repository Configure AWS CodePipeline to start whenever a change is committed to the repository.

Store the source code in an Amazon S3 bucket Configure AWS CodePipeline to start every 15 minutes

Store the source code in an Amazon EC2 instance's ephemeral storage. Configure the instance to start AWS CodePipeline whenever there are changes to the source code

Amazon SQS

Amazon Cognito

Amazon Kinesis

Amazon SNS

Amazon ElastiCache

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

AWSAppSync

Amazon Cognito identity pools

Amazon Cognito user pools

Amazon Lambda@Edge

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

Modify the application to have both shared images and caching data written to Amazon EBS.

Modify the application to read and write cache data on Amazon S3, and also store shared images on S3.

Modify the application to use Amazon S3 for serving shared images; cache data can then be written to local disks.

Modify the application to read and write cache data on Amazon S3, while continuing to write shared images to local disks.

Use the Ret function to import the VPC into the application stack from the infrastructure template

Use the export flag in the infrastructure template, and then use the Fn::lmportValue function in the application template

Use the DependsOn attribute to specify that the application instance depends on the VPC in the application template

Use the Fn::GetAtt function to include the attribute of the VPC in the application template.

Launch and run the load-tester EC2 instance from us-east-1 instead.

Re-configure the load-testing software to re-resolve DNS for each web request.

Use a 3rd-party load-testing service which offers globally-distributed test clients.

Configure ELB and Auto Scaling to distribute across us-west-2a and us-west-2c.

Configure ELB session stickiness to use the app-specific session cookie.

Create a new global secondary index for the table to help with the additional requests.

Retry the failed read requests with exponential backoff.

Immediately retry the failed read requests.

Use the DynamoDB “UpdateItem” API to increase the provisioned throughput capacity of the table.

SWF tasks are assigned once and never duplicated

SWF requires an S3 bucket for workflow storage

SWF workflow executions can last up to a year

SWF triggers SNS notifications on task assignment

SWF uses deciders and workers to complete tasks

SWF requires at least 1 EC2 instance per domain

Immutable

Rolling

All at Once

Rolling with additional batch

Use sticky sessions with an Elastic Load Balancer target group.

Use Amazon SQS to save session data.

Use Amazon DynamoDB to perform scalable session hadling.

Use Elastic Load Balancer connection draining to stop sending requests to failing instances.

Subversion

AWS CodeBuild

AWS CodeCommit

AWS CodeStar

Set the imaging queue visibility Timeout attribute to 20 seconds

Set the Imaging queue ReceiveMessageWaitTimeSeconds attribute to 20 seconds

Set the imaging queue MessageRetentionPeriod attribute to 20 seconds

Set the DelaySeconds parameter of a message to 20 seconds

Encrypt the game data with individual user keys.

Restrict access to specific items based on certain primary key values.

Stage data in SQS queues to inject metadata before accessing DynamoDB.

Read records from DynamoDB and discard irrelevant data client-side.

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.

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.

Retain the items in a single table

Delete items individually over a 24 hour period

Delete the table and create a new table per hour

Create a new table per hour