DVA-C01 Sample Questions Answers

Use Auto scaling to scale the stream for better performance.

Increase the delay between the GetRecords call and the PutRecords call.

Increase the number of shards in the data stream.

Specify a shard iterator using the shardlterator parameter.

Implement exponential backoff on the GetRecords call and the PutRecords call.

AWS Certificate Manager (ACM)

AWS Systems Manager Parameter Store

AWS Trusted Advisor

AWS KMS

Amazon GuardDuty

Amazon EC2 VPC Flow Logs

Amazon CloudWatch Logs

Amazon CloudSearch

AWS CloudTrail

Instead of using Node js. rewrite the Lambda function using Python

Instead of packaging the libraries in the ZIP file with the function move them to a Lambda layer and use the layer with the function.

Allocate the maximum available CPU units lo the function

Increase the available memory to the function.

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

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

Use an IAM role to assume a role and execute API calls using the role.

Create an IAM user to be shared with the entire development team, provide the development team with the access key.

Create an IAM user for each developer on the team: provide each developer with a unique access key

Set up a federation through an Amazon Cognito user pool.

Use AWS VM Import to migrate a web server image to AWS Launch the image on a compute-optimized Amazon EC2 instanceLaunch.

Launch multiple Amazon Lighsall instance behind a load balancer. Set up the website on those instances.

Deploy the website code in an AWS Elastic Beanstalk environment. Use Auto Scaling to scale the numbers of instance

Use Amazon S3 to host the website. Use Amazon CloudFornt to deliver the content at scale.

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

Encrypt the data before sending it to Amazon S3

Import a custom key into AWS KMS with annual rotation enabled

Use AWS KMS with automatic key rotation

Export a key from AWS KMS to encrypt the data

Create an IAM user that has permissions to access the DynamoDB table. Create an access key for this user. Store the access key ID and secret...... key in the Lambda function environment variables.

Add a resource-based policy to the DynamoDB table to allow access from the Lambda function's IAM role.

Create an IAM policy that allows access to the DynamoDB table. Attach this policy to the Lambda function's 1AM role.

Create a DynamoDB Accelerator (DAX) cluster. Configure the Lambda function to use the DAX cluster to access the DynamoDB table.

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.

Reregister the failed instances with the ALB.

Enable all Availability Zones for the ALB.

Use the instance refresh feature to redeploy the EC2 Auto Scaling group.

Restart the EC2 instances that are not receiving traffic.

All at once

Rolling

Rolling with additional batch

Immutable

Build the container from the amazon/aws-xray-daemon base image. Use the AWS X-Ray SDK to instrument the application.

Install the Amazon CloudWatch agent on the container image. Use the CloudWatch SDK to publish custom metrics from each of the microservices.

Install the AWS X-Ray daemon on each of the ECS instances.

Configure AWS CloudTrail data events to capture the traffic between the microservices.

Query the instance metadata from http://169.254.169.254/latest/meta-data/.

Query the instance user data from http://169 254.169.254/latest/user-data/.

Query the Amazon Machine Image (AMI) information from http://169 254.169.254/latesl/meta-data/ami/.

Check the hosts file of the operating system.

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.

Create an access key for an IAM user. Store the access key in the application's environment variables.

Create an IAM role. Create an access key for the role. Store the access key in the application's environment variables.

Associate an IAM role with the EC2 instance. Use the instance metadata service to retrieve the credentials.

Configure a bucket policy for the S3 bucket. Allow access from the EC2 instance ID in the bucket policy.

Add the permission to the role. Terminate the existing EC2 instance. Launch a new EC2 instance.

Add the permission to the role so that the change will take effect automatically.

Add the permission to the role. Hibernate and restart the existing EC2 instance.

Add the permission to the S3 bucket. Restart the EC2 instance.

Update 20% of the planned changes to the production stage. Deploy the new production stage. Monitor the results. Repeat this process five times to test all planned changes

