DVA-C02 Practice Exam Questions with Answers AWS Certified Developer - Associate Certification

Use a CloudFormation parameter to pass the master user credentials at deployment to the OpenSearch Service domain's MasterUserOptions and the Lambda function's environment variable. Set the No Echo attenuate to true.

Use a CloudFormation parameter to pass the master user credentials at deployment to the OpenSearch Service domain's MasterUserOptions and to create a parameter. In AWS Systems Manager Parameter Store. Set the No Echo attribute to true. Create an 1AM role that has the ssm GetParameter permission. Assign me role to the Lambda function. Store me parameter name as the Lambda function's environment variable. Resolve the parameter's value at runt

Use a CloudFormation parameter to pass the master uses credentials at deployment to the OpenSearch Service domain's MasterUserOptions and the Lambda function's environment varleWe Encrypt the parameters value by using the AWS Key Management Service (AWS KMS) encrypt command.

Use CloudFoimalion to create an AWS Secrets Manager Secret. Use a CloudFormation dynamic reference to retrieve the secret's value for the OpenSearch Service domain's MasterUserOptions. Create an 1AM role that has the secrets manager. GetSecretvalue permission. Assign the role to the Lambda Function Store the secrets name as the Lambda function's environment variable. Resole the secret's value at runtime.

Create a new Lambda function alias before updating the CloudFormation stack.

Change the S3 object key or the S3 version in the CloudFormation template before updating the CloudFormation stack.

Upload the zipped source code to another S3 bucket before updating the CloudFormation stack.

Associate a code signing configuration with the Lambda function before updating the CloudFormation stack.

Modify the existing CodeArtifact repository to associate an upstream repository with the public package repository.

Create a new CodeArtifact repository that has an external connection to the public package repository.

Create a new CodeArtifact domain that contains a new repository that has an external connection to the public package repository.

Modify the CodeArtifact repository resource policy to allow artifacts to be fetched from the public package repository.

Configure the fleet of EC2 instances to use encrypted EBS volumes to store data.

Configure the application to write all data to an encrypted Amazon S3 bucket.

Configure a custom encryption algorithm for the application that will encrypt and decrypt all data.

Configure an Amazon Machine Image (AMI) that has an encrypted root volume and store the data to ephemeral disks.

Load the S3 objects into Amazon Redshift by using a COPY command. Implement dynamic data masking. Refactor the analytics service to read from Amazon Redshift.

Set up an S3 Object Lambda function. Attach the function to an S3 Object Lambda Access Point. Program the function to call a PII redaction API.

Use AWS Key Management Service (AWS KMS) to implement encryption in the S3 bucket. Re-upload all the existing S3 objects. Give the kms

permission to the analytics service.

Create an Amazon Simple Notification Service (Amazon SNS) topic. Implement message data protection. Refactor the analytics service to publish data access requests to the SNS topic.

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.

Use the Lambda function's ConcurrentExecutions metric in Amazon CloudWatch to measure the throughput.

Modify the application to log the calculated throughput to Amazon CloudWatch Logs. Use Amazon EventBridge to invoke a separate Lambda function to process the logs on a schedule.

Modify the application to publish custom Amazon CloudWatch metrics when the Lambda function receives and processes each message. Use the metrics to calculate the throughput.

Use the Lambda function's Invocations metric and Duration metric to calculate the throughput in Amazon CloudWatch.

Configure Amazon EC2 to deliver the EC2 instance lifecycle events from all accounts to the Amazon EventBridge event bus of the main account. Add an EventBridge rule to the event bus of the main account that matches all EC2 instance lifecycle events. Add the SQS queue as a target of the rule.

Use the resource policies of the SQS queue in the main account to give each account permissions to write to that SQS queue. Add to the Amazon EventBridge event bus of each account an EventBridge rule that matches all EC2 instance lifecycle events. Add the SQS queue in the main account as a target of the rule.

Write an AWS Lambda function that scans through all EC2 instances in the company accounts to detect EC2 instance lifecycle changes. Configure the Lambda function to write a notification message to the SQS queue in the main account if the function detects an EC2 instance lifecycle change. Add an Amazon EventBridge scheduled rule that invokes the Lambda function every minute.

Configure the permissions on the main account event bus to receive events from all accounts. Create an Amazon EventBridge rule in each account to send all the EC2 instance lifecycle events to the main account event bus. Add an EventBridge rule to the main account event bus that matches all EC2 instance lifecycle events. Set the SQS queue as a target for the rule.

