What is a Blue-Green Deployment?

Blue-green deployment is a deployment strategy that reduces downtime and risk by running two separate environments (“blue” and “green”).

• Blue Environment: Represents the live, currently running version of the application.
• Green Environment: Contains the new version of the application to be deployed.

With this approach:

• The load balancer initially directs all traffic to the blue environment.
• Once the green environment is ready and tested, traffic is switched to the green environment.
• If issues arise, traffic can be quickly reverted to the blue environment.

This strategy eliminates downtime and provides a quick rollback mechanism.

Why Use Blue-Green Deployments?

Blue-green deployments offer several advantages:

1. Minimized Downtime: Traffic switching between environments is instantaneous.
2. Rollback Capability: Returning to the previous version is as simple as switching traffic back.
3. Improved Testing: The green environment can be fully tested in production conditions before it goes live.
4. Safer Updates: Reduces the risk of catastrophic failure by isolating new changes.

ECS and ALB: Key Components for Blue-Green Deployments

Amazon ECS

Amazon ECS is a fully managed container orchestration service. It helps deploy, manage, and scale containerized applications seamlessly. ECS supports two launch types:

1. EC2 Launch Type: Run containers on a cluster of Amazon EC2 instances.
2. Fargate Launch Type: Serverless model where AWS manages the infrastructure.

Application Load Balancer (ALB)

ALB is a Layer 7 load balancer designed to route HTTP/HTTPS traffic. It offers advanced routing mechanisms, such as host-based and path-based routing, making it ideal for blue-green deployments.

Implementing Blue-Green Deployments with ECS and ALB

Here’s how to set up blue-green deployments using ECS and ALB:

1. Create ECS Services

In a blue-green deployment, you’ll have two ECS services:

• Blue Service: Running the current version of your application.
• Green Service: Running the new version of your application.

Each service should have its own task definition, defining container image, resources, and environment variables.

Steps:

1. Define Task Definitions: Create separate task definitions for the blue and green versions. Specify the Docker image version and other configurations.
2. Set Up Services: Deploy the blue service and verify it’s functioning as expected. Create the green service, pointing to the new task definition.

2. Configure the Application Load Balancer

The ALB will manage traffic routing between the blue and green environments. Use target groups to direct traffic.

Steps:

1. Create Target Groups: Blue Target Group: Points to the blue ECS service. Green Target Group: Points to the green ECS service.
2. Set Up Listeners: Configure ALB listeners to route traffic to the target groups. Example: A listener on port 80 routes traffic to either the blue or green target group.
3. Health Checks: Configure health checks for each target group to ensure traffic is directed only to healthy tasks.

3. Deploy the Green Environment

1. Update the Task Definition: Modify the green task definition to point to the new version of the container image. Deploy the updated green service.
2. Test the Green Environment: Use a separate URL or ALB rules to test the green service without affecting live traffic.

4. Switch Traffic to the Green Environment

1. Modify the Listener Rule: Update the ALB listener rule to route traffic from the blue target group to the green target group.
2. Monitor Performance: Use Amazon CloudWatch or ALB metrics to monitor the green environment’s performance.

5. Rollback if Necessary

If issues occur with the green environment:

1. Update the listener rule to revert traffic to the blue target group.
2. Debug and fix issues in the green environment before attempting another deployment.

Automating Blue-Green Deployments with AWS CodeDeploy

AWS CodeDeploy can automate blue-green deployments for ECS services. With CodeDeploy:

1. Create an Application and Deployment Group: Define the ECS services and ALB target groups.
2. Set Up Deployment Configurations: Specify traffic shifting settings, like linear or all-at-once.
3. Run Deployments: CodeDeploy automatically updates the green environment, shifts traffic, and monitors health metrics.

Best Practices for Blue-Green Deployments

1. Automate the Process: Use AWS CodeDeploy, CI/CD pipelines, or custom scripts to reduce manual steps.
2. Monitor Metrics: Use CloudWatch and ALB health checks to monitor application performance.
3. Test Thoroughly: Validate the green environment before switching traffic.
4. Implement Incremental Traffic Shifting: Gradually shift traffic to the green environment to detect issues early.
5. Plan Rollbacks: Always have a rollback strategy to minimize risks.

Conclusion

Blue-green deployments with ECS and ALB provide a robust, scalable solution for deploying containerized applications with minimal risk and downtime. By leveraging AWS’s powerful tools, you can automate and optimize the deployment process, ensuring seamless transitions between application versions. Whether you’re running a small application or a large-scale system, this strategy empowers you to deliver updates confidently and reliably.

The post Blue-Green Deployments with ECS and Application Load Balancers appeared first on Rambunct Consulting.

By the end of this blog, you’ll have a fully automated CI/CD pipeline that pulls code from GitHub, builds a Docker image, pushes it to ECR, and deploys it to ECS using AWS CodePipeline.

Step 1: Setting Up the AWS Infrastructure

Before we dive into the pipeline setup, we first need to configure the necessary AWS services that will handle our containerized application: Amazon ECR, Amazon ECS, and AWS CodePipeline.

