Cara Install NGINX Ingress Controller di Kubernetes (Lengkap + Contoh Konfigurasi)

Pengantar

Dalam dunia container orchestration, Kubernetes menjadi solusi populer untuk mengelola aplikasi berbasis container. Namun, setelah aplikasi berjalan di dalam cluster, muncul kebutuhan penting yaitu bagaimana cara mengakses aplikasi tersebut dari luar cluster. Di sinilah peran Ingress Controller menjadi sangat penting, dan salah satu yang paling banyak digunakan adalah NGINX Ingress Controller yang berfungsi sebagai gateway untuk mengatur lalu lintas HTTP/HTTPS menuju service di dalam Kubernetes. NGINX Ingress Controller ini penting karena memudahkan routing traffic ke berbagai service, mendukung domain dan subdomain (host-based routing), serta mendukung SSL/TLS (HTTPS), sehingga lebih fleksibel dibandingkan NodePort atau LoadBalancer biasa. Karena Kubernetes yang berjalan di VPS tidak memiliki LoadBalancer secara default, kita akan menggunakan MetalLB untuk menyediakan external IP agar service bisa diakses dari luar. Artikel ini akan membahas langkah lengkap mulai dari instalasi hingga konfigurasi akses menggunakan domain.

Apa Itu Ingress di Kubernetes?

Ingress adalah resource di Kubernetes yang digunakan untuk mengatur akses HTTP/HTTPS dari luar ke dalam cluster, menentukan aturan routing berdasarkan host atau path, serta berfungsi sebagai “gerbang masuk” ke aplikasi yang berjalan di dalam cluster. Namun, Ingress tidak dapat berjalan sendiri karena hanya berupa sekumpulan aturan, sehingga dibutuhkan Ingress Controller seperti NGINX untuk mengeksekusi dan memproses request sesuai konfigurasi yang telah ditentukan.

Persiapan Sebelum Install

Sebelum mulai, pastikan kamu sudah memenuhi beberapa persyaratan berikut:

Memiliki cluster Kubernetes yang sudah aktif (bisa menggunakan kubeadm, Minikube, atau layanan cloud)
kubectl sudah terinstal dan terhubung dengan cluster Kubernetes
Node memiliki akses internet untuk melakukan pull image yang dibutuhkan

Install MetalLB

Karena kita menggunakan VPS, kita perlu membuat LoadBalancer sendiri menggunakan MetalLB.

Install MetalLB
MetalLB digunakan untuk menyediakan IP eksternal (LoadBalancer) pada cluster Kubernetes di environment non-cloud seperti VPS atau bare metal.
```
kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.13.12/config/manifests/metallb-native.yaml
```
Membuat IP Pool
IP Pool digunakan untuk menentukan range IP yang akan dipakai oleh MetalLB.
Buat file konfigurasi:
```
nano ip-pool.yaml
```
Isi konfigurasi:
```
apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: default-pool
  namespace: metallb-system
spec:
  addresses:
  - 192.168.1.240-192.168.1.250
```
Apply:
```
kubectl apply -f ip-pool.yaml
```
Catatan:
- Gunakan IP yang masih kosong (tidak digunakan sistem)
- IP harus berada dalam satu network dengan node
Membuat L2 Advertisement
Digunakan untuk mengumumkan IP yang sudah dibuat agar bisa digunakan oleh service.
Buat file:
```
nano l2.yaml
```
Isi konfigurasi:
```
apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: l2
  namespace: metallb-system
```
Apply:
```
kubectl apply -f l2.yaml
```
Verifikasi MetalLB
```
kubectl get pods -n metallb-system
```
Pastikan semua pod berstatus Running.

Cara Install NGINX Ingress Controller

