Forem: Amol Mali

Auto-Tag Docker Images with Semantic Versioning Using GitHub Actions

Amol Mali — Sun, 29 Jun 2025 07:22:33 +0000

🚀 Auto-Tag Docker Images with Semantic Versioning Using GitHub Actions

Docker images tagged with long SHA hashes are hard to track. Let's fix that.

In this guide, you’ll learn how to automatically build and push Docker images to Docker Hub using semantic version tags like v1.0.0, and optionally update latest as well — all triggered directly by a git tag.

🧰 Prerequisites

Before getting started, make sure you have:

A working GitHub repository with a Dockerfile
A Docker Hub account
GitHub Secrets:
- DOCKER_USERNAME
- DOCKER_PASSWORD or access token
Semantic version tags in your repository (e.g., git tag v1.2.3)

🔄 What We'll Automate

Watch for pushes to tags like v1.2.3
Extract the tag version from GITHUB_REF
Build the Docker image
Tag it with both v1.2.3 and latest
Push both to Docker Hub

⚙️ GitHub Actions Workflow

Here's a complete example of a workflow file to place at .github/workflows/docker-release.yml:


yaml
name: Release Docker Image

on:
  push:
    tags:
      - 'v*.*.*'  # Matches v1.0.0, v2.3.1 etc.

jobs:
  docker:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Extract tag version
        id: version
        run: echo "VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV

      - name: Log in to Docker Hub
        run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin

      - name: Build Docker image
        run: |
          docker build -t ${{ secrets.DOCKER_USERNAME }}/your-app:${{ env.VERSION }} .
          docker tag ${{ secrets.DOCKER_USERNAME }}/your-app:${{ env.VERSION }} ${{ secrets.DOCKER_USERNAME }}/your-app:latest

      - name: Push Docker image
        run: |
          docker push ${{ secrets.DOCKER_USERNAME }}/your-app:${{ env.VERSION }}
          docker push ${{ secrets.DOCKER_USERNAME }}/your-app:latest

Automate Server Deployments with GitHub Actions & SSH

Amol Mali — Sun, 29 Jun 2025 07:09:05 +0000

🚀 Automate Server Deployments with GitHub Actions & SSH

Modern development teams want code changes to move from GitHub to production without friction. In this guide, we’ll extend our CI/CD pipeline to automatically deploy to a server using SSH—no manual steps required.

This builds on the previous blog where we created a pipeline to build and push Docker images using GitHub Actions.

🧰 Prerequisites

Before getting started, ensure you have:

A GitHub account
A Linux server with SSH access (e.g. DigitalOcean, AWS EC2, VPS)
A Docker Hub account (if using Docker)
SSH key pair added to your server’s ~/.ssh/authorized_keys
GitHub repository secrets:
- SSH_HOST # e.g., 192.168.1.100
- SSH_USER # e.g., ubuntu
- SSH_PRIVATE_KEY # No passphrase
- SSH_KNOWN_HOSTS # Generated via ssh-keyscan <server-ip>

🔐 Security Tips

Generate SSH keys without passphrases specifically for GitHub Actions
Only add the private key to GitHub Secrets
Use ssh-keyscan your-server-ip to safely populate SSH_KNOWN_HOSTS

🔒 Avoid using root—prefer a user with limited sudo access if needed.

⚙️ Why Use GitHub Actions for Deployment?

By adding SSH deployment to your existing pipeline, you:

Avoid manual scp, git pull, or docker run commands
Trigger deployments automatically on code changes
Keep all deployment logic under version control

🔄 CI/CD Workflow with SSH Deployment

Here’s how the full pipeline works:

Code is pushed to the main branch
GitHub Actions:
- Builds the Python app
- Pushes a Docker image to Docker Hub
- SSHs into the server and deploys the latest Docker image

📋 Full GitHub Actions Workflow

name: CI/CD Pipeline

on:
push:
  branches:
    - main

jobs:
build:
  runs-on: ubuntu-latest

  steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.11'

    - name: Install dependencies
      run: |
        pip install -r requirements.txt

docker:
  needs: build
  runs-on: ubuntu-latest

  steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Log in to Docker Hub
      run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin

    - name: Build and Push Docker Image
      run: |
        docker build -t ${{ secrets.DOCKER_USERNAME }}/python-cicd:${{ github.sha }} .
        docker push ${{ secrets.DOCKER_USERNAME }}/python-cicd:${{ github.sha }}

