Supercharge Software Delivery: Mastering CI/CD with Jenkins, AWS ECR, and ECS

Praveen Dandu
9 min readAug 7


Introduction to CI/CD Pipelines

In the fast-paced world of software development, delivering high-quality applications quickly and efficiently is essential. Continuous Integration and Continuous Deployment (CI/CD) pipelines have emerged as crucial tools in modern software development practices. These pipelines automate the process of building, testing, and deploying code, making it easier for development teams to collaborate, integrate changes, and release software with confidence.

The Significance of CI/CD Pipelines

The Software Development Life Cycle (SDLC) with CI/CD

The Software Development Life Cycle (SDLC) encompasses all the stages involved in creating and deploying software. When combined with CI/CD, the SDLC becomes a streamlined process, integrating development, testing, and deployment at every step. CI ensures that each code change is automatically integrated into the shared codebase, and CD automates the release and deployment processes, leading to faster time-to-market and reduced risks associated with manual interventions.

The Difference Between CI and CD

Continuous Integration (CI) refers to the practice of automatically integrating code changes into the main repository multiple times a day. The primary goal of CI is to detect integration issues early and ensure that the codebase is always in a stable state. On the other hand, Continuous Deployment (CD) takes the process a step further by automatically deploying code changes to production or a production-like environment. CD minimizes the time gap between writing code and making it available to users, increasing the speed of software delivery.

Understanding CI/CD Pipelines

CI/CD Pipeline Overview

A CI/CD pipeline is a set of automated steps that code changes go through, starting from version control system commits and ending with deployment. The pipeline typically consists of the following stages:

  • Code Checkout: The pipeline fetches the latest code changes from the version control system, such as GitHub.
  • Build: The code is compiled and built into executable artifacts.
  • Test: Automated tests are executed to verify the quality and functionality of the code.
  • Deploy: If all tests pass, the code is deployed to a staging environment for further testing.
  • Release: The approved code changes are deployed to the production environment.

The Role of Jenkins in CI/CD Pipelines

Jenkins is a widely used open-source automation server that plays a vital role in setting up and managing CI/CD pipelines. It offers a flexible and extensible platform for automating various stages of the software development process. Jenkins provides a user-friendly interface for configuring pipelines and integrates seamlessly with popular version control systems like GitHub.

Setting up a CI/CD Pipeline using Jenkins


  • A GitHub account for version control.
  • A DockerHub account for hosting Docker images.
  • An Amazon Web Services (AWS) account with Elastic Container Registry (ECR) and Elastic Container Service (ECS) set up.

Jenkins Installation

Below is a code snippet that outlines the installation process for Jenkins on an Ubuntu Linux machine

# Step 1: Update package index and install necessary dependencies
sudo apt-get update
sudo apt-get install -y openjdk-8-jdk

# Step 2: Add the Jenkins repository key to the system
wget -q -O - | sudo apt-key add -

# Step 3: Add the Jenkins repository to the system
sudo sh -c 'echo deb binary/ > /etc/apt/sources.list.d/jenkins.list'

# Step 4: Update the package index again
sudo apt-get update

# Step 5: Install Jenkins
sudo apt-get install -y jenkins

# Step 6: Start Jenkins service
sudo systemctl start jenkins

# Step 7: Enable Jenkins to start on boot
sudo systemctl enable jenkins

Please note that this code assumes you are using an Ubuntu Linux distribution. If you are using a different operating system, the installation steps may vary. Additionally, it’s essential to refer to the official Jenkins documentation for the most up-to-date installation instructions for your specific environment

Jenkins Configuration

Below is a code snippet that outlines the steps to configure Jenkins with GitHub integration and necessary plugins:

# Step 1: Access Jenkins Web UI
Once Jenkins is installed and running, access the Jenkins web interface by navigating to http://your-server-ip:8080 in your web browser.

# Step 2: Unlock Jenkins
On the initial setup, you'll be prompted to unlock Jenkins. Follow the instructions on the screen to retrieve the initial admin password from the server.

# Step 3: Install Recommended Plugins
Select "Install suggested plugins" to install the recommended plugins for Jenkins. This will include essential plugins for version control, build tools, and integrations.

# Step 4: Set up Admin User
Create an admin user by providing the required details (username, password, full name, email) in the subsequent screen.

# Step 5: Configure Jenkins URL (Optional)
If you're using a reverse proxy or have a specific Jenkins URL, you can set it up in the next screen. Otherwise, you can continue with the default settings.

# Step 6: Jenkins Home Page
You'll be redirected to the Jenkins home page after the setup is complete.

