Apa itu Ingress dan bagaimana ia me-route trafik eksternal ke Service?

Question

IT Interview Practice · Accepted Answer

Sebuah **Ingress** adalah objek Kubernetes yang mendefinisikan **aturan routing HTTP/HTTPS** — memetakan hostname dan path URL ke **Service** backend. Ia dijalankan oleh sebuah **Ingress Controller** (nginx, Traefik, gateway cloud) dan memberi Anda satu titik masuk, terminasi TLS, dan routing host/path alih-alih satu LoadBalancer per service.

## Masalah yang dipecahkan Ingress

```text
Mengekspos banyak service dengan type: LoadBalancer berarti BANYAK cloud LB (dan IP publik)
— mahal, dan tanpa routing hostname/path bersama atau TLS.
Ingress memberi SATU titik masuk yang me-route berdasarkan host & path ke Service ClusterIP internal.
```

## Bagaimana semuanya terhubung

```text
      Internet
         │
   ┌─────┴──────────────┐
   │ Ingress Controller │  (sebuah Pod, mis. nginx; biasanya di belakang SATU LoadBalancer)
   │  reads Ingress rules│
   └─────┬──────────────┘
         │ me-route berdasarkan host / path
   ┌─────┼───────────────┬───────────────┐
   ▼                     ▼               ▼
 Service: web        Service: api    Service: admin  (semuanya ClusterIP)
   │                     │               │
 Pods                  Pods            Pods

Ingress (aturan)  ≠  Ingress Controller (proxy berjalan yang memaksakannya)
```

## Sebuah manifest Ingress

```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        # cert/key TLS disimpan di sebuah 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" → Pod api
shop.example.com/...     → Service "web" → Pod web
TLS diterminasi di controller memakai cert dalam Secret "shop-tls".
```

## Poin-poin kunci

```text
• Anda WAJIB menjalankan Ingress Controller — objek Ingress saja tidak melakukan apa pun.
• ingressClassName memilih controller mana yang menangani aturan.
• Ingress hanya HTTP/HTTPS (L7). Untuk TCP/UDP mentah pakai Service atau Gateway API.
• Gateway API yang lebih baru adalah penerus yang terus berkembang dengan routing lebih kaya dan berorientasi peran.
```

```bash
kubectl get ingress                  # daftar aturan, host, alamat
kubectl describe ingress app-ingress # lihat backend & event
```

## Mengapa ini penting

Ingress adalah cara standar untuk mengekspos aplikasi HTTP/HTTPS ke dunia luar di Kubernetes, sehingga memahaminya adalah pengetahuan networking esensial bagi insinyur level menengah. Masalah yang dipecahkannya konkret dan umum: mengekspos banyak service via `type: LoadBalancer` berarti menyediakan cloud load balancer dan IP publik terpisah per service — mahal dan tanpa routing hostname bersama atau TLS — sedangkan sebuah **Ingress** memberi Anda satu titik masuk yang me-route berdasarkan **host dan path** ke Service ClusterIP internal dan menterminasi **TLS** secara terpusat. Perbedaan yang membuat orang tersandung adalah antara **objek Ingress** (aturan routing deklaratif) dan **Ingress Controller** (proxy berjalan sesungguhnya — nginx, Traefik, gateway cloud — yang mengawasi aturan itu dan memaksakannya); aturan tidak melakukan apa pun tanpa controller yang terpasang, dan `ingressClassName` memilih controller mana yang menanganinya. Memahami bahwa Ingress beroperasi di **L7 (hanya HTTP/HTTPS)** — sehingga TCP/UDP mentah membutuhkan Service atau Gateway API yang lebih baru — dan bahwa **Gateway API** adalah penerus yang terus berkembang dan lebih ekspresif, mencerminkan pengetahuan terkini di dunia nyata. Karena hampir setiap aplikasi yang menghadap pengguna di Kubernetes membutuhkan routing berbasis host/path dan TLS dari satu titik masuk, dan karena perbedaan objek-vs-controller sering menjadi sumber kebingungan baik dalam wawancara maupun praktik, pemahaman kokoh atas Ingress adalah fondasi untuk mengekspos dan mengoperasikan workload web di sebuah cluster.

Masalah yang dipecahkan Ingress

Bagaimana semuanya terhubung

Sebuah manifest Ingress

Poin-poin kunci

Mengapa ini penting

Pertanyaan terkait