This project involves 3 layers:

1. Frontend: Nginx serving the web pages.

2. Backend: Apache HTTP serving as a backend service.

3. Database: MySQL storing the application data.

The main idea for choosing this project is that it touches almost every fundamental concept that I have learned and documented in my previous blog.

• Pods & Deployments to run the containers.

• Services to provide stable access for the frontend, backend and database.

• Ingress to route traffic efficiently between frontend and backend.

• ConfigMaps & Secrets to manage application configurations and sensitive information like database passwords.

• PersistentVolumes & PersistentVolumeClaims to ensure MySQL data persists even if pods restart.

• Namespaces to organize and isolate resources for this project.

So yes — that’s it!

Create a Namespace

It’s always better to because it provides logical isolation of resources within a Kubernetes cluster.

# namespace.yaml
apiVersion: v1
kind: Namespace
metadata: 
    name: webapp

Apply it.

kubectl apply -f namespace.yaml

Create a ConfigMaps and Secrets

It’s always a good practice to store all the sensitive credentials like db password in secret and we can store application configuration files in configmaps.

Creating Secrets

apiVersion: v1
kind: Secret
metadata:
  name: mysql-secret
  namespace: webapp
type: Opaque
data: 
  mysql-root-password: cm9vdHBhc3M=   # base64 for 'rootpass'

# convert into base64
echo -n "rootpass" | base64

Creating ConfigMaps

apiVersion: v1
kind: ConfigMaps
metadata:
  name: webapp-config
  namespace: webapp
data:
  API_URL: "http://backend-svc:8000"

Apply both secret and configmaps.

kubectl apply -f mysql-secret.yaml
kubectl apply -f webapp-config.yaml

Now, to not let my data dissolve when my pod gets recreated, I need to create PV and PVCs for MySQL.

Creating PV + PVCs for MySQL

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mysql-pv
  namespace: webapp
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /mnt/data/mysql
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pvc
  namespace: webapp
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Apply it:

kubectl apply -f pv-pvc.yaml

Deployments for Frontend, Backend and Database

For Frontend (Deployment + Service)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  namespace: webapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend
        image: nginx:latest
        ports:
        - containerPort: 80
        envFrom:
        - configMapRef:
            name: webapp-config
---
apiVersion: v1
kind: Service
metadata:
  name: frontend-svc
  namespace: webapp
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 30080
  selector:
    app: frontend

Apply it.

kubectl apply -f frontend.yaml

For Backend (Deployment + Service)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
  namespace: webapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - name: backend
        image: hashicorp/http-echo
        args:
          - "-text=Hello from backend"
          - "-listen=:80"
        ports:
        - containerPort: 80  # ← Change from 8080 to 80
---
apiVersion: v1
kind: Service
metadata:
  name: backend-svc
  namespace: webapp
spec:
  type: ClusterIP
  ports:
  - port: 80          # ← Match the container port
    targetPort: 80
  selector:
    app: backend

# i could also use https:latest image in here but have used "hashicorp/http-echo" cause my backend
# is not a real application yet and I wanted a simple test endpoint that responds to /api requests.

Apply it.

kubectl apply -f backend.yaml

For Database (Deployment + Service)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql
  namespace: webapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:5.7
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-secret
              key: mysql-root-password
        ports:
        - containerPort: 3306
        volumeMounts:
        - name: mysql-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-storage
        persistentVolumeClaim:
          claimName: mysql-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: mysql-svc
  namespace: webapp
spec:
  type: ClusterIP
  ports:
  - port: 3306
  selector:
    app: mysql

Apply it.

kubectl apply -f database.yaml

Now after I create deployment for frontend, backend and databases, in a specific namespace - Now I need to enable ingress in my cluster to efficiently route traffic.

minikube addons enable ingress

Now, ingress rule:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: webapp-ingress
  namespace: webapp
spec:
  rules:
  - host: webapp.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: frontend-svc
            port:
              number: 80
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: backend-svc
            port:
              number: 80

Apply this:

kubectl apply -f ingress.yaml

Testing

If you are running Kubernetes directly on a Linux server, you can access your applications via a browser by adding the Minikube IP to your /etc/hosts file like this:

<minikube_IP> webapp.local

Once that’s done, you can access your services using:

• http://webapp.local/ → frontend

• http://webapp.local/api → backend

Since I’m running Minikube through WSL, accessing these URLs via a browser isn’t straightforward, so using curl is the simplest way to interact with the services.

Testing frontend and backend with curl.

curl http://webapp.local
curl http://webapp.local/api

Minikube VM is on a separate network from my Windows host. Thats why I can’t directly access URLs like http://webapp.local from my browser.

To solve this, port forwarding is a simple and effective option.

kubectl port-forward svc/frontend-svc 8080:80 -n webapp

svc/frontend-svc → the service you want to forward.
8080 → the port on your local machine.
80 → the port the service is listening on inside the cluster.
-n webapp → namespace of the service.

You can expose the backend in the same way, but exposing the backend is not generally a good practice.
Now in your browser visit: http://localhost:8080