1.1: Create an Amazon ECR Repository

Amazon ECR (Elastic Container Registry) is a fully managed Docker container registry where you can store, manage, and deploy Docker images. Follow these steps to create a repository:

1. Go to the ECR Console.
2. Click on Create Repository.
3. Enter a name for your repository (e.g., rambunct-demo).
4. Choose whether you want the repository to be public or private (private is the default).

After creation, you’ll get a repository URI, which looks something like this:
aws_account_id.dkr.ecr.us-east-1.amazonaws.com/rambunct-demo

1. This is the URI you will use to tag and push Docker images from CodeBuild to ECR.

1.2: Create an ECS Cluster, Task and Service

Now that we have an ECR repository, let’s set up Amazon ECS (Elastic Container Service), which will manage and deploy our containers.

1. Go to ECS Console, click Create Cluster.
2. Select Fargate as the launch type.
3. Provide a cluster name (e.g., demo-rambunct) and click Create.
4. In ECS Console, go to Task Definitions and click Create new Task Definition.
5. Choose Fargate as the launch type.
6. Set task name, provide ECR image URI, and set port mapping (3000).
7. Choose memory and CPU settings, then click Create.
8. Go to your cluster, click Create under Services.
9. Select Fargate, task definition, and service name.

1.3: Set Up IAM Roles and Permissions

Before we proceed, ensure you have the correct IAM roles with the required permissions for CodePipeline, CodeBuild, and ECS to interact with each other.

Step 2: Set Up CodePipeline with GitHub, CodeBuild, and ECS

Now that the infrastructure is set up, we can create CodePipeline, which automates the CI/CD process. GitHub will serve as the source for the application code, CodeBuild will build the Docker image, and ECS will deploy it.

2.1: Set Up the Source Stage (GitHub)

In the Source stage, we will configure AWS CodePipeline to pull code from GitHub. This is where your application code and Dockerfile are stored.

Dockerfile example

# Use Python base image FROM python:3.9-slim # Set the working directory inside the container WORKDIR /app # Copy the requirements file COPY requirements.txt . # Install dependencies (Flask in this case) RUN pip install -r requirements.txt # Copy the rest of the application code COPY . . # Expose port 3000 for the Flask app EXPOSE 3000 # Start the Flask application CMD [“python”, “app.py”]

app.py example

from flask import Flask app = Flask(__name__) @app.route(‘/’) def hello(): return “Hello Rambunct” if __name__ == ‘__main__’: app.run(host=’0.0.0.0′, port=3000)

1. Go to the CodePipeline Console and click Create Pipeline.
2. Enter a name for your pipeline (e.g., rambunct-demo-pipeline).
3. For the Source provider, choose GitHub and connect your GitHub account.
4. Select the repository and branch (e.g., main) that contains your Dockerfile and application code.

2.2: Set Up the Build Stage (CodeBuild)

Next, we will configure AWS CodeBuild to build the Docker image from the Dockerfile stored in GitHub and push the image to ECR.

1. In the build provider select other build providers and AWS CodeBuild.
2. Select create a project and provide the service role with access to ECR.
3. Set buildspec.yml as the buildspec file (this will be used to define the build steps).
   The buildspec.yml file tells CodeBuild how to build the Docker image and push it to ECR. Here’s an example buildspec.yml:

2.3: Set Up the Deploy Stage (Amazon ECS)

The Deploy stage will deploy the Docker image from ECR to ECS.

1. In CodePipeline, for the Deploy stage, choose Amazon ECS as the deploy provider.
2. Select your ECS Cluster and Service.
3. Configure the Task Definition to reference the Docker image in ECR (aws_account_id.dkr.ecr.us-east-1.amazonaws.com/rambunct-demo:latest).
4. Use the imagedefinitions.json file generated in the Build stage as the input artifact.

Step 3: Monitor and Test the Deployment

Once everything is set up, you can trigger the pipeline by pushing code to the GitHub repository or manually starting the pipeline.

CodePipeline will

1. Pull the latest code and Dockerfile from GitHub.
2. Use CodeBuild to build the Docker image and push it to ECR.
3. Deploy the image to ECS.

You can monitor and troubleshoot the deployment using:

• ECS Console: View the status of your ECS tasks and services.
• Amazon CloudWatch Logs: Check the logs generated by your ECS containers.
• CloudWatch Alarms: Set alarms to notify you of failures or performance issues in ECS.

You can also view the output using the HTTP link

Conclusion

By combining Amazon ECS, ECR, GitHub, and CodePipeline, you can create a streamlined and automated deployment pipeline for your containerized applications. This CI/CD pipeline ensures that whenever new code is committed to GitHub, it is automatically built, pushed to ECR, and deployed to ECS. With this setup, you can focus on developing features while CodePipeline handles the building, pushing, and deployment process.

The post Streamlining Containerised Web Application Deployment with Amazon ECS, Amazon ECR, GitHub, and AWS CodePipeline: A Complete Guide appeared first on Rambunct Consulting.