Kubernetes 101: Ingress

Ingress di Kubernetes itu API object yang keren banget buat ngatur akses eksternal ke layanan-layanan dalam cluster.

Perkenalan

Ingress di Kubernetes itu API object yang keren banget buat ngatur akses eksternal ke layanan-layanan dalam cluster. Ingress bukan cuma alat teknis, Ingress juga jadi jembatan yang nyambungin permintaan pengguna ke layanan yang tepat di ekosistem Kubernetes.

Beda sama strategi networking lain kayak NodePort atau LoadBalancer, Ingress ngasih lo kontrol detail buat routing HTTP dan HTTPS ke layanan dalam cluster, berdasarkan berbagai faktor kayak host atau path.

Peran dan Fungsi Ingress

Peran utama Ingress itu termasuk load balancing, SSL termination, dan domain-based virtual hosting. Ingress nyediain aturan yang terpusat dan terorganisir buat ngatur koneksi masuk, ia bikin jaringan jadi lebih efisien. Intinya, Ingress berfungsi sebagai "pintu" ke cluster, dan ngatur akses eksternal ke layanan dengan efisien.

Load Balancing

Load balancing itu proses buat ngebagi traffic jaringan ke beberapa server atau pod biar nggak ada satu server yang kewalahan. Peran ini penting banget buat menjaga responsifitas dan ketersediaan aplikasi. Di konteks Kubernetes Ingress, load balancing fokus buat ngebagi traffic masuk ke layanan backend yang sesuai, berdasarkan aturan Ingress.

Load balancing yang dilakukan sama Ingress di Kubernetes punya beberapa kemampuan canggih nih, kayak gini:

• Session Affinity: Kemampuan load balancer buat ngirim semua permintaan dari klien ke pod yang sama setelah koneksi terjalin. Ini penting banget buat aplikasi yang butuh nyimpen state.
• Custom Load Balancing Algorithms: Beberapa Ingress Controllers ngizinin lo pake algoritma kustom buat load balancing, nggak cuma yang standar kayak round-robin atau least-connections.
• Health Checks and Failovers: Kalau ada pod yang nggak sehat, load balancer bakal otomatis berhenti ngirim traffic ke situ dan alihin ke pod lain yang sehat.

SSL Termination

SSL (Secure Sockets Layer) sama penggantinya, TLS (Transport Layer Security), itu protokol kriptografi buat jaga komunikasi jadi aman di jaringan komputer. Pas traffic dienkripsi pake SSL/TLS, informasi itu jadi ga bisa dibaca sama siapa pun kecuali server yang lo kirim informasi ke situ.

Di konteks Kubernetes Ingress, SSL Termination itu proses di mana Ingress Controller yang bertanggung jawab buat dekrip permintaan SSL/TLS. Jadi SSL/TLS itu 'dihentikan' di load balancer, nantinya backend server nggak perlu repot-repot ngelakuin dekripsi dan enkripsi traffic SSL/TLS.

Kalo udah ngumpulin proses komputasi ini di Ingress Controller, lo bisa lebih gampang atur dan update sertifikat SSL/TLS lo, jadi sistemnya bakal lebih aman. Ini juga bikin sumber daya di backend server lo lebih lega buat fokus jalanin aplikasi lo.

Domain-based Virtual Hosting

Domain-based virtual hosting itu fitur yang bikin satu IP address bisa host banyak domain atau hostnames. Tiap domain bisa diarahin ke layanan yang beda di dalam cluster. Caranya ya pake Host HTTP header buat bedain antara domain yang satu sama yang lain.

Contohnya, lo bisa punya konfigurasi Ingress yang ngarahin semua traffic dari service1.example.com ke layanan bernama service1 di cluster lo, dan semua traffic dari service2.example.com ke layanan bernama service2.

Kemampuan buat ngarahin traffic berdasarkan nama domain ini itu bener-bener keren banget kalo lo punya banyak microservices, karena lo bisa ekspos banyak layanan pake satu IP address, pake domain yang beda buat tiap layanan. Fitur routing berbasis domain di Kubernetes Ingress bikin dia jadi pilihan yang oke banget buat arsitektur microservices kayak gitu.

Prinsip Kerja Ingress

Ingress tuh kerjanya kayak reverse proxy gitu. Dia nerima koneksi yang masuk dan ngirimin ke layanan yang sesuai di dalam cluster. Biar lo paham cara kerjanya, nih coba pelajarin peran Ingress controllers dan Ingress rules:

• Ingress Controllers: Ini sebenernya pod di dalam cluster yang baca dan terapin aturan yang didefinisikan di Ingress Resources. Controller-controller ini bisa jadi server reverse proxy apa aja, dan perannya itu ngatur rute akses masuk.
• Ingress Rules: Ini instruksi khusus yang ngarahin aliran traffic. Pas pengguna ngirim permintaan, Ingress Controller bakal cek aturan Ingress dan kirim permintaan ke layanan yang cocok.

