AWS CodePipeline: A Comprehensive Guide - Part 2

Advanced Features

Custom Actions

What is Custom Actions?

Custom actions in AWS CodePipeline allow you to extend the pipeline’s functionality, enabling workflows that are not natively supported by AWS services. This is particularly useful for integrating with third-party tools or handling specific business logic.

How to Create Custom Actions

Custom actions are user-defined and can be integrated into any stage of a pipeline. They typically involve AWS Lambda functions, which can execute custom scripts or trigger external systems.

Example: A Custom Approval Process Using Lambda

Imagine a scenario where your organization requires every production deployment to go through an automated check of user feedback ratings stored in a database.

1. Lambda Function Code (Python):

   • Task: Check if the average feedback rating is above 4.0 before approving deployment.

   import json
   
   def lambda_handler(event, context):
       # Simulated feedback check
       feedback_ratings = [4.5, 4.2, 4.0, 4.8]
       avg_rating = sum(feedback_ratings) / len(feedback_ratings)
   
       if avg_rating >= 4.0:
           return {"status": "Approved", "message": "Deployment can proceed."}
       else:
           return {"status": "Rejected", "message": "Low feedback rating."}
   

   • What this does: Simulates a feedback check. If the average rating is acceptable, it approves deployment; otherwise, it rejects it.

2. Integrating the Lambda Function with CodePipeline:

   • Use the Lambda action in the appropriate stage of your pipeline to invoke this function.

   {
     "name": "CustomApprovalAction",
     "actionTypeId": {
       "category": "Invoke",
       "owner": "AWS",
       "provider": "Lambda",
       "version": "1"
     },
     "configuration": {
       "FunctionName": "FeedbackApprovalCheck"
     },
     "inputArtifacts": [],
     "outputArtifacts": []
   }
   

   • Outcome: The pipeline will invoke the Lambda function and proceed based on its response.

Manual Approvals

Manual approvals introduce a human checkpoint in the pipeline, ensuring critical deployments are reviewed before proceeding. This is especially valuable for production environments.

How to Set Up Manual Approvals

1. Add a Manual Approval Action:

   • Specify an approval stage in the pipeline where a designated reviewer must confirm the deployment.

   {
     "name": "ApprovalStage",
     "actionTypeId": {
       "category": "Approval",
       "owner": "AWS",
       "provider": "Manual",
       "version": "1"
     },
     "configuration": {
       "NotificationArn": "arn:aws:sns:region:account-id:approval-topic",
       "CustomData": "Please review the changes before approving."
     },
     "outputArtifacts": []
   }
   

   • What this does: Sends a notification (e.g., email or SMS) to the specified SNS topic for review.

2. In AWS Console:

   • Go to your pipeline in AWS CodePipeline console
   • Click “Edit”
   • Choose “+ Add stage” at the position you want the approval
   • Name the stage (e.g., “Approval”)
   • Click “Add stage”
   • In the new stage, click “+ Add action group”
   • Select “Approval” as the action provider
   • Configure with notification settings and optional comments
   • Click “Done” to save

3. Outcome: The pipeline pauses at this stage until a reviewer explicitly approves or rejects the action.

Example: Adding an Approval Stage Before Production Deployment

• Use case: You’ve automated testing and staging, but a manual check is required before pushing to production.
• Steps:
  1. Add a Manual Approval stage after testing.
  2. Configure the stage to send notifications to the team lead.
  3. The pipeline resumes only after approval.

Pipeline as Code

Managing pipelines as code enables you to define and version-control your pipeline configurations, making them reusable and portable. AWS supports defining pipelines using CloudFormation, Terraform, or other Infrastructure as Code (IaC) tools.

Using CloudFormation to Define Pipelines

1. Example CloudFormation YAML:

   Resources:
     MyPipeline:
       Type: AWS::CodePipeline::Pipeline
       Properties:
         RoleArn: arn:aws:iam::account-id:role/CodePipelineRole
         Stages:
           - Name: Source
             Actions:
               - Name: SourceAction
                 ActionTypeId:
                   Category: Source
                   Owner: AWS
                   Provider: S3
                   Version: 1
                 Configuration:
                   S3Bucket: my-source-bucket
                   S3ObjectKey: source.zip
                 OutputArtifacts:
                   - Name: SourceOutput
           - Name: Build
             Actions:
               - Name: BuildAction
                 ActionTypeId:
                   Category: Build
                   Owner: AWS
                   Provider: CodeBuild
                   Version: 1
                 InputArtifacts:
                   - Name: SourceOutput
   

   • What this does:
     • Creates a pipeline with two stages: Source (pulling from S3) and Build (using CodeBuild).
   • Outcome: You can deploy this YAML file to create a fully functional pipeline.