Install NGINX Ingress Controller
Cara paling umum untuk menginstall Ingress Controller adalah menggunakan manifest resmi dari Kubernetes.
```
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/cloud/deploy.yaml
```
Perintah ini akan:
- Membuat namespace ingress-nginx
- Deploy controller
- Membuat service (biasanya LoadBalancer)
Cek Status Pod
Pastikan semua pod berjalan dengan baik:
```
kubectl get pods -n ingress-nginx
```
Pastikan:
- Status Running
- Tidak ada error atau crash
Cek Service Ingress
```
kubectl get svc -n ingress-nginx
```
Biasanya akan muncul:
- LoadBalancer jika menggunakan cloud
- NodePort jika menggunakan VPS atau lokal
Contoh output:
```
ingress-nginx-controller   NodePort   10.x.x.x      80:30080/TCP
```
(Opsional) Ubah ke LoadBalancer
Jika menggunakan VPS atau lab lokal, ubah tipe service menjadi LoadBalancer:
```
kubectl edit svc ingress-nginx-controller -n ingress-nginx
```
Ubah menjadi :
```
type: LoadBalancer
```

Deploy nginx menggunakan Ingress

Di tahap ini, kita akan menggunakan domain publik sehingga aplikasi bisa diakses dari internet.

Siapkan Domain dan DNS
Misalnya Anda memiliki domain:
```
app.example.com
```
Tambahkan A record di DNS provider (Cloudflare, Niagahoster, dan lainnya):
```
app.example.com → IP_POOL_METALLB
```
Pastikan:
- IP mengarah ke server Kubernetes
- DNS sudah terpropagasi (biasanya 1–5 menit)

Deploy Aplikasi

Buat deployment:

kubectl create deployment nginx-app --image=nginx

Expose ke service:

kubectl expose deployment nginx-app --port=80 --type=ClusterIP

Cek status:

kubectl get pods
kubectl get svc

Pastikan Ingress Controller Aktif
```
kubectl get pods -n ingress-nginx
kubectl get svc -n ingress-nginx
```
Pastikan:
- Pod Ingress berstatus Running
- Service memiliki external IP atau bisa diakses
Membuat Ingress (Domain)

Buat file konfigurasi:
```
nano ingress.yaml
```
Isi konfigurasi berikut:
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: app.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-app
            port:
              number: 80
```
Penjelasan konfigurasi:
- apiVersion digunakan untuk menentukan versi API Kubernetes
- kind: Ingress menandakan resource yang dibuat adalah Ingress
- metadata.name adalah nama Ingress
- ingressClassName: nginx menunjukkan bahwa Ingress menggunakan NGINX Controller
- host adalah domain yang akan digunakan untuk akses aplikasi
- path: / berarti semua request diarahkan ke service
- pathType: Prefix mencocokkan semua path yang diawali dengan "/"
- service.name adalah nama service tujuan
- port.number adalah port service yang digunakan
Apply konfigurasi:
```
kubectl apply -f ingress.yaml
```
Akses dari Browser
```
http://app.example.com
```
Output:

Keterangan:
Jika berhasil, halaman default NGINX akan tampil di browser.

Kesimpulan

NGINX Ingress Controller merupakan solusi penting dalam Kubernetes untuk mengatur akses aplikasi dari luar cluster dengan cara yang lebih rapi, fleksibel, dan scalable. Ingress sendiri hanya berisi aturan routing, sedangkan Ingress Controller bertugas mengeksekusi aturan tersebut dan mengarahkan traffic ke service yang sesuai. Pada environment VPS atau bare metal, penggunaan MetalLB menjadi kunci agar Kubernetes dapat memiliki external IP layaknya di cloud. Dengan konfigurasi yang tepat, yaitu Ingress Controller menggunakan tipe LoadBalancer dan service aplikasi menggunakan ClusterIP, aplikasi dapat diakses menggunakan domain tanpa perlu NodePort. Secara keseluruhan, kombinasi NGINX Ingress Controller, MetalLB, dan domain menghasilkan arsitektur yang mudah diakses dari internet, mendukung banyak aplikasi dalam satu cluster, lebih terstruktur serta mudah dikelola, dan siap digunakan untuk kebutuhan production. Dengan memahami alur ini, kamu tidak hanya berhasil melakukan setup, tetapi juga memahami konsep dasar bagaimana traffic dikelola di Kubernetes secara profesional.