Home  >  Kubernetes

Service Discovery & Networking

Dalam Kubernetes, jaringan dan komunikasi antar Pod sangat penting untuk membuat aplikasi terdistribusi yang skalabel. Pod bersifat dinamis, bisa dipindahkan atau direstart kapan saja, dan memiliki IP yang bersifat sementara. Oleh karena itu, Kubernetes menyediakan Service Discovery dan Networking untuk memastikan aplikasi dan komponen-komponennya bisa saling terhubung dengan stabil.

1. Memahami Service di Kubernetes

Service di Kubernetes adalah objek yang memberikan akses jaringan yang stabil dan konstan ke sekumpulan Pod. Service bertindak sebagai abstraction layer yang memungkinkan Pod untuk berkomunikasi satu sama lain tanpa harus mengetahui detail IP Pod secara langsung.

Jenis-Jenis Service di Kubernetes

1. ClusterIP (Default):

  • Fungsi: Jenis service ini membuat endpoint internal yang hanya dapat diakses dari dalam cluster.
  • Use Case: Cocok untuk komunikasi antar Pod di dalam cluster. Misalnya, jika Pod frontend ingin berkomunikasi dengan Pod backend.

Contoh YAML:

apiVersion: v1
kind: Service
metadata:
  name: my-clusterip-service
spec:
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
  type: ClusterIP

Penjelasan:

  • selector: Menentukan Pod yang akan dihubungkan oleh Service berdasarkan label.
  • port: Port yang dibuka oleh Service (misalnya, port 80).
  • targetPort: Port yang digunakan oleh container di Pod (misalnya, 8080).

2. NodePort:

  • Fungsi: Mengizinkan akses dari luar cluster ke service dengan mengikat service ke port yang spesifik di setiap Node dalam cluster.
  • Use Case: Digunakan saat Anda ingin mengakses aplikasi di dalam cluster dari jaringan eksternal, tanpa load balancer.

Contoh YAML:

apiVersion: v1
kind: Service
metadata:
  name: my-nodeport-service
spec:
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
    nodePort: 30007
  type: NodePort

Penjelasan:

nodePort: Port yang dibuka pada Node untuk mengakses aplikasi. Kubernetes secara otomatis menetapkan port di kisaran 30000-32767 jika Anda tidak menentukan sendiri.

3. LoadBalancer:

  • Fungsi: Mengizinkan akses dari luar cluster dengan menggunakan load balancer eksternal yang disediakan oleh platform cloud (seperti DO Load Balancer, AWS ELB, GCP Load Balancer, Azure LB).
  • Use Case: Digunakan untuk aplikasi yang perlu diakses secara publik dari internet.

Contoh YAML:

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

Penjelasan:

Platform cloud akan membuat load balancer dan mengarahkan traffic dari internet ke Node dalam cluster Anda melalui LoadBalancer.

Service Selector dan Label

Selector: Service menggunakan selector untuk menghubungkan dirinya ke Pod berdasarkan label. Dengan kata lain, setiap Pod yang memiliki label yang cocok dengan selector akan dihubungkan ke Service tersebut.
Contoh:

selector:
  app: my-app

Label: Pod yang cocok dengan label di atas akan otomatis terkait dengan Service.

metadata:
  labels:
    app: my-app

Jika Pod dengan label app=my-app bertambah atau berkurang (misalnya saat scaling), Service secara otomatis akan menyesuaikan tanpa konfigurasi manual.

2. Ekspos Aplikasi dengan Service

Service digunakan untuk mengekspos aplikasi yang berjalan di Pod sehingga bisa diakses oleh pengguna, baik itu dari dalam cluster (melalui ClusterIP) atau dari luar (melalui NodePort atau LoadBalancer).

Langkah-Langkah untuk Ekspos Aplikasi

1. Membuat Deployment untuk Aplikasi

Buat deployment sederhana untuk aplikasi Anda (misalnya, NGINX):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