Parallel Actions

AWS CodePipeline allows multiple actions to run concurrently within a stage, which can significantly reduce pipeline execution time. This is especially useful for large projects or multi-region deployments.

Use Cases for Parallel Actions

1. Running Multiple Tests: Execute unit, integration, and performance tests simultaneously.
2. Deploying to Multiple Regions: Deploy an application to several AWS regions at the same time.

How to Configure Parallel Actions

1. Define multiple actions within a single stage in your pipeline configuration.
2. These actions will execute in parallel by default.

Example: Running Tests in Parallel

{
  "name": "TestStage",
  "actions": [
    {
      "name": "UnitTests",
      "actionTypeId": {
        "category": "Test",
        "owner": "AWS",
        "provider": "CodeBuild",
        "version": "1"
      },
      "inputArtifacts": [{ "name": "BuildOutput" }]
    },
    {
      "name": "IntegrationTests",
      "actionTypeId": {
        "category": "Test",
        "owner": "AWS",
        "provider": "CodeBuild",
        "version": "1"
      },
      "inputArtifacts": [{ "name": "BuildOutput" }]
    }
  ]
}

In AWS Console:

1. Edit your pipeline
2. In your chosen stage, click “+ Add action group”
3. Configure the new action
4. For “Run order,” use the same number as another action to run them in parallel
5. If you set different run order numbers, actions will run sequentially in that order

• What this does:
  • Executes both UnitTests and IntegrationTests simultaneously.
• Outcome: Reduced overall testing time.

Example: Multi-Region Deployment

• Deploy the same application to us-east-1 and eu-west-1 concurrently.

{
  "name": "DeployStage",
  "actions": [
    {
      "name": "DeployToUSEast1",
      "actionTypeId": {
        "category": "Deploy",
        "owner": "AWS",
        "provider": "ElasticBeanstalk",
        "version": "1"
      },
      "configuration": {
        "ApplicationName": "MyApp",
        "EnvironmentName": "ProdUSEast1"
      }
    },
    {
      "name": "DeployToEUWest1",
      "actionTypeId": {
        "category": "Deploy",
        "owner": "AWS",
        "provider": "ElasticBeanstalk",
        "version": "1"
      },
      "configuration": {
        "ApplicationName": "MyApp",
        "EnvironmentName": "ProdEUWest1"
      }
    }
  ]
}

• Outcome: The application is deployed to multiple regions simultaneously, ensuring global availability.

Security and Best Practices

Security is a critical aspect of any CI/CD workflow, especially when working with AWS CodePipeline. By adhering to best practices, you can ensure your pipelines are secure, scalable, and maintainable.

1. IAM Roles and Permissions

IAM (Identity and Access Management) roles are used to grant the necessary permissions for CodePipeline to interact with other AWS services securely.

How to Securely Configure IAM Roles for CodePipeline

• Each pipeline should have its own IAM role with only the permissions it needs to function. This is called the least privilege principle.

Example: Creating a Role for CodePipeline

1. Create an IAM role in the AWS Management Console.
2. Attach the AWSCodePipelineFullAccess policy.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["codepipeline:*", "s3:*", "codebuild:*", "codedeploy:*"],
      "Resource": "*"
    }
  ]
}

• What it does:
  This allows the pipeline to manage CodePipeline, S3 (for artifacts), CodeBuild, and CodeDeploy resources.

• Outcome: The pipeline can perform necessary actions without needing overly broad permissions.

2. Securing Source Repositories

Your source repository (e.g., GitHub, AWS CodeCommit) is the starting point of your pipeline. A security breach here could compromise your entire workflow.

Using HTTPS and SSH for Secure Repository Access

• HTTPS: Ensures data transmitted between your repository and AWS is encrypted.
• SSH: Provides an additional layer of security using keys.

Example: Connecting AWS CodePipeline to GitHub via HTTPS