Configure an AWS CloudTrail log file delivery to an Amazon S3 bucket. Create an Amazon CloudWatch alarm for the GetSecretValue. Secrets Manager API operation requests

Create a secrets manager-secret-unused AWS Config managed rule. Create an Amazon EventBridge rule to Initiate notification when the AWS Config managed rule is met.

Deactivate the applications secrets and monitor the applications error logs temporarily.

Configure AWS X-Ray for the applications. Create a sampling rule lo match the GetSecretValue Secrets Manager API operation requests.

Add a Delay task after the GetResource task. Add a catcher to the GetResource task. Configure the catcher with an error type of TooManyRequestsException. Configure the next step to be the Delay task Configure the Delay task to wait for an interval of 10 seconds Configure the next step to be the GetResource task.

Add a catcher to the GetResource task Configure the catcher with an error type of TooManyRequestsException. an interval of 10 seconds, and a maximum attempts value of 1. Configure the next step to be the GetResource task.

Add a retrier to the GetResource task Configure the retrier with an error type of TooManyRequestsException, an interval of 10 seconds, and a maximum attempts value of 1.

Duplicate the GetResource task Rename the new GetResource task to TryAgain Add a catcher to the original GetResource task Configure the catcher with an error type of TooManyRequestsException. Configure the next step to be TryAgain.

Set the event source mapping batch size to 10 for the high priority queue and to 90 for the low priority queue

Set the delivery delay to 0 seconds for the high priority queue and to 10 seconds for the low priority queue

Set the event source mapping maximum concurrency to 10 for the high priority queue and to 90 for the low priority queue

Set the event source mapping batch window to 10 for the high priority queue and to 90 for the low priority queue

Specify the disable-rollback option during the update-stack operation.

Unset the Cloud Forma lion stack failure options.

Add an AWS CodeBuild stage lo CodePipeline to run the aws apigateway create-deployment AWS CLI command.

Add an action to CodePipeline to run the aws cloudfront create-invalidation AWS CLI command.

Submit a quota increase request to AWS Support to increase the function to the required size.

Use a compression algorithm that is more efficient than ZIP.

Break up the function into multiple smaller functions.

Zip the .zip file twice to compress the file more.

Move common libraries, function dependencies, and custom runtimes into Lambda layers.

Set up an Amazon API Gateway REST API with a gateway response configured for status code 200 Add response templates that contain sample responses captured from the real third-party API.

Set up an AWS AppSync GraphQL API with a data source configured for each third-party API Specify an integration type of Mock Configure integration responses by using sample responses captured from the real third-party API.

Create an AWS Lambda function for each third-party API. Embed responses captured from the real third-party API. Configure Amazon Route 53 Resolver with an inbound endpoint for each Lambda function's Amazon Resource Name (ARN).

Set up an Amazon API Gateway REST API for each third-party API Specify an integration request type of Mock Configure integration responses by using sample responses captured from the real third-party API

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.

From the main branch, create a feature branch for production bug fixes. Create a second feature branch from the main branch for development of the new version.

Create a Git tag of the code that is currently deployed in production. Create a Git tag for the development of the new version. Push the two tags to the CodeCommit repository.

From the main branch, create a branch of the code that is currently deployed in production. Apply an IAM policy that ensures no other other users can push or merge to the branch.

Create a new CodeCommit repository for development of the new version of the application. Create a Git tag for the development of the new version.

Expose the Lambda function by using function URLs.

Expose the Lambda function by using a Gateway Load Balancer.

Expose the Lambda function by using a Network Load Balancer.

Expose the Lambda function by using AWS Global Accelerator

Expose the Lambda function by using Amazon API Gateway.

Create the Lambda function. Configure VPC1 access for the function. Attach a security group named SG1 to both the Lambda function and the database. Configure the security group inbound and outbound rules to allow TCP traffic on Port 3306.

Create and launch a Lambda function in a new public subnet that is in a new VPC named VPC2. Create a peering connection between VPC1 and VPC2.

Create the Lambda function. Configure VPC1 access for the function. Assign a security group named SG1 to the Lambda function. Assign a second security group named SG2 to the database. Add an inbound rule to SG1 to allow TCP traffic from Port 3306.