Update the Amazon Route 53 DNS record entry for the production stage API to use a weighted routing policy Set the weight to a value of 80. Add a second record for the production domain name Change the second routing policy to a weighted routing policy. Set the weight of the second policy to a value of 20. Change the alias of the second policy to use the testing stage API.

Deploy an Application Load Balancer (ALB) in front of the REST API Change the production API Amazon Route 53 record to point traffic to the ALB Register the production and testing stages as targets of the ALB with weights of 80% and 20%. respectively.

Configure canary settings for the production stage API. Change the percentage of traffic directed to canary deployment to 20%. Make the planned updates to the production stage Deploy the changes.

Use Amazon CloudWatch to aggregate the microservices' logs and metrics, and build the monitoring dashboard

Use AWS CloudTrail to aggregate the microservices' logs and metrics, and build the monitoring dashboard

Use the AWS X-Ray SDK to add instrumentation in all the microsen/ices, and monitor using the X-Ray service map.

Use AWS Health to monitor the health of all the microservices

Store the credentials in AWS Secrets Manager. Retrieve the credentials by using the GetSecretValue API operation.

Store the credentials in AWS Key Management Service (AWS KMS). Retrieve the credentials by using the GetPublicKey API operation.

Store the credentials in AWS Security Token Service (AWS STS). Retrieve the credentials by using the GetCallerldentity API operation.

Store the credentials in AWS Systems Manager Parameter Store. Retrieve the credentials by using the GetParameter API operation.

Amazon DynamoDB

Amazon Cognito

Amazon ElastiCache

Application Load Balancer

Amazon Simple Queue Service (Amazon SQS)

For the existing DynamoDB table, create a new global secondary index (GSI) that has the UserName as a partition key and the TotalReactionsOnBlogs as a sort key.

For the existing DynamoDB table, create a new local secondary index (LSI) that has the UserName as a partition key and the TotalReactionsOnBlogs as a sort key

Back up and restore the DynamoDB table to a new DynamoDB table Create a new global secondary index (GSI) that has the UserName as a partition key and the TotalReactionsOnBlogs as a sort key Delete the old DynamoDB table

Back up and restore the DynamoDB table to a new DynamoDB table. Create a new local secondary index (LSI) that has the UserName as a partition key and the TotalReactionsOnBlogs as a sort key. Delete the old DynamoDB table.

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.

Install the Amazon CloudWatch agent on the Amazon EC2 host that runs Fargate.

Configure the awslogs log driver in the ECS task definition.

Configure AWS CloudTrail for the ECS containers.

Install the ECS logs collector on the ECS hosts.

The AWS SDK needs to be included in the AWS Lambda deployment package.

VPC Flow Logs are not enabled for the application VPC.

Active tracing needs to be enabled for the Lambda function

The memory needs to be increased to 2 GB for the TEST environments.

Option A

Option B

Option C

Option D

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 Amazon Cognito user pools for external social identity providers. Configure 1AM roles for the identity pools.

Program the sign-in page to create users' 1AM groups with the 1AM roles attached to the groups.

Create an Amazon RDS for SQL Server DB instance to store the users and manage the permissions to the backend resources in AWS.

Configure the sign-in page to register and store the users and their passwords in an Amazon DynamoDB table with an attached 1AM policy.

Enable AWS CloudTrail logging and use the logs to map each latency and bottleneck

Enable and configure AWS X-Ray tracing on API Gateway and the Lambda function Use X-Ray to trace and analyze user requests

Enable Amazon CloudWatch Logs for the Lambda function Enable execution logs for API Gateway to view and analyze user request logs.

Enable VPC Flow Logs to capture and analyze network traffic within the VPC

Increase the number of shards of the Kinesis data stream

Decrease the timeout of the Lambda function

Increase the memory that is allocated to the Lambda function.

Decrease the number of shards of the Kinesis data stream

Increase the timeout of the Lambda function

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

AWS CloudFormation will create a new database and delete the old one

AWS CloudFormation will create a new database and keep the old one

