How to Set Up a 3-Tier Architecture on Kubernetes

By /

Listen to this Post

Featured Image
In modern cloud-native applications, the 3-tier architecture remains a dominant pattern, especially when deployed on Kubernetes. This architecture separates applications into three logical layers:

  1. Presentation Tier (Frontend) – Handles user interaction (e.g., web UI).
  2. Application Tier (Backend) – Processes business logic (e.g., APIs).
  3. Data Tier (Database) – Manages data storage (e.g., PostgreSQL, MySQL).

You Should Know: Kubernetes Deployment Steps for 3-Tier Architecture

1. Deploy the Frontend (Presentation Tier)

Use a Deployment and Service to expose the frontend:

apiVersion: apps/v1
kind: Deployment
metadata:
name: frontend
spec:
replicas: 3
selector:
matchLabels:
app: frontend
template:
metadata:
labels:
app: frontend
spec:
containers:
- name: nginx
image: nginx:latest
ports:
- containerPort: 80

apiVersion: v1
kind: Service
metadata:
name: frontend-service
spec:
selector:
app: frontend
ports:
- protocol: TCP
port: 80
targetPort: 80
type: LoadBalancer

2. Deploy the Backend (Application Tier)

A Node.js API can be deployed with:

apiVersion: apps/v1
kind: Deployment
metadata:
name: backend
spec:
replicas: 2
selector:
matchLabels:
app: backend
template:
metadata:
labels:
app: backend
spec:
containers:
- name: api
image: node:18
command: ["node", "server.js"]
ports:
- containerPort: 3000

apiVersion: v1
kind: Service
metadata:
name: backend-service
spec:
selector:
app: backend
ports:
- protocol: TCP
port: 3000
targetPort: 3000

3. Deploy the Database (Data Tier)

For a PostgreSQL database with persistent storage:

apiVersion: apps/v1
kind: StatefulSet
metadata:
name: postgres
spec:
serviceName: "postgres"
replicas: 1
selector:
matchLabels:
app: postgres
template:
metadata:
labels:
app: postgres
spec:
containers:
- name: postgres
image: postgres:15
env:
- name: POSTGRES_PASSWORD
value: "securepassword"
ports:
- containerPort: 5432
volumeMounts:
- name: postgres-storage
mountPath: /var/lib/postgresql/data
volumeClaimTemplates:
- metadata:
name: postgres-storage
spec:
accessModes: [ "ReadWriteOnce" ]
resources:
requests:
storage: 10Gi

apiVersion: v1
kind: Service
metadata:
name: postgres-service
spec:
selector:
app: postgres
ports:
- protocol: TCP
port: 5432
targetPort: 5432

4. Verify Deployment

Check running pods:

kubectl get pods

Access logs:

kubectl logs <pod-name>

Port-forward to test services:

kubectl port-forward svc/frontend-service 8080:80

What Undercode Say

The 3-tier architecture remains a robust choice for Kubernetes deployments due to its scalability and separation of concerns. By leveraging Deployments, Services, and StatefulSets, you ensure high availability and resilience. Future trends may shift towards serverless and microservices, but for now, mastering this pattern is essential for cloud engineers.

Prediction

Kubernetes will continue evolving, but 3-tier architectures will stay relevant for monolithic and hybrid cloud apps. Expect tighter AI/ML integration in orchestration tools.

Expected Output:

  • Frontend accessible at `http://:80`
  • Backend API at `http://backend-service:3000`
  • PostgreSQL at `postgres-service:5432`

https://youtube.com/r0VCvxdIFno

References:

Reported By: Nagavamsi Do – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅

Join Our Cyber World:

💬 Whatsapp | 💬 Telegram

Related Posts: