Create a Simple Pipeline with CodePipeline, CodeCommit & CodeDeploy

1. Create a CodeCommit Repository

To create a CodeCommit repository

Open the CodeCommit console at https://console.aws.amazon.com/codecommit/.
In the Region selector, choose the AWS Region where you want to create the repository and pipeline.
On the Repositories page, choose Create repository.
On the Create repository page, in Repository name, enter a name for your repository (for example, MyDemoRepo).
Choose Create.

To set up a local repository

In this step, you set up a local repository to connect to your remote CodeCommit repository.

With your new repository open in the console, choose Clone URL on the top right of the page, and then choose Clone SSH. The address to clone your Git repository is copied to your clipboard.
In your terminal or command line, navigate to a local directory where you’d like your local repository to be stored. In this tutorial, we use /tmp.
Run the following command to clone the repository, replacing the SSH address with the one you copied in the previous step. This command creates a directory called MyDemoRepo. You copy a sample application to this directory.
```
git clone ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/MyDemoRepo
```

2. Add Sample Code to Your CodeCommit Repository

Download the following file: SampleApp_Linux.zip
Unzip the files from SampleApp_Linux.zip into the local directory you created earlier (for example, /tmp/MyDemoRepo or c:\temp\MyDemoRepo).
Be sure to place the files directly into your local repository. Do not include a SampleApp_Linux folder. On your local Linux, macOS, or Unix machine, for example, your directory and file hierarchy should look like this:

/tmp
   └-- MyDemoRepo
       │-- appspec.yml
       │-- index.html
       │-- LICENSE.txt
       └-- scripts
           │-- install_dependencies
           │-- start_server
           └-- stop_server

Change directories to your local repo:

(For Linux, macOS, or Unix) cd /tmp/MyDemoRepo (For Windows) cd c:\temp\MyDemoRepo

Run the following command to stage all of your files at once:
```
git add -A
```
Run the following command to commit the files with a commit message:
```
git commit -m "Add sample application files"
```
Run the following command to push the files from your local repo to your CodeCommit repository:
```
git push
```
The files you downloaded and added to your local repo have now been added to the master branch in your CodeCommit MyDemoRepo repository and are ready to be included in a pipeline.

3. Create an EC2 Linux Instance and Install the CodeDeploy Agent

In this step, you create the EC2 instance where you deploy a sample application. As part of this process, you install the CodeDeploy agent on the EC2 instance. The CodeDeploy agent is a software package that enables an instance to be used in CodeDeploy deployments. You also attach an IAM role to the instance (known as an instance role) to allow it to fetch files that the CodeDeploy agent uses to deploy your application.

To create an instance role

Open the IAM console at https://console.aws.amazon.com/iam/).
From the console dashboard, choose Roles.
Choose Create role.
Under Select type of trusted entity, select AWS service. Under Choose a use case, select EC2, and then choose Next: Permissions.
Search for and select the policy named AmazonEC2RoleforAWSCodeDeploy, and then choose Next: Tags.
Choose Next: Review. Enter a name for the role (for example, EC2InstanceRole).
Choose Create role.

To launch an instance

Open the Amazon EC2 console at https://console.aws.amazon.com/ec2/.
From the console dashboard, choose Launch instance, and select Launch instance from the options that pop up.
On Step 1: Choose an Amazon Machine Image (AMI), locate Amazon Linux 2 AMI (HVM), SSD Volume Type, and then choose Select. (This AMI is labeled “Free tier eligible” and can be found at the top of the list.)
On the Step 2: Choose an Instance Type page, choose the free tier eligible t2.micro type as the hardware configuration for your instance, and then choose Next: Configure Instance Details.
On the Step 3: Configure Instance Details page, do the following:
- In Number of instances, enter 1.
- In Auto-assign Public IP, choose Enable.
- In IAM role, choose the IAM role you created in the previous procedure (for example, EC2InstanceRole).
- Expand Advanced Details, and in the User data field, enter the following:
```
#!/bin/bash
yum -y update
yum install -y ruby
yum install -y aws-cli
cd /home/ec2-user
aws s3 cp s3://aws-codedeploy-us-east-2/latest/install . --region us-east-2
chmod +x ./install
./install auto
```
  This code installs the CodeDeploy agent on your instance as it is created.
