build a complete Agentic DevOps Environment end-to-end.
This is not a script
This is a mini autonomous DevOps platformrunning locally.
We will build:
✅ GitHub Repo
✅ AI Agent (Decision Brain)
✅ Jenkins CI/CD
✅ SonarQube (Code Quality)
✅ Trivy (Security Scan)
✅ Docker Deployment
✅ Health Check + Rollback
✅ Slack Notification (Optional)
All inside Docker.
You’ll have a real working Agent-Driven CI/CD System.
🏗 FINAL ARCHITECTURE
Text
GitHub PR
↓ (Webhook)
AI Agent (Flask + LLM + Rules)
↓ Decision
Jenkins Pipeline
↓
├── Build
├── Unit Test
├── Sonar Scan
├── Trivy Scan
├── Docker Build
├── Deploy Container
├── Health Check
└── Rollback if Failed
↓
Feedback to GitHub PR
🚀 PHASE 1 — FULL ENVIRONMENT SETUP
✅ Step 1: Create Project Folder
mkdir agentic-devops
cd agentic-devops
✅ Step 2: Create docker-compose.yml
This runs everything.
version: '3'
services:
jenkins:
image: jenkins/jenkins:lts
container_name: jenkins
ports:
- "8080:8080"
volumes:
- jenkins_home:/var/jenkins_home
sonarqube:
image: sonarqube
container_name: sonarqube
ports:
- "9000:9000"
agent:
build: ./agent
container_name: agent
ports:
- "5000:5000"
volumes:
jenkins_home:
Run:
docker-compose up -d
🧠 PHASE 2 — Build the AI Agent
Create folder:
Bash
mkdir agent
cd agent
requirements.txt
Text
flask
requests
openai
agent.py
Python
from flask import Flask, request
import requests
import os
app = Flask(__name__)
JENKINS_URL = "http://jenkins:8080/job/demo/build"
JENKINS_USER = "admin"
JENKINS_TOKEN = "your_token"
@app.route("/webhook", methods=["POST"])
def webhook():
data = request.json
if "pull_request" in data:
pr_title = data["pull_request"]["title"]
print("PR received:", pr_title)
decision = analyze_pr(pr_title)
if decision == "approve":
trigger_pipeline()
return "Pipeline triggered", 200
else:
return "PR Rejected", 403
return "Ignored", 200
def analyze_pr(title):
# Simple logic (extend with LLM later)
risky_words = ["delete", "drop table", "shutdown"]
for word in risky_words:
if word in title.lower():
return "reject"
return "approve"
def trigger_pipeline():
requests.post(
JENKINS_URL,
auth=(JENKINS_USER, JENKINS_TOKEN)
)
if name == "main":
app.run(host="0.0.0.0", port=5000)
Dockerfile
*Dockerfile
FROM python:3.10
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["python", "agent.py"
Rebuild:
docker-compose build
docker-compose up -d
🔧 PHASE 3 — Jenkins Complete Pipeline
Create Jenkinsfile inside microservice repo:
Groovy
pipeline {
agent any
stages {
stage('Build') {
steps {
sh 'mvn clean package'
}
}
stage('Unit Test') {
steps {
sh 'mvn test'
}
}
stage('SonarQube Scan') {
steps {
sh 'mvn sonar:sonar'
}
}
stage('Security Scan - Trivy') {
steps {
sh 'docker build -t demo-service:latest .'
sh 'trivy image demo-service:latest'
}
}
stage('Deploy') {
steps {
sh 'docker run -d --name demo -p 8081:8080 demo-service:latest'
}
}
stage('Health Check') {
steps {
script {
sleep(10)
def response = sh(
script: "curl -s http://localhost:8081/health",
returnStdout: true
).trim()
if (response != "OK") {
sh "docker stop demo"
error("Deployment failed - rolled back")
}
}
}
}
}
}
"🔔 PHASE 4 — Connect GitHub Webhook"
GitHub Repo → Settings → Webhooks
Payload URL:
Text
http://your-ip:5000/webhook
Events: ✔ Pull Requests
🧠 WHAT MAKES THIS AGENTIC?
Normal CI:
PR triggers pipeline blindly.
Your Agentic CI:
Evaluates PR
Makes decision
Blocks risky changes
Runs full intelligent pipeline
Verifies health
Rolls back
Reports outcome
That is autonomous behavior.
🔥 PHASE 5 — Upgrade to Real AI (Optional)
Replace rule logic with LLM:
Py
import openai
def analyze_pr(title):
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{"role": "system", "content": "You are a senior DevSecOps engineer."},
{"role": "user", "content": f"Review this PR title and decide approve or reject: {title}"}
]
)
decision = response['choices'][0]['message']['content']
if "approve" in decision.lower():
return "approve"
return "reject"
Now your DevOps system has AI judgment.
🎯 You Now Have
✔ AI-driven PR validation
✔ Intelligent CI/CD
✔ Security scanning
✔ Code quality gate
✔ Auto deployment
✔ Health validation
✔ Rollback
This is a complete mini Agentic DevOps platform.
PHASE 1 — FULL ENVIRONMENT SETUP
We’ll use:
Docker Desktop (with K8s enabled)
Jenkins (Docker)
SonarQube (Docker)
Agent (Flask)
Kubernetes (local cluster)
✅ Step 1: Enable Kubernetes
In Docker Desktop:
Settings → Kubernetes → Enable
Verify:
Bash
Copy code
kubectl get nodes
You should see:
Copy code
docker-desktop
🧠 PHASE 2 — Updated docker-compose.yml
Now we separate CI + Agent only.
Yaml
Copy code
version: '3'
services:
jenkins:
image: jenkins/jenkins:lts
container_name: jenkins
ports:
- "8080:8080"
volumes:
- jenkins_home:/var/jenkins_home
sonarqube:
image: sonarqube
container_name: sonarqube
ports:
- "9000:9000"
agent:
build: ./agent
container_name: agent
ports:
- "5000:5000"
volumes:
jenkins_home:
Run:
Bash
Copy code
docker-compose up -d
🚀 PHASE 3 — Kubernetes Deployment Files
Create folder in microservice repo:
Bash
Copy code
mkdir k8s
deployment.yaml
Yaml
Copy code
apiVersion: apps/v1
kind: Deployment
metadata:
name: demo-service
spec:
replicas: 2
selector:
matchLabels:
app: demo-service
template:
metadata:
labels:
app: demo-service
spec:
containers:
- name: demo-service
image: demo-service:latest
ports:
- containerPort: 8080
livenessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 10
periodSeconds: 5
service.yaml
Yaml
Copy code
apiVersion: v1
kind: Service
metadata:
name: demo-service
spec:
type: NodePort
selector:
app: demo-service
ports:
- port: 80
targetPort: 8080
nodePort: 30007
Apply manually first:
Bash
Copy code
kubectl apply -f k8s/
Test:
Copy code
http://localhost:30007/health
🔥 PHASE 4 — Jenkins Pipeline with Kubernetes
Now we modify Jenkinsfile.
Groovy
C
pipeline {
agent any
environment {
IMAGE_NAME = "demo-service"
}
stages {
stage('Build') {
steps {
sh 'mvn clean package'
}
}
stage('Docker Build') {
steps {
sh "docker build -t $IMAGE_NAME:latest ."
}
}
stage('Deploy to Kubernetes') {
steps {
sh "kubectl apply -f k8s/"
sh "kubectl rollout status deployment/demo-service"
}
}
stage('Health Check') {
steps {
script {
sleep(15)
def response = sh(
script: "curl -s http://localhost:30007/health",
returnStdout: true
).trim()
if (response != "OK") {
sh "kubectl rollout undo deployment/demo-service"
error("Deployment failed. Rolled back.")
}
}
}
}
}
}
Now we have:
✔ Kubernetes deployment
✔ Rollout monitoring
✔ Automatic rollback
🧠 PHASE 5 — Upgrade AI Agent for Smart Deployment
Now improve decision logic.
Update agent.py:
Python
Copy code
def analyze_pr(title):
if "db" in title.lower():
return "manual_approval"
if "hotfix" in title.lower():
return "approve"
return "approve"
Add logic:
Python
Copy code
if decision == "manual_approval":
return "Needs Manual Review", 403
Now AI classifies deployment risk.
**🚀 PHASE 6 — Advanced Autonomous Health Verification
Instead of curl only, agent can:
Query pod status
Check restart count
Check CPU spik
Add inside pipeline:
Groovy
stage('Verify Pods') {
steps {
script {
sh "kubectl get pods"
sh "kubectl describe deployment demo-service"
}
}
}
For advanced:
Agent queries:
kubectl get events
If CrashLoopBackOff detected → rollback.
🎯 WHAT YOU BUILT NOW
You now have:
✔ AI-based PR evaluation
✔ Intelligent CI trigger
✔ Kubernetes deployment
✔ Rolling updates
✔ Auto rollback
✔ Health validation
✔ Multi-replica service
✔ Liveness probes
This is a real Autonomous DevOps System
🔥 To Make This Enterprise-Level
Next additions:
1️⃣ Use Docker Registry
Push image to local registry instead of latest tag.
2️⃣ Canary Deployment
Deploy v2 with 10% traffic.
3️⃣ Prometheus Metrics Check
Agent checks error rate before approving rollout.
4️⃣ GitOps (ArgoCD)
Agent modifies Git manifest → Argo deploys.
5️⃣ Multi-Microservice Detection
Agent analyzes changed directory → deploy only affected service.