In this article, I will show you how to:

• Create a Jenkins Pipeline

• Install required plugins

• Configure GitHub Webhook

• Enable automatic build trigger

• Deploy a Django app using Docker

• View pipeline stages using Stage View

This is a complete CI/CD implementation.

---

🟢 Step 1: Install Required Plugin (Stage View)

📌 Screenshot: Manage Jenkins → Plugins → Available Plugins

Search for:

Pipeline Aggregator View

🔹 What is Pipeline Aggregator View?

• Shows visual Stage View

• Displays build history

• Shows stage duration

• Displays success/failure in green/red

Click Install.

---

🟢 Step 2: Create New Pipeline Job

📌 Screenshot: New Item Page

1. Click New Item

2. Enter name:

   djangocicd
   

3. Select Pipeline

4. Click OK

---

🟢 Step 3: General Configuration

📌 Screenshot: General Section

🔹 Description

This is a CI/CD for a Django app

---

🔹 GitHub Project (Enable)

Add repository URL:

https://github.com/LondheShubham153/django-notes-app.git

This connects Jenkins to GitHub.

---

🔹 Other Options Explained

Option	Purpose
Discard Old Builds	Saves storage
Do Not Allow Concurrent Builds	Prevents multiple runs
Pipeline Speed/Durability Override	Performance tuning
Preserve Stashes	Keeps temporary files
This Project is Parameterized	Allows runtime parameters
Throttle Builds	Limit parallel builds

---

🟢 Step 4: Configure Build Triggers

📌 Screenshot: Trigger Section

Enable:

✅ GitHub hook trigger for GITScm polling

This allows Jenkins to build automatically when code is pushed.

Other options explained:

Option	Use
Build Periodically	Cron-based build
Poll SCM	Checks repo every few minutes
GitHub Pull Requests	PR trigger
Build After Other Projects	Chain jobs

---

🟢 Step 5: Pipeline Script Configuration

📌 Screenshot: Pipeline Script Editor

Definition → Select:

Pipeline Script

Now paste this complete script:

pipeline {
    agent {
        label "hunter"
    }

    stages {

        stage("code") {
            steps {
                echo "Cloning the code"
                git url: "https://github.com/LondheShubham153/django-notes-app.git", branch: "main"
                echo "Code cloned successfully"
            }
        }

        stage("build") {
            steps {
                echo "Building Docker image"
                sh "whoami"
                sh "docker build -t notes-app:latest ."
                echo "Build successful"
            }
        }

        stage("test") {
            steps {
                echo "Running tests"
            }
        }

        stage("deploy") {
            steps {
                echo "Deploying container"
                sh "docker rm -f notes-app-container || true"
                sh "docker run -d -p 8000:8000 --name notes-app-container notes-app:latest"
                echo "Deployment successful"
            }
        }
    }

    post {
        always {
            echo "Pipeline finished"
        }
        success {
            echo "Pipeline executed successfully"
        }
        failure {
            echo "Pipeline failed"
        }
    }
}

---

🔹 Use Groovy Sandbox

Keep this enabled for security.

---

🟢 Step 6: Setup GitHub Webhook

📌 Screenshot: GitHub → Settings → Webhooks

Click Add Webhook

---

🔹 Payload URL

If using ngrok:

https://your-ngrok-url/github-webhook/

Example from screenshot:

https://unviolably-exostotic-cory.ngrok-free.dev/github-webhook/

---

🔹 Content Type

Select:

application/json

---

🔹 Secret

Optional but recommended for security.

---

🔹 SSL Verification

Options:

Option	Meaning
Enable SSL Verification	Secure (Recommended)
Disable	Not recommended

---

🔹 Which Events to Trigger?

Select:

Send me everything

Or choose:

Just the push event

---

🔹 Active

Make sure checkbox is enabled.

Click Update Webhook

---

🟢 Step 7: How Webhook Works

When you push code:

1. GitHub sends POST request to Jenkins

2. Jenkins receives webhook

3. Pipeline automatically starts

4. Stages execute sequentially

5. Docker container gets deployed

---

🟢 Step 8: Stage View (Visual Pipeline Monitoring)

📌 Screenshot: Jenkins Stage View

You will see:

Stage	Status	Time
code	✅ Green	3s
build	✅ Green	1min 42s
test	✅ Green	41ms
deploy	✅ Green	3s

---

🔹 What Stage View Shows

• Build number (#11, #10, #9)

• Stage duration

• Average time

• Success/Failure color coding

Green → Success

Red → Failed

---

🟢 Step 9: Access the Deployed Application

After deployment:

http://<server-ip>:8000

If running locally:

http://localhost:8000

---

🟢 Complete CI/CD Flow Architecture

Developer → Push Code → GitHub →
Webhook → Jenkins →
Build → Test → Deploy →
Docker Container Running

---

🎯 Final Output

When everything is correct, you will see:

• All stages green

• Console output showing deployment

• Running container on port 8000

• Automatic trigger on every push

---

🔥 What Makes This Production-Ready?

• Automated build

• Dockerized deployment

• Webhook integration

• Stage monitoring

• Error handling using post block

• Container recreation logic

---

🏁 Conclusion

In this guide, we:

✔ Installed required plugin

✔ Created pipeline job

✔ Configured triggers

✔ Wrote Declarative Jenkinsfile

✔ Configured GitHub Webhook

✔ Deployed Django app using Docker

✔ Monitored pipeline using Stage View

This is a complete real-world CI/CD implementation.