2022-06-18

Service dalam Kubernetes

Apa itu Service dalam Kubernetes

Dalam Kubernetes, mengelola bagaimana bagian-bagian aplikasi Anda berkomunikasi satu sama lain atau dengan layanan eksternal sangat penting. Di situlah konsep "Service" masuk ke dalam permainan. Service dalam Kubernetes adalah resource yang Anda gunakan untuk mengekspos aplikasi yang berjalan dalam sekelompok Pod sebagai layanan jaringan.

Service melacak alamat IP pod menggunakan pemilih label. Karena pod bersifat ephemeral (berumur pendek), kumpulan pod yang dikirimkan lalu lintas oleh sebuah layanan dapat berubah secara dinamis saat pod dibuat dan dihapus. Alamat IP sebuah layanan tetap sama seiring berjalannya waktu, dan aplikasi lain dapat mengandalkan alamat yang konsisten ini meskipun terjadinya perubahan pod yang mendasarinya.

Service Kubernetes berperan sebagai penyeimbang beban L4 (Layer 4). Ini memastikan bahwa lalu lintas didistribusikan di antara pod-pod yang tersedia.

Diagram berikut menggambarkan bagaimana Service beroperasi:

  +--------------+     +------------+     +------------+
  |              |     |            |     |            |
  |    Client    +----->  Service   +----->    Pod     |
  |              |     |            |     |            |
  +--------------+     +------------+     +------------+
                           /\ |
                          /   \
                 selector /     \ label
                        /       \
           +------------+       +------------+
           |            |       |            |
           |    Pod     |       |    Pod     |
           |            |       |            |
           +------------+       +------------+

Client: Memulai permintaan.
Service: Mendistribusikan lalu lintas jaringan.
Pods: Memproses permintaan.

Jenis Service dalam Kubernetes

Ada tiga jenis Service dalam Kubernetes:

ClusterIP
NodePort
LoadBalancer

Service ClusterIP

Pod bersifat ephemeral, dan sulit untuk mengetahui pada node mana sebuah Pod ditempatkan. Bahkan jika Anda mengetahuinya, Pod dapat sering di-restart, sehingga tidak ada jaminan untuk mengakses Pod yang sama secara konsisten.

Menggunakan Service ClusterIP bermanfaat karena ia mengabstraksi alamat IP Pod yang sifatnya tidak permanen dan menempatkan proxy dengan IP statis di depannya. Hal ini menghilangkan kebutuhan untuk mengetahui IP Pod dan memungkinkan penyeimbangan beban untuk mengakses Pod-pod tersebut.

Contoh: Mengekspos dan Menyeimbangkan Beban Pod di dalam Cluster menggunakan ClusterIP

Mulai Minikube:

bash

$ minikube start

Buat Pod helloworld:

bash

$ kubectl run --port 8080 --image gcr.io/google-samples/hello-app:1.0 --restart Never helloworld

pod/helloworld created

Ekspos Pod helloworld sebagai Service ClusterIP helloworld-clusterip:

bash

$ kubectl expose pod helloworld --type ClusterIP --port 8080 --name helloworld-clusterip

Sekarang, uji akses ke Service ClusterIP helloworld dari Pod lain di dalam cluster:

bash

$ kubectl run --restart Never --image curlimages/curl:7.68.0 -it --rm curl sh

/ $ curl helloworld-clusterip:8080
Hello, world!
Version: 1.0.0
Hostname: helloworld

/ $ exit

Namun, sistem operasi host tidak dapat mengakses pod.

bash

$ kubectl get pod,svc -o wide

NAME             READY   STATUS    RESTARTS   AGE     IP           NODE       NOMINATED NODE   READINESS GATES
pod/helloworld   1/1     Running   0          3m57s   10.244.0.3   minikube   <none>           <none>

NAME                           TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE     SELECTOR
service/helloworld-clusterip   ClusterIP   10.99.232.132   <none>        8080/TCP   2m37s   run=helloworld
service/kubernetes             ClusterIP   10.96.0.1       <none>        443/TCP    5m4s    <none>

