DEV Community: Jonathan Chijioke

Flask Web + DB on Kubernetes

Jonathan Chijioke — Wed, 06 Aug 2025 18:24:01 +0000

🧰 Project Overview

This project demonstrates how to:
• Containerize a simple Flask web app and a mock database API
• Deploy both services using Kubernetes
• Use inter-service communication inside the cluster
• Access the frontend via browser and retrieve data from the backend

📦** Project Structure**

🔧 Prerequisites
• Docker
• Minikube
• kubectl
• A basic understanding of Python and terminal commands

*Step 1: Create the Flask Apps
Web/app.py (file)
*

📄 db/app.py

🐳 Step 2: Dockerize the Apps

📄 web/Dockerfile

📄 db/Dockerfile

📄 requirements.txt (for both)

🧪 Step 3: Build Docker Images in Minikube

RUN:

minikube start
eval $(minikube docker-env)

Then build:
docker build -t flask-web ./web
docker build -t flask-db ./db
**
🧾 Step 4: Create Kubernetes Deployment & Service Files
**
📄 db-deployment.yaml

📄 web-deployment.yaml

🚀 Step 5: Deploy to Kubernetes

kubectl apply -f db-deployment.yaml
kubectl apply -f web-deployment.yaml

Check the status:

kubectl get pods
kubectl get services

🌐 Step 6: Access the Web App

minikube service web-service --url

*I went on to improve the project by adding monitoring and logging *

✅ Monitoring using Prometheus + Grafana
✅ Logging using Loki + Grafana

*Goal *

Prometheus - Collect metrics (CPU, memory, HTTP request)
Grafana - Visualize metrics and logs
Loki - Collect and search logs

🧱 Prerequisites

Make sure you have:
• Minikube
• kubectl
• Your web and db services already deployed
• Optional: Helm (we’ll use it for easier installation)

*Part 1: Monitoring with Prometheus + Grafana *

✅ Step 1: Enable Helm in Minikube (optional but recommended)
**
minikube addons enable helm-tiller
**
✅ Step 2: Add Helm Repos

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo add grafana https://grafana.github.io/helm-charts
helm repo update

✅ Step 3: Install Prometheus

helm install prometheus prometheus-community/prometheus

This installs:
• Prometheus server
• Node exporter
• Alertmanager

Check it: kubectl get pods
**
✅ Step 4: Install Grafana**

helm install grafana grafana/grafana \
--set adminPassword='admin' \
--set service.type=NodePort

Find the Grafana service:

minikube service grafana --url

✅ Step 5: Add Prometheus as Data Source in Grafana

Open Grafana (from minikube service grafana)
Go to Settings > Data Sources
Click Add Data Source
Choose Prometheus
URL: http://prometheus-server
Click Save & Test Now you’re ready to build dashboards! ** ✅ Step 6: Add Metrics to Your Flask Apps (Optional but recommended) ** Add prometheus_flask_exporter to both web/requirements.txt and db/requirements.txt:

Flask
requests
prometheus_flask_exporter

Update both app.py files:

from prometheus_flask_exporter import PrometheusMetrics

metrics = PrometheusMetrics(app)

Rebuild and redeploy the images:

eval $(minikube docker-env)
docker build -t flask-web ./web
docker build -t flask-db ./db
kubectl rollout restart deployment web
kubectl rollout restart deployment db

Kubernetes Cluster Deployment (Mini DevOps Project)

Jonathan Chijioke — Wed, 06 Aug 2025 18:12:22 +0000

Tools
Docker, Kubernetes

What to Do:
• Deploy a Node.js or Python app on a Kubernetes cluster.
• Use Minikube for local testing.

Outcome: Demonstrates understanding of containerization & orchestration.

How This Project is Useful to Companies or the Industries
This project mimics how modern tech companies manage applications in production environments using containers and Kubernetes, which are industry standards for:

Consistency: Docker ensures apps behave the same across all environments.
Scalability & Availability: Kubernetes can scale apps up/down automatically and keep them running smoothly—even during failures.
Microservices Deployment: Most modern systems are built as microservices, and Kubernetes helps manage their communication and lifecycles.
Automation & CI/CD Pipelines: This project fits into automated deployment workflows used in DevOps teams.
Cloud-Ready Skillset: Companies on AWS, Azure, or GCP expect familiarity with these tools—even if starting in a local setup like Minikube.

Real-World Business Value & Problem-Solving Impact

This project directly addresses challenges that real companies face in software deployment and infrastructure management:

Problem: “It works on my machine”

Company Challenge: Apps behave differently in development, testing, and production environments.

How This Project Helps:
Docker standardizes the app environment, ensuring it runs the same way everywhere—from a developer’s laptop to a production server.

Problem: Manual, inconsistent deployments

Company Challenge: Manual deployment leads to human error, downtime, and lack of traceability.

How This Project Helps:
Using Kubernetes and YAML configuration allows declarative, version-controlled deployments, which are automated, repeatable, and scalable.

Problem: Need for scalability and high availability

