DEV Community: Shankar Thejaswi

Building and Releasing Dockerized Applications using Azure Pipelines

Shankar Thejaswi — Wed, 11 Jun 2025 07:54:41 +0000

Introduction

As containerized applications become the norm in modern DevOps workflows, having an automated CI/CD pipeline to build, test, and deploy Docker images is essential. Azure Pipelines — a part of Azure DevOps — provides a powerful, cloud-native platform to manage the entire lifecycle of your Docker applications, from source control to deployment.

In this blog, you'll learn how to:

Build Docker images in Azure Pipelines
Push them to Azure Container Registry (ACR) or Docker Hub
Deploy them to services like Azure Kubernetes Service (AKS)

Prerequisites

Before starting, ensure you have:

A Git repository (Azure Repos or GitHub)
Dockerfile in your app's root directory
Azure DevOps organization and project
Azure Container Registry (or Docker Hub) created

Step 1: Create an Azure Pipeline (YAML)

In your repo, create a azure-pipelines.yml file to define your pipeline steps.

Sample Pipeline to Build and Push Docker Image to Azure Container Registry (ACR):

trigger:
  branches:
    include:
      - main

variables:
  imageName: myapp
  registry: myacr.azurecr.io

stages:
- stage: Build
  jobs:
  - job: DockerBuild
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    - checkout: self

    - task: DockerInstaller@0
      inputs:
        dockerVersion: '20.10.7'

    - task: Docker@2
      inputs:
        containerRegistry: 'MyACRServiceConnection'
        repository: '$(imageName)'
        command: 'buildAndPush'
        Dockerfile: '**/Dockerfile'
        tags: |
          latest
          $(Build.BuildId)

Note:

Replace MyACRServiceConnection with a valid Azure DevOps service connection to your ACR.
Set registry variable to your ACR login server (myacr.azurecr.io).

Step 2: Configure Azure Container Registry Service Connection

To allow Azure DevOps to push images to ACR:

Go to Project Settings → Service connections
Click + New service connection → Docker Registry
Choose Azure Container Registry
Authenticate using Azure Resource Manager and select your ACR
Name it (e.g., MyACRServiceConnection) and save

Step 3: (Optional) Deploy to Azure Kubernetes Service

You can extend the pipeline to deploy your Docker image to AKS.

- stage: Deploy
  dependsOn: Build
  jobs:
  - job: DeployToAKS
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    - task: Kubernetes@1
      inputs:
        connectionType: 'Azure Resource Manager'
        azureSubscriptionEndpoint: 'MyAzureRMConnection'
        azureResourceGroup: 'myResourceGroup'
        kubernetesCluster: 'myAKSCluster'
        command: apply
        useConfigurationFile: true
        configuration: 'manifests/deployment.yaml'

Make sure your Kubernetes deployment YAML (manifests/deployment.yaml) pulls the latest Docker image from ACR using the same tag.

Conclusion

With Azure Pipelines, you can easily build and release Dockerized applications to any container registry or hosting environment. This CI/CD workflow ensures consistency, scalability, and speed in your software delivery process.

Automating AWS Deployments with GitHub and CodePipeline using Jenkins

Shankar Thejaswi — Tue, 25 Feb 2025 15:22:12 +0000

Introduction

Continuous Integration and Continuous Deployment (CI/CD) is a fundamental practice in DevOps that automates the deployment process, reducing manual work and improving efficiency. AWS CodePipeline is a managed CI/CD service that automates code changes to application deployment. Combined with GitHub and Jenkins, you can create a robust deployment workflow to AWS services such as S3, ECS, Lambda, or EC2.

In this blog, we'll walk through setting up a CI/CD pipeline using GitHub, Jenkins, and AWS CodePipeline to deploy an application to AWS.

Step 1: Setting Up AWS CodePipeline

Create an S3 Bucket for Artifacts

AWS CodePipeline requires an S3 bucket to store artifacts during deployment.