AWS CloudFormation will overwrite the existing database and rename it

AWS CloudFormation will leave the existing database and will not create a new one

Immutable

Rolling

Rolling with additional batch

Traffic splitting

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

Install and run the X-Ray SDK on the on-premises servers to capture and relay the data to the X-Ray service.

Install and run the X-Ray daemon on the on-premises servers to capture and relay the data to the X-Ray service

Capture incoming requests on-premises and configure an AWS Lambda function to pull, process, and relay relevant data to X-Ray using the PutTraceSegments API call

Capture incoming requests on-premises and configure an AWS Lambda function to pull, process, and relay relevant data to X-Ray using the PutTelemetryRecords API call.

Set up a stage for each environment In each stage, point to different Lambda functions that implement the logging logic m the code Access the logs in Amazon CloudWatch Logs

Set up a stage for each environment In each stage, define a different logging level according to the logging requirements Access the logs in Amazon CloudWatch Logs

Set up a stage and use the same Lambda functions In Amazon CloudWatch Logs set up a filter based on the log level according to the logging requirements

Set up a stage for each environment In each stage, define a variable for the log level Set the value according to the logging requirements.

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.

VPN logs

BGP logs

VPC Flow Logs

AWS CloudTrail logs

Write operations on the DynamoDB table are being throttled

The SOS queue delivered the message to the function more than once

API Gateway duplicated the message in the SOS queue

The polling function timeout is greater than the queue visibility timeout

"Mapping" : "AWS::CloudFormation::Stack",

"Type" : "AWS;:CloudFcrmation::NestedStack",

"Typ©" : "AWS::CloudFormation::Stack",

"Mapping" : "AWS::CloudFormation::NestedStack",

Create a Lambda function in the parent account and use cross-account IAM roles with the AWS Security Token Service (AWS STS) AssumeRole API call to make AWS Lambda invoke the API call to invoke all the cross-account Lambda functions.

Subscribe all the multi-account Lambda functions to an Amazon SNS topic and make a SNS Publish API call with the payload to the SNS topic.

Set up an Amazon SQS queue with the queue policy permitting the ReceiveMessage action for multi-account Lambda functions. Then send the payload to the SQS queue using the sqs:SendMessage permission and poll the queue using multi-account Lambda functions.

Use a worker on an Amazon EC2 instance to poll for the payload event. Invoke all Lambda functions using the Lambda Invoke API after using cross-account IAM roles with the AWS Security Token Service (AWS STS) AssumeRole API call.

Create a RESTful API with the API Gateway; transform the incoming JSON into a valid XML message for the SOAP interface using mapping templates.

Create a RESTful API with the API Gateway; pass the incoming JSON to the SOAP interface through an Application Load Balancer.

Create a RESTful API with the API Gateway; pass the incoming XML to the SOAP interface through an Application Load Balancer.

Create a RESTful API with the API Gateway; transform the incoming XML into a valid message for the

SOAP interface using mapping templates.

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.

Install certificates on the EC2 instances.

Create a private VPC endpoint.

Configure the S3 bucket with server-side encryption with AWS KMS managed encryption keys (SSE-KMS).

Create an S3 bucket policy that denies traffic when the value for the aws:SecureTransport condition key is false.

Configure a high-resolution CloudWatch alarm.

Set up a custom CloudWatch dashboard.

Use Amazon CloudWatch Logs Insights.

Change to a default CloudWatch metric.

Implement an AWS Lambda authorizer that references the DynamoDB authentication table

Create a model that requires the credentials, then grant API Gateway access to the authentication table

Modify the integration requests to require the credentials, then grant API Gateway access to the authentication table

Implement an Amazon Cognito authorizer that references the DynamoDB authentication table

Amazon S3

AWS CloudTrail

Amazon CloudWatch

Amazon DynamoDB

dynaracdb:DeleteItem

dynamodb:GetItem

dynamcdb:Putltem

dynamodb:Updateltem

dynamcdb:Getltem

