90 Days of DevOps

🚀 CI/CD Magic with Jenkins, Docker, and Docker Hub for Your Django Notes App!

Abhishek Jinde's photo
Abhishek Jinde
·

5 min read

Hello, fellow DevOps enthusiasts! 👋

Imagine this: You’re working on an exciting Django project, and every time there’s a code change, you manually build, push, and deploy the app… 😩 Sounds tedious, right? What if I told you there’s a way to automate all of this with the power of CI/CD pipelines? Today, we’re diving into a practical walkthrough where we'll build, deploy, and scale a Django Notes App using Jenkins, Docker, and Docker Hub.

Let’s gear up and get started! 🎉

Project Overview 📝

In this blog post, we’re going to:

  1. Set up a Jenkins pipeline that automates code building, image pushing, and container deployment.

  2. Build a Docker image for our Django Notes App.

  3. Push the image to Docker Hub, so you can pull it from anywhere!

  4. Deploy the app using Docker Compose.

But before we jump into the action, here’s a sneak peek of what our pipeline will look like:

A clean and modern DevOps pipeline diagram showing four stages connected by arrows. The stages are labeled 'Code', 'Build', 'Push', and 'Deploy', from left to right. Each stage is represented as a distinct block with relevant icons: a code symbol for 'Code', a wrench for 'Build', a cloud upload for 'Push', and a server or container for 'Deploy'. The blocks should be colorful and stand out with clear labels, all arranged horizontally on a sleek white or light background.

1️⃣ Setting Up the Project 🛠️

Project Repository 📂

We’ll use a Django Notes App hosted on GitHub. You can check it out here.

Our repository structure looks like this:

Copy code├── Dockerfile
├── docker-compose.yml
├── notes
│   ├── ...
└── manage.py

The Dockerfile and docker-compose.yml files are key to containerizing and deploying the app.

Prerequisites 🧰

Before getting started, make sure you have:

  • Jenkins set up and running.

  • Docker installed on your Jenkins server.

  • A Docker Hub account.

2️⃣ Jenkins Pipeline: Automating the Magic 🪄

Now, let’s dive into the heart of the project—our Jenkins pipeline script. This script automates everything from cloning the repo to deploying the app.

Here’s the full pipeline script:

pipeline {
    agent any

    stages {
        stage("Clone") {
            steps {
                echo "Cloning the Code"
                git url: "https://github.com/Abhishek-Jinde/django-notes-app.git", branch: "main"
            }
        }
        stage("Build") {
            steps {
                echo "Building the image"
                sh "docker build -t my-note-app ."
            }
        }
        stage("Push to DockerHub") {
            steps {
                echo "Pushing the image to DockerHub"
                withCredentials([usernamePassword(credentialsId: "dockerHub", passwordVariable: "dockerHubPass", usernameVariable: "dockerHubUser")]) {
                    sh "docker tag my-note-app ${env.dockerHubUser}/my-note-app:latest"
                    sh "docker login -u ${env.dockerHubUser} -p ${env.dockerHubPass}"
                    sh "docker push ${env.dockerHubUser}/my-note-app:latest"
                }
            }
        }
        stage("Deploy") {
            steps {
                echo "Deploying the container"
                sh "docker-compose down && docker-compose up -d"
            }
        }
    }
}

Breaking Down the Pipeline 💡

  1. Stage 1: Clone the Repository (⏬ Cloning)

    • We start by cloning the code from the GitHub repo. Jenkins pulls the latest code from the main branch to ensure our pipeline always works with the most updated code.

    • Key Command: git url: "https://github.com/Abhishek-Jinde/django-notes-app.git"

  2. Stage 2: Build the Docker Image (🏗️ Building)

    • Next, we build the Docker image for our Django app using the Dockerfile. This containerizes our app, allowing it to run in any environment without hiccups.

    • Key Command: sh "docker build -t my-note-app ."

Here’s what happens in the Dockerfile:

  • We start with the official Python image, install dependencies, copy the app code, and run it in a container.

  • A visual representation of the Docker image creation process. Show a sequence that starts with source code, a Dockerfile, and dependencies, leading to a Docker container image. Include stages like building, packaging, and deploying the container. Use clean lines and clear icons, with a tech-oriented color scheme like blues and grays. Include Docker's logo subtly in the background and have arrows indicating the flow from code to container. The background should be minimalistic, focusing on the process steps in a structured format.

    Stage 3: Push to Docker Hub (☁️ Pushing)

    • We tag the image and push it to Docker Hub. This makes it accessible from anywhere!

    • Credentials are managed securely using Jenkins’ withCredentials method.

    • Key Commands:

        sh "docker tag my-note-app ${env.dockerHubUser}/my-note-app:latest"
  sh "docker push ${env.dockerHubUser}/my-note-app:latest"

An image showcasing how a Docker image appears on Docker Hub. Display a user interface similar to Docker Hub, with a container image listing showing details like the repository name, image tags, download counts, and description. Include a search bar at the top and buttons for actions like 'Pull,' 'Star,' and 'Share.' The design should be clean and simple, with a focus on blues, grays, and white colors that align with Docker's branding. Subtle Docker logos or icons can be included.

  1. Stage 4: Deploy with Docker Compose (🚀 Deploying)

    • Finally, we deploy the containerized app using Docker Compose. We bring down any existing containers and spin up new ones with the latest image.

    • Key Command: sh "docker-compose down && docker-compose up -d"

3️⃣ Deployment: Let’s See It in Action! 💻

Once the pipeline runs, your Django Notes App is live and ready to be accessed. You can visit it via http://<your-server-ip>:8000. 🎉

  • Why This Pipeline Rocks 🌟

    • End-to-End Automation: From code to production, everything happens seamlessly.

    • Scalability: Easily deploy updates or rollbacks by re-running the pipeline.

    • Security: Credentials are stored securely, keeping your Docker Hub account safe.

    • Portability: The app runs inside a Docker container, ensuring it works anywhere!

4️⃣ Conclusion: Ready to Elevate Your DevOps Game? 🚀

By setting up this Jenkins pipeline, we’ve automated the entire CI/CD process, making deployments faster and more reliable. Whether you’re scaling a small project or managing a large app, this setup is a must-have in your DevOps toolkit.

Try out the pipeline for your projects and let me know how it goes! Have questions? Drop them in the comments below, and I’d be happy to help. 🤓

Until next time—Happy DevOps-ing! 💻⚙️

Devopsci-cdJenkinsDocker