Go to the AWS Console → S3 → Create a new bucket.
Ensure you disable Block all public access (artifacts do not need to be public).
Note the bucket name for later use.

Create an IAM Role for CodePipeline

AWS CodePipeline needs permissions to access GitHub, deploy applications, and interact with AWS services.

Navigate to IAM → Roles → Create Role.
Select AWS Service → Choose CodePipeline.
Attach the following policies:
- AWSCodePipelineFullAccess
- AmazonS3FullAccess
- AWSCodeBuildAdminAccess
Name the role and create it.

Create a CodePipeline

Navigate to AWS CodePipeline → Create a new pipeline.
Choose GitHub as the source provider and connect your repository.
Add Jenkins as the build provider.
Deploy using AWS CodeDeploy (for EC2/ECS) or another AWS service as needed.
Click Create Pipeline.

Step 2: Configuring GitHub and Jenkins for AWS Deployment

Install and Configure Jenkins

Install Jenkins on an AWS EC2 instance or a local server.
Install necessary plugins:
- AWS CodePipeline Plugin
- Git Plugin
- Pipeline Plugin
Set up credentials for AWS within Jenkins.
Create a new Jenkins Pipeline Job that fetches code from GitHub and triggers deployments.

Add AWS Credentials to Jenkins

In Jenkins, go to Manage Jenkins → Manage Credentials.
Add AWS credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) under Global Credentials.

Create a Jenkinsfile

Create a Jenkinsfile in your repository to define the build and deployment stages:

pipeline {
    agent any
    environment {
        AWS_ACCESS_KEY_ID = credentials('AWS_ACCESS_KEY_ID')
        AWS_SECRET_ACCESS_KEY = credentials('AWS_SECRET_ACCESS_KEY')
    }
    stages {
        stage('Checkout Code') {
            steps {
                git branch: 'main', url: 'https://github.com/your-repo.git'
            }
        }
        stage('Build') {
            steps {
                sh 'echo Building application...'
            }
        }
        stage('Deploy to AWS') {
            steps {
                sh 'aws s3 sync . s3://my-bucket-name --delete'
            }
        }
    }
}

Replace my-bucket-name with your actual S3 bucket name.

Step 3: Deploying an Application to AWS

Depending on your target AWS service, modify the Jenkinsfile to deploy accordingly:

Deploy to AWS ECS (Dockerized Applications)

        stage('Deploy to ECS') {
            steps {
                sh '''
                aws ecr get-login-password | docker login --username AWS --password-stdin <AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com
                docker build -t my-app .
                docker tag my-app:latest <AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com/my-app:latest
                docker push <AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com/my-app:latest
                aws ecs update-service --cluster my-cluster --service my-service --force-new-deployment
                '''
            }
        }

Step 4: Automating Rollbacks and Monitoring

Enable Rollbacks in CodeDeploy

Use CodeDeploy Deployment Configs (CodeDeployDefault.OneAtATime) to control rollout speed.
Enable CloudWatch Alarms to trigger rollbacks on failure.

Set Up Monitoring with CloudWatch

Use AWS CloudWatch Logs for debugging.
Set up Amazon SNS Notifications for deployment alerts.

Debugging and Troubleshooting

Check Jenkins build logs for errors.
Use AWS CodePipeline Execution History to track failures.
Review CloudWatch Logs for detailed error messages.

Conclusion

By integrating Jenkins, GitHub, and AWS CodePipeline, you can automate your deployment process, ensuring faster and more reliable application updates. This setup reduces manual intervention, improves development efficiency, and enhances security.

Automating EC2 Deployment with Terraform, Ansible, and Shell Script

Shankar Thejaswi — Wed, 05 Feb 2025 16:50:42 +0000

Introduction

Infrastructure automation is key to efficient DevOps practices. Two of the most powerful tools for Infrastructure as Code (IaC) are Terraform and Ansible. Terraform is great for provisioning infrastructure, while Ansible excels at configuration management. In this blog, we'll see how to deploy an EC2 instance using Terraform and then configure it using Ansible—all orchestrated by a simple shell script.