deploy:
  needs: docker
  runs-on: ubuntu-latest

  steps:
    - name: Deploy to Server via SSH
      uses: appleboy/ssh-action@v1
      with:
        host: ${{ secrets.SSH_HOST }}
        username: ${{ secrets.SSH_USER }}
        key: ${{ secrets.SSH_PRIVATE_KEY }}
        known_hosts: ${{ secrets.SSH_KNOWN_HOSTS }}
        script: |
          docker pull ${{ secrets.DOCKER_USERNAME }}/python-cicd:${{ github.sha }}
          docker stop app || true
          docker rm app || true
          docker run -d --name app -p 3000:3000 ${{ secrets.DOCKER_USERNAME }}/python-cicd:${{ github.sha }}

✅ Testing & Troubleshooting

Use -v or -vvv in SSH scripts for verbose logs
Ensure the server user is in the docker group
Use act to test GitHub Actions locally

📈 Bonus: Make It Even Better

Here’s how you can upgrade your deployment pipeline:

🔄 Add Rollback Logic

If a deployment fails, you can roll back to a previous image by storing the old commit SHA or Docker tag and restarting the container:

docker run -d --name app -p 3000:3000 your-docker-user/python-cicd:previous-commit-sha

🌐 Blue-Green Deployments with Nginx

Avoid downtime by running two versions of your app (e.g., app-blue and app-green) and switching traffic using Nginx.

Example Nginx Config:

upstream backend {
    server 127.0.0.1:3001;  # app-blue
    # server 127.0.0.1:3002;  # app-green
}

server {
    listen 80;

    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

To switch versions:

Deploy app-green on port 3002
Update Nginx to point to 3002
Reload Nginx: sudo systemctl reload nginx
Remove old container if needed

In your GitHub Action SSH script:

docker run -d --name app-green -p 3002:3000 your-docker-user/python-cicd:${{ github.sha }}
sudo sed -i 's/3001/3002/' /etc/nginx/sites-available/default
sudo systemctl reload nginx
docker stop app-blue || true
docker rm app-blue || true

This enables zero-downtime deploys.

🔔 Send Deployment Alerts to Slack

Keep your team updated automatically using a Slack webhook.

Create a Slack Incoming Webhook
Add SLACK_WEBHOOK as a GitHub Secret
Use this step in your GitHub Actions:

- name: Notify Slack
  uses: 8398a7/action-slack@v3
  with:
    status: ${{ job.status }}
    fields: repo,message,commit,author
  env:
    SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK }}

You’ll get instant alerts on success, failure, or cancellation of deployments.

💬 Final Thoughts

Automating deployments with GitHub Actions and SSH is a game-changer for solo developers and teams alike. Once configured, every git push to your main branch becomes a full-cycle delivery—from source code to a live service.

CI/CD Pipeline with GitHub Actions: From Code to Deployment

Amol Mali — Sun, 29 Jun 2025 06:03:34 +0000

Modern software development demands speed, consistency, and automation. CI/CD (Continuous Integration and Continuous Deployment) is a crucial practice that automates the steps between writing code and deploying it to production.

In this article, we’ll walk through building a complete CI/CD pipeline using GitHub Actions — from committing code to deploying a containerized Python app.

Whether you’re a developer, DevOps engineer, or curious learner, this guide will help you go from code to deployment with confidence.

🧭 What is GitHub Actions?

GitHub Actions is a built-in CI/CD and automation platform in GitHub. It lets you trigger workflows based on events — like pushing code, creating pull requests, or scheduling jobs — and run scripts to build, test, or deploy applications.

✅ No external CI/CD server needed
✅ Fully integrated with your repository
✅ Free for public repos and generous free tier for private ones

🧰 Prerequisites

Before diving in, make sure you have the following:

A GitHub account
A Docker Hub account
A Docker personal access token for authentication → How to create one
Docker installed locally (for optional manual testing) Basic knowledge of Python and Git

📦 What We’ll Build

We’ll set up a pipeline that:

Triggers on every push to the main branch
Installs dependencies
Builds a Docker image
Pushes the image to Docker Hub

This entire process will be automated via GitHub Actions.

🔗 GitHub Repo

👉 github.com/amolxops/python-cicd-github-actions.git

🐍 The Python App

We’ll use a simple Flask application that returns “Hello, Welcome to the World of Github Actions CI/CD workflow!” when accessed. You can adapt this to any app stack you prefer.

app.py

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, Welcome to the World of Github Actions CI/CD workflow!"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=3000)

requirements.txt

flask==2.3.3

Dockerfile

FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

EXPOSE 3000

CMD ["python", "app.py"]
FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

