DVA-C02 Deployment Practice Test 9 — 15 Questions

Question 1

A company uses AWS CodeDeploy to manage deployments to an Amazon EC2 Auto Scaling group. The deployment group is configured with a blue/green deployment type. The developer notices that after a deployment, the old instances (blue environment) are terminated immediately after the new instances (green environment) pass health checks. The company wants to keep the old instances running for 30 minutes to allow for quick rollback if issues are detected. Which TWO configuration changes should the developer make to achieve this? (Choose TWO.)

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Set the 'terminateBlueInstancesOnDeploymentSuccess' action to 'KEEP_ALIVE'.. Option A is correct because in a CodeDeploy blue/green deployment to EC2 Auto Scaling groups, the deployment group's deployment configuration includes a terminateBlueInstancesOnDeploymentSuccess action, and setting it to KEEP_ALIVE prevents CodeDeploy from terminating the original (blue) instances after the replacement (green) instances pass health checks. Option C is correct because terminationWaitTimeInMinutes is the companion property that specifies how long the blue instances are retained when the action is KEEP_ALIVE; setting it to 30 keeps the old instances running for exactly 30 minutes, enabling a quick rollback. The other options are incorrect because blueInstanceTermination, originalSettings, and waitTimeForBlueTermination are not valid CodeDeploy deployment-group properties for controlling blue instance termination; the actual API/CLI fields are terminateBlueInstancesOnDeploymentSuccess and terminationWaitTimeInMinutes.

Answer

Set the 'blueInstanceTermination' property to 'WAIT'.

Answer

Set the 'blueInstanceTermination' property to 'originalSettings'.

Answer

Set the 'waitTimeForBlueTermination' to 30.

Question 2

A company is using AWS CodeCommit as a source repository for a CI/CD pipeline. The developer has set up AWS CodePipeline with a source stage that uses CodeCommit. The pipeline triggers automatically on changes to the repository. The developer wants to ensure that only changes to the 'main' branch trigger the pipeline. Which THREE configurations should the developer set in the CodePipeline source stage? (Choose THREE.)

Accepted Answer

Disable 'Poll for source changes'.. Option B is correct because disabling 'Poll for source changes' stops CodePipeline from periodically polling the CodeCommit repository, which is required when you instead rely on event-driven change detection. Option C is correct because setting 'Change detection' to 'Amazon CloudWatch Events' (now EventBridge) configures CodePipeline to be triggered by CodeCommit repository events rather than polling. Option E is correct because specifying the 'Branch name' as 'main' restricts the source stage to only use changes pushed to the main branch. Option A is incorrect because 'Output artifact format' controls how the source artifact is packaged (e.g., CodePipeline default vs. full clone), not which branch triggers the pipeline. Option D is incorrect because 'Repository name' must be the name of the CodeCommit repository, not the branch name 'main'.

Answer

Set 'Output artifact format' to 'CodeCommit'.

Answer

Set 'Repository name' to 'main'.

Question 3

A company is deploying a containerized application on Amazon ECS using Fargate launch type. The application consists of multiple microservices, each deployed as a separate ECS service. The company uses AWS CodePipeline to automate deployments. The pipeline has a Source stage (CodeCommit), a Build stage (CodeBuild), and a Deploy stage (ECS). Recently, a deployment failed because the new task definition referenced an environment variable that was not available in the Parameter Store. The developer wants to prevent such failures in the future by validating the task definition before deployment. The developer has access to the AWS CLI and the AWS SDKs. The pipeline is configured to use CodeBuild for the build stage. What is the MOST efficient way to validate the task definition before deployment?

Accepted Answer

Add a step in the CodeBuild buildspec that runs 'aws ecs register-task-definition --cli-input-json file://taskdef.json --no-cli-pager --dry-run' to validate the task definition.. To validate the syntax and schema of an ECS task definition file (taskdef.json) before deployment, the developer can attempt to register it using the 'aws ecs register-task-definition' command during the Build stage in AWS CodeBuild. If the JSON file contains syntax errors, invalid parameters, or schema violations, the AWS CLI command will fail synchronously, causing the CodeBuild build stage to fail and preventing the pipeline from proceeding to the Deploy stage.

Option B is incorrect because 'aws ecs update-service' does not accept a local JSON file path for the '--task-definition' parameter; it requires an already registered task definition family or ARN. Furthermore, calling 'update-service' would trigger an actual deployment, bypassing the separation of concerns between the Build and Deploy stages.
Option C is incorrect because 'aws ecs run-task' does not accept a local JSON file path and would attempt to run an active task rather than just validating the definition.
Option D is incorrect because 'aws ecs describe-task-definition' is used to retrieve details of an already registered task definition and does not accept a local JSON file path.