Export the data from the Aurora database to Amazon S3. Create and launch a Lambda function in VPC1. Configure the Lambda function query the data from Amazon S3.

Configure the DB cluster's public access setting to Yes.

Configure an Amazon RDS database proxy for the Lambda functions.

Configure a NAT gateway and a security group for the Lambda functions.

Configure the VPC, subnets, and a security group for the Lambda functions.

Use AWS Glue to perform frequent ETL updates from the Accounts database to the Payments database.

Use Amazon ElastiCache in Payments, with the cache updated by triggers in the Accounts database.

Use Amazon Data Firehose to deliver all changes from the Accounts database to the Payments database.

Use Amazon DynamoDB Streams to deliver all changes from the Accounts database to the Payments database.

Configure a Lambda function destination with a failure condition Specify Lambda function as the destination type Specify the error-handling Lambda function's Amazon Resource Name (ARN) as the resource

Enable AWS X-Ray active tracing on the initial Lambda function. Configure X-Ray to capture stack traces of the failed invocations. Invoke the error-handling Lambda function by including the stack traces in the event object.

Configure a Lambda function trigger with a failure condition Specify Lambda function as the destination type Specify the error-handling Lambda function's Amazon Resource Name (ARN) as the resource

Create a status check alarm on the initial Lambda function. Configure the alarm to invoke the error-handling Lambda function when the alarm is initiated. Ensure that the alarm passes the stack trace in the event object.

Amazon S3 with encrypted files prefixed with “config”

AWS Secrets Manager secrets with a tag that is named SecretString

AWS Systems Manager Parameter Store SecureString parameters

CloudFormation NoEcho parameters

The X-Forwarded-Proto header

The X-F Forwarded-Host header

The X-Forwarded-For header

The X-Forwarded-Port header

Server-side encryption with Amazon S3 managed keys (SSE-S3)

Server-side encryption with AWS KMS managed keys (SSE-KMS}

Server-side encryption with customer-provided keys (SSE-C)

Server-side encryption with self-managed keys

Configure a high-resolution CloudWatch alarm.

Set up a custom CloudWatch dashboard.

Use Amazon CloudWatch Logs Insights.

Change to a default CloudWatch metric.

BatchGetltem

Getltem

Scan

Query

Configure S3 Object Lock to update to the latest version of the files every time an S3 object is updated.

Configure the S3 bucket to clear all old objects from the bucket before new artifacts are uploaded.

Set CloudFront to invalidate the cache after the artifacts have been deployed to Amazon S3.

Set CloudFront to modify the distribution origin after the artifacts have been deployed to Amazon S3.

Upload the package to Amazon S3. Use the Functions page on the Lambda console to upload the package from the S3 location.

Create an AWS Support ticket to increase the maximum package size.

Use the update-function-code AWS CLI command. Pass the -publish parameter.

Repackage the Lambda function as a Docker container image. Upload the image to Amazon Elastic Container Registry {Amazon ECR). Create a new Lambda function by using the Lambda console. Reference the image that is deployed to Amazon ECR.

Sign the .zip file digitally. Create a new Lambda function by using the Lambda console. Update the configuration of the new Lambda function to include the Amazon Resource Name (ARN) of the code signing configuration.

Use S3 Batch Operations to invoke an AWS Lambda function to create new variants of the photos with the required dimensions and resolutions. Create a 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. Create a Lambda@Edge function to route requests to the corresponding photo vacant 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 of the processed photos on Amazon S3 for subsequent requests.

The Lambda function's concurrency limit has been exceeded.

DynamoDB table requires a global secondary index (GSI) to support writes.

The Lambda function does not have IAM permissions to write to DynamoDB.

The DynamoDB table is not running in the same Availability Zone as the Lambda function.

Add the permissions to an 1AM policy. Attach the policy to a role. Attach the role to the EC2 instance profile.

Add the permissions inline to an 1AM group. Attach the group to the EC2 instance profile.

Add the permissions to an 1AM policy. Attach the policy to a user. Attach the user to the EC2 instance profile.

Add the permissions to an 1AM policy. Use 1AM web identity federation to access the S3 bucket with the policy.

Store the files in an Amazon S3 bucket Use the S3 Glacier Instant Retrieval storage class Create an S3 Lifecycle policy to transition the files to the S3 Glacier Deep Archive storage class after 1 year