- Leave the rest of the items on the Step 3: Configure Instance Details page unchanged. Choose Next: Add Storage.
Leave the Step 4: Add Storage page unchanged, and then choose Next: Add Tags.
Choose Add Tag. In Key, enter Name, and in Value, enter MyCodePipelineDemo. Choose Next: Configure Security Group. Later, you create a CodeDeploy application that deploys the sample application to this instance. CodeDeploy selects instances to deploy based on the tags that are attached to instances.
On the Step 6: Configure Security Group page, do the following:
- Next to Assign a security group, choose Create a new security group.
- In the row for SSH, under Source, choose My IP.
- Choose Add Rule, choose HTTP, and then under Source, choose My IP.
Choose Review and Launch.
On the Review Instance Launch page, choose Launch. When prompted for a key pair, choose Proceed without a key pair.
Choose View Instances to close the confirmation page and return to the console.
You can view the status of the launch on the Instances page. When you launch an instance, its initial state is pending. After the instance starts, its state changes to running, and it receives a public DNS name. (If the Public DNS column is not displayed, choose the Show/Hide icon, and then select Public DNS.)
It can take a few minutes for the instance to be ready for you to connect to it. View the information in the Status Checks column to see if your instance has passed its status checks.

4. Create an Application in CodeDeploy

In CodeDeploy, an application is a resource that contains the software application you want to deploy. Later, you use this application with CodePipeline to automate deployments of the sample application to your Amazon EC2 instance.

First, you create a role that allows CodeDeploy to perform deployments. Then, you create a CodeDeploy application.

To create a CodeDeploy service role

Open the IAM console at https://console.aws.amazon.com/iam/).
From the console dashboard, choose Roles.
Choose Create role.
Under Select type of trusted entity, select AWS service. Under Choose a use case, select CodeDeploy, and then choose Next: Permissions. The AWSCodeDeployRole managed policy is already attached to the role.
Choose Next: Tags, and Next: Review.
Enter a name for the role (for example, CodeDeployRole), and then choose Create role.

To create an application in CodeDeploy

Open the CodeDeploy console at https://console.aws.amazon.com/codedeploy.
If the Applications page does not appear, on the AWS CodeDeploy menu, choose Applications.
Choose Create application.
In Application name, enter MyDemoApplication.
In Compute Platform, choose EC2/On-premises.
Choose Create application.

To create a deployment group in CodeDeploy

A deployment group is a resource that defines deployment-related settings like which instances to deploy to and how fast to deploy them.

On the page that displays your application, choose Create deployment group.
In Deployment group name, enter MyDemoDeploymentGroup.
In Service Role, choose the service role you created earlier (for example, CodeDeployRole).
Under Deployment type, choose In-place.
Under Environment configuration, choose Amazon EC2 Instances. In the Key field, enter the name you used to tag the instance (for example, MyCodePipelineDemo).
Under Deployment configuration, choose CodeDeployDefault.OneAtaTime.
Under Load Balancer, clear Enable load balancing. You do not need to set up a load balancer or choose a target group for this example.
Expand the Advanced section. Under Alarms, if any alarms are listed, choose Ignore alarm configuration.
Choose Create deployment group.

5. Create Your First Pipeline in CodePipeline

You’re now ready to create and run your first pipeline. In this step, you create a pipeline that runs automatically when code is pushed to your CodeCommit repository.

To create a CodePipeline pipeline

Sign in to the AWS Management Console and open the CodePipeline console at http://console.aws.amazon.com/codesuite/codepipeline/home.Open the CodePipeline console at https://console.aws.amazon.com/codepipeline/.
Choose Create pipeline.
In Step 1: Choose pipeline settings, in Pipeline name, enter MyFirstPipeline.
In Service role, choose New service role to allow CodePipeline to create a service role in IAM.
Leave the settings under Advanced settings at their defaults, and then choose Next.
In Step 2: Add source stage, in Source provider, choose AWS CodeCommit. In Repository name, choose the name of the CodeCommit repository you created in Step 1: Create a CodeCommit Repository. In Branch name, choose master, and then choose Next step.

