Halaman ini diterjemahkan oleh Cloud Translation API.

Membuat load balancer eksternal berbasis layanan backend

Autopilot Standard

Halaman ini menunjukkan cara men-deploy Layanan LoadBalancer eksternal yang membuat Load Balancer Jaringan passthrough eksternal berbasis layanan backend. Sebelum membaca halaman ini, pastikan Anda memahami hal-hal berikut:

Untuk mempelajari Load Balancer Jaringan passthrough eksternal secara umum lebih lanjut, lihat Load Balancer Jaringan passthrough eksternal berbasis layanan backend.

Sebelum memulai

Sebelum memulai, pastikan Anda telah menjalankan tugas berikut:

Aktifkan Google Kubernetes Engine API.

Aktifkan Google Kubernetes Engine API

Jika ingin menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan gcloud components update.
Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region dan compute/zone. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location.

Persyaratan

Untuk membuat Service LoadBalancer eksternal, cluster GKE Anda harus menggunakan versi 1.25.5 atau yang lebih baru. Untuk menggunakan load balancing berbobot, cluster Anda harus menggunakan versi 1.31.0-gke.1506000 atau yang lebih baru.
Add-on HttpLoadBalancing harus diaktifkan di cluster Anda. Add-on ini diaktifkan secara default. Fungsi ini memungkinkan cluster mengelola load balancer yang menggunakan layanan backend.

Memilih cluster

Anda dapat membuat cluster baru atau memilih cluster yang ada yang memenuhi persyaratan.

Buat cluster baru

Autopilot

Untuk membuat cluster Autopilot baru:

gcloud container clusters create-auto CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Ganti kode berikut:

CLUSTER_NAME: nama cluster baru.
RELEASE_CHANNEL: nama saluran rilis GKE untuk cluster.
VERSION: versi GKE untuk cluster.
COMPUTE_LOCATION: region Compute Engine cluster.

Standar

Untuk membuat cluster Standard baru:

gcloud container clusters create CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Ganti kode berikut:

CLUSTER_NAME: nama cluster baru.
RELEASE_CHANNEL: nama saluran rilis GKE untuk cluster.
VERSION: versi GKE untuk cluster.
COMPUTE_LOCATION: region Compute Engine cluster.

Mengupgrade cluster yang ada

Gunakan gcloud CLI untuk mengupdate cluster yang ada:

gcloud container clusters upgrade CLUSTER_NAME \
    --cluster-version=VERSION \
    --master \
    --location=COMPUTE_LOCATION

Ganti kode berikut:

CLUSTER_NAME: nama cluster yang ada.
VERSION: versi GKE spesifik yang ingin Anda gunakan untuk mengupgrade cluster. Untuk informasi selengkapnya, lihat Mengupgrade bidang kontrol secara manual.
COMPUTE_LOCATION: region Compute Engine cluster.

Men-deploy sampel workload

Deploy contoh beban kerja berikut yang menyediakan Pod penayangan untuk Layanan LoadBalancer eksternal.

Simpan contoh Deployment berikut sebagai store-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: store
spec:
  replicas: 20
  selector:
    matchLabels:
      app: store
  template:
    metadata:
      labels:
        app: store
    spec:
      containers:
      - image: gcr.io/google_containers/echoserver:1.10
        imagePullPolicy: Always
        name: echoserver
        ports:
          - name: http
            containerPort: 8080
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
            scheme: HTTP

Terapkan manifes ke cluster:
```
kubectl apply -f store-deployment.yaml
```

Pastikan ada 20 Pod aktif untuk Deployment:

kubectl get pods

Outputnya mirip dengan hal berikut ini:

NAME                     READY   STATUS    RESTARTS   AGE
store-cdb9bb4d6-s25vw      1/1     Running   0          10s
store-cdb9bb4d6-vck6s      1/1     Running   0          10s
....

Membuat Layanan LoadBalancer eksternal

Ekspos contoh beban kerja dengan membuat Layanan LoadBalancer eksternal.

Simpan manifes Service berikut sebagai store-v1-lb-svc.yaml:

apiVersion: v1
kind: Service
metadata:
  name: store-v1-lb-svc
  annotations:
    cloud.google.com/l4-rbs: "enabled"
spec:
  type: LoadBalancer
  selector:
    app: store
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
    targetPort: 8080

Terapkan manifes ke cluster:
```
kubectl apply -f store-v1-lb-svc.yaml
```

Perhatikan poin-poin berikut tentang manifes contoh ini:

Manifes Layanan harus menyertakan anotasi cloud.google.com/l4-rbs: "enabled" saat manifes pertama kali diterapkan ke cluster. Tindakan ini akan menginstruksikan GKE untuk membuat Load Balancer Jaringan passthrough eksternal berbasis layanan backend. Load Balancer Jaringan passthrough eksternal berbasis layanan backend diperlukan untuk mendukung fitur seperti IPv6 dan load balancing berbobot.
Jika Anda menambahkan anotasi cloud.google.com/l4-rbs: "enabled" ke manifes Layanan LoadBalancer eksternal yang sudah ada (yaitu, setelah load balancer dibuat), GKE akan mengabaikan anotasi tersebut. Layanan LoadBalancer Eksternal yang dibuat tanpa anotasi ini dalam manifesnya menggunakan Load Balancer Jaringan passthrough eksternal berbasis kumpulan target. Sebaiknya jangan gunakan Load Balancer Jaringan passthrough eksternal berbasis kumpulan target.

Mengaktifkan load balancing berbobot

Untuk mendistribusikan koneksi baru secara proporsional ke node berdasarkan jumlah Pod aktif, siap, dan tidak berhenti di setiap node, aktifkan load balancing berbobot dengan menambahkan anotasi networking.gke.io/weighted-load-balancing: "pods-per-node" ke manifes Layanan.

Tambahkan anotasi networking.gke.io/weighted-load-balancing: "pods-per-node" ke manifes Layanan store-v1-lb-svc.yaml, dan pastikan Anda juga menetapkan externalTrafficPolicy: Local sehingga terlihat seperti ini:

apiVersion: v1
kind: Service
metadata:
  name: store-v1-lb-svc
  annotations:
    cloud.google.com/l4-rbs: "enabled"
    networking.gke.io/weighted-load-balancing: "pods-per-node"
spec:
  type: LoadBalancer
  externalTrafficPolicy: Local
  selector:
    app: store
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
    targetPort: 8080

Terapkan manifes ke cluster:
```
kubectl apply -f store-v1-lb-svc.yaml
```

Perhatikan hal-hal berikut tentang contoh load balancing berbobot ini:

Manifes Layanan menggunakan externalTrafficPolicy: Local. Jika tidak perlu mengaktifkan load balancing berbobot, Anda juga dapat menggunakan externalTrafficPolicy: Cluster. Untuk mengetahui detail cara externalTrafficPolicy menentukan pengelompokan node, node mana yang lulus health check load balancer, dan cara paket diproses, lihat Konsep Layanan LoadBalancer.
Jika Anda mengaktifkan load balancing berbobot, GKE tidak mencegah Anda menggunakan externalTrafficPolicy: Cluster, tetapi externalTrafficPolicy: Cluster secara efektif menonaktifkan load balancing berbobot karena paket mungkin dirutekan, setelah load balancer, ke node yang berbeda.

Anda juga dapat mengaktifkan load balancing berbobot di Layanan LoadBalancer eksternal yang ada menggunakan kubectl edit svc service-name. Perintah kubectl edit akan membuka manifes Layanan load balancer yang ada di editor teks yang dikonfigurasi, tempat Anda dapat mengubah manifes dan menyimpan perubahan. Saat Anda mengedit Layanan LoadBalancer eksternal yang ada,perhatikan poin-poin berikut:

Layanan LoadBalancer eksternal yang ada harus menghasilkan pembuatan Load Balancer Jaringan passthrough eksternal berbasis layanan backend. Artinya, Service LoadBalancer eksternal yang ada harus menyertakan anotasi cloud.google.com/l4-rbs: "enabled" saat manifes pertama kali diterapkan ke cluster.

Menambahkan anotasi networking.gke.io/weighted-load-balancing: "pods-per-node" ke Layanan LoadBalancer eksternal yang ada dan menggunakan Load Balancer Jaringan passthrough eksternal berbasis kumpulan target tidak akan berpengaruh.
Saat memperbarui manifes Layanan LoadBalancer eksternal yang ada, pastikan untuk menetapkan externalTrafficPolicy: Local. Menggunakan externalTrafficPolicy: Cluster secara efektif menonaktifkan load balancing berbobot karena paket mungkin dirutekan, setelah load balancer, ke node lain.

Menonaktifkan load balancing berbobot

Untuk mendistribusikan koneksi baru ke node, terlepas dari jumlah Pod penayangan yang ada di setiap node, nonaktifkan load balancing berbobot dengan menghapus anotasi networking.gke.io/weighted-load-balancing: "pods-per-node" dari manifes Layanan.

Memverifikasi Layanan LoadBalancer eksternal dan komponennya