Store the files in an Amazon S3 bucket. Use the S3 Standard storage class. Create an S3 Lifecycle policy to transition the files to the S3 Glacier Flexible Retrieval storage class after 1 year.

Store the files on an Amazon Elastic Block Store (Amazon EBS) volume Use Amazon Data Lifecycle Manager (Amazon DLM) to create snapshots of the EBS volumes and to store those snapshots in Amazon S3

Store the files on an Amazon Elastic File System (Amazon EFS) mount. Configure EFS lifecycle management to transition the files to the EFS Standard-Infrequent Access (Standard-IA) storage class after 1 year.

Use AWS SAM CLI commands in AWS CodeDeploy lo invoke the Lambda functions lo lest the deployment

Declare the EventlnvokeConfig on the Lambda functions in the AWS SAM templates with OnSuccess and OnFailure configurations.

Enable gradual deployments through AWS SAM templates.

Set the deployment preference type to Canary10Percen130Minutes Use hooks to test the deployment.

Set the deployment preference type to Linear10PefcentEvery10Minutes Use hooks to test the deployment.

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.

Write a script that deletes old records; schedule the script 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.

Use Amazon Cognito user pools to manage user accounts. Create an Amazon Cognito user pool authorizer in API Gateway to control access to the API. Use the Lambda function to store the photos and details in the DynamoDB table. Retrieve previously uploaded photos directly from the DynamoDB table.

Use Amazon Cognito user pools to manage user accounts. Create an Amazon Cognito user pool authorizer in API Gateway to control access to the API. Use the Lambda function to store the photos in Amazon S3. Store the object's S3 key as part of the photo details in the DynamoDB table. Retrieve previously uploaded photos by querying DynamoDB for the S3 key.

Create an IAM user for each user of the application during the sign-up process. Use IAM authentication to access the API Gateway API. Use the Lambda function to store the photos in Amazon S3. Store the object's S3 key as part of the photo details in the DynamoDB table. Retrieve previously uploaded photos by querying DynamoDB for the S3 key.

Create a users table in DynamoDB. Use the table to manage user accounts. Create a Lambda authorizer that validates user credentials against the users table. Integrate the Lambda authorizer with API Gateway to control access to the API. Use the Lambda function to store the photos in Amazon S3. Store the object's S3 key as par of the photo details in the DynamoDB table. Retrieve previously uploaded photos by querying DynamoDB for the S3 key.<

Increase the page size for each request by setting the Limit parameter to be higher than the default value Configure the application to retry any request that exceeds the provisioned throughput.

Create a global secondary index (GSI). Set query attribute to be the partition key of the index

Perform a parallel scan operation by issuing individual scan requests in the parameters specify the segment for the scan requests and the total number of segments for the parallel scan.

Turn on read capacity auto scaling for the DynamoDB table. Increase the maximum read capacity units (RCUs).

Increase the SQS event source's batch size setting.

Configure provisioned concurrency for the Lambda function based on the third-party API's documented rate limits.

Increase the retry attempts and maximum event age in the Lambda function's asynchronous configuration.

Configure maximum concurrency on the SQS event source based on the third-party service's documented rate limits.

A read-through cache

A write-behind cache

A lazy-loading cache

A write-through cache

Save the secrets in a text file and store the text file in Amazon S3 Provision a customer managed key Use the key for secret encryption in Amazon S3 Read the contents of the text file and read the export as environment variables Configure S3 Object Lambda to rotate the text file every month

Save the secrets as strings in AWS Systems Manager Parameter Store and use the default AWS Key Management Service (AWS KMS) key Configure an Amazon EC2 user data script to retrieve the secrets during the startup and export as environment variables Configure an AWS Lambda function to rotate the secrets in Parameter Store every month.

Save the secrets as base64 encoded environment variables in the application properties. Retrieve the secrets during the application startup. Reference the secrets in the application code. Write a script to rotate the secrets saved as environment variables.

Store the secrets in AWS Secrets Manager Provision a new customer master key Use the key to encrypt the secrets Enable automatic rotation Configure an Amazon EC2 user data script to programmatically retrieve the secrets during the startup and export as environment variables

Update the IAM instance profile that is attached to the EC2 instance to include the S3:* permission for the S3 bucket.

Update the IAM instance profile that is attached to the EC2 instance to include the S3:ListBucket permission for the S3 bucket.