Company Challenge: Handling traffic spikes or keeping services running when something crashes.

How This Project Helps:
Kubernetes manages multiple replicas of the app and can self-heal by restarting failed containers. It supports horizontal scaling to meet demand automatically.

Problem: Complex application management

Company Challenge: Managing microservices or multiple apps becomes complex without orchestration.

How This Project Helps:
Kubernetes provides a central control plane to deploy, monitor, and scale containerized apps efficiently, simplifying infrastructure management.

Problem: Transition to DevOps culture

Company Challenge: Companies want to move from traditional IT to agile DevOps workflows.

How This Project Helps:
This project shows practical knowledge of CI/CD principles, container lifecycle management, and DevOps tools that companies look for in junior to mid-level engineers.

Infrastructure as Code (AWS Terraform Project)

Jonathan Chijioke — Wed, 06 Aug 2025 13:28:31 +0000

Tools
TERRAFORM AND AWS

*WHAT TO DO *
•Write Terraform scripts to deploy AWS EC2, S3, and a Load Balancer.
•Automate provisioning with Ansible.

FUNCTION
The main function of this project is to automate the deployment and configuration of cloud infrastructure on AWS using Infrastructure as Code (IaC).

Primary Purpose / Main Function:
To provision and configure a scalable, cloud-based environment on AWS using Terraform for infrastructure and Ansible for software configuration — all automatically, repeatably, and reliably.

What This Means Practically:
1. Infrastructure Automation:
• Launch EC2 instances
• Create S3 buckets
• Set up a Load Balancer
→ all through code, not clicking in the AWS console.
2. Configuration Management:
• Automatically install and configure software (like Nginx) on EC2 using Ansible.
3. Repeatability & Version Control:
• Since everything is defined in code, you can version it in Git and reuse it.

Why It’s Valuable:
• Mimics real-world DevOps practices
• Reduces human error
• Scales infrastructure easily
• Saves time and effort for developers and sysadmins

*NEW THINGS I LEARNED FROM THIS PROJECTS *

Tools and Technologies
Terraform - Infrastructure as Code (IaC) tool to provision cloud resources on AWS.
Key Concepts: Providers, Resources, Variables, Outputs, State Files
Real-World Use: Used by DevOps engineers to automate cloud setup

Ansible - Configuration management tool for installing software and configuring servers.
Key Concepts: Playbooks, Inventory files, Tasks, Modules (apt, service, etc.)
Real-World Use: Automate post-deployment setup (e.g., install Nginx)

Important Files Created
Main.tf - Defines your AWS resources (EC2, S3, ALB)
provider.tf - Sets your AWS region/provider
variables.tf - Declares configurable variables (e.g., instance type)
outputs.tf - Prints useful outputs like EC2 IP
playbook.yml - Ansible playbook to install/configure software
hosts.ini - Ansible inventory to list EC2 host(s)

How This Project Solves Real-World Industry Problems

Problem: Manual and Error-Prone Infrastructure Deployment

In many organizations, infrastructure is still created manually through the AWS console or basic scripting, which is time-consuming, inconsistent, and prone to human error.

Solution: This project uses Terraform, an Infrastructure as Code (IaC) tool, to define infrastructure in reusable, version-controlled code. This allows companies to:

Automatically provision EC2 instances, S3 buckets, and load balancers
Create identical environments for dev, test, and production
Reduce deployment times from hours to minutes

Problem: Configuration Drift and Manual Server Setup

Without automation, servers are often configured differently over time, leading to inconsistencies and hard-to-reproduce bugs.

Solution: This project uses Ansible to automate configuration and software installation (e.g., installing Nginx on EC2). This:
•Ensures consistent server setup every time
•Prevents configuration drift
•Saves sysadmin and DevOps time during scaling or recovery

Problem: Slow Time-to-Market and Poor DevOps Practices

Companies aiming for continuous integration and deployment (CI/CD) struggle with manual bottlenecks in infrastructure and setup.

Solution: The project showcases modern DevOps practices by:
• Automating environment provisioning and setup
• Making infrastructure changes auditable via Git version control
• Allowing developers to spin up environments on demand

This reduces lead time for deployment, accelerates product delivery, and enables agile workflows.

Problem: Scalability and Resilience Challenges

Traditional infrastructure may not scale well with increased user demand or fail gracefully.

Solution: With Terraform managing scalable AWS components like Load Balancers, and EC2 autoscaling (if extended), companies can:
• Balance traffic automatically
• Improve availability and fault tolerance
• Prepare infrastructure for high-traffic events

Problem: High Operational Costs and Inefficiency

Hiring large teams to manually manage cloud resources can become expensive and unmanageable.

Solution: This automation:
• Lowers operational overhead
• Reduces the need for manual intervention
• Frees up engineering resources for higher-value tasks

Basic CI/CD Pipeline (For a Web App)

Jonathan Chijioke — Wed, 06 Aug 2025 13:06:36 +0000

TOOLS

Github Actions/ Jennkins

