DOP-C01 무료 덤프문제 온라인 액세스

A company that runs many workloads on AWS has an Amazon EBS spend that has increased over time. The DevOps team notices there are many unattached EBS volumes. Although there are workloads where volumes are detached, volumes over 14 days old are stale and no longer needed. A DevOps engineer has been tasked with creating automation that deletes unattached EBS volumes that have been unattached for 14 days.
Which solution will accomplish this?

• A.Use Amazon EC2 and Amazon Data Lifecycle Manager to configure a volume lifecycle policy.
  Set the interval period for unattached EBS volumes to 14 days and set the retention rule to delete. Set the policy target volumes as *.
• B.Create an Amazon CloudWatch Events rule to execute an AWS Lambda function daily.
  The Lambda function should find unattached EBS volumes and tag them with the current date, and delete unattached volumes that have tags with dates that are more than 14 days old.
• C.Configure the AWS Config ec2-volume-inuse-check managed rule with a configuration changes trigger type and an Amazon EC2 volume resource target.
  Create a new Amazon CloudWatch Events rule scheduled to execute an AWS Lambda function in 14 days to delete the specified EBS volume.
• D.Use AWS Trusted Advisor to detect EBS volumes that have been detached for more than 14 days.
  Execute an AWS Lambda function that creates a snapshot and then deletes the EBS volume.

You have been asked to de-risk deployments at your company. Specifically, the CEO is concerned about outages that occur because of accidental inconsistencies between Staging and Production, which sometimes cause unexpected behaviors in Production even when Staging tests pass. You already use Docker to get high consistency between Staging and Production for the application environment on your EC2 instances. How do you further de-risk the rest of the execution environment, since in AWS, there are many service components you may use beyond EC2 virtual machines?

• A.Develop models of your entire cloud system in CloudFormation. Use this model in Staging and Production to achieve greater parity.
• B.Use AMIs to ensure the whole machine, including the kernel of the virual machines, is consistent, since Docker uses Linux Container (LXC) technology, and we need to make sure the container environment is consistent.
• C.Use AWS ECS and Docker clustering. This will make sure that the AMIs and machine sizes are the same across both environments.
• D.Use AWS Config to force the Staging and Production stacks to have configuration parity. Any differences will be detected for you so you are aware of risks.

A company is using several AWS CloudFormation templates for deploying infrastructure as code.
In most of the deployments, the company uses Amazon EC2 Auto Scaling groups. A DevOps Engineer needs to update the AMIs for the Auto Scaling group in the template if newer AMIs are available.
How can these requirements be met?

• A.Manage the AMI mappings in the CloudFormation template. Use Amazon CloudWatch Events for detecting new AMIs and updating the mapping in the template. Reference the map in the launch configuration resource block.
• B.Use conditions in the AWS CloudFormation template to check if new AMIs are available and return the AMI ID. Reference the returned AMI ID in the launch configuration resource block.
• C.Launch an Amazon EC2 m4 small instance and run a script on it to check for new AMIs. If new AMIs are available, the script should update the launch configuration resource block with the new AMI ID.
• D.Use an AWS Lambda-backed custom resource in the template to fetch the AMI IDs. Reference the returned AMI ID in the launch configuration resource block.

A DevOps Engineer needs to design and implement a backup mechanism for Amazon EFS. The Engineer is given the following requirements:
- The backup should run on schedule.
- The backup should be stopped if the backup window expires.
- The backup should be stopped if the backup completes before the
backup window.
- The backup logs should be retained for further analysis.
- The design should support highly available and fault-tolerant
paradigms.
- Administrators should be notified with backup metadata.
Which design will meet these requirements?

• A.Use AWS Data Pipeline with an Amazon CloudWatch Events rule for scheduling the start/stop of backup activity. Run backup scripts on Amazon EC2 in a single Availability Zone. Use Auto Scaling lifecycle hooks and the SSM Run Command on EC2 for uploading the backup logs to Amazon RDS.
  Use Amazon SNS to notify administrators with backup activity metadata.
• B.Use Amazon SWF with an Amazon CloudWatch Events rule for scheduling the start/stop of backup activity. Run backup scripts on Amazon EC2 in an Auto Scaling group. Use Auto Scaling lifecycle hooks and the SSM Run Command on EC2 for uploading backup logs to Amazon Redshift. Use CloudWatch Alarms to notify administrators with backup activity metadata.
• C.Use AWS Lambda with an Amazon CloudWatch Events rule for scheduling the start/stop of backup activity. Run backup scripts on Amazon EC2 in an Auto Scaling group. Use Auto Scaling lifecycle hooks and the SSM Run Command on EC2 for uploading backup logs to Amazon S3.
  Use Amazon SNS to notify administrators with backup activity metadata.
• D.Use AWS CodePipeline with an Amazon CloudWatch Events rule for scheduling the start/stop of backup activity. Run backup scripts on Amazon EC2 in a single Availability Zone. Use Auto Scaling lifecycle hooks and the SSM Run Command on Amazon EC2 for uploading backup logs to Amazon S3.
  Use Amazon SES to notify admins with backup activity metadata.

A company is using AWS CodeCommit as its source code repository. After an internal audit, the compliance team mandates that any code change that go into the master branch must be committed by senior developers.
Which solution will meet these requirements?

• A.Create a repository in CodeCommit with a working and master branch.
  Create separate IAM groups for senior developers and developers.
  Use an IAM policy to assign each IAM group their corresponding branches.
  Once the code is merged to the working branch, senior developers can pull the changes from the working branch to the master branch.
• B.Create two repositories in CodeCommit: one for working and another for the master.
  Create separate IAM groups for senior developers and developers.
  Assign the resource-level permissions on the repositories tied to the IAM groups.
  After the code changes are reviewed, sync the approved files to the master code commit repository.
• C.Create a repository in CodeCommit.
  Create separate IAM groups for senior developers and developers.
  Use AWS Lambda triggers on the master branch and get the user name of the developer at the event object of the Lambda function.
  Validate the user name with the IAM group to approve or deny the commit.
• D.Create a repository in CodeCommit.
  Create separate IAM groups for senior developers and developers.
  Assign code commit permissions for both groups, with code merge permissions for the senior developers group.
  Create a trigger to notify senior developers with a URL link to approve or deny commit requests delivered through Amazon SNS.
  Once a senior developer approves the code, the code gets merged to the master branch.