Ingress Controller Explained: Routing External Traffic in Kubernetes

Introduction

In Kubernetes, Services such as ClusterIP, NodePort, and LoadBalancer provide ways to expose applications. However, when multiple applications are running inside a cluster, managing external access becomes difficult and expensive.

Imagine having:

Website Application
API Application
Monitoring Dashboard

Creating a separate LoadBalancer for each application increases complexity and cloud costs.

This is where Ingress and Ingress Controllers come into play.

Ingress provides a smart way to route external traffic to different services using a single entry point.

In this guide, we will learn Ingress, Ingress Controllers, architecture, traffic routing, real-world examples, and interview questions.

What is an Ingress?

An Ingress is a Kubernetes resource that manages external HTTP and HTTPS access to services within a cluster.

It provides:

URL-Based Routing
Host-Based Routing
SSL/TLS Termination
Centralized Traffic Management
Load Balancing

Why Do We Need Ingress?

Without Ingress:

Frontend → LoadBalancer
Backend → LoadBalancer
Monitoring → LoadBalancer

Problems:

Multiple Public IPs
Higher Cloud Costs
Complex Management

With Ingress:

Internet
    │
    ▼
Ingress Controller
    │
 ┌──┼──┐
 ▼  ▼  ▼
Frontend
Backend
Monitoring

Benefits:

Single Entry Point
Reduced Cost
Easier Management

What is an Ingress Controller?

An Ingress resource alone cannot process traffic.

A separate component called an Ingress Controller is required.

The Ingress Controller:

Reads Ingress Rules
Monitors Cluster Changes
Routes Traffic
Performs Load Balancing

Think of it as a reverse proxy running inside Kubernetes.

Popular Ingress Controllers

NGINX Ingress Controller

Most widely used.

Traefik

Popular for cloud-native environments.

HAProxy Ingress

High-performance option.

AWS Load Balancer Controller

Used on AWS EKS.

Istio Gateway

Used in Service Mesh architectures.

Kubernetes Ingress Architecture

Internet
    │
    ▼
Load Balancer
    │
    ▼
Ingress Controller
    │
 ┌──┼──┐
 ▼  ▼  ▼
Frontend Service
Backend Service
Monitoring Service

Traffic enters through the Ingress Controller and is routed to the appropriate service.

How Ingress Works

Step 1:

User accesses:

https://example.com

Step 2:

Request reaches Ingress Controller.

Step 3:

Ingress Rules are evaluated.

Step 4:

Traffic is forwarded to the correct Service.

Step 5:

Service forwards traffic to Pods.

Host-Based Routing

Different domains can point to different services.

Example:

app.example.com
api.example.com
monitor.example.com

Traffic Flow

app.example.com
      │
      ▼
Frontend Service

api.example.com
      │
      ▼
Backend Service

Path-Based Routing

Traffic can be routed based on URL paths.

Example:

/app
/api
/admin

Routing Example

/app  → Frontend Service

/api  → Backend Service

/admin → Admin Service

Ingress Resource Example

apiVersion: networking.k8s.io/v1
kind: Ingress

metadata:
  name: app-ingress

spec:
  rules:

  - host: app.example.com

    http:
      paths:

      - path: /
        pathType: Prefix

        backend:
          service:
            name: frontend-service

            port:
              number: 80

Apply Ingress:

kubectl apply -f ingress.yaml

Multiple Service Routing Example

apiVersion: networking.k8s.io/v1
kind: Ingress

metadata:
  name: ecommerce-ingress

spec:
  rules:

  - host: shop.example.com

    http:
      paths:

      - path: /products
        pathType: Prefix

        backend:
          service:
            name: product-service

            port:
              number: 80

      - path: /orders
        pathType: Prefix

        backend:
          service:
            name: order-service

            port:
              number: 80

SSL/TLS with Ingress

Ingress supports HTTPS traffic.

Example:

tls:
- hosts:
  - app.example.com

  secretName: tls-secret

Benefits:

Secure Communication
SSL Offloading
Centralized Certificate Management

Installing NGINX Ingress Controller

Example:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/cloud/deploy.yaml

Verify Installation:

kubectl get pods -n ingress-nginx

Real-World Example

Suppose a company runs:

Frontend Application

shop.company.com

Backend API

api.company.com

Monitoring Dashboard

monitor.company.com

Instead of creating three LoadBalancers:

3 Public IPs
3 LoadBalancers
Higher Cost

The company uses:

1 Ingress Controller
1 LoadBalancer
Multiple Routes

This is the standard architecture in production Kubernetes environments.

Ingress vs LoadBalancer

Feature	Ingress	LoadBalancer
Layer	Layer 7 (HTTP/HTTPS)	Layer 4
URL Routing	✅	❌
Host Routing	✅	❌
SSL Termination	✅	❌
Cost Efficient	✅	❌
Multiple Services	✅	Limited

Benefits of Ingress

Centralized Traffic Management

Manage all routes from one place.

Cost Optimization

Reduces the number of LoadBalancers.

SSL Termination

Handles HTTPS centrally.

Better Scalability

Supports large microservices environments.

Advanced Routing

Supports path-based and host-based routing.

Common Mistakes

❌ Creating Ingress without an Ingress Controller

❌ Incorrect DNS configuration

❌ Missing TLS certificates

❌ Wrong backend service names

❌ Exposing sensitive applications publicly

Kubernetes Interview Questions

What is Ingress?

Ingress is a Kubernetes resource used to manage external HTTP and HTTPS traffic routing to services.

What is an Ingress Controller?

An Ingress Controller is a component that processes Ingress rules and routes traffic accordingly.

Can Ingress work without an Ingress Controller?

No. Ingress rules require an Ingress Controller to function.

What is the most popular Ingress Controller?

NGINX Ingress Controller.

What is the difference between Ingress and LoadBalancer?

Ingress provides Layer 7 routing and supports multiple services through a single entry point, while LoadBalancer exposes a service directly.

Does Ingress support HTTPS?

Yes. Ingress supports SSL/TLS termination using certificates.

Conclusion

Ingress Controllers are a critical part of Kubernetes networking. They provide a centralized and cost-effective way to route external traffic to applications running inside a cluster.

By using host-based routing, path-based routing, SSL termination, and load balancing, Ingress simplifies traffic management and improves scalability for modern cloud-native applications.

Understanding Ingress Controllers is essential before learning advanced topics such as Helm, Persistent Volumes, StatefulSets, RBAC, and Kubernetes Security.