Update the developer's user permissions to include the S3:ListBucket permission for the S3 bucket.

Update the S3 bucket policy by including the S3:ListBucket permission and by setting the Principal element to specify the account number of the EC2 instance.

Attach the Lambda function to the VPC through private subnets. Create a security group that allows network access to the private resources. Associate the security group with the Lambda function.

Configure the Lambda function to route traffic through a VPN connection. Create a security group that allows network access to the private resources. Associate the security group with the Lambda function.

Configure a VPC endpoint connection for the Lambda function. Set up the VPC endpoint to route traffic through a NAT gateway.

Configure an AWS PrivateLink endpoint for the private resources. Configure the Lambda function to reference the PrivateLink endpoint.

Change the AWS CloudFormation templates for us-east-1 and us-west-1 to use an AWS AMI. Relaunch the stack for both Regions.

Copy the custom AMI from us-east-1 to us-west-1. Update the AWS CloudFormation template for us-west-1 to refer to AMI ID for the copied AMI Relaunch the stack

Build the custom AMI in us-west-1 Create a new AWS CloudFormation template to launch the stack in us-west-1 with the new AMI ID

Manually deploy the application outside AWS CloudFormation in us-west-1.

Ensure that the deployment group is using the correct role name for the CodeDeploy service role.

Attach the AWSCodeDeployRoleECS policy to the CodeDeploy service role.

Attach the AWSCodeDeployRole policy to the CodeDeploy service role.

Ensure the CodeDeploy agent is installed and running on all instances in the deployment group.

Amazon Cloudfront

Amazon ElastiCache to Memcached

Amazon ElastiCache for Redis in cluster mode

Amazon DynamoDB Accelerate (DAX)

AWS CodeDeploy

AWS CodeArtifact

AWS CodeCommit

Amazon CodeGuru

Define a resource-based policy on the S3 bucket to deny access when a request meets the condition “aws:SecureTransport”: “false”.

Define a resource-based policy on the S3 bucket to allow access when a request meets the condition “aws:SecureTransport”: “false”.

Define a role-based policy on the other accounts' roles to deny access when a request meets the condition of “aws:SecureTransport”: “false”.

Define a resource-based policy on the KMS key to deny access when a request meets the condition of “aws:SecureTransport”: “false”.

Enable AWS X-Ray on the Lambda function. In the generated trace map. select the line between Lambda and Amazon S3.

Query the Lambda function's log file in Amazon CloudWatch Logs Insights. Return the average of the auto-discovered ©duration field.

Enable CloudWatch Lambda Insights on the function. View the latency graph that CloudWatch Lambda Insights provides.

Enable AWS X-Ray on the Lambda function. Select Amazon S3 in the latency graph to view the latency histogram.

Set the function's reserved concurrency to 1. Calculate the rolling average in the function. Store the calculated rolling average in Amazon ElastiCache.

Modify the function to store the values in Amazon ElastiCache. When the function initializes, use the previous values from the cache to calculate the rolling average.

Set the function's provisioned concurrency to 1. Calculate the rolling average in the function. Store the calculated rolling average in Amazon ElastiCache.

Modify the function to store the values in the function's layers. When the function initializes, use the previously stored values to calculate the rolling average.

Create multiple S3 bucket polices by using each VPC endpoint ID that have the aws SourceVpce value in the StringNotEquals condition.

Create a single S3 bucket policy that has the aws SourceVpc value and in the StingNotEquals condition to use VPC ID.

Create a single S3 bucket policy that the multiple aws SourceVpce value and in the SringNotEquals condton to use vpce.

Create a single S3 bucket policy that has multiple aws sourceVpce value in the StingNotEquale condition. Repeat for all the VPC endpoint IDs.

Use the AWS:.Region pseudo parameter

Require the Region as a CloudFormation parameter

Find the Region from the AWS::Stackld pseudo parameter by using the Fn::Split intrinsic function

Dynamically import the Region by referencing the relevant parameter in AWS Systems Manager Parameter Store

Encode each employee's contact information and photos using Base64. Store the information in an Amazon DynamoDB table using a sort key.

Store each employee's contact information in an Amazon DynamoDB table along with the object keys for the photos stored in Amazon S3.

Use Amazon Cognito user pools to implement the employee directory in a fully managed software-as-a-service (SaaS) method.

Store employee contact information in an Amazon RDS DB instance with the photos stored in Amazon Elastic File System (Amazon EFS).