Pastikan Service Anda berjalan:
```
kubectl get svc store-v1-lb-svc
```
Outputnya mirip dengan berikut ini:
```
NAME               TYPE           CLUSTER-IP        EXTERNAL-IP     PORT(S)          AGE
store-v1-lb-svc   LoadBalancer   10.44.196.160     35.193.28.231   8080:32466/TCP   11m
```
GKE menetapkan EXTERNAL_IP untuk Load Balancer Jaringan passthrough eksternal.

Catatan: GKE perlu waktu beberapa menit untuk mengalokasikan alamat IP eksternal sebelum load balancer siap menyalurkan aplikasi Anda.

Uji koneksi ke load balancer:

curl EXTERNAL_IP:PORT

Ganti kode berikut:

EXTERNAL_IP: alamat IP yang dialokasikan untuk Load Balancer Jaringan passthrough eksternal.
PORT: nomor port yang dialokasikan untuk Load Balancer Jaringan passthrough eksternal.

Outputnya mirip dengan hal berikut ini:

Hostname: store-v1-lb-svc-cdb9bb4d6-hflxd

Pod Information:
  -no pod information available-

Server values:
  server_version=nginx: 1.13.3 - lua: 10008

Request Information:
  client_address=10.128.0.50
  method=GET
  real path=/
  query=
  request_version=1.1
  request_scheme=http
  request_uri=EXTERNAL_IP