Function of Github Actions

Continuous Integration (CI)
• Automatically run tests when you push code.
• Lint, format, or validate your code.
• Build your app (React, Node, Java, etc.) after every change
Continuous Deployment (CD)
• Deploy your app to:
• AWS EC2 or S3
• Heroku, Vercel, Netlify
• Docker Hub, Kubernetes, etc.
• Can trigger on branch pushes (e.g., main or production).
Automation
Run tasks like:
• Sending Slack/email notifications
• Creating GitHub releases
• Syncing branches
• Automatically labeling PRs/issues

WHY GITHUB ACTION

Native to GitHub
• No need for extra tools or integrations.
• Everything is configured in your repo using simple YAML files.
Automation Made Easy
• Automate tests, builds, deployments, notifications, and more.
• Triggers on events like push, pull_request, issue, etc.
Continuous Integration & Deployment (CI/CD)
• Run tests automatically every time you push code.
• Build and deploy to production (e.g., EC2, Netlify, Firebase) right from GitHub.
Secure & Scalable
• Uses GitHub Secrets to safely store credentials.
• Can scale from small side projects to large teams.
Custom Workflows
• You define what happens and when.
• Use thousands of community-created actions or write your own.

GitHub Actions saves you time, reduces errors, and gives you full control over your development and deployment pipelines — all inside GitHub.

What to Do:
• Set up GitHub Actions to automate the deployment of a simple web app.
• Deploy the app on AWS EC2 or DigitalOcean.

BEST PRACTICE RECOMMENDATION

For individual developers, small teams, and projects hosted on GitHub: GitHub Actions is best practice It’s faster to set up, easier to maintain, and integrates natively with GitHub
For large enterprise setups, complex workflows, or non-GitHub codebases: Jenkins is best It gives more control and flexibility, especially in custom pipelines or on-premise requirements.

Conclusion:
Use GitHub Actions if you’re starting out or want speed and simplicity.
Use Jenkins if you need deep customisation and enterprise-level control.

NEW THINGS I LEARNED FROM THIS PROJECT

Tools and Technologies Used
PM2 - Node- Node.js process manager for keeping app alive on EC2
Dotenv - Manages environment variables (.env file)

Important Files Created
.env - Stores sensitive config like PORT (ignored by Git)
Jenkinsfile - pipeline as code script defining automated stages

*How This CI/CD Project Is Useful for Companies
*

Solves the Problem of Manual Deployment 🚨 The Problem:

Many small to mid-sized companies still deploy apps manually — uploading files via FTP, running scripts by hand, or SSH-ing into servers to restart apps. This is slow, error-prone, and not scalable.

✅ Solution:
• With a Jenkinsfile and GitHub integration, every time code is pushed, Jenkins:
• Pulls the latest code
• Installs dependencies
• Runs (optional) tests
• Deploys to production using pm2
• This reduces human error, increases deployment speed, and allows developers to focus on coding, not server maintenance.

Introduces CI/CD Practices to Streamline Development

🚨 The Problem:

Without CI/CD, teams struggle with:
• Unpredictable deployments
• Lack of version control in production
• Difficulty reproducing builds

✅ Your Solution:
• The project introduces Continuous Integration and Continuous Deployment (CI/CD) practices.
• Jenkins acts as a single source of truth for:
• Build history
• Test results
• Deployment logs
• This standardizes the release process and ensures repeatable deployments across environments.

Makes Onboarding New Developers Easier

🚨 The Problem:

New hires often waste days setting up local environments or learning how the deployment works.

✅ Your Solution:
• Your app has a README.md, .gitignore, .env config, and Jenkinsfile — this makes the repo:
• Self-documenting
• Easy to clone and run
• Transparent about CI/CD logic
• New devs can start contributing faster, reducing downtime during onboarding.

Improves Uptime and Error Recovery

🚨 The Problem:

If a Node.js app crashes on a live server, it can go down for hours if there’s no monitoring or recovery tool.

✅ Your Solution:
• You use PM2 to:
• Automatically restart the app if it crashes
• Save and reload the app on server reboots
• This enhances reliability and uptime — a key priority for companies running customer-facing services.

Reduces Infrastructure Cost for Startups or SMEs

🚨 The Problem:

Not every business can afford complex CI/CD tools like CircleCI, GitLab CI/CD, or AWS CodePipeline.

✅ Your Solution:
• Jenkins is open-source and free
• EC2 is pay-as-you-go
• This stack is perfect for:
• Startups
• Non-profits
• Internal apps at larger enterprises
• It provides professional-grade automation at minimal cost.

Lays the Foundation for DevOps Culture

🚨 The Problem:

Many teams operate in silos — developers don’t talk to sysadmins, and releases break due to miscommunication.

✅ Your Solution:
• By using CI/CD and automated deployments, your project:
• Brings Dev and Ops workflows together
• Makes the build & deployment process visible and repeatable
• Encourages a shared understanding of how code gets to production

This promotes a DevOps culture, even in companies that are just starting to adopt modern practices.