1. Generate a personal access token in GitHub with the necessary repository permissions.
2. Use the token as credentials when setting up your pipeline’s source stage.

curl -u "username:token" https://api.github.com/user/repos

• What it does:
  Authenticates securely with GitHub and lists your repositories.

Multi-Factor Authentication (MFA) for AWS Accounts

Enabling MFA adds an extra layer of security to your AWS account.

• MFA requires you to enter a one-time code generated on your phone in addition to your password.

How to Enable MFA:

1. Go to the IAM Dashboard.
2. Select your user, and click Manage MFA.
3. Follow the steps to set up a virtual MFA device.

• Outcome: Even if someone steals your password, they cannot access your AWS account without the MFA code.

3. Best Practices

Adopting best practices helps make pipelines more organized, scalable, and easier to maintain.

Naming Conventions for Pipelines

• Use meaningful names that reflect the purpose of the pipeline.
  Example:
  • project-name-environment-stage
  • For a production deployment pipeline: ecommerce-prod-deploy

Structuring Pipelines for Clarity and Scalability

• Separate Pipelines for Environments:
  Maintain different pipelines for development, staging, and production to avoid accidental deployments to the wrong environment.

• Break Down Complex Pipelines:
  For a large application, consider splitting the pipeline into smaller ones based on services (e.g., frontend pipeline, backend pipeline).

Regularly Updating and Reviewing Pipeline Configurations

• Pipelines should evolve with your application.
  • Why? AWS services, security policies, and application dependencies change over time.

Example: Automating Pipeline Updates with AWS CLI

aws codepipeline update-pipeline --cli-input-json file://pipeline-config.json

• What it does:
  Updates the pipeline configuration with the details in pipeline-config.json.

• Outcome: You can maintain pipeline configurations as code and apply changes consistently.

Example Workflow: Applying Best Practices

Let’s assume you are deploying a photo-sharing app with a CodePipeline setup.

1. IAM Role:
   Create a role with the least privilege that allows CodePipeline to access S3 (for storing artifacts) and ECS (for deployment).

   {
     "Action": ["s3:GetObject", "ecs:UpdateService"],
     "Effect": "Allow",
     "Resource": "*"
   }
   

2. Source Repository Security:
   Use HTTPS with GitHub and enable MFA on your AWS account.

3. Pipeline Structure:

   • Separate pipelines for dev and prod.
   • Add a manual approval stage in the prod pipeline to prevent unintended deployments.

4. Monitoring and Updating:
   Regularly review permissions, update the source repository token, and ensure the pipeline integrates with the latest AWS services.

Layman Example:

Imagine you’re managing a house with several keys (one for the front door, one for the garage, etc.). Giving out a master key to everyone (broad permissions) is risky. Instead, you give each person just the key they need (least privilege). Similarly, you install a doorbell camera (MFA) to ensure visitors are legitimate. Periodically, you check if any locks need updating (pipeline review) to keep the house secure.

Troubleshooting and Monitoring

When working with AWS CodePipeline, things might not always go as planned. Whether it’s authentication issues, pipeline actions failing, or debugging logs, understanding how to troubleshoot and monitor your pipeline effectively is crucial.

1. Common Errors and Fixes

Errors can occur at different stages of the pipeline. Understanding what could go wrong and how to fix it is key to maintaining a smooth pipeline.

Authentication Issues with Repositories

One of the most common issues in a CodePipeline is authentication errors when connecting to source repositories (e.g., GitHub, CodeCommit).

What are common causes of authentication errors?

• Expired access tokens: If you’re using GitHub, your personal access token might expire, causing authentication failures.
• Invalid credentials: Incorrect repository credentials (like an incorrect username/password or access keys) can cause issues.

How to fix authentication errors:

1. For GitHub:
   Regenerate the personal access token from GitHub and update the connection in your CodePipeline source stage.

   git remote set-url origin https://<username>:<new-token>@github.com/username/repository.git
   

2. For AWS CodeCommit:
   Update the credentials used in the pipeline by creating a new set of AWS IAM credentials and configuring them in the pipeline.

• Outcome: These steps ensure your repository is accessible to the pipeline, allowing the source stage to function correctly.

Troubleshooting Failed Actions in Pipelines

An action in a pipeline may fail due to a variety of reasons such as misconfigured permissions, incorrect build settings, or resource issues.