Prerequisites

Before we begin, ensure you have the following installed on your local machine:

AWS CLI (configured with necessary credentials)
Terraform
Ansible
SSH Key Pair (for connecting to EC2 instance)

Step 1: Writing the Terraform Script

Terraform will be used to provision the EC2 instance.

`main.tf`

provider "aws" {
  region = "us-east-1"
}

resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0" # Example AMI (Change as per requirement)
  instance_type = "t2.micro"
  key_name      = "your-key-pair"

  tags = {
    Name = "Terraform-EC2"
  }
}

output "instance_ip" {
  value = aws_instance.web.public_ip
}

Step 2: Writing the Ansible Playbook

Once the EC2 instance is up, Ansible will configure it.

`playbook.yml`

- name: Configure EC2 instance
  hosts: all
  become: yes
  tasks:
    - name: Install Apache
      apt:
        name: apache2
        state: present

    - name: Start Apache
      service:
        name: apache2
        state: started

Step 3: Writing the Shell Script

A shell script will automate Terraform execution and Ansible deployment.

`deploy.sh`

#!/bin/bash

# Initialize Terraform
terraform init

# Apply Terraform and capture instance IP
terraform apply -auto-approve > output.txt

# Extract IP address
INSTANCE_IP=$(grep -oP '(?<=instance_ip = )[^ ]+' output.txt)

echo "EC2 Instance IP: $INSTANCE_IP"

# Wait for instance to be ready
sleep 30

# Add instance to Ansible inventory
echo "[web]" > inventory
echo "$INSTANCE_IP ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/your-key.pem" >> inventory

# Run Ansible playbook
ansible-playbook -i inventory playbook.yml

Step 4: Running the Script
Make the script executable and run it:

chmod +x deploy.sh
./deploy.sh

Conclusion
This setup automates EC2 provisioning with Terraform and configuration management with Ansible using a shell script. It eliminates manual intervention, ensuring a smooth, repeatable, and scalable deployment process. Happy automating!

DEV Community: Shankar Thejaswi

Building and Releasing Dockerized Applications using Azure Pipelines

Introduction

Prerequisites

Step 1: Create an Azure Pipeline (YAML)

Sample Pipeline to Build and Push Docker Image to Azure Container Registry (ACR):

Step 2: Configure Azure Container Registry Service Connection

Step 3: (Optional) Deploy to Azure Kubernetes Service

Conclusion

Automating AWS Deployments with GitHub and CodePipeline using Jenkins

Introduction

Step 1: Setting Up AWS CodePipeline

** Create an S3 Bucket for Artifacts**

** Create an IAM Role for CodePipeline**

** Create a CodePipeline**

Step 2: Configuring GitHub and Jenkins for AWS Deployment

** Install and Configure Jenkins**

** Add AWS Credentials to Jenkins**

** Create a Jenkinsfile**

Step 3: Deploying an Application to AWS

** Deploy to AWS ECS (Dockerized Applications)**

Step 4: Automating Rollbacks and Monitoring

** Enable Rollbacks in CodeDeploy**

** Set Up Monitoring with CloudWatch**

** Debugging and Troubleshooting**

Conclusion

Automating EC2 Deployment with Terraform, Ansible, and Shell Script

Introduction

Prerequisites

main.tf

playbook.yml

deploy.sh

Create an S3 Bucket for Artifacts

Create an IAM Role for CodePipeline

Create a CodePipeline

Install and Configure Jenkins

Add AWS Credentials to Jenkins

Create a Jenkinsfile

Deploy to AWS ECS (Dockerized Applications)

Enable Rollbacks in CodeDeploy

Set Up Monitoring with CloudWatch

Debugging and Troubleshooting

`main.tf`

`playbook.yml`

`deploy.sh`