Python Deployment: A Deep Dive into GitHub Actions and Docker

Hello everyone! 👋

I'm currently on a learning journey into the world of DevOps and SRE, and I'm excited to share my experience with the DevOps SRE Daily Challenge.

This week's task was a big one: setting up a full CI/CD pipeline to deploy a Python application.

A huge shout-out to my mentor, Sagar Utekar, for guiding me through this. It was a fantastic learning experience, and I wanted to document the process for anyone else starting out.

👉 You can check out the final code on my GitHub repo: Hritikraj8804/devops-python-app

---

What are GitHub Actions? (The Brains of the Operation) 🧠

First things first, I had to understand the tool. GitHub Actions is a powerful CI/CD platform built right into GitHub. It lets you automate almost anything — from running tests on every commit to deploying your application to the cloud.

The key components I learned about are:

• Workflow: The main YAML file in .github/workflows/ that defines the process.
• Event: The trigger, like a push to the main branch.
• Job: A set of steps that run on a server.
• Step: An individual task, like running a command.
• Action: A reusable piece of code, often from the Marketplace (like actions/checkout).
• Runner: The virtual server that executes your job.

---

My Goal: Automate Pushing a Docker Image to Docker Hub

Instead of deploying directly to a server via SSH, I decided to containerize my app with Docker.

The goal: automatically build a Docker image and push it to Docker Hub every time I pushed new code.

Here’s how I achieved it. 🚀

---

Step 1: The Dockerfile - The Recipe for My App 📜

A Dockerfile is a script that tells Docker how to build your image. It’s the foundation of your container.

Here’s the Dockerfile I created for my simple Python Flask app:

# Use an official Python runtime as a parent image
FROM python:3.10-slim

# Set the working directory in the container
WORKDIR /app

# Copy the requirements file and install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the application's code
COPY . .

# Expose port 8000
EXPOSE 8000

# Command to run the application using Gunicorn
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]

---

Step 2: Manual Build and Push (Practice Run) 🏗️

Before automating, I verified the process manually.

1. Build the image:

docker build -t my-python-app .

1. Log in to Docker Hub:

docker login

1. Tag for Docker Hub:

docker tag my-python-app hritikraj8804/my-python-app

1. Push to Docker Hub:

docker push hritikraj8804/my-python-app

✅ Success! My image was on Docker Hub. Now it was time to make GitHub handle this automatically.

---

The Magic: Automating with GitHub Actions ✨

This is where it all came together. I created a workflow file at .github/workflows/docker-publish.yml.

---

The Secret Ingredient: Managing Secrets and Variables 🔑

You can’t just put your credentials directly in code! GitHub provides a secure way to manage this:

• Secrets 🤫: For sensitive data like API keys and passwords. They’re encrypted and hidden once set. I used these for DOCKERHUB_TOKEN.
• Variables 📝: For non-sensitive values you want to reuse, like project names.

I went to Settings → Secrets and variables → Actions in my repo and added:

• DOCKERHUB_USERNAME
• DOCKERHUB_TOKEN

---

The Workflow File (docker-publish.yml)

This YAML file tells GitHub Actions exactly what to do.

name: Build and Push Docker Image

on:
  push:
    branches: [ main ]
  workflow_dispatch:

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Log in to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ${{ secrets.DOCKERHUB_USERNAME }}/devops-python-app:latest

Once I pushed this file to my main branch, GitHub Actions automatically kicked in and pushed my image to Docker Hub. 🎉

---

What I Learned 💡

This challenge was a huge step forward for me.
Going from manual steps to a fully automated CI/CD pipeline felt like magic. ✨

Key takeaways:

• GitHub Actions is powerful and flexible for automation.
• Docker makes applications portable and deployment-ready.
• Secrets management is essential for security in DevOps.

👉 If you’re starting your DevOps journey, I highly recommend building something like this yourself. Nothing beats hands-on learning!

---