Kubernetes 101: Service

Di Kubernetes, Services adalah abstraksi penting yang mendefinisikan sekumpulan Pod yang logis melalui kebijakan yang menjelaskan cara mengaksesnya.

Perkenalan

Di Kubernetes, Service adalah abstraksi penting yang mendefinisikan sekumpulan Pod yang logis melalui kebijakan yang menjelaskan cara mengaksesnya. Tidak seperti Pod yang bisa datang dan pergi, Service hadir dengan IP dan nama DNS yang stabil.

Bahkan ketika Pod yang mendasarinya diganti karena kegagalan atau peningkatan, Service tetap mempertahankan karakteristiknya, memastikan bahwa komponen lain tidak kehilangan konektivitas.

Services merupakan bagian integral dari Kubernetes karena ia memberikan prediktabilitas dalam lingkungan yang dinamis. Services menyediakan sarana terpadu untuk mengakses beragam fungsi yang disediakan oleh masing-masing Pod, terlepas dari life cycle-nya.

Saat Pod menghilang dan muncul kembali, Services memastikan cara yang andal untuk menjangkau Pod yang aktif, sehingga menciptakan pengalaman pengguna yang lancar.

Peran Services pada Cluster Kubernetes

Services di cluster Kubernetes berperan penting. Tanggung jawab penting mereka adalah:

1. Load balancing: Services mendistribusikan lalu lintas jaringan ke beberapa Pod untuk memastikan tak ada satu Pod pun yang menjadi penghambat. Load balancing ini membantu mencapai ketersediaan tinggi dan toleransi kesalahan dalam aplikasi.
2. Stable network configuration: Kubernetes Services menyediakan jaringan yang stabil dengan menetapkan alamat IP yang konsisten, memisahkan siklus hidup singkat Pod dari jaringan. Artinya, meskipun Pod mati dan diganti, alamat IP Services tetap tidak berubah, sehingga mengurangi kebutuhan akan pembaruan konfigurasi.
3. Intercommunication among pods: Services memfasilitasi komunikasi yang lancar antar Pod yang berbeda. Services memungkinkan Pod, yang bisa menjadi bagian dari berbagai deployment tetapi merupakan bagian dari aplikasi yang sama, untuk berinteraksi dan berfungsi secara tersinkronisasi.

Penemuan Services di Kubernetes

Penemuan Services adalah fitur krusial dalam sistem terdistribusi seperti Kubernetes. Fitur ini memungkinkan aplikasi dan layanan mikro yang berjalan pada cluster untuk menemukan dan berkomunikasi satu sama lain secara otomatis. Kubernetes menyelesaikan penemuan layanan melalui dua cara:

1. Environment Variables: Kubernetes secara otomatis membuat environment variables untuk masing-masing Services yang aktif dalam sebuah cluster. Variabel-variabel ini meliputi nama Services dan port, menyediakan komunikasi Pod-ke- Services.

Namun, penggunaan environment variables untuk Services mungkin saja menjadi rumit dalam sistem yang lebih besar karena adanya tabrakan penamaan dan perlunya memulai ulang Pod untuk mengenali Services baru.

2. DNS: Kubernetes menawarkan pendekatan yang lebih canggih untuk penemuan layanan menggunakan server DNS, umumnya CoreDNS atau Kube-DNS. Ketika Service dibuat, maka akan diberi nama DNS. Setiap Pod dalam cluster dapat menjangkau Service menggunakan nama tersebut, sehingga menyederhanakan komunikasi antar-layanan secara signifikan.

DNS Kubernetes

Kubernetes Domain Name System (DNS) adalah layanan bawaan yang diluncurkan saat startup cluster, yang dirancang untuk menyediakan resolusi nama untuk layanan dalam cluster Kubernetes.

Tujuannya untuk memungkinkan pod dan layanan dalam cluster berkomunikasi satu sama lain secara efisien menggunakan nama domain yang mudah diingat, bukan alamat IP yang rumit.

Cara kerja Kubernetes DNS sederhana namun efektif. Saat kamu membuat Service, ia diberi nama DNS unik dalam format service-name.namespace-name.svc.cluster.local, di mana:

1. service-name adalah nama layananmu.
2. namespace-name adalah nama dari namespace tempat layananmu berada.
3. svc adalah nilai statis yang menunjukkan ini adalah sebuah layanan.
4. cluster.local adalah domain default untuk cluster (bisa diubah jika diperlukan).

Misalnya, jika kamu memiliki Service bernama my-service dalam namespace bernama my-namespace, nama domain yang sepenuhnya memenuhi syarat (FQDN) adalah my-service.my-namespace.svc.cluster.local.

Pod-pod dalam namespace yang sama bisa mengakses layanan menggunakan nama Services. Jika Pod berada dalam namespace yang berbeda, maka Pod tersebut harus menggunakan nama domain yang memenuhi syarat. Server DNS merespons dengan Service’s ClusterIP, sehingga memungkinkan Pod yang meminta untuk mengakses Service.

Salah satu manfaat signifikan dari Kubernetes DNS adalah ia memungkinkan aplikasi menemukan layanan secara mandiri, artinya – aplikasi tidak perlu melakukan hardcode pada alamat IP dependensinya.

Fungsionalitas ini sangat penting dalam lingkungan dinamis seperti Kubernetes, di mana Pod (dan juga alamat IP) sering kali datang dan pergi.

Dengan mengabstraksikan detail jaringan dan memungkinkan layanan ditempatkan berdasarkan namanya, Kubernetes DNS meningkatkan keterpaduan layanan mikro yang longgar, sehingga sistem menjadi lebih kuat, terukur, dan lebih mudah dikelola.

Memahami Objek Endpoint di Kubernetes

Di Kubernetes, objek Endpoint yaitu kumpulan alamat IP dan port yang dimiliki oleh Service. Ketika sebuah Service ditentukan untuk memilih Pod, objek Endpoint terkait akan dibuat secara otomatis, menyimpan alamat IP dan port dari Pod yang akan diteruskan trafiknya oleh Service.

Objek endpoint berperan penting dalam menjaga komunikasi antara Services dan Pod. Jika sebuah Pod mati dan digantikan oleh Pod baru, IP Pod baru tersebut akan diperbarui di objek Endpoints, sehingga memastikan ketersediaan layanan yang berkesinambungan.

Objek Endpoint diberi nama yang identik dengan Service terkait dan melacak alamat IP dan port untuk koneksi masuk. Contohnya, anggaplah sebuah nama Service bernama my-service yang memilih semua Pod dengan label app=MyApp. Jika Pod ini memiliki IP 192.0.2.1 dan 192.0.2.2, maka objek Endpoints my-service akan menyertakan alamat IP tersebut.

Service dan Deployment di Kubernetes

Pod mewakili unit terkecil yang dapat disebarkan dalam cluster Kubernetes dan dapat dibuat atau dihancurkan dengan cepat selama siklus hidup aplikasi. Namun, mengelola Pod satu per satu dalam sistem yang besar bisa jadi hal yang rumit. Di sinilah peran Deployment.

Deployment di Kubernetes mengelola status yang diinginkan untuk Pod dan ReplicaSet. Deployment memastikan bahwa jumlah Pod yang ditentukan dapat berjalan pada waktu tertentu dengan membuat atau menghancurkan Pod sesuai kebutuhan.

Services, Deployment, dan Pod berkaitan erat dalam sistem Kubernetes. Saat Deployment mempertahankan keadaan Pod yang diinginkan, Service menyediakan antarmuka jaringan terpadu ke Pod tersebut.

Service menggunakan pemilih label untuk memilih Pod yang dikelola oleh Deployment. Hubungan tersebut memfasilitasi pemaparan Pod (yang mungkin memiliki IP non-deterministik karena siklus hidupnya yang dinamis) melalui suatu Service, sehingga memberikan jaringan yang stabil.

Contohnya, bayangkan Deployment yang mengelola sekumpulan Pod. Jika Pod ini dikonfigurasi untuk melayani permintaan HTTP, Service dapat diatur menggunakan selector yang cocok dengan label dari Pod tersebut. Kemudian Service dapat mendistribusikan permintaan masuk ke Pod, memastikan load balancing yang efisien.

Cara Kerja Pods Label Selector

Di Kubernetes, label adalah pasangan key-value yang melekat pada objek, seperti Pod, yang dimaksudkan untuk menyampaikan informasi yang bermakna dan relevan.

Label menyediakan metadata pengenal dan berfungsi sebagai sarana untuk mengkategorikan dan mengatur sumber daya berdasarkan karakteristik bersama. Misalnya, Label dapat menunjukkan bahwa Pod tertentu merupakan bagian dalam lapisan aplikasi tertentu, seperti frontend atau backend.

Label selector adalah mekanisme yang digunakan oleh Services (dan sumber daya lainnya, seperti Deployment atau ReplicaSet) untuk menentukan kumpulan Pod yang akan diterapkan. Bidang ‘selector’ pada definisi Service menyediakan ketentuan yang harus dipenuhi. Pod yang memenuhi ketentuan ini dipilih dan menjadi bagian dari Service.

Berikut ini contoh definisi Service dengan selector:

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: MyApp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 9376

Pada contoh ini, Service my-service menargetkan Pod apa pun yang diberi label app=MyApp. Selector-nya app: MyApp sesuai dengan pasangan key-value dari label yang melekat pada Pod.

Saat menerapkan Service ini, komponen kube-proxy pada setiap node di cluster Kubernetes-mu akan mengatur rute. Aturan ini mengarahkan traffic yang ditujukan ke IP dan port Service ke salah satu Pod yang telah dipilih oleh pemilih label Service.

Ingatlah bahwa saat Kumpulan Pod dipilih oleh Service (misalnya, saat Pod dibuat, dihapus, atau labelnya diperbarui), Service akan secara otomatis diperbarui dan traffic akan dialihkan ke Kumpulan Pod yang baru.

Maka dari itu, label selector memungkinkan Kubernetes Services untuk berasosiasi dengan Pod secara dinamis dan fleksibel, meyediakan antarmuka yang andal untuk kelompok Pod dan memisahkan lyfe-cycle Pod yang bersifat sementara dari bagian lain dalam sistem.

Mekanisme ini adalah inti dari bagaimana Services memungkinkan stabilitas jaringan dalam menghadapi churn Pod, dan memungkinkan Kubernetes menyediakan jaringan layanan yang kuat dan terdistribusi.

Berbagai Jenis Services di Kubernetes

Kubernetes menawarkan beberapa jenis Services untuk disesuaikan dengan berbagai kasus penggunaan:

1. ClusterIP: Jenis default Services di Kubernetes. ClusterIP menyediakan Services di dalam cluster yang dapat diakses oleh aplikasi lain. Layanan ini mendapatkan alamat IP unik yang bertahan selama durasi Services dan dapat dijangkau oleh komponen lain di dalam cluster.
2. NodePort: NodePort Service dapat diakses dari luar cluster. NodePort bekerja dengan membuka port statis untuk setiap Node dalam cluster dan meneruskan traffic dari port tersebut ke Service. Meskipun NodePort menyediakan konektivitas eksternal, tapi ia kurang fleksibel karena semua traffic harus melalui port statis yang ditentukan.
3. LoadBalancer: LoadBalancer Service menyediakan penyeimbang beban dari infrastruktur dasar dan mengatur traffic eksternal ke Service. LoadBalancer merupakan ekstensi dari NodePort Sevice dan menawarkan lebih banyak fleksibilitas dan kontrol untuk setiap traffic yang masuk.
4. ExternalName: ExternalName Service memetakan Service ke nama DNS. Ini adalah cara untuk membuat Service untuk layanan yang sudah ada yang berada di luar cluster. Service ini tidak memiliki penyeleksi atau menentukan Endpoints apa pun. Sebaliknya, ia meneruskan permintaan ke alamat eksternal.

Contoh Service Manifest

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: MyApp
  ports:
  - protocol: TCP
    port: 80
    targetPort: 9376
  type: LoadBalancer

Ayo kita uraikan setiap bagiannya:

1. apiVersion: v1: Mendefinisikan versi Kubernetes API yang kamu gunakan untuk membuat objek ini. Untuk Service, versi API adalah v1.
2. kind: Service: Menentukan tipe objek Kubernetes yang ingin kamu buat. Dalam hal ini, jenisnya adalah Service.
3. metadata: Mencakup data yang membantu mengidentifikasi objek secara unik. Untuk objek ini hanya mencakup:

   name: my-app-service: Nama Service. Nama ini harus unik dalam konteks namespace.

4. spec: Menjelaskan keadaan objek yang diinginkan. Kolom spesifikasinya mencakup:

   selector: Mendefinisikan bagaimana Service mengidentifikasi Pod yang akan diarahkan traffic-nya. Contohnya, Service memilih Pod dengan label app=MyApp.

   ports: Daftar port yang diekspos oleh Service. Dalam hal ini, hanya ada satu port.

       protocol: TCP: Protokol jaringan yang didengarkan port ini. Pilihan lainnya bisa berupa UDP atau SCTP.

       port: 80: Nomor port yang didengarkan Service. Traffic yang dikirim ke port ini akan diteruskan ke Pod.

       targetPort: 9376: Nomor port pada Pod yang akan diteruskan oleh Service ke traffic. TargetPort bisa sama dengan portnya, atau bisa juga berbeda.

   type: LoadBalancer: Bidang ini menunjukkan jenis Service. LoadBalancer berarti Service akan diekspos secara eksternal menggunakan load balancer penyedia cloud.

Contoh nama Service ini my-app-service akan mendengarkan traffic TCP pada port 80 dan meneruskannya ke port TCP 9376 pada Pod mana pun yang berlabel app=MyApp. Jika cluster dijalankan di penyedia cloud yang mendukungnya, Services akan diekspos secara eksternal melalui cloud load balancer.