What are the common causes of failed actions?

• IAM permissions: Lack of necessary permissions for the action to execute.
• Failed build process: If the build process fails (e.g., due to errors in the buildspec.yml file).

How to fix failed actions:

1. IAM permissions fix:

   • Ensure the IAM role associated with the pipeline has the correct permissions to interact with the required AWS services (like CodeBuild, S3, etc.).

   Example IAM permissions for CodePipeline:

   {
     "Effect": "Allow",
     "Action": [
       "codebuild:StartBuild",
       "s3:GetObject",
       "codedeploy:CreateDeployment"
     ],
     "Resource": "*"
   }
   

2. Build failure fix:

   • Check the build logs to see if there were any issues in the buildspec.yml file. For instance, if there’s an error in the build script, the pipeline will fail.

   • You can find logs under CodeBuild logs in the AWS console to understand what went wrong.

• Outcome: Fixing permissions or resolving build errors will ensure your pipeline actions proceed smoothly.

2. Using AWS CloudWatch

AWS CloudWatch is a powerful tool to monitor your pipeline and track metrics for performance and errors. It integrates seamlessly with CodePipeline to provide visibility into your pipeline’s operations.

Setting up CloudWatch to Monitor Pipeline Activity

To start using CloudWatch for monitoring your pipeline, you need to create custom metrics or use the default ones provided by AWS.

How to set up CloudWatch monitoring:

1. Enable CloudWatch Logs for Pipeline:
   In the pipeline configuration, enable CloudWatch logging for every stage you want to monitor.

   Example for enabling logging in a CodeBuild action:

   {
     "actions": [
       {
         "name": "BuildAction",
         "actionTypeId": {
           "category": "Build",
           "owner": "AWS",
           "provider": "CodeBuild",
           "version": "1"
         },
         "configuration": {
           "ProjectName": "myCodeBuildProject"
         },
         "runOrder": 1,
         "outputArtifacts": [
           {
             "name": "BuildOutput"
           }
         ],
         "inputArtifacts": [
           {
             "name": "SourceOutput"
           }
         ],
         "cloudWatchLogsEnabled": true
       }
     ]
   }
   

2. Viewing CloudWatch Logs: Once CloudWatch is enabled, you can view the logs through the AWS CloudWatch Console under Logs > Log Groups > your specific log stream.

• What it does:
  This sends the pipeline’s log data (e.g., build logs, deployment logs) to CloudWatch, where you can monitor and troubleshoot more easily.

• Outcome: CloudWatch helps you track performance metrics and errors, allowing for quick diagnosis and resolution of issues.

Viewing Logs for Debugging Pipeline Stages

If your pipeline is failing at a specific stage, logs are the first place you should check. Logs provide detailed information on why a failure occurred.

How to view pipeline logs for debugging:

1. Go to AWS CodePipeline in the console.
2. Select your pipeline and click on the failed action.
3. Under Details, you will find an option to view the logs from CloudWatch or CodeBuild (depending on the failed action).

• What it does:
  Viewing the logs helps identify the root cause of failures, whether it’s a failed test, a broken build, or an issue with deployment configurations.

• Outcome: You can quickly pinpoint issues and take the necessary steps to fix them, saving time and effort.

3. Pipeline Execution History

AWS CodePipeline provides an Execution History feature that stores past pipeline executions, allowing you to view detailed logs and understand what happened during each execution.

What is Pipeline Execution History?

It’s a historical record of all your pipeline executions, including information about success, failure, and the time each stage was executed. This helps track the progress of a pipeline over time and assists in debugging issues that might have occurred in past executions.

How to use Pipeline Execution History:

1. Go to CodePipeline in the AWS console.
2. In your pipeline, click on History to see past executions.
3. Review each execution’s status (success, failure, or in-progress) and click on failed executions for detailed logs.

• What it does:
  This feature allows you to review past pipeline runs, which is helpful for debugging and understanding the long-term health of your pipeline.

• Outcome: You can trace the history of a pipeline to see which actions passed or failed, making it easier to identify recurring issues.

Layman Example:

Imagine you’re baking a cake using a recipe (CodePipeline). If the cake fails to rise (the pipeline fails), you might look at the recipe (CloudWatch logs) to see what went wrong. Maybe you missed an ingredient (incorrect permissions) or the oven (CodeBuild) was set to the wrong temperature. By reviewing the recipe (pipeline history), you can figure out where things went off track and fix it before your next bake.