$ curl 10.99.232.132:8080
curl: (28) Failed to connect to 10.99.232.132 port 8080 after 75007 ms: Operation timed out

Service NodePort

Service NodePort memungkinkan mengekspos Pod ke jaringan eksternal, yang tidak mungkin dilakukan dengan ClusterIP. Ini dicapai dengan membuat Pod dapat diakses melalui IP Node dan port yang ditentukan.

Contoh: Mengekspos Pod secara Eksternal menggunakan NodePort

Ekspos Pod sebagai Service NodePort:

bash

$ kubectl expose pod helloworld --type NodePort --port 8080 --name helloworld-nodeport

Sekarang, uji akses ke Service NodePort helloworld dari dalam cluster:

bash

$ kubectl run --restart Never --image curlimages/curl:7.68.0 -it --rm curl sh

/ $ curl helloworld-nodeport:8080
Hello, world!
Version: 1.0.0
Hostname: helloworld

/ $ exit

Anda juga dapat mengaksesnya secara eksternal menggunakan IP Node dan NodePort:

bash

$ minikube service helloworld-nodeport --url
$ curl $(minikube service helloworld-nodeport --url)

Hello, world!
Version: 1.0.0
Hostname: helloworld

Namun, kekurangan menggunakan NodePort adalah Anda perlu mengetahui IP Node dan NodePort, yang biasanya merupakan nomor port tinggi di atas 30000. Selain itu, dalam sebuah cluster dengan beberapa host, IP node dapat berubah, membuat metode akses ini kurang stabil.

Untuk mengatasi masalah ini, Anda dapat menggunakan jenis layanan LoadBalancer, yang menempatkan penyeimbang beban di depan node dan memberikannya IP dan DNS statis, menghilangkan kebutuhan untuk mengetahui IP node.

Service LoadBalancer

Service LoadBalancer merupakan perluasan dari Service NodePort dan biasanya digunakan di lingkungan cloud. Service ini memudahkan akses ke Pod dengan mengarahkan lalu lintas eksternal dari penyeimbang beban penyedia cloud ke node pada port tertentu, dan akhirnya ke Pod.

Contoh: Mengekspos Pod secara Eksternal menggunakan LoadBalancer

Ekspos Pod sebagai Service LoadBalancer:

bash

$ kubectl expose pod helloworld --type LoadBalancer --port 8080 --name helloworld-lb

Sekarang, uji akses ke Service LoadBalancer helloworld dari dalam cluster:

bash

$ kubectl run --restart Never --image curlimages/curl:7.68.0 -it --rm curl sh

/ $ curl helloworld-lb:8080
Hello, world!
Version: 1.0.0
Hostname: helloworld

/ $ exit

Anda juga dapat mengaksesnya secara eksternal dengan mengambil URL LoadBalancer dan menggunakan curl:

bash

$ minikube service helloworld-lb --url
$ curl $(minikube service helloworld-lb --url)

Hello, world!
Version: 1.0.0
Hostname: helloworld

Ketika mengoperasikan kluster Kubernetes di cloud, layanan LoadBalancer akan diberikan IP publik dan DNS yang dapat digunakan untuk mengakses layanan.

Masalah dengan LoadBalancer

Meskipun layanan LoadBalancer memberikan cara yang baik untuk mengekspos Pod secara eksternal dan mengabstraksi IP Node, ada beberapa kelemahan:

Setiap layanan memerlukan LoadBalancer sendiri, yang dapat mahal.
Service ini beroperasi pada L4, artinya layanan tersebut tidak menyadari lebih dari tumpukan TCP/IP dan tidak dapat menangani routing berdasarkan host/path HTTP.
Untuk penyeimbangan beban L7 (lapisan aplikasi) yang lebih canggih, yang memungkinkan routing berdasarkan host dan path HTTP, Kubernetes menyediakan resource lain yang disebut Ingress.