From broken builds to a fully automated deployment pipeline.
As part of my DevOps learning journey, I wanted to build something practical, realistic, and close to production workflows — not just follow tutorials.
So I built a two-tier web application and automated its entire build, test, and deployment lifecycle using Jenkins, Docker, and Docker Compose.
This article walks through:
• The architecture I built
• The CI/CD pipeline design
• Real issues I faced (and fixed)
• Key DevOps learnings
🧱 Project Overview
The goal was simple but important:
Automate everything from code commit to deployment — with no manual steps.
Tech Stack
• Frontend / API: Flask (Python)
• Database: MySQL
• CI/CD: Jenkins (Pipeline as Code)
• Containerization: Docker
• Orchestration: Docker Compose
• Version Control: GitHub
🏗 Architecture Overview
The application follows a classic two-tier architecture:
• Web tier: Flask application
• Data tier: MySQL database
• Both services run in separate Docker containers
• Managed via Docker Compose
GitHub
↓
Jenkins Pipeline
↓
Docker Build
↓
Tests
↓
Docker Compose Deploy
🐳 Docker & Docker Compose Setup
Docker Compose is used to define and run multiple containers together.
Services:
• db: MySQL 8 container
• web: Flask application container
Key highlights:
• Database initialization using init.sql
• Environment variables for DB connectivity
• Service dependency (web depends on db)
📸 Image: docker-compose.yml (services definition)
🐍 Flask Application
The Flask app exposes simple endpoints:
• / → health check
• /users → fetches data from MySQL
The database connection is handled using environment variables, making the app environment-agnostic.
📸 Image: db.py (MySQL connection using env variables)
📸 Image: app.py (Flask routes and app runner)
This design ensures:
• No hardcoded credentials
• Easy containerization
• Smooth CI/CD execution
🐋 Dockerfile (Application Image)
The Flask app is containerized using a simple, optimized Dockerfile:
• Lightweight base image (python:3.9-slim)
• Dependency installation via requirements.txt
• Exposes port 5000
• Runs the app using CMD
📸 Image: Dockerfile
⚙️ Jenkins CI/CD Pipeline
This is where the real DevOps work happens.
The pipeline is written using Jenkins Declarative Pipeline and stored as a Jenkinsfile in the repository.
Pipeline Stages:
1. Checkout – Pull source code from GitHub
2. Build Image – Build Docker images using Docker Compose
3. Run Tests – Start DB container and validate application
4. Deploy – Bring up all services using Docker Compose
📸 Image: Jenkinsfile (pipeline stages)
📊 Jenkins Stage View (Pipeline Execution)
The Jenkins Stage View clearly shows:
• Which stage failed
• How long each stage took
• When the pipeline finally turned green
This helped massively during debugging.
📸 Image: Jenkins Stage View (failed → successful build)
🧨 Real Issues I Faced (and Fixed)
This project was not smooth, and that’s where the learning came from.
🔴 Issue 1: Jenkins couldn’t find Jenkinsfile
• Root cause: Case sensitivity
• jenkinsfile ≠ Jenkinsfile
✅ Fixed by forcing correct filename in Git
🔴 Issue 2: docker: not found in Jenkins
• Jenkins was running inside a container
• Docker CLI wasn’t available inside Jenkins
✅ Installed Docker CLI inside Jenkins container
🔴 Issue 3: Docker Compose v1 vs v2 mismatch
• Jenkins environment only had docker-compose
• Pipeline was using docker compose
✅ Aligned Jenkinsfile with available tooling
🔴 Issue 4: Permission denied on /var/run/docker.sock
• Jenkins user couldn’t talk to Docker daemon
• Linux socket permission issue
✅ Fixed by adjusting Docker socket permissions (for local CI)
✅ Final Result
After resolving all issues:
• ✔ Fully automated CI/CD pipeline
• ✔ Build → Test → Deploy without manual steps
• ✔ Dockerized multi-container application
• ✔ Jenkins pipeline running clean and green
📸 Image: Successful Jenkins pipeline run
📚 Key Learnings
This project taught me far more than any tutorial:
• DevOps is more about debugging systems than writing YAML
• Linux fundamentals matter a lot
• CI/CD environments behave differently than local machines
• Logs are your best debugging tool
• Small permission issues can break entire pipelines
• Automation only works when every layer is understood
🔗 Source Code
GitHub Repository:
👉 https://github.com/developedbyviv/Two-tier-Architecture-Application
Top comments (1)
Jenkins in 2025... you are funny 😆