End-to-End DevOps Project

?? What We’re Building Today

Goal: Create a CI/CD pipeline that automates:

1. Building a Dockerized application.
2. Testing the application for quality assurance.
3. Pushing the Docker image to a container registry.
4. Deploying the application to a Kubernetes cluster using Helm.
5. Monitoring the application with Prometheus and Grafana.

??? Project Setup

Tools Involved:

1. GitHub: Code repository.
2. Jenkins: CI/CD pipeline.
3. Docker: Containerization.
4. Kubernetes: Deployment and orchestration.
5. Helm: Kubernetes package management.
6. Prometheus & Grafana: Monitoring and visualization.

??? Step-by-Step Implementation

1. Application Code Setup

Create a simple Node.js web application.

File: app.js

const express = require('express');  
const app = express();  
const PORT = 3000;  

app.get('/', (req, res) => {  
    res.send('Hello, DevOps Enthusiasts! ??');  
});  

app.listen(PORT, () => {  
    console.log(`Server running on https://localhost:${PORT}`);  
});          

Add a Dockerfile to containerize the application:

File: Dockerfile

FROM node:14  
WORKDIR /app  
COPY package*.json ./  
RUN npm install  
COPY . .  
EXPOSE 3000  
CMD ["node", "app.js"]          

Push the code to a GitHub repository.

2. CI/CD Pipeline with Jenkins

Set up a Jenkins pipeline to build, test, and deploy the application.

Jenkinsfile: (groovy)

pipeline {  
    agent any  
    stages {  
        stage('Checkout Code') {  
            steps {  
                git 'https://github.com/your-repo/devops-end-to-end.git'  
            }  
        }  
        stage('Build Docker Image') {  
            steps {  
                sh 'docker build -t your-dockerhub-username/devops-app:${BUILD_NUMBER} .'  
            }  
        }  
        stage('Push to Docker Hub') {  
            steps {  
                withDockerRegistry([credentialsId: 'docker-hub-credentials', url: '']) {  
                    sh 'docker push your-dockerhub-username/devops-app:${BUILD_NUMBER}'  
                }  
            }  
        }  
        stage('Deploy to Kubernetes') {  
            steps {  
                sh 'helm upgrade --install devops-app ./helm-chart --set image.tag=${BUILD_NUMBER}'  
            }  
        }  
    }  
}          

3. Kubernetes Deployment with Helm

Use a Helm Chart to define your Kubernetes deployment and service.

File: values.yaml

image:  
  repository: your-dockerhub-username/devops-app  
  tag: "latest"  
replicaCount: 2  
service:  
  type: LoadBalancer  
  port: 3000          

Deploy the application:

helm upgrade --install devops-app ./helm-chart          

4. Monitoring with Prometheus and Grafana

Install Prometheus and Grafana using Helm:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts  
helm install monitoring prometheus-community/kube-prometheus-stack          

Access Grafana to set up dashboards:

kubectl port-forward svc/monitoring-grafana 3000:80          

?? Project Workflow

1. Code Push: Developers push code to GitHub.
2. CI Pipeline: Jenkins builds and tests the Docker image.
3. CD Pipeline: Docker image is pushed to Docker Hub and deployed to Kubernetes.
4. Monitoring: Prometheus and Grafana track application health and performance.

?? What We’ve Achieved

• Automated the complete DevOps lifecycle: build → test → deploy → monitor.
• Integrated tools like GitHub, Jenkins, Docker, Kubernetes, and Helm.
• Gained real-world experience in building production-ready pipelines.

?? Key Takeaways

1. Automation is Key: A fully automated CI/CD pipeline reduces manual effort and accelerates releases.
2. Modularity and Reusability: Using tools like Helm and Docker ensures consistency across environments.
3. Monitoring is Critical: Tools like Prometheus and Grafana provide visibility into application health.