Request Headers:
  accept=*/*
  host=EXTERNAL_IP
  user-agent=curl/7.81.0

Request Body:
  -no body in request-

Periksa Layanan LoadBalancer dan kumpulan anotasinya yang menjelaskan resource Google Cloud-nya:
```
kubectl describe svc store-v1-lb-svc
```
Outputnya mirip dengan hal berikut ini:
```
Name:                     my-service-external
Namespace:                default
Labels:                   <none>
Annotations:              cloud.google.com/l4-rbs: enabled
                          networking.gke.io/weighted-load-balancing: pods-per-node #This annotation appears in the output only if weighted load balancing is enabled.
                          service.kubernetes.io/backend-service: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/firewall-rule: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/firewall-rule-for-hc: k8s2-qvveq1d8-default-my-service-ext-5s55db85-fw
                          service.kubernetes.io/healthcheck: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/tcp-forwarding-rule: a808124abf8ce406ca51ab3d4e7d0b7d
Selector:                 app=my-app
Type:                     LoadBalancer
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.18.102.23
IPs:                      10.18.102.23
LoadBalancer Ingress:     35.184.160.229
Port:                     tcp-port  8080/TCP
TargetPort:               8080/TCP
NodePort:                 tcp-port  31864/TCP
Endpoints:                10.20.1.28:8080,10.20.1.29:8080
Session Affinity:         None
External Traffic Policy:  Local
HealthCheck NodePort:     30394

Events:
  Type    Reason                Age                    From                     Message
  ----    ------                ----                   ----                     -------
  Normal  ADD                   4m55s                  loadbalancer-controller  default/my-service-ext
```
Ada beberapa kolom yang menunjukkan bahwa Load Balancer Jaringan passthrough eksternal berbasis layanan backend dan resource Google Cloud-nya berhasil dibuat:
- Kolom Events. Kolom ini kosong saat LoadBalancer Service dan resource-nya berhasil dibuat. Jika terjadi, error akan dicantumkan di sini.
- Daftar Annotations yang diaktifkan: GKE menambahkan daftar anotasi hanya baca berikut ke manifes Service. Setiap anotasi yang namanya diawali dengan service.kubernetes.io/ digunakan untuk menunjukkan nama resource Google Cloud yang dibuat sebagai bagian dari atau untuk mendukung load balancer.
  - Anotasi networking.gke.io/weighted-load-balancing: pods-per-node menunjukkan bahwa load balancing berbobot telah diterapkan dan load balancer mendistribusikan traffic ke Pod backend berdasarkan jumlah Pod yang berjalan di setiap node.
  - Anotasi service.kubernetes.io/backend-service menunjukkan nama layanan backend load balancer.
  - Anotasi service.kubernetes.io/healthcheck menunjukkan nama health check load balancer yang digunakan oleh layanan backend.
  - Anotasi service.kubernetes.io/tcp-forwarding-rule atau service.kubernetes.io/udp-forwarding-rule menunjukkan nama aturan penerusan load balancer.
  - Anotasi service.kubernetes.io/firewall-rule menunjukkan nama aturan firewall yang dibuat untuk mengizinkan traffic ke node cluster. Rentang sumber untuk aturan firewall ini dapat disesuaikan menggunakan spec.loadBalancerSourceRanges[]. Guna mengetahui detail tambahan tentang aturan firewall untuk Layanan LoadBalancer, lihat Aturan firewall dan daftar alamat IP sumber yang diizinkan.
  - Anotasi service.kubernetes.io/firewall-rule-for-hc menunjukkan nama aturan firewall yang diperlukan untuk health check load balancer.
Verifikasi bahwa resource load balancer dan aturan firewall telah dibuat untuk Layanan LoadBalancer eksternal:
- Untuk melihat aturan penerusan, jalankan perintah berikut:
```
  gcloud compute forwarding-rules describe FWD_RULE_NAME \
    --region=REGION_NAME
```
  Ganti kode berikut:
  - FWD_RULE_NAME: nama aturan penerusan yang diberikan oleh anotasi hanya baca service.kubernetes.io/tcp-forwarding-rule atau service.kubernetes.io/udp-forwarding-rule. Untuk memeriksa anotasi ini, jalankan kubectl describe svc SERVICE_NAME.
  - REGION_NAME: region Google Cloud yang berisi cluster. Untuk cluster zona, region berisi zona yang digunakan oleh cluster.
- Untuk melihat layanan backend, jalankan perintah berikut:
```
gcloud compute backend-services describe BACKEND_SERVICE_NAME \
  --region=REGION_NAME
```
  Ganti kode berikut:
  - BACKEND_SERVICE_NAME: nama layanan backend yang disediakan oleh anotasi hanya baca service.kubernetes.io/backend-service. Untuk memeriksa anotasi hanya baca ini, jalankan kubectl describe svc SERVICE_NAME.
  - REGION_NAME: region Google Cloud yang berisi cluster. Untuk cluster zona, region berisi zona yang digunakan oleh cluster.
- Untuk melihat health check load balancer, jalankan perintah berikut:
```
gcloud compute health-checks describe HEALTH_CHECK_NAME \
  --region=REGION_NAME
```
  Ganti kode berikut:
  - HEALTH_CHECK_NAME: nama health check load balancer. Nama health check diberikan oleh anotasi hanya baca service.kubernetes.io/healthcheck. Untuk memeriksa anotasi hanya baca ini, jalankan kubectl describe svc SERVICE_NAME.
  - REGION_NAME: region Google Cloud yang berisi cluster. Untuk cluster zona, region berisi zona yang digunakan oleh cluster.
- Untuk melihat aturan firewall, jalankan perintah berikut:
```
gcloud compute firewall-rules describe FIREWALL_RULE_NAME \
gcloud compute firewall-rules describe HEALTH_CHECK_FIREWALL_RULE_NAME
```
  Ganti kode berikut:
  - FIREWALL_RULE_NAME: nama aturan firewall yang mengizinkan traffic ke load balancer. Nama aturan firewall ini disediakan oleh anotasi hanya baca service.kubernetes.io/firewall-rule. Untuk memeriksa anotasi hanya baca ini, jalankan kubectl describe svc SERVICE_NAME.
  - HEALTH_CHECK_FIREWALL_RULE_NAME: nama aturan firewall yang mengizinkan health check backend load balancer (node cluster). Nama aturan firewall ini disediakan oleh anotasi hanya baca service.kubernetes.io/firewall-rule-for-hc. Untuk memeriksa anotasi hanya baca ini, jalankan kubectl describe svc SERVICE_NAME.

Menghapus Layanan LoadBalancer eksternal

Untuk menghapus contoh Layanan LoadBalancer eksternal store-v1-lb-svc, gunakan perintah berikut:

kubectl delete service store-v1-lb-svc

GKE akan otomatis menghapus semua resource load balancer yang dibuat untuk Service LoadBalancer eksternal.

Memecahkan masalah Layanan LoadBalancer eksternal

Jika tidak menetapkan externalTrafficPolicy: Local, Anda mungkin mendapatkan peristiwa peringatan, saat mendeskripsikan Layanan menggunakan perintah berikut:

kubectl describe svc store-v1-lb-svc`

Events:
  Type     Reason                   Age      From                     Message
  ----     ------                   ----     ----                     -------
  Warning  UnsupportedConfiguration 4m55s    loadbalancer-controller  Weighted load balancing by pods-per-node has no effect with External Traffic Policy: Cluster.

Untuk mengaktifkan load balancing berbobot secara efektif, Anda harus menetapkan externalTrafficPolicy: Local.

Langkah selanjutnya

Untuk mengetahui ringkasan tentang Layanan Load Balancer, lihat Layanan LoadBalancer.
Untuk deskripsi parameter Layanan Load Balancer, lihat Parameter Layanan LoadBalancer.
Memecahkan masalah load balancing di GKE.