After you select the repository name and branch, a message displays the Amazon CloudWatch Events rule to be created for this pipeline.
Under Change detection options, leave the defaults. This allows CodePipeline to use Amazon CloudWatch Events to detect changes in your source repository.
Choose Next.
In Step 3: Add build stage, choose Skip build stage, and then accept the warning message by choosing Skip again. Choose Next.
In Step 4: Add deploy stage, in Deploy provider, choose AWS CodeDeploy. In Application name, choose MyDemoApplication. In Deployment group, choose MyDemoDeploymentGroup, and then choose Next step.
In Step 5: Review, review the information, and then choose Create pipeline.
The pipeline starts running after it is created. It downloads the code from your CodeCommit repository and creates a CodeDeploy deployment to your EC2 instance. You can view progress and success and failure messages as the CodePipeline sample deploys the webpage to the Amazon EC2 instance in the CodeDeploy deployment.

Congratulations! You just created a simple pipeline in CodePipeline.
Next, you verify the results.

To verify that your pipeline ran successfully

View the initial progress of the pipeline. The status of each stage changes from No executions yet to In Progress, and then to either Succeeded or Failed. The pipeline should complete the first run within a few minutes.
After Succeeded is displayed for the pipeline status, in the status area for the Deploy stage, choose AWS CodeDeploy. This opens the CodeDeploy console.
On the Deployments tab, choose the deployment ID. On the page for the deployment, under Deployment lifecycle events, choose the instance ID. This opens the EC2 console.
On the Description tab, in Public DNS, copy the address (for example, ec2-192-0-2-1.us-west-2.compute.amazonaws.com), and then paste it into the address bar of your web browser.This is the sample application you downloaded and pushed to your CodeCommit repository.

6. Modify Code in Your CodeCommit Repository

Your pipeline is configured to run whenever code changes are made to your CodeCommit repository. In this step, you make changes to the HTML file that is part of the sample CodeDeploy application in the CodeCommit repository. When you push these changes, your pipeline runs again, and the changes you make are visible at the web address you accessed earlier.

Change directories to your local repo:

(For Linux, macOS, or Unix) cd /tmp/MyDemoRepo (For Windows) cd c:\temp\MyDemoRepo

Use a text editor to modify the index.html file:

(For Linux or Unix)gedit index.html (For OS X)open –e index.html (For Windows)notepad index.html

Revise the contents of the index.html file to change the background color and some of the text on the webpage, and then save the file.

<!DOCTYPE html>
<html>
<head>
  <title>Updated Sample Deployment</title>
  <style>
    body {
      color: #000000;
      background-color: #CCFFCC;
      font-family: Arial, sans-serif;  
      font-size:14px;
    }

    h1 {
      font-size: 250%;
      font-weight: normal;
      margin-bottom: 0;
    }

    h2 {
      font-size: 175%;
      font-weight: normal;
      margin-bottom: 0;
    }
  </style>
</head>
<body>
  <div align="center"><h1>Updated Sample Deployment</h1></div>
  <div align="center"><h2>This application was updated using CodePipeline, CodeCommit, and CodeDeploy.</h2></div>
  <div align="center">
    <p>Learn more:</p> 
    <p><a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/">CodePipeline User Guide</a></p>
    <p><a href="https://docs.aws.amazon.com/codecommit/latest/userguide/">CodeCommit User Guide</a></p>
    <p><a href="https://docs.aws.amazon.com/codedeploy/latest/userguide/">CodeDeploy User Guide</a></p>
  </div>
</body>
</html>

Commit and push your changes to your CodeCommit repository by running the following commands, one at a time:
```
git commit -am "Updated sample application files"
git push
```

To verify your pipeline ran successfully

View the initial progress of the pipeline. The status of each stage changes from No executions yet to In Progress, and then to either Succeeded or Failed. The running of the pipeline should be complete within a few minutes.
After Succeeded is displayed for the action status, refresh the demo page you accessed earlier in your browser.