The S3 event notification does not activate for files that are larger than 1.000 MB.

The resource-based policy for the Lambda function does not have the required permissions to be invoked by Amazon S3.

Lambda functions cannot be invoked directly from an S3 event.

The S3 bucket needs to be made public.

Store the credentials in AWS Secrets Manager in the primary Region. Enable secret replication to the secondary Region Update the application to use the Amazon Resource Name (ARN) based on the Region.

Store credentials in AWS Systems Manager Parameter Store in the primary Region. Enable parameter replication to the secondary Region. Update the application to use the Amazon Resource Name (ARN) based on the Region.

Store credentials in a config file. Upload the config file to an S3 bucket in me primary Region. Enable Cross-Region Replication (CRR) to an S3 bucket in the secondary region. Update the application to access the config file from the S3 bucket based on the Region.

Store credentials in a config file. Upload the config file to an Amazon Elastic File System (Amazon EFS) file system. Update the application to use the Amazon EFS file system Regional endpoints to access the config file in the primary and secondary Regions.

Add the export LC-_ALL" on _ US, tuft" command to the pre _ build section to ensure POSIX Localization.

Use Amazon Cognate to store key-value pairs for large numbers of environment variables

Update the settings for the build project to use an Amazon S3 bucket for large numbers of environment variables

Use AWS Systems Manager Parameter Store to store large numbers ot environment variables

Create an Amazon ElastiCache for Redis instance. Enable encryption of data in transit and at rest. Store frequently accessed data in the cache.

Create an Amazon ElastiCache for Memcached instance. Enable encryption of data in transit and at rest. Store frequently accessed data in the cache.

Create an Amazon RDS for MySQL read replica. Connect to the read replica by using SSL. Configure the read replica to store frequently accessed data.

Create an Amazon DynamoDB table and a DynamoDB Accelerator (DAX) cluster for the table. Store frequently accessed data in the DynamoDB table.

Import the SSL/TLS certificate into AWS Certificate Manager (ACM) in the same Region as the API. Create a DNS A record for the custom domain.

Import the SSL/TLS certificate into CloudFront. Create a DNS CNAME record for the custom domain.

Import the SSL/TLS certificate into AWS Certificate Manager (ACM) in the same Region as the API. Create a DNS CNAME record for the custom domain.

Import the SSL/TLS certificate into AWS Certificate Manager (ACM) in the us-east-1 Region. Create a DNS CNAME record for the custom domain.

Store the credentials in AWS Systems Manager Parameter Store. Select the database that the parameter will access. Use the default AWS Key Management Service (AWS KMS) key to encrypt the parameter. Enable automatic rotation for the parameter. Use the parameter from Parameter Store on the Lambda function to connect to the database.

Encrypt the credentials with the default AWS Key Management Service (AWS KMS) key. Store the credentials as environment variables for the Lambda function. Create a second Lambda function to generate new credentials and to rotate the credentials by updating the environment variables of the first Lambda function. Invoke the second Lambda function by using an Amazon EventBridge rule that runs on a schedule. Update the database to use the new c

Store the credentials in AWS Secrets Manager. Set the secret type to Credentials for Amazon RDS database. Select the database that the secret will access. Use the default AWS Key Management Service (AWS KMS) key to encrypt the secret. Enable automatic rotation for the secret. Use the secret from Secrets Manager on the Lambda function to connect to the database.

Encrypt the credentials by using AWS Key Management Service (AWS KMS). Store the credentials in an Amazon DynamoDB table. Create a second Lambda function to rotate the credentials. Invoke the second Lambda function by using an Amazon EventBridge rule that runs on a schedule. Update the DynamoDB table. Update the database to use the generated credentials. Retrieve the credentials from DynamoDB with the first Lambda function. Connect to the d

Build the container image and run the docker scan command locally. Mitigate any findings before pushing changes to the source code repository. Write a pre-commit hook that enforces the use of this workflow before commit.

Create a new CodePipeline stage that occurs after the container image is built. Configure ECR basic image scanning to scan on image push. Use an AWS Lambda function as the action provider. Configure the Lambda function to check the scan results and to fail the pipeline if there are findings.

Create a new CodePipeline stage that occurs after source code has been retrieved from its repository. Run a security scanner on the latest revision of the source code. Fail the pipeline if there are findings.