2. Membuat Service ClusterIP

Ekspos aplikasi menggunakan ClusterIP:

apiVersion: v1
kind: Service
metadata:
  name: nginx-clusterip-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: ClusterIP

3. Membuat Service NodePort

Ekspos aplikasi agar bisa diakses dari luar cluster:

apiVersion: v1
kind: Service
metadata:
  name: nginx-nodeport-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
    nodePort: 30007
  type: NodePort

4. Mengakses Service

  • Untuk ClusterIP, Anda hanya dapat mengakses Service dari dalam cluster menggunakan:
    curl http://<ClusterIP>:80
  • Untuk NodePort, akses dari luar cluster menggunakan:
    curl http://<Node-IP>:30007
  • Untuk LoadBalancer, Kubernetes secara otomatis akan membuat load balancer eksternal dan Anda bisa mengaksesnya melalui alamat IP yang diberikan oleh cloud provider.

3. Skema Komunikasi Antar Pod di Kubernetes

Dalam Kubernetes, semua Pod dalam cluster dapat saling berkomunikasi satu sama lain. Pod berkomunikasi melalui jaringan internal cluster menggunakan IP yang unik.

Model Jaringan Kubernetes

  • Setiap Pod diberikan IP unik di dalam cluster.
  • Semua Pod dapat berkomunikasi langsung satu sama lain tanpa memerlukan NAT (Network Address Translation).
  • Komunikasi antar Pod dalam satu node dan antar node dikelola oleh kube-proxy menggunakan mekanisme iptables atau IPVS (IP Virtual Server).

Service Discovery dengan DNS

  • Kube-DNS: Kubernetes menggunakan sistem DNS internal (kube-dns) untuk memetakan nama service ke IP. Setiap service yang dibuat secara otomatis mendapatkan nama DNS berdasarkan nama service dan namespace.
    Contoh:

Jika ada service nginx-service dalam namespace default, maka Pod dalam cluster dapat mengaksesnya menggunakan:
nginx-service.default.svc.cluster.local

Komunikasi Antar Pod Menggunakan Service

  1. Pod ke Pod Komunikasi Melalui Service:
    • Pod A bisa berkomunikasi dengan Pod B menggunakan alamat DNS dari service yang menargetkan Pod B.
    • Contoh, jika Anda memiliki service bernama backend-service, Pod yang menjalankan frontend bisa mengakses backend dengan:
      curl http://backend-service:80
  2. Load Balancing dalam Service:
    • Service di Kubernetes melakukan load balancing secara otomatis. Ketika beberapa Pod ditargetkan oleh sebuah service, kube-proxy akan membagi traffic di antara Pod-Pod tersebut menggunakan round-robin atau metode lain yang disediakan oleh Kubernetes.

Pod Network Policy

Untuk mengontrol komunikasi antar Pod, Kubernetes mendukung Network Policy yang memungkinkan Anda mengatur aturan inbound dan outbound traffic antar Pod. Misalnya, Anda bisa membuat kebijakan agar hanya Pod dari namespace tertentu yang bisa mengakses Pod lain.
Contoh sederhana Network Policy:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-access-to-nginx
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: nginx
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 80

Penjelasan:

  • Hanya Pod dengan label app=frontend yang diizinkan mengakses Pod dengan label app=nginx pada port 80.

Kesimpulan

  • Kubernetes Service adalah cara untuk menyediakan akses yang stabil dan konstan ke Pod yang dinamis.
  • Ada tiga tipe utama service: ClusterIP, NodePort, dan LoadBalancer, yang masing-masing menyediakan akses internal dan eksternal.
  • Komunikasi antar Pod menggunakan IP unik dan DNS internal yang memungkinkan resolusi nama otomatis untuk service di cluster.
  • Kubernetes juga mendukung Network Policy untuk mengatur dan mengontrol komunikasi antar Pod.

Categories:Kubernetes

Tags:

Related Posts