EXPOSE 3000

CMD ["python", "app.py"]

🔧 Setting Up GitHub Actions Workflow

Create a workflow file at .github/workflows/ci-cd.yml:

name: CI/CD Pipeline

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: |
          pip install -r requirements.txt

  docker:
    needs: build
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Log in to Docker Hub
        run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin

      - name: Build and Push Docker Image
        run: |
          docker build -t ${{ secrets.DOCKER_USERNAME }}/python-cicd:${{ github.sha }} .
          docker push ${{ secrets.DOCKER_USERNAME }}/python-cicd:${{ github.sha }}

🔐 Adding GitHub Secrets

Keep credentials safe by adding secrets:

Go to Settings > Secrets and variables > Actions
Add: DOCKER_USERNAME and DOCKER_PASSWORD These allow the workflow to authenticate securely with Docker Hub.

✅ What Happens Now?

With this setup, every time you push to main branch:

GitHub checks out the latest code
Installs dependencies
Builds a Docker image
Pushes it to your Docker Hub (tagged with the commit SHA)

✨ No more manual Docker builds or pushes!

📚 Bonus: Running the Container

After the image is pushed, run it anywhere Docker is installed:

docker run -p 3000:3000 your-username/python-cicd:<commit-sha>

Want to deploy it to a server automatically? Add a new job using appleboy/ssh-action to deploy via SSH. Let me know if you'd like help extending the workflow!

💡 Wrap-Up

CI/CD pipelines make development faster and more reliable. Using GitHub Actions, you’ve automated everything from building a Docker image to pushing it to the registry.

This guide covered:

A simple Python + Flask app
Dockerizing the app
Automating with GitHub Actions

Whether you’re building APIs, websites, or internal tools — this foundation sets you up for scalable and efficient deployments.

🙌 Let’s Connect

If you found this guide helpful or have questions, drop a comment or connect with me here on Medium. Follow for more content on DevOps, automation, and Linux tips.

What is DevOps? A Practical Guide for Beginners

Amol Mali — Thu, 26 Jun 2025 11:42:48 +0000

“DevOps isn’t a role. It’s a mindset — and a toolchain.”

In today’s fast-paced digital world, businesses are under pressure to deliver high-quality software faster than ever before. Traditional software development and IT operations often function in silos, leading to slow deployments, miscommunication, and unreliable systems. That’s where DevOps comes in.

DevOps is more than just a set of tools — it’s a cultural and professional movement that emphasizes collaboration, communication, and integration between software developers and IT operations. This guide is your practical starting point for understanding DevOps and how to begin your journey toward adopting it.

🔍 What is DevOps?

DevOps (a combination of “Development” and “Operations”) is a methodology that aims to unify software development (Dev) and IT operations (Ops). The goal is to shorten the software development lifecycle and deliver high-quality software continuously.

Core Principles of DevOps:

Collaboration: Breaking down silos between dev and ops teams.
Automation: Streamlining repetitive tasks like testing, integration, and deployment.
Continuous Integration/Continuous Deployment (CI/CD): Delivering code changes quickly and reliably.
Monitoring & Feedback: Continuously tracking performance and using insights to improve.

🚀 Why DevOps Matters: Key Benefits

Adopting DevOps transforms how teams build and deliver software. Here’s how:

Faster Deployment Cycles: Teams release updates more frequently and with greater confidence. Example: Amazon deploys code every 11.7 seconds on average — thanks to robust DevOps practices.
Improved Collaboration: DevOps breaks down walls between departments, fostering a culture of shared responsibility and faster issue resolution.
Higher Quality Releases: With automated testing and continuous monitoring, teams can catch and fix bugs earlier in the lifecycle.
Faster Time to Market: Organizations can respond to market demands swiftly, providing a competitive edge.
More Reliable Systems: With infrastructure-as-code and real-time monitoring, environments are more consistent and predictable.
Cost Savings: DevOps enables more efficient resource allocation and cost optimization.

🛠️ Getting Started with DevOps: A Beginner’s Guide

Here’s a step-by-step roadmap for anyone new to DevOps:

Step 1: Understand the DevOps Culture

DevOps isn’t just about tools — it starts with a mindset shift:

Embrace collaboration: Everyone owns the product’s success, from developers to operations to QA.
Fail fast, learn faster: Mistakes are learning opportunities. Automate and iterate.
Customer focus: Continuously gather feedback and improve based on real-world usage.

📌 Tip: Encourage blameless postmortems and daily standups to foster transparency.

Step 2: Learn Essential DevOps Tools