Add an action to the deployment stage of the pipeline so that the action occurs before the deployment to the EKS cluster. Configure ECR basic image scanning to scan on image push. Use an AWS Lambda function as the action provider. Configure the Lambda function to check the scan results and to fail the pipeline if there are findings.

Store the API credentials in AWS Secrets Manager. Retrieve the API credentials at runtime by using the AWS SDK. Use the credentials to make the API call.

Store the API credentials in a local code variable. Push the code to a secure Git repository. Use the local code variable at runtime to make the API call.

Store the API credentials as an object in a private Amazon S3 bucket. Restrict access to the S3 object by using IAM policies. Retrieve the API credentials at runtime by using the AWS SDK. Use the credentials to make the API call.

Store the API credentials in an Amazon DynamoDB table. Restrict access to the table by using resource-based policies. Retrieve the API credentials at runtime by using the AWS SDK. Use the credentials to make the API call.

Create a new Lambda function and a new API Gateway API endpoint. Configure the new Lambda function to write to the S3 bucket. Modify the original Lambda function to post updates to the new API endpoint.

Use Amazon Kinesis Data Streams to create a new data stream. Modify the Lambda function to publish orders to the oats stream Configure in data stream to write to the S3 bucket.

Enable DynamoDB Streams on me DynamoOB table. Create a new lambda function. Associate the stream's Amazon Resource Name (ARN) with the Lambda Function Configure the Lambda function to write to the S3 bucket as records appear in the table’s stream.

Modify the Lambda function to punish to a new Amazon. Simple Lambda function receives orders. Subscribe a new Lambda function to the topic. Configure the new Lambda function to write to the S3 bucket as updates come through the topic.

Assign a public IP address to the DB instance. Modify the security group of the DB instance to allow inbound traffic from the IP address of the Lambda function.

Set up an AWS Direct Connect connection between the Lambda function and the DB instance.

Configure an Amazon CloudFront distribution to create a secure connection between the Lambda function and the DB instance.

Configure the Lambda function to connect to the private subnets in the VPC. Add security group rules to allow traffic to the DB instance from the Lambda function.

Use an AWS Lambda function as a CloudFormation custom resource to generate and rotate the password.

Use an AWS Systems Manager Parameter Store resource with the SecureString data type to generate and rotate the password.

Use a cron daemon on the application s host to generate and rotate the password.

Use an AWS Secrets Manager resource to generate and rotate the password.

Contact AWS Support for a limit increase.

Use the AWS CLI to get the metrics.

Analyze the applications and remove the API call.

Retry the call with exponential backoff.

Change the Amazon SQS standard queue to an Amazon SQS FIFO queue by using the Amazon SQS message deduplication ID.

Set up a dead-letter queue.

Set the maximum concurrency limit of the AWS Lambda function to 1

Change the message processing to use Amazon Kinesis Data Streams instead of Amazon SQS.

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.

Inspect the frontend logs for API failures. Call the POST API manually by using the requests from the log file.

Create and inspect the Lambda dead-letter queue. Troubleshoot the failed functions. Reprocess the events.

Inspect the Lambda logs in Amazon CloudWatch for possible errors. Fix the errors.

Make sure that caching is disabled for the POST API in API Gateway.

Check whether the policy that is assigned to the JAM role that is attached to the EC2 instances grants access to Amazon S3.

Check the S3 bucket policy to validate the access permissions for the S3 bucket.

Check whether the policy that is assigned to the 1AM user that is attached to the EC2 instances grants access to Amazon S3.

Check the S3 Lifecycle policy to validate the permissions that are assigned to the S3 bucket.

Check the security groups that are assigned to the EC2 instances. Make sure that a rule is not blocking the access to Amazon S3.

Disable application-level DNS caching.

Enable application-level DNS caching.

Enable application pooling.

Disable application pooling.

Create four access points that allow access to the central S3 bucket. Assign an access point to each web application bucket.

Create a bucket policy that allows access to the central S3 bucket. Attach the bucket policy to the central S3 bucket.

Create a cross-origin resource sharing (CORS) configuration that allows access to the central S3 bucket. Add the CORS configuration to the central S3 bucket.

Create a Content-MD5 header that provides a message integrity check for the central S3 bucket. Insert the Content-MD5 header for each web application request.

Configure the SQS queue as a dead-letter queue for the Lambda function.