dynamodb:DescribeTable

dynamcdb:GetRecords

dynamcdb:Putltem

dynamodb:updateTable

dynamodb:Updateltem

dynamodb:Getltem

dynamodb:Putltem

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

Use the Amazon Cognito user pools to get short-lived credentials for the second account

Create a dedicated IAM access key for the second account, and send it by mail.

Create a cross-account access role, and use sts:AssumeRcie API to get short-lived credentials

Establish trust, and add an SSH key for the second account to the IAM user

Use Auto Scaling to scale the stream for better performance

Increase the delay between the GetRecords call and the PutRecords call.

Increase the number of shards in the data stream

Specify a shard iterator using the Shardlterator parameter.

Implement exponential backoff on the GetRecords call and the PutRecords call.

1. Update the application code in the existing deployment.

2. Select a new load balancer type before running the deployment.

3. Deploy the new version of the application code to the environment.

1. Create a new environment with the same configurations except for the load balancer type.

2. Deploy the same application version as used in the original environment.

3. Run the swap-environment-cnames action.

1. Clone the existing environment, changing the associated load balancer type.

2. Deploy the same application version as used in the original environment.

3. Run the swap-environment-cnames action.

1. Edit the environment definitions in the existing deployment.

2. Change the associated load balancer type according to the requirements.

3. Rebuild the environment with the new load balancer type.

Separate the Lambda handler from the core logic

Use Amazon CloudWatch Events to send the processed data

Publish the processed data to an Amazon SNS topic

Push the processed data to Amazon SQS

Add annotations to the segment document and the code

Add metadata to the segment document and the code

Configure the necessary X-Ray environment variables

Install required plugins for the appropriate AWS SDK

Sign the AWS CLI command using the signature version 4 process.

Run the aws configure AWS CLI command and specify the access key id and secret access key.

Specify a role for the EC2 instance with the necessary privileges.

Pass the access key id and secret access key as parameters for each AWS CLI command.

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.

Use a different Lambda trigger

Use Lambda environment variables

Use a Lambda alias

Use Lambda tags.

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.

Configure the Python code to run the AWS CLl through shell to call the Putltem operation

Call the Putltem operation from Python by using the DynamoDB HTTP API

Queue the items in AWS Glue: which will put them into the DynamoDB table

Use the AWS software development kit (SDK) for Python (boto3) to call the Putltem operation

Application Load Balancer and Amazon EC2

Amazon API Gateway and AWS Lambda

Amazon CloudFront and Amazon S3

Amazon CloudFront and AWS Elastic Beanstalk

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

Enable EC2 termination protection on all production instances unless approval has been given through AWS Resource Access Manager.

Modify the developer group’s permissions policy to deny them access to delete production instances unless approved has been given through AWS Resource Access Manager.

Modify the developer group’s permission policy to require multi-factor authentication (MFA) only production instances are being delete Enable EC2 termination protection on production instances.

Enable EC2 termination protection on production instances. Deny the developer group’s permissions policy access to terminate instance. Create a new role that developer can assume when termination is necessary.

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.

Amazon DynamoDB Streams

Amazon DynamoDB Accelerator

Amazon DynamoDB global tables

Amazon DynamoDB transactions

Periodically send the thread count to AWS X-Ray segments, then generate a service graph on demand

Create a custom Amazon CloudWatch metric and periodically perform a PutMetricData call with the current thread count.

Periodically log thread count data to Amazon S3. Use Amazon Kinesis to process the data into a graph.

Periodically write the current thread count to a table using Amazon DynarnoDB and use Amazon CloudFront to create a graph

Enable versioning on the cdfonts bucket for each web font

Create a policy on the cdfonts bucket to enable access to everyone

Add the Content-MD5 header to the request for webfonts in the cdfonts bucket from the website

Configure the cdfonts bucket to allow cross-origin requests by creating a CORS configuration

The Lambda function did not advance the Kinesis stream pointer to the next record after the error.