Answer

Add a step in the CodeBuild buildspec that runs 'aws ecs update-service --service my-service --task-definition <task-def-arn>' to see if the service accepts the task definition.

Answer

Add a step in the CodeBuild buildspec that runs 'aws ecs run-task --task-definition <task-def-arn> --count 1' to test the task definition.

Answer

Add a step in the CodeBuild buildspec that runs 'aws ecs describe-task-definition --task-definition <task-def-arn>' to check if the task definition exists.

Question 4

A developer is deploying a web application on AWS Elastic Beanstalk. The application uses a relational database and requires a custom environment variable for the database connection string. The developer has created an Elastic Beanstalk environment and wants to set the environment variable securely without exposing it in the source code or configuration files. The developer also wants to ensure that the environment variable is available to the application instances at deployment time. What is the BEST way to achieve this?

Accepted Answer

Set the environment variable using the Elastic Beanstalk console or CLI by configuring environment properties.. Configuring environment properties in Elastic Beanstalk via the console or CLI is the best way to securely set environment variables without exposing them in source code or configuration files. These properties are injected into the application environment at deployment time and are stored securely by Elastic Beanstalk. They are not visible in the source repository and can be managed centrally. This method also allows for easy updates and separation of configuration from code.

Answer

Store the connection string in AWS Systems Manager Parameter Store and retrieve it from the application code at runtime.

Answer

Hardcode the connection string in the application code and commit it to the source repository.

Answer

Store the connection string in a file named 'env.txt' in the application source bundle and read it at application startup.

Question 5

A developer is using AWS CodeBuild to build and test a Java application. The buildspec.yaml file includes phases for install, pre_build, build, and post_build. The developer notices that the build fails intermittently due to network timeouts when downloading dependencies from an external repository. The developer wants to improve the reliability of the build by caching the dependencies. The build environment is Linux and the dependencies are stored in the /root/.m2 directory (Maven cache). The developer has an S3 bucket for caching. What should the developer add to the buildspec.yaml to enable caching?

Accepted Answer

Add a 'cache' section with 'paths' including '/root/.m2' and 'location' set to the S3 bucket name.. AWS CodeBuild allows caching using a 'cache' section in the buildspec.yaml file. By specifying the 'paths' with '/root/.m2' and the 'location' as the S3 bucket (using the bucket name), CodeBuild will cache the Maven dependencies between builds, reducing network timeouts. Option A is incorrect because manually copying to S3 in the install phase would not leverage CodeBuild's caching mechanism and would require additional scripting. Option B is incorrect because the 'artifacts' section is for output artifacts generated by the build, not for caching dependencies. Option D is incorrect because the 'env' section with Parameter Store is for storing environment variables or secrets, not for caching.

Answer

Add a 'phases' section with install commands to manually copy dependencies to S3.

Answer

Add an 'artifacts' section with 'files' including '/root/.m2/**/*' and 'location' set to the S3 bucket.

Answer

Add an 'env' section with 'parameter-store' variables to store the dependency paths.

Question 6

A company uses AWS CloudFormation to deploy infrastructure. The developer has created a stack that includes an Amazon RDS DB instance. The stack creation fails with a rollback, and the error message indicates that the DB instance could not be created because the DB instance identifier already exists. The developer has verified that there is no existing DB instance with that identifier in the account. The stack uses a custom resource to generate the DB instance identifier. The custom resource is a Lambda function that returns a unique identifier. The developer suspects that the custom resource is returning a stale value. What is the MOST likely cause of this issue?

Accepted Answer

The custom resource Lambda function has not been updated with the new code; the stack is using a previous version of the function.. The custom resource Lambda function may not have been updated with new code, causing the stack to use a previous version that returns a stale DB instance identifier. This stale identifier could conflict with an existing DB instance from a previous stack creation attempt. Option B is incorrect because CloudFormation does not reuse previous custom resource outputs based on stack name; each stack creation invokes the custom resource anew. Option C is incorrect because a random number generator without a seed would still produce different values on each invocation. Option D is incorrect because if the service token were incorrect, the custom resource would fail to invoke, leading to a different error about missing properties or invalid service token.

Answer

The stack is using the same stack name, and CloudFormation is reusing the previous custom resource output.

Answer

The custom resource Lambda function is returning the same value because it uses a random number generator without a seed.

Answer

The custom resource Lambda function is not being invoked during stack creation because the service token is incorrect.

Question 7