While culture is key, tools enable the practices. Here are some foundational ones:

Tool — Purpose

Git: Version control
Jenkins / GitHub Actions: Automate build, test, and deployment
Docker: Containerization (lightweight environments)
Kubernetes: Container orchestration at scale
Terraform: Infrastructure as Code (IaC)
Prometheus + Grafana: Monitoring and visualization
ELK Stack: Log aggregation and analysis

Start with one tool at a time — e.g., Jenkins for CI/CD or Docker for local development.

Step 3: Build a CI/CD Pipeline

A CI/CD pipeline automates the process of taking code from development to production.

Continuous Integration (CI):
1. Developers push code to a shared repository (e.g., GitHub).
2. Automated tests run to validate the code.
3. Builds are triggered automatically.
Continuous Deployment (CD):
1. Code is automatically deployed to staging or production if all checks pass.
2. Rollbacks can be automated in case of failures.
📌 Best Practices:
- Keep builds fast and atomic.
- Run unit + integration tests.
- Use feature toggles for safe deployments.

Step 4: Implement Monitoring and Feedback Loops

Once code is live, the job isn’t done.

Monitoring: Use tools like Prometheus, Datadog, or New Relic to monitor application performance and infrastructure health.
Logging: Implement centralized logging with tools like ELK Stack or Fluentd.
Alerting: Set up real-time alerts for anomalies or failures.

📌 Why it matters: Monitoring lets teams detect issues before users do and continuously improve based on performance and usage patterns.

⚠️ Overcoming Common DevOps Challenges

Transitioning to DevOps can be tough. Here are common pitfalls and how to tackle them:

Resistance to change: Encourage small wins and involve all stakeholders early.
Tool overload: Avoid chasing trends — adopt tools that solve your specific needs.
Lack of visibility: Make pipelines and logs transparent and accessible to all teams.
Siloed knowledge: Promote cross-functional training and documentation.

🎯 How to Get Started in DevOps

If you’re new, here’s a simple roadmap:

Learn Linux and Networking Basics
Understand Git and CI/CD tools (start with GitHub Actions)
Get hands-on with Docker
Explore IaC with Terraform or Ansible
Run Kubernetes locally (Minikube or Kind)
Monitor with Prometheus + Grafana
Learn Cloud Basics (Start with AWS Free Tier or Google Cloud Free)

📚 Resources I Recommend

👋 Final Thoughts

DevOps isn’t a destination — it’s an evolving journey. Whether you’re a developer curious about automation or an ops engineer eager to collaborate better, embracing DevOps will elevate your software delivery process and product quality.

Start small. Learn continuously. Automate wisely.

Forem: Amol Mali

Auto-Tag Docker Images with Semantic Versioning Using GitHub Actions

🚀 Auto-Tag Docker Images with Semantic Versioning Using GitHub Actions

🧰 Prerequisites

🔄 What We'll Automate

⚙️ GitHub Actions Workflow

Automate Server Deployments with GitHub Actions & SSH

🚀 Automate Server Deployments with GitHub Actions & SSH

🧰 Prerequisites

🔐 Security Tips

⚙️ Why Use GitHub Actions for Deployment?

🔄 CI/CD Workflow with SSH Deployment

📋 Full GitHub Actions Workflow

✅ Testing & Troubleshooting

📈 Bonus: Make It Even Better

🔄 Add Rollback Logic

🌐 Blue-Green Deployments with Nginx

🔔 Send Deployment Alerts to Slack

💬 Final Thoughts

CI/CD Pipeline with GitHub Actions: From Code to Deployment

🧭 What is GitHub Actions?

🧰 Prerequisites

📦 What We’ll Build

🔗 GitHub Repo

🐍 The Python App

🔧 Setting Up GitHub Actions Workflow

🔐 Adding GitHub Secrets

✅ What Happens Now?

📚 Bonus: Running the Container

💡 Wrap-Up

🙌 Let’s Connect

What is DevOps? A Practical Guide for Beginners

🔍 What is DevOps?

Core Principles of DevOps:

🚀 Why DevOps Matters: Key Benefits

🛠️ Getting Started with DevOps: A Beginner’s Guide

Step 1: Understand the DevOps Culture

Step 2: Learn Essential DevOps Tools

Step 3: Build a CI/CD Pipeline

📌 Best Practices:

Step 4: Implement Monitoring and Feedback Loops

⚠️ Overcoming Common DevOps Challenges

🎯 How to Get Started in DevOps

📚 Resources I Recommend

👋 Final Thoughts