Contohnya, lo bisa punya aturan Ingress yang ngarahin traffic yang dikirim ke serviceA.yourdomain.com ke layanan serviceA di dalam cluster lo, dan serviceB.yourdomain.com ke serviceB. Lo juga bisa punya aturan berdasarkan path URL, misalnya yourdomain.com/serviceA dialihin ke serviceA dan yourdomain.com/serviceB ke serviceB.

Enkripsi SSL/TLS buat komunikasi yang aman juga dikelola di bagian ini, dengan Ingress Controllers pake secrets yang disediain buat dekrip traffic dan nerusin ke layanan yang sesuai.

Ingress dengan Relation pada Services dan Endpoint Resources

Ingress, Services, dan Endpoint Resources itu kayak komponen-komponen yang saling terhubung dalam ekosistem Kubernetes.

• Services di Kubernetes itu cara abstrak buat ekspos aplikasi yang jalan di sekelompok Pods. Mereka ngasih titik akhir statis yang bisa digunain aplikasi lain buat akses fungsi-fungsi yang ditawarin sama aplikasi lo.
• Endpoint Resources itu objek Kubernetes yang nyimpen alamat IP dan port dari Pods yang bisa diarahin traffic sama suatu service.

Ingress ngalihin traffic yang masuk ke services, yang kemudian dialihin lagi ke endpoint pods mereka. Service dan endpoint resources itu mengabstraksi sifat berubah-ubah dari pods, biar Ingress bisa alihin traffic ke alamat yang tetep walaupun pods nya berubah-ubah.

Software Ingress

Pemilihan Ingress Controller yang pas itu perlu banget. Lo bisa milih tergantung beberapa faktor kayak kasus penggunaan yang spesifik, kompleksitas sistem lo, dan jenis traffic yang lo harapkan. Nih, beberapa opsi yang bisa lo pertimbangkan:

• Nginx: Opsi populer banget karena performa dan stabilitasnya yang tinggi, Nginx punya banyak opsi konfigurasi. Bagus banget buat handle berbagai beban kerja dan punya komunitas yang aktif buat dukungan.
• Traefik: Dikenal dengan kesederhanaan dan konfigurasi otomatisnya, Traefik cocok buat lo yang pengen manajemen yang lancar dan tanpa ribet. Dia juga mendukung protokol-modern kayak gRPC dan WebSockets.
• HAProxy atau Ambassador: Kalo lo butuh manajemen traffic yang advanced, kedua Ingress Controller ini bisa dipertimbangkan, sih, soalnya mereka punya fitur kaya untuk kontrol traffic, termasuk rate limiting yang advanced dan circuit breakers yang detail.

Setiap controller emang punya kelebihan dan kekurangan masing-masing, dan intinya sesuaikan aja sama kebutuhan spesifik cluster lo.

Konfigurasi Ingress

Ingress di Kubernetes punya banyak banget opsi buat ngatur traffic, termasuk routing berdasarkan path dan host, juga konfigurasi SSL/TLS yang advanced.

Path dan Host-Based Routing: Konfigurasi ini ngalihin traffic berdasarkan path URL dan hostname. Misalnya, lo bisa alihin 'myapp.com/users' ke 'user-service' dan 'myapp.com/payments' ke 'payment-service'.

Konfigurasi SSL/TLS: Ingress bisa disetel dengan berbagai macam konfigurasi SSL/TLS. Lo bisa punya satu wildcard certificate buat banyak subdomain atau certificate spesifik buat tiap layanan. Dia juga mendukung protokol-proto baru kayak HTTP/2 dan gRPC, yang butuh konfigurasi khusus.

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  tls:
  - hosts:
    - myapp.example.com
    secretName: myapp-certificate
  rules:
  - host: myapp.example.com
    http:
      paths:
      - pathType: Prefix
        path: "/users"
        backend:
          service:
            name: user-service
            port:
              number: 8080
      - pathType: Prefix
        path: "/payments"
        backend:
          service:
            name: payment-service
            port:
              number: 8080

Nih, uraiannya:

• apiVersion: Ini versi API Kubernetes yang lo pake buat bikin objek ini.
• kind: Ini nentuin tipe resource Kubernetes yang mau lo buat. Dalam kasus ini, kita bikin Ingress.
• metadata: Ini berisi data tentang Ingress, kayak nama dan anotasinya. Di kasus ini, resource Ingress dinamain "example-ingress", dan bakal ada anotasi yang ngubah semua permintaan yang masuk ke root (/) dari service yang ditarget.
• spec: Ini tempat dimana perilaku Ingress didefinisiin.
• tls: Bagian ini dipake buat nentuin sertifikat TLS buat domain yang ditentuin. Di contoh ini, kita pake secret yang namanya myapp-certificate yang berisi sertifikat TLS buat domain myapp.example.com.
• rules: Bagian ini berisi daftar aturan host buat traffic HTTP.
• rules.host: Buat host myapp.example.com, kita pake aturan ini:
• rules.http.paths: Bagian ini berisi semua aturan berbasis jalur dan layanan backend terkait.
• rules.http.paths.pathType: Ini nentuin gimana path permintaan yang masuk dicocokin dengan nilai path. Prefix berarti semua path yang dimulai sama nilai itu harus diarahin ke backend service yang ditentuin.
• rules.http.paths.path: Semua traffic yang dateng ke myapp.example.com/users atau myapp.example.com/payments bakal diarahin ke backend service masing-masing.
• rules.http.paths.backend: Tempat kita nentuin backend service kemana traffic bakal diarahin. Kita udah nentuin dua service: user-service dan payment-service yang bakal dengerin di port 8080.