A developer is deploying a serverless application using AWS SAM. The application includes an API Gateway HTTP API and multiple Lambda functions. The developer wants to implement a gradual deployment strategy where 10% of traffic is shifted to the new version, and if no errors occur, the remaining traffic is shifted after 5 minutes. The developer has defined the deployment preference in the SAM template. However, after deploying, the developer notices that the traffic shift happens immediately and not gradually. The SAM template includes the following configuration for one of the Lambda functions:

DeploymentPreference:
  Type: Linear10PercentEvery5Minutes

The developer has confirmed that the Lambda function version is being updated. What is the MOST likely reason the gradual deployment is not working?

Accepted Answer

The API Gateway integration is pointing to the Lambda function without specifying a version or alias.. For gradual deployments to work with API Gateway HTTP API, the Lambda function must be integrated using the function's ARN with the version number (e.g., my-function:1), not the function name alone. If the integration uses the function name (without version), API Gateway always invokes the $LATEST version, bypassing the traffic shifting. Option A is incorrect because CodeDeploy is automatically used when DeploymentPreference is set in SAM. Option C is incorrect because the Lambda alias is created by SAM for traffic shifting; if the alias were not created, the deployment would fail. Option D is incorrect because the default version is $LATEST, but the issue is with how API Gateway invokes the function.

Answer

The developer did not create a Lambda alias for the function.

Answer

The developer did not enable canary deployment in the API Gateway stage.

Answer

The Lambda function is using the default version, which cannot be used with gradual deployments.

Question 8

A company is using AWS CloudFormation to manage a stack that includes an Amazon RDS DB instance. The developer needs to update the DB instance class from db.t3.small to db.t3.medium. The update should occur without interrupting the database availability. Which CloudFormation stack update method should the developer use?

Accepted Answer

Use a blue/green deployment strategy by creating a new stack with the updated DB instance class, then migrate the data and switch the application to the new DB instance.. To update an RDS instance class without downtime, a blue/green deployment strategy is effective. This involves creating a new RDS instance with the desired class, configuring replication from the original, and then promoting the new instance to primary. After switching the application to the new endpoint, the old instance can be decommissioned. CloudFormation alone does not provide automated blue/green for RDS; additional orchestration is needed.

Answer

Modify the DBInstanceClass property and set the UpdateReplacePolicy attribute to Retain, then update the stack. This will create a new DB instance and swap endpoints without downtime.

Answer

Create a change set, then execute it. This will automatically perform a blue/green deployment for the RDS instance, ensuring no downtime.

Answer

Use a direct update by modifying the DBInstanceClass property and then running aws cloudformation update-stack, which will apply the change immediately without downtime.

Question 9

A developer is using AWS CodePipeline to automate the deployment of a serverless application. The pipeline has a source stage from AWS CodeCommit, a build stage using AWS CodeBuild, and a deploy stage using AWS CloudFormation. The developer wants to ensure that the pipeline only deploys changes that have passed unit tests. Where should the developer add the unit test execution?

Accepted Answer

In the build stage, by adding a buildspec.yml that includes commands to run the unit tests.. Unit tests should be integrated into the build stage using CodeBuild. The buildspec.yml file can define commands to run tests after the code is compiled. If tests fail, the build fails, preventing the pipeline from proceeding to deployment. This ensures that only code that passes unit tests is deployed.

Answer

By creating a separate test stage before the deploy stage that uses AWS CodeBuild to run the tests.

Answer

In the source stage, by adding a post-action that runs the tests.

Answer

In the deploy stage, by adding a pre-deployment action that runs the tests.

Question 10

A developer is deploying a containerized application to Amazon ECS using AWS CodeDeploy for blue/green deployments. The application uses an Application Load Balancer (ALB) to route traffic to two target groups. The developer needs to ensure that traffic is shifted from the original task set to the replacement task set only after the replacement tasks pass health checks. Which two configurations are required to achieve this? (Choose two.)

Accepted Answer

The ALB must have two target groups: one for the original task set and one for the replacement task set, and the CodeDeploy deployment group must reference both.. For ECS blue/green with CodeDeploy, you need two target groups attached to the ALB: one for the original task set and one for the replacement. The CodeDeploy deployment group must reference both target groups and use a deployment configuration that shifts traffic gradually (e.g., Linear or Canary). This ensures traffic is rerouted only after the replacement tasks pass health checks.

Answer

The CodeDeploy application must be configured with a deployment configuration that specifies the traffic rerouting method as AllAtOnce.

Answer

The ECS service must be configured with a deployment controller type of CODE_DEPLOY, and the task definition must specify a health check.

Answer

The ALB listener must have a rule that forwards traffic to both target groups simultaneously, and CodeDeploy will adjust the weights based on health checks.

Question 11