The Lambda event source used asynchronous invocation, resulting in duplicate records.

The Lambda function did not handle the error, and the Lambda service attempted to reprocess the data.

The Lambda function is not keeping up with the amount of data coming from the stream.

IAM temporary credentials using AWS STS.

Amazon Directory Service

Amazon Cognito with unauthenticated access enabled

IAM with SAML integration

Use AWS Step Functions to execute parallel Lambda functions, and join the results.

Create an AWS SQS for each vendor, poll the queue from a worker instance, and joint the results.

Use AWS Lambda to asynchronously call a Lambda function for each vendor, and join the results.

Use Amazon CloudWatch Events to orchestrate the Lambda functions.

Use S3 Virtual Hosting

Set an S3 Bucket policy.

Enable IAM Identity Federation.

Set an S3 ACL on the bucket or the object.

Create a CloudFront distribution for the bucket

Previously-created resources are kept but the stack creation terminates.

Previously-created resources are deleted and the stack creation terminates.

The stack creation continues, and the final results indicate which steps failed.

CloudFormation templates are parsed in advance so stack creation is guaranteed to succeed.

Create a ZIP file with the source code and all dependent libraries.

Create a ZIP file with the source code and a script that installs the dependent libraries at runtime.

Create a ZIP file with the source code. Stage the dependent libraries on an Amazon S3 bucket indicated by the Lambda environment variable LD_LIBRARY_PATH

Create a ZIP file with the source code and a buildspec.yaml file that installs the dependent libraries on AWS Lambda.

Strongly consistent reads use the same amount of throughput as eventually consistent reads

Strongly consistent reads use more throughput than eventually consistent reads.

Strongly consistent reads use less throughput than eventually consistent reads

Strongly consistent reads use variable throughput depending on read activity

5xx HTTP response code

200 HTTP response code

306 HTTP response code

4xx HTTP response code

Use instance memory to save session state.

Use instance storage to save session state.

Use EBS to save session state

Use ElastiCache to save session state.

Use Glacier to save session slate.

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

Sequential

instanceID_log-HH-DD-MM-YYYY

instanceID_log-YYYY-MM-DD-HH

HH-DD-MM-YYYY-log_instanceID

YYYY-MM-DD-HH-log_instanceID

An Amazon SNS topic to be triggered when a concurrent user threshold is met

An Amazon Cloudwatch Networkin metric

Amazon CloudFront to leverage AWS Edge Locations

A Custom Amazon CloudWatch metric for concurrent users.

AWS Lambda

AWS X-Ray

Amazon SQS

Amazon API Gateway

DescnbeInstances

DescribeAMls

DescribeImages

GetAMls

You cannot retrieve a list of AMIs as there are over 10,000 AMIs

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.

Change the existing Lambda function handling the uploads to create thumbnails at the time of upload. Have the function store both the image and thumbnail in Amazon S3.

Create a second Lambda function that handles thumbnail generation and storage. Change the existing Lambda function to invoke it asynchronously.

Create an S3 event notification with a Lambda function destination. Create a new Lambda function to generate and store thumbnails.

Create an S3 event notification to an SQS Queue. Create a scheduled Lambda function that processes the queue, and generates and stores thumbnails.

Configure an Elastic Load Balancer with SSL pass-through.

Configure SSL certificates on an Elastic Load Balancer.

Configure an Elastic Load Balancer with a Loadable Storage System.

Install SSL certificates on the EC2 instances.

Configure an Elastic Load Balancer with SSL termination.

Submit a limit increase request to AWS Support to increase the function to the size needed.

Use a compression algorithm that is more efficient than ZIP.

Break the function into multiple smaller Lambda functions.

ZIP the ZIP file twice to compress it further.

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.

Use AWS CloudFormation get-template then CloudFormation execute-change-set.

Use AWS CloudFormation validate-template then CloudFormation create-change-set.

Use AWS CloudFormation package then CloudFormation deploy.

Use AWS CloudFormation create-stack then CloudFormation update-stack.