Layanan LoadBalancer multi-jaringan

Multi-jaringan GKE memungkinkan Anda menghubungkan workload ke beberapa jaringan VPC. Anda dapat mengekspos Pod multi-jaringan ini ke klien internal atau eksternal menggunakan Layanan Kubernetes type: LoadBalancer. GKE menyediakan load balancer Google Cloud L4 untuk Layanan yang mengirim traffic ke Pod di jaringan sekunder yang ditentukan.

Dokumen ini menjelaskan cara GKE mengimplementasikan Layanan LoadBalancer untuk Pod multi-jaringan. Dokumen ini mencakup konfigurasi, kemampuan, dan batasan fitur yang diperlukan.

Cara kerja Layanan LoadBalancer multi-jaringan

Untuk mengekspos workload multi-jaringan, Anda membuat Service dari type: LoadBalancer. Layanan ini harus menyertakan pemilih khusus yang menargetkan Pod berdasarkan jaringan antarmuka sekundernya. Anda juga menambahkan anotasi untuk menentukan apakah akan membuat load balancer internal atau eksternal.

Label networking.gke.io/network dalam pemilih memfilter endpoint berdasarkan jaringan. Hal ini memastikan bahwa load balancer hanya mengirim traffic ke antarmuka Pod yang terhubung ke jaringan yang ditentukan.

Layanan LoadBalancer internal

Untuk membuat load balancer internal, tambahkan anotasi networking.gke.io/load-balancer-type: "Internal" ke manifes Layanan Anda. Contoh berikut menunjukkan Layanan yang membuat load balancer internal untuk menargetkan Pod di jaringan dmz:

apiVersion: v1
kind: Service
metadata:
  name: web-app-internal-lb
  namespace: default
  annotations:
    networking.gke.io/load-balancer-type: "Internal"
spec:
  externalTrafficPolicy: Local
  ports:
  - port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    networking.gke.io/network: dmz
    app: web-app
  type: LoadBalancer

Layanan LoadBalancer eksternal

Untuk membuat load balancer jaringan eksternal berbasis layanan backend, tambahkan anotasi cloud.google.com/l4-rbs: enabled ke manifes Layanan Anda. Contoh berikut menunjukkan Layanan yang membuat load balancer eksternal untuk menargetkan Pod di jaringan dmz:

apiVersion: v1
kind: Service
metadata:
  name: web-app-external-lb
  namespace: default
  annotations:
    cloud.google.com/l4-rbs: enabled
spec:
  externalTrafficPolicy: Local
  ports:
  -   port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    networking.gke.io/network: dmz
    app: web-app
  type: LoadBalancer

Konfigurasi Pod dan jaringan

Pod Anda harus memiliki antarmuka di jaringan yang ditargetkan oleh Layanan LoadBalancer. Anda juga harus mengonfigurasi perutean dalam Pod sehingga dapat merespons permintaan dengan benar di antarmuka jaringan yang sesuai.

Anda dapat mengonfigurasi perutean Pod dengan salah satu cara berikut:

  • Menetapkan antarmuka default: Gunakan networking.gke.io/default-interface anotasi di Pod untuk menetapkan antarmuka jaringan sekunder sebagai rute default.

  • Mengonfigurasi perutean berbasis kebijakan: Gunakan initContainer dengan NET_ADMIN kemampuan untuk mengonfigurasi aturan perutean di dalam Pod.

Contoh berikut menunjukkan manifes Deployment untuk Pod dengan antarmuka di jaringan dmz. Anotasi networking.gke.io/default-interface menetapkan antarmuka dmz (eth1) sebagai rute default.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  labels:
    app: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
      annotations:
        networking.gke.io/default-interface: 'eth1'
        networking.gke.io/interfaces: |-
          [
            {"interfaceName":"eth0","network":"default"},
            {"interfaceName": "eth1","network": "dmz"}
          ]
    spec:
      containers:
      -   name: whereami
        image: us-docker.pkg.dev/google-samples/containers/gke/whereami:v1
        ports:
        -   containerPort: 8080

Memverifikasi endpoint multi-jaringan

GKE menggunakan pengontrol khusus, multinet-endpointslice-controller.gke.io, untuk mengelola endpoint untuk Layanan multi-jaringan. Pengontrol ini membuat objek EndpointSlice untuk Layanan multi-jaringan Anda. Alamat IP dalam objek EndpointSlice ini milik jaringan sekunder yang ditentukan dalam pemilih Layanan.

Jika load balancer tidak memiliki backend yang responsif, periksa EndpointSlice untuk Layanan guna memverifikasi bahwa pengontrol telah memilih alamat IP Pod yang benar. Jika EndpointSlice tidak memiliki endpoint, pastikan label pemilih Layanan cocok dengan Pod yang berjalan dan pemilih networking.gke.io/network cocok dengan jaringan Pod.

Batasan

Layanan LoadBalancer multi-jaringan memiliki batasan berikut:

  • Load balancer internal memerlukan subsetting GKE.
  • Load balancer berbasis kumpulan target atau grup instance tidak didukung.
  • Layanan yang menggunakan externalTrafficPolicy: Cluster tidak didukung.
  • Layanan tidak dapat menargetkan Pod hostNetwork.
  • Jaringan IPv6 dan stack ganda tidak didukung.
  • Anda tidak dapat mengubah jaringan Layanan yang ada.
  • Hanya jaringan Lapisan 3 yang didukung.

Langkah berikutnya