8th Week :- "Why Kubernetes Services Fall Short in DevOps – And How Ingress Solves It

🚫 Problem: Why Kubernetes Services Alone Are Not Ideal for Production

In Kubernetes, a Service is used to expose a set of Pods as a network service. It ensures that traffic is correctly routed to healthy pods using a stable IP address or DNS name. There are mainly three types of Services:

1. ClusterIP – accessible only within the cluster (default)

2. NodePort – exposes service on a static port on each node

3. LoadBalancer – creates an external load balancer (on supported cloud providers)

❌ Drawbacks of Using Just Services

---

✅ Solution: Ingress + Ingress Controller

🌐 What is Ingress?

Ingress is an API object in Kubernetes that acts as an entry point to your cluster. It allows you to route external HTTP and HTTPS traffic to internal services based on:

• Hostnames (example.com)

• Paths (/api, /frontend)

• TLS settings

Think of Ingress as a smart router for your Kubernetes apps.

🧠 What is Ingress Controller?

Ingress rules alone don’t do anything. You need an Ingress Controller, which is a pod running in your cluster that watches the Ingress objects and fulfills the routing.

Popular Ingress Controllers:

• NGINX Ingress Controller

• HAProxy Ingress

• Traefik

• Istio Gateway (part of service mesh)

Among these, NGINX is the most widely used due to its simplicity and flexibility.

---

🧾 Sample Ingress YAML File (Using NGINX)

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
  namespace: default
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
    - host: myapp.example.com
      http:
        paths:
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: backend-service
                port:
                  number: 5000
          - path: /
            pathType: Prefix
            backend:
              service:
                name: frontend-service
                port:
                  number: 80

🧩 Breakdown of Ingress YAML

---

📦 Step-by-Step Example: Deploy Backend and Frontend with Ingress

🎯 Use Case

You have two services:

• Frontend (React/Vue) served on /

• Backend (Express/Django) served on /api

1️⃣ Backend Deployment YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
        - name: backend
          image: your-dockerhub/backend:latest
          ports:
            - containerPort: 5000
---
apiVersion: v1
kind: Service
metadata:
  name: backend-service
spec:
  selector:
    app: backend
  ports:
    - protocol: TCP
      port: 5000
      targetPort: 5000
  type: ClusterIP

2️⃣ Frontend Deployment YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
        - name: frontend
          image: your-dockerhub/frontend:latest
          ports:
            - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: frontend-service
spec:
  selector:
    app: frontend
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

3️⃣ Ingress YAML File (Same as Above)

Ensure your domain (myapp.example.com) is pointing to your cluster’s LoadBalancer IP.

---

⚙️ Setting up NGINX Ingress Controller

✅ Step 1: Install via Helm

bashCopyEdithelm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

helm install nginx-ingress ingress-nginx/ingress-nginx \
  --set controller.publishService.enabled=true

✅ Step 2: Get External IP

bashCopyEditkubectl get svc -n ingress-nginx

Look for the EXTERNAL-IP of the nginx-ingress-controller and point your domain (myapp.example.com) to it using DNS.

---

☁️ How This Works in a Cloud Provider

1. You deploy the backend and frontend via kubectl apply -f deployment.yml.

2. You install the Ingress Controller (NGINX).

3. You create an Ingress resource with routing rules.

4. Your cloud provider provisions a LoadBalancer for the Ingress Controller.

5. You map your domain to that LoadBalancer IP.

6. Incoming requests are handled by the Ingress Controller and routed based on your rules.

✅ Final Thoughts

Ingress is an essential part of production-ready Kubernetes clusters. It reduces costs, simplifies networking, improves maintainability, and is crucial for DevOps success in cloud deployments.