Real-World Use Cases

1. Deploying a Multi-Tier Web Application

A multi-tier web application typically has three layers:

• Frontend (User Interface): The part users see, like a website or app interface.
• Backend (Logic Layer): The “brain” that processes user requests.
• Database: Stores and retrieves data, like user details or product information.

Example: Setting Up a Pipeline for Frontend, Backend, and Database

Scenario: You’re deploying an e-commerce application. It has:

• A React-based frontend.
• A Node.js backend for handling API requests.
• A MySQL database for managing user and order data.

1. Pipeline Stages:

   • Source: Pull the latest code from repositories (e.g., GitHub).
   • Build: Use AWS CodeBuild to compile the frontend and backend code.
   • Test: Run automated tests (e.g., unit tests for the backend).
   • Deploy: Deploy the components to different environments.

2. Commands and Explanation:

   • Frontend Build:

     npm install && npm run build
     

     • What it does:
       Installs dependencies (npm install) and compiles the React code into static files (npm run build) ready for deployment.

   • Backend Build:

     npm install
     zip -r backend.zip .
     

     • What it does:
       Installs backend dependencies and packages the code into a ZIP file for deployment.

3. Database Deployment:

   • Use AWS RDS to provision a MySQL database. Use a migration tool (e.g., Flyway) to set up database tables.

     flyway -url=jdbc:mysql://<rds-endpoint> -user=<db-user> -password=<db-password> migrate
     

     • What it does:
       Connects to the database and applies migration scripts to create or update the schema.

Outcome:

The pipeline ensures that all three layers (frontend, backend, and database) are built, tested, and deployed seamlessly. Changes to the code automatically flow through the pipeline.

2. Blue-Green Deployments with CodePipeline

Blue-green deployment is a technique to reduce downtime and risk during software updates. Here’s how it works:

• Blue Environment: The existing live version of your application.
• Green Environment: The new version you are deploying.

How CodePipeline Supports Blue-Green Deployments

AWS CodePipeline integrates with AWS Elastic Beanstalk and AWS CodeDeploy to handle traffic switching between environments.

1. Example Scenario: Switching Traffic During Deployments

   • Task: You want to deploy a new version of your app but need to ensure users experience no downtime.
   • Steps:
     • Set up two Elastic Beanstalk environments: one for Blue (current) and one for Green (new).
     • Use AWS CodeDeploy’s deployment configuration for traffic shifting.

2. Configuration File for Traffic Shifting:

   {
     "deploymentStyle": {
       "deploymentType": "BLUE_GREEN",
       "deploymentOption": "WITH_TRAFFIC_CONTROL"
     }
   }
   

   • What this does:
     Instructs CodeDeploy to route traffic from the Blue environment to the Green environment gradually or instantly.

Outcome:

CodePipeline ensures the new version is tested in the Green environment before switching live traffic. If something goes wrong, traffic can revert to the Blue environment.

Real-Life Example:

An online store deploys a new payment feature using this approach. Users won’t notice downtime, and the team can quickly roll back if the payment feature fails.

3. Using CodePipeline for Microservices

Microservices architecture involves splitting an application into small, independent services (e.g., user service, payment service, order service). Each service has its own pipeline.

Managing Multiple Microservices with Separate Pipelines

1. Scenario:
   Imagine a food delivery app with these services:

   • User Service: Manages user authentication.
   • Order Service: Handles food orders.
   • Notification Service: Sends order updates.

2. Pipeline Design for Each Microservice:

   • Each service has its own repository, build process, and deployment logic.
   • Dependencies are managed via versioning. For example:
     • User Service v1.0 works with Notification Service v1.0 but not v2.0.

3. Best Practices for Dependency Management:

   • Use a shared artifact repository (e.g., AWS CodeArtifact) to store and share versioned builds.
   • Set up integration tests between services.

Example: Deploying Independent Microservices

1. User Service Pipeline:

   • Source: Pulls code from GitHub.

   • Build: Packages the service into a Docker image.

     docker build -t user-service:latest .
     docker push <ecr-repo-url>/user-service:latest
     

     • What this does:
       Creates a Docker image of the service and pushes it to Amazon ECR.

   • Deploy: Runs the image on an ECS cluster.

2. Order Service Pipeline:

   • Follows the same steps but deploys independently.

Handling Inter-Service Dependencies

• Use Case: The Order Service depends on the User Service.
• Solution: Add an integration test stage in the pipeline to ensure compatibility.

Outcome:

Microservices pipelines allow independent deployments, enabling faster updates and better scalability. Each service can be updated without affecting others.

Conclusion

In this section, we’ll recap the benefits of using AWS CodePipeline and provide some encouragement for implementing pipelines in your own projects. Additionally, we’ll offer resources to further deepen your understanding and help you get hands-on experience with AWS CodePipeline.

1. Recap the Benefits of Using AWS CodePipeline

AWS CodePipeline is a powerful tool that can help automate and streamline the software delivery process. By integrating various AWS services and third-party tools, CodePipeline allows you to automate each step of your deployment process—from code commits to production deployment. Some key benefits include:

• Automation: AWS CodePipeline automates the entire software release lifecycle, saving time and reducing manual errors.
• Faster Time-to-Market: By continuously building, testing, and deploying code, CodePipeline helps speed up the delivery of new features and bug fixes.
• Scalability: It supports large-scale applications with multiple teams working in parallel, making it easy to scale your pipeline as your needs grow.
• Integration with AWS and Third-Party Services: CodePipeline integrates with other AWS services like CodeBuild, Lambda, and Elastic Beanstalk, and third-party services such as GitHub and Jenkins.

(Why is automation so important in software development?)
Automation reduces human error, increases efficiency, and ensures that processes are consistently followed. In simple terms, it’s like having a robot that does all the repetitive tasks for you, which frees up your time for more creative work.

2. Encourage Readers to Implement a Pipeline in Their Projects

By now, you’ve learned the core concepts of AWS CodePipeline, including how it can automate the build, test, and deployment phases of your projects. Implementing a pipeline might seem daunting at first, but it will pay off in the long run by:

• Reducing manual effort: Once your pipeline is set up, it will handle tasks like building, testing, and deploying code automatically, which saves time and effort.
• Improving code quality: Automated tests and consistent deployments reduce the chances of introducing bugs or errors into production.
• Ensuring faster feedback: With each change made to the codebase, you get instant feedback on whether the code passes tests and is ready to be deployed, which accelerates the development cycle.

(How can starting a pipeline improve your workflow?)
Imagine you are assembling a product with multiple parts. Instead of manually checking each part every time, you create an assembly line where the parts automatically get checked for quality as they pass through. This makes the process faster and ensures that every part is correctly assembled. Similarly, setting up a CodePipeline improves your development flow by automating repetitive tasks.

3. Provide Additional Resources

To help you dive deeper into AWS CodePipeline, here are some valuable resources:

• AWS CodePipeline Documentation
  The official documentation provides detailed information on every aspect of CodePipeline, from basic setup to advanced configurations. It’s an excellent resource for learning more about specific actions, services, and best practices.

• AWS Developer Blog
  The AWS Developer Blog is packed with articles, tutorials, and updates on various AWS tools, including CodePipeline. It’s a great way to stay up-to-date with new features and get practical tips from AWS experts.

• Tutorials and Videos for Hands-On Learning
  AWS provides a range of tutorials and videos to help you get hands-on experience. Some great places to check out are:

  • AWS Training and Certification
  • AWS YouTube Channel (for video tutorials on using CodePipeline and other AWS services)

(How do these resources help you?)
Think of these resources as tools in your toolbox. The documentation gives you the full guide, the blog keeps you updated with the latest trends, and the tutorials offer a hands-on approach to learning. Together, they help you build a solid foundation and expand your knowledge.

Summary and Final Thoughts

To summarize, AWS CodePipeline is a robust tool that helps automate your software delivery lifecycle. It’s designed to make deployments faster, more reliable, and easier to manage. Whether you’re a beginner or an experienced developer, CodePipeline can help streamline your development process.

By leveraging the resources provided and starting to build your own pipeline, you’ll quickly realize how much time and effort you save, allowing you to focus on what truly matters—building great software!

References and Resources

• AWS CodePipeline Documentation
• AWS CodePipeline Blog
• AWS CodePipeline GitHub Repository