Jadi, dengan konfigurasi Ingress ini, permintaan client ke myapp.example.com/users bakal diarahin ke service user-service di cluster Kubernetes, dan permintaan ke myapp.example.com/payments bakal diarahin ke payment-service. Semua keputusan routing ini dibuat di level Ingress, sebelum traffic nyampe ke service aplikasinya sendiri.

PathType

Di Kubernetes Ingress, field pathType dipake buat nentuin gimana Ingress Controller harus nyocokin permintaan yang masuk dengan nilai path yang udah lo definisiin di manifest Ingress lo. Di versi API networking.k8s.io/v1, ada tiga nilai yang valid: Exact, Prefix, dan ImplementationSpecific.

• Exact: Permiintaan path yang masuk harus persis banget sama kayak path yang udah lo tentuin di aturan Ingress. Misalnya, kalo aturan lo punya path: "/foo" dan pathType: Exact, aturan itu cuma berlaku buat permintaan yang path-nya bener-bener /foo. Kalo permintaannya nggak sama persis, ya nggak bakal cocok.
• Prefix: Tipe path ini nyocokin berdasarkan prefix URL path yang dipisah dengan /. Pencocokannya dilakuin elemen per elemen. Misalnya, kalo aturan lo punya path: "/foo" dan pathType: Prefix, itu bakal cocok buat semua permintaan yang dimulai dengan /foo, kayak /foo, /foo/, /foo/bar, dan seterusnya.
• ImplementationSpecific: Ini tipe path default yang dipake kalo lo nggak spesifikin tipe path. ImplementationSpecific ninggalin interpretasi aturan pencocokan ke Ingress Controller. Perilaku implementasinya bisa mirip dengan Prefix atau Exact, atau bisa juga perilaku custom yang ditentuin sama controller. Tapi, ONXP saranin lo buat spesifikin tipe path dengan jelas biar nggak ada ambiguitas.

Ingat, ya, cara path diinterpretasi dan apakah permintaan diarahin ulang atau nggak (respon HTTP 301 atau 302) tergantung sama implementasi Ingress Controller yang spesifik, dan tipe path yang dipilih juga bisa pengaruhin ini.

Ingress Annotation

Annotation di Kubernetes ngasih lo kemampuan buat nambahin metadata non-identifikasi ke objek. Buat Ingress, annotation bisa dipake buat kustomisasi perilaku Ingress controller.

Efek dari sebuah annotation tergantung sama Ingress controller yang lo pake. Nih beberapa contoh pake NGINX Ingress Controller yang sering dipake:

nginx.ingress.kubernetes.io/rewrite-target: Ini dipake kalo lo mau ngubah URL path sebelum nerusin traffic ke backend service. Misalnya:

nginx.ingress.kubernetes.io/rewrite-target: /$2

nginx.ingress.kubernetes.io/ssl-redirect: Ini memaksa pengalihan SSL, terlepas dari protokol yang digunakan untuk panggilan asli. Misalnya:

nginx.ingress.kubernetes.io/ssl-redirect: "true"

Konfigurasi ini bakal ngapus bagian path yang dicocokin dan ganti dengan nilai di rewrite-target. Ini berguna banget kalo backend service lo ngarepin traffic di endpoint yang beda.

nginx.ingress.kubernetes.io/ssl-redirect: Ini maksa redirection ke SSL, gak peduli protokol yang dipake buat panggilan aslinya. Misalnya:

nginx.ingress.kubernetes.io/affinity: "cookie"

nginx.ingress.kubernetes.io/affinity: "cookie"

Konfigurasi ini bakal pake cookie untuk ngaktifin session affinity.

nginx.ingress.kubernetes.io/cors-allow-headers: Ini ngasih lo kontrol buat nentuin header mana yang diizinin buat permintaan cross-origin. Misalnya:

nginx.ingress.kubernetes.io/cors-allow-headers: "DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type"

Konfigurasi ini cuma bakal ngizinin header tertentu buat permintaan cross-origin.

Jadi, itulah Kubernetes Ingress. Mulai dari cara konfigurasi path, tipe-tipe path yang bisa dipilih, sampe gimana cara pake annotation buat ngustomisasi perilaku Ingress controller. Dengan pemahaman ini, lo bisa lebih efektif ngerouting traffic ke service-service di dalam cluster Kubernetes lo.