# Step 7: Install GitHub Plugin
To integrate Jenkins with GitHub, you need to install the GitHub plugin. Follow these steps to install it:
1. Click on "Manage Jenkins" in the left-hand menu.
2. Select "Manage Plugins" from the dropdown list.
3. In the "Available" tab, search for "GitHub Integration" or "GitHub" plugin.
4. Check the checkbox next to the "GitHub Integration" plugin.
5. Click "Install without restart" to install the plugin.

# Step 8: Configure GitHub Credentials
To interact with your GitHub repositories, Jenkins needs credentials. Follow these steps to add your GitHub credentials to Jenkins:
1. Click on "Manage Jenkins" in the left-hand menu.
2. Select "Manage Credentials" from the dropdown list.
3. Click on "Global" domain.
4. Click "Add Credentials" on the left-hand side.
5. Choose "Username with password" from the "Kind" dropdown.
6. Enter your GitHub username and password.
7. Optionally, provide a unique ID and description for the credentials.
8. Click "OK" to save the credentials.

# Step 9: Configure Jenkins System Settings (Optional)
Depending on your requirements, you may need to configure additional system settings, such as email notifications, security settings, etc. This step is optional and can be done through the "Manage Jenkins" > "Configure System" section.

# Step 10: Test GitHub Integration
To ensure that Jenkins is properly integrated with GitHub, you can create a sample Jenkins job that fetches code from your GitHub repository and executes a simple build.

Congratulations! You have successfully configured Jenkins with GitHub integration and necessary plugins. Now, you can proceed to create your CI/CD pipeline and automate the deployment process for your projects.

Creating the CI/CD Pipeline in Jenkins

Creating a CI/CD pipeline in Jenkins involves defining the pipeline stages and steps using a Jenkinsfile. The Jenkinsfile is a Groovy script that lives in the root of your project’s version control repository. It defines the entire pipeline and automates the process from code checkout to deployment. Below is an outline of the steps to create the pipeline:

Step 1: Create a Jenkinsfile
Create a Jenkinsfile in the root directory of your project. The Jenkinsfile will define the pipeline using the “Pipeline DSL” syntax. The Jenkinsfile should be committed to your version control repository (e.g., GitHub).

Step 2: Define Pipeline Stages
Inside the Jenkinsfile, define the pipeline stages that reflect the SDLC with CI/CD. Common stages include “Checkout,” “Build,” “Test,” “Deploy,” and “Release.” You can also customize the pipeline stages based on your specific project requirements.

Step 3: Code Checkout
In the “Checkout” stage, configure Jenkins to fetch the latest code from the GitHub repository using your GitHub credentials. This ensures that the pipeline always operates on the latest codebase.

Step 4: Build
In the “Build” stage, specify the build steps required for your project. This may include compiling code, generating artifacts, or packaging your application.

Step 5: Test
In the “Test” stage, define automated tests to be executed on your code. These tests should verify the functionality, performance, and quality of your application.

Step 6: Deploy (to Staging)
In the “Deploy” stage, configure Jenkins to deploy the built artifacts to a staging environment for further testing. This environment should closely resemble the production environment to identify any issues early.

Step 7: Release (to Production)
In the “Release” stage, automate the process of promoting the tested code from the staging environment to the production environment. This step may involve additional approval processes or checks to ensure a safe release.

Step 8: Error Handling and Cleanup (Optional)
Consider adding error handling and cleanup steps to the pipeline to handle failures gracefully and clean up any temporary resources.

Step 9: Parallel and Conditional Execution (Optional)
Jenkins pipelines allow parallel execution of stages and conditional execution based on certain criteria. Utilize these features to optimize the pipeline and improve overall efficiency.

Step 10: Commit and Push Jenkinsfile
After defining the Jenkinsfile and configuring the pipeline stages, commit the Jenkinsfile to your version control repository and push the changes.

Step 11: Create Jenkins Pipeline Job
In the Jenkins web interface, create a new pipeline job and link it to the Jenkinsfile in your version control repository. Jenkins will automatically detect changes in the repository and trigger the pipeline accordingly.

Step 12: Test and Refine
Run the pipeline and monitor its execution. Debug any issues that arise and refine the pipeline as needed to ensure a smooth and efficient CI/CD process.

By following these steps and defining your pipeline as code using a Jenkinsfile, you can set up an automated CI/CD pipeline that integrates code changes, tests, and deploys your application seamlessly.

Real-world Example — Automating Docker Image Deployment to ECS

Step 1: Developer Commits Code to GitHub The developer writes code and commits it to the GitHub repository.

Step 2: Jenkins Fetches Commits and Triggers the Pipeline Jenkins continuously monitors the GitHub repository for changes. Upon detecting a new commit, it triggers the CI/CD pipeline.