Create code that uses the AWS SDK to call the SQS SendMessage operation to add the invocation details to the SQS queue. Add the code to the end of the Lambda function.

Add two asynchronous invocation destinations to the Lambda function: one destination for successful invocations and one destination for failed invocations. Configure the SQS queue as the destination for each type. Create an Amazon CloudWatch alarm based on the DestinationDeliveryFailures metric to catch any message that cannot be delivered.

Add a single asynchronous invocation destination to the Lambda function to capture successful invocations. Configure the SQS queue as the destination. Create an Amazon CloudWatch alarm based on the DestinationDeliveryFailures metric to catch any message that cannot be delivered.

Attach the existing 1AM policy to the Lambda function.

Create an 1AM role for the Lambda function Attach the existing 1AM policy to the role Attach the role to the Lambda function

Create an 1AM user with programmatic access Attach the existing 1AM policy to the user. Add the user access key ID and secret access key as environment variables in the Lambda function.

Add the AWS account root user access key ID and secret access key as encrypted environment variables in the Lambda function

Double the Auto Scaling group's maximum number of servers

Host the application code on AWS lambda

Scale vertically by resizing the EC2 instances

Create an Amazon Cloudfront distribution to cache the static content

Store the application’s sialic content in Amazon S3

Create an AWS Key Management Service (AWS KMS) key. Assign the KMS key to the S3 bucket.

Set the x-amz-server-side-encryption header when invoking the PutObject API operation.

Provide the encryption key in the HTTP header of every request.

Apply TLS to encrypt the traffic to the S3 bucket.

sam deploy -force-upload

sam deploy -no-execute-changeset

sam package

sam sync -watch

Define a development stage on the API Gateway API. Instruct the other developers to point the endpoints to the development stage.

Define a new API Gateway API that points to the new API application code. Instruct the other developers to point the endpoints to the new API.

Implement a query parameter in the API application code that determines which code version to call.

Specify new API Gateway endpoints for the API endpoints that the developer wants to add.

Export the existing API to an OpenAPI file. Create a new API. Import the OpenAPI file. Modify the new API to add request validation. Perform the tests. Modify the existing API to add request validation. Deploy the existing API to production.

Modify the existing API to add request validation. Deploy the updated API to a new API Gateway stage. Perform the tests. Deploy the updated API to the API Gateway production stage.

Create a new API. Add the necessary resources and methods, including new request validation. Perform the tests. Modify the existing API to add request validation. Deploy the existing API to production.

Clone the existing API. Modify the new API to add request validation. Perform the tests. Modify the existing API to add request validation. Deploy the existing API to production.

Create an SOS FIFO queue. Enable message deduplication on the SOS FIFO queue.

Reduce the maximum Lambda concurrency that the SOS queue can invoke.

Use Lambda's temporary storage to keep track of processed message identifiers.

Configure a message group ID for every sent message. Enable message deduplication on the SQS standard queue.

Store the database credentials as environment variables for the Lambda function. Set the environment variables to rotate automatically.

Store the database credentials in AWS Secrets Manager. Set up managed rotation on the database credentials.

Store the database credentials in AWS Systems Manager Parameter Store as secure string parameters. Set up managed rotation on the parameters.

Store the database credentials in the X-Amz-Security-Token parameter. Set up managed rotation on the parameter.

The developer must manually keep Hack of the data encryption keys used for each data object.

The SDK encrypts the data encryption key and stores it (encrypted) as part of the resumed ophertext.

The SDK stores the data encryption keys automaticity in Amazon S3.

The data encryption key is stored m the user data for the EC2 instance.

Modify the IAM policy resource to be "arn aws dynamo* us-west-2 account-id table/*"

Modify the IAM policy to include the dynamodb * action

Create a trust policy that specifies the EC2 service principal. Associate the role with the policy.

Create a trust relationship between the role and dynamodb Amazonas com.

Encrypt the environment variables by using AWS Secrets Manager. Set up automatic rotation in Secrets Manager.

Encrypt the environment variables by using AWS Key Management Service (AWS KMS) customer managed keys. Enable automatic key rotation.

Encrypt the environment variables by using AWS Key Management Service (AWS KMS) AWS managed keys. Configure a custom AWS Lambda function to automate key rotation.

Encrypt the environment variables by using AWS Systems Manager Parameter Store. Set up automatic rotation in Parameter Store.