Wat is Ingress en hoe routeert het extern verkeer naar Services?

Question

IT Interview Practice · Accepted Answer

Een **Ingress** is een Kubernetes-object dat **HTTP/HTTPS-routingregels** definieert — het koppelt hostnames en URL-paden aan backend-**Services**. Het wordt vervuld door een **Ingress Controller** (nginx, Traefik, cloud-gateways) en geeft je één entrypoint, TLS-terminatie en host/path-routing in plaats van een LoadBalancer per service.

## Het probleem dat Ingress oplost

```text
Veel services blootstellen met type: LoadBalancer betekent VEEL cloud-LB's (en publieke IP's)
— duur, en geen gedeelde hostname/path-routing of TLS.
Ingress geeft ÉÉN entrypoint dat op host & path routeert naar interne ClusterIP-Services.
```

## Hoe het in elkaar past

```text
      Internet
         │
   ┌─────┴──────────────┐
   │ Ingress Controller │  (a Pod, e.g. nginx; usually behind ONE LoadBalancer)
   │  reads Ingress rules│
   └─────┬──────────────┘
         │ routes by host / path
   ┌─────┼───────────────┬───────────────┐
   ▼                     ▼               ▼
 Service: web        Service: api    Service: admin  (all ClusterIP)
   │                     │               │
 Pods                  Pods            Pods

Ingress (rules)  ≠  Ingress Controller (the running proxy that enforces them)
```

## Een Ingress-manifest

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  tls:
    - hosts: [shop.example.com]
      secretName: shop-tls        # TLS-cert/key opgeslagen in een Secret
  rules:
    - host: shop.example.com
      http:
        paths:
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: api
                port: { number: 80 }
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port: { number: 80 }
```

```text
shop.example.com/api/... → Service "api" → api Pods
shop.example.com/...     → Service "web" → web Pods
TLS wordt beëindigd bij de controller met de cert in de "shop-tls" Secret.
```

## Kernpunten

```text
• Je MOET een Ingress Controller draaien — het Ingress-object alleen doet niets.
• ingressClassName selecteert welke controller de regels afhandelt.
• Ingress is alleen HTTP/HTTPS (L7). Voor rauwe TCP/UDP gebruik een Service of Gateway API.
• De nieuwere Gateway API is de evoluerende opvolger met rijkere, rolgerichte routing.
```

```bash
kubectl get ingress                  # lijst regels, hosts, adressen
kubectl describe ingress app-ingress # bekijk backends & events
```

## Waarom het belangrijk is

Ingress is de standaardmanier om HTTP/HTTPS-applicaties naar de buitenwereld bloot te stellen op Kubernetes, dus het begrijpen ervan is essentiële netwerkkennis voor medior engineers. Het probleem dat het oplost is concreet en veelvoorkomend: veel services blootstellen via `type: LoadBalancer` betekent per service een aparte cloud load balancer en publiek IP provisioneren — duur en zonder gedeelde hostname-routing of TLS — terwijl een **Ingress** je één entrypoint geeft dat op **host en path** routeert naar interne ClusterIP-Services en **TLS** centraal beëindigt. Het onderscheid waar mensen over struikelen is dat tussen het **Ingress-object** (declaratieve routingregels) en de **Ingress Controller** (de daadwerkelijk draaiende proxy — nginx, Traefik, een cloud-gateway — die die regels bewaakt en afdwingt); de regels doen niets zonder een geïnstalleerde controller, en `ingressClassName` selecteert welke controller ze afhandelt. Begrijpen dat Ingress op **L7 (alleen HTTP/HTTPS)** werkt — dus rauwe TCP/UDP heeft een Service of de nieuwere Gateway API nodig — en dat de **Gateway API** de evoluerende, expressievere opvolger is, weerspiegelt actuele, praktijkgerichte kennis. Omdat vrijwel elke gebruikersgerichte applicatie op Kubernetes host/path-gebaseerde routing en TLS vanuit één entrypoint nodig heeft, en omdat het object-versus-controller-onderscheid een frequente bron van verwarring is in zowel interviews als praktijk, is een gedegen begrip van Ingress fundamenteel om webworkloads op een cluster bloot te stellen en te bedienen.

Het probleem dat Ingress oplost

Hoe het in elkaar past

Een Ingress-manifest

Kernpunten

Waarom het belangrijk is

Gerelateerde vragen