Step 3: Building the Docker Image Jenkins fetches the code from GitHub, builds the Docker image using a Dockerfile, and tags it with a version number.

Step 4: Pushing Docker Image to ECR The newly built Docker image is pushed to the Amazon ECR, a secure and scalable container registry.

Step 5: Deploying the Docker Image to ECS Jenkins deploys the Docker image to Amazon ECS, an orchestration service that automates the deployment of containers.

Step 6: Post-Deployment Testing (Optional) If required, Jenkins can trigger automated tests on the deployed application to ensure its functionality and performance.

Below is a sample Jenkinsfile that demonstrates the steps to automate Docker image deployment to Amazon ECS:

pipeline {
agent any

stages {
stage('Checkout') {
steps {
// Step 1: Developer Commits Code to GitHub
// Jenkins automatically fetches the code from GitHub
checkout scm
stage('Build') {
steps {
// Step 3: Building the Docker Image
// Replace 'your-docker-image-name' with your Docker image name
sh 'docker build -t your-docker-image-name:${GIT_COMMIT} .'
stage('Push to ECR') {
environment {
// Step 4: Pushing Docker Image to ECR
// Replace 'your-aws-region', 'your-ecr-repo-name', and 'your-ecr-registry-id' with your AWS details
AWS_REGION = 'your-aws-region'
ECR_REPO_NAME = 'your-ecr-repo-name'
ECR_REGISTRY_ID = 'your-ecr-registry-id'
steps {
withCredentials([usernamePassword(credentialsId: 'aws-credentials-id', usernameVariable: 'AWS_ACCESS_KEY_ID', passwordVariable: 'AWS_SECRET_ACCESS_KEY')]) {
// Login to ECR
sh "aws ecr get-login-password --region ${AWS_REGION} | docker login --username AWS --password-stdin ${ECR_REGISTRY_ID}.dkr.ecr.${AWS_REGION}"

// Tag and Push the Docker image to ECR
sh "docker tag your-docker-image-name:${GIT_COMMIT} ${DOCKER_IMAGE_TAG}"
sh "docker push ${DOCKER_IMAGE_TAG}"
stage('Deploy to ECS') {
environment {
// Step 5: Deploying the Docker Image to ECS
// Replace 'your-ecs-cluster-name', 'your-ecs-service-name', and 'your-ecs-task-definition-name' with your ECS details
ECS_CLUSTER_NAME = 'your-ecs-cluster-name'
ECS_SERVICE_NAME = 'your-ecs-service-name'
ECS_TASK_DEFINITION_NAME = 'your-ecs-task-definition-name'
steps {
withCredentials([usernamePassword(credentialsId: 'aws-credentials-id', usernameVariable: 'AWS_ACCESS_KEY_ID', passwordVariable: 'AWS_SECRET_ACCESS_KEY')]) {
// Update ECS Service with the new task definition
sh "aws ecs update-service --region ${AWS_REGION} --cluster ${ECS_CLUSTER_NAME} --service ${ECS_SERVICE_NAME} --force-new-deployment"
stage('Post-Deployment Testing') {
steps {
// Step 6: Post-Deployment Testing (Optional)
// Implement your post-deployment tests here, if required

Please note that this Jenkinsfile assumes you have set up the necessary AWS credentials (Access Key ID and Secret Access Key) as a Jenkins credential with the ID ‘aws-credentials-id’. It also assumes you have already set up the ECS cluster, service, and task definition in your AWS account.

Remember to replace all placeholders (e.g., ‘your-docker-image-name’, ‘your-aws-region’, etc.) with your actual values specific to your project and AWS account.

This Jenkinsfile will automate the entire CI/CD process for your Dockerized application, deploying it to Amazon ECS upon successful builds.


CI/CD pipelines, when combined with tools like Jenkins, significantly enhance software development workflows by automating code integration, testing, and deployment. By setting up a CI/CD pipeline, developers can streamline the SDLC, detect issues early, and deliver high-quality applications with greater speed and reliability. This real-world example of automating Docker image deployment to Amazon ECS demonstrates the power and efficiency of CI/CD in modern software development practices.

Thank you for reading my blog! If you enjoyed the content and want to receive timely updates whenever I publish a new article, make sure to follow me on Medium. It’s quick and easy! Just log in to your Medium account (or create one if you haven’t already), visit my profile, and click the “Follow” button. Stay informed and never miss a new post! Your support means a lot to me, and I’m excited to continue sharing valuable insights with you. Happy reading! 🚀



Praveen Dandu

🚀 DevOps Engineer | Automating Infrastructure, Streamlining Deployments | Continuous Integration & Delivery Specialist