A developer is using AWS CodeDeploy with a blue/green deployment strategy to update an application running on Amazon ECS with the Fargate launch type. After the new (green) task set is created and traffic is shifted to it, users immediately report errors when trying to write data. The developer discovers that the green task set is connecting to a different database than the blue task set. The database endpoints are configured in the ECS task definition. What is the simplest way to prevent this issue in future deployments?

Accepted Answer

Modify the blue/green deployment configuration to use the same database endpoint for both task sets by updating the environment variables in the task definition before deployment.. The issue stems from the green task set using a different database endpoint than the blue task set, which is configured via environment variables in the ECS task definition. By updating the task definition to use the same database endpoint before deployment, both task sets will connect to the same database, ensuring consistency during the traffic shift. This is the simplest fix as it requires no additional infrastructure or complex routing changes.

Answer

Create two separate Amazon RDS databases and use an Amazon Route 53 weighted routing policy to distribute traffic.

Answer

Use an Application Load Balancer (ALB) with stickiness to route each user to the correct task set.

Answer

Use AWS CloudFormation to create a new database stack for each deployment and update the task definition dynamically.

Question 12

A developer is using AWS CodeDeploy with a blue/green deployment on an Amazon ECS service running on Fargate. The developer wants to ensure that the new (green) task set is fully healthy and serving traffic before the old (blue) task set is terminated. The deployment should automatically roll back to the blue task set if the green task set fails health checks. Which configuration should the developer set in the CodeDeploy deployment group?

Accepted Answer

Deployment type: blue/green, with rollback configuration enabled to trigger automatic rollback and reroute traffic to the original task set. The developer needs to configure the CodeDeploy deployment group with a blue/green deployment type and enable automatic rollback. This ensures that if the green task set fails health checks, CodeDeploy automatically terminates the green deployment and reroutes traffic back to the original blue task set, meeting the requirement for a fully healthy green task set before termination.

Answer

Deployment type: blue/green, Deployment configuration: CodeDeployDefault.ECSAllAtOnce

Answer

Deployment type: blue/green, Deployment configuration: CodeDeployDefault.ECSLinear10PercentEvery1Minutes

Answer

Deployment type: blue/green, with an Application Load Balancer

Question 13

A developer is deploying a multi-container Docker application on Amazon ECS using the Fargate launch type. The application consists of a web server and a background worker. The web server must be scaled independently and must be accessible from the internet via an Application Load Balancer. The worker should not be accessible from the internet. Which ECS configuration should the developer use?

Accepted Answer

Create two separate ECS services, each with its own task definition, and place the web server in a public subnet with the worker in a private subnet.. It uses two separate ECS services, each with its own task definition, allowing independent scaling of the web server and worker. Placing the web server in a public subnet with an Application Load Balancer makes it internet-accessible, while the worker in a private subnet is isolated from direct internet traffic, meeting the security requirement.

Answer

Create one ECS service with both containers in the same task definition, but only expose the web server port.

Answer

Create one ECS service with two tasks, each containing one container.

Answer

Create one ECS service with two containers in the same task, and use a service discovery to expose the worker.

Question 14

A developer is using AWS CodeDeploy to deploy an application to an EC2 Auto Scaling group. The application must remain fully available; only one instance should be taken offline at a time. The developer wants to configure the deployment to update instances one by one, ensuring that the deployment fails fast if any instance fails to deploy. Which deployment configuration should the developer choose?

Accepted Answer

CodeDeployDefault.OneAtATime. CodeDeployDefault.OneAtATime, is correct because it deploys the application to one instance at a time, ensuring that only one instance is taken offline during the deployment. This satisfies the requirement for the application to remain fully available. Additionally, this configuration fails fast: if any instance fails to deploy, the deployment stops immediately, preventing further instances from being updated.

Answer

CodeDeployDefault.AllAtOnce

Answer

CodeDeployDefault.HalfAtATime

Answer

CodeDeployDefault.BlueGreen

Question 15

A company uses AWS Elastic Beanstalk to run a web application. They want to deploy a new version with zero downtime and roll forward if successful. They have two environments: a production environment (current version) and a staging environment (new version). After verifying the staging environment, they want to swap the URLs so that production now points to the new version. Which deployment strategy should they use?

Accepted Answer

Blue/green deployment with environment CNAME swap. Blue/green deployment with an environment CNAME swap allows you to run two separate Elastic Beanstalk environments (production and staging) simultaneously. After verifying the new version in the staging environment, you swap the CNAME records so that the production URL points to the staging environment, achieving zero downtime and a roll-forward strategy. This approach decouples the deployment from the existing environment, ensuring no disruption to live traffic during the swap.

Answer

All at once deployment

Answer

Rolling deployment with additional batch

Answer

Immutable deployment