Halaman ini diterjemahkan oleh Cloud Translation API.

Mengonfigurasi load balancer eksternal

Load balancer eksternal (ELB) mengekspos layanan untuk diakses dari luar organisasi dari kumpulan alamat IP yang ditetapkan ke organisasi dari kumpulan IP eksternal instance yang lebih besar.

Alamat IP Virtual (VIP) ELB tidak berkonflik antar-organisasi dan bersifat unik di semua organisasi. Oleh karena itu, Anda hanya boleh menggunakan layanan ELB untuk layanan yang harus diakses oleh klien di luar organisasi.

Workload yang berjalan di dalam organisasi dapat mengakses layanan ELB selama Anda mengizinkan workload keluar dari organisasi. Pola traffic ini secara efektif memerlukan traffic keluar dari organisasi sebelum kembali ke layanan internal.

Sebelum memulai

Untuk mengonfigurasi layanan ELB, Anda harus memiliki hal berikut:

Memiliki project yang Anda konfigurasi load balancernya. Untuk mengetahui informasi selengkapnya, lihat Membuat project.
Kebijakan masuk ProjectNetworkPolicy (PNP) yang disesuaikan untuk mengizinkan traffic ke layanan ELB ini. Untuk mengetahui informasi selengkapnya, lihat Mengonfigurasi PNP untuk mengizinkan traffic ke ELB.
Peran identitas dan akses yang diperlukan:
- Admin NetworkPolicy Project: memiliki akses untuk mengelola kebijakan jaringan project di namespace project. Minta Admin IAM Organisasi Anda untuk memberi Anda peran Admin NetworkPolicy Project (project-networkpolicy-admin).
- Admin Load Balancer: Minta Admin IAM Organisasi Anda untuk memberi Anda peran Admin Load Balancer (load-balancer-admin).
- Admin Load Balancer Global: Untuk ELB global, minta Admin IAM Organisasi Anda untuk memberi Anda peran Admin Load Balancer Global (global-load-balancer-admin). Untuk mengetahui informasi selengkapnya, lihat Deskripsi peran standar.

Mengonfigurasi PNP untuk mengizinkan traffic ke ELB

Agar layanan ELB berfungsi, Anda harus mengonfigurasi dan menerapkan kebijakan ingress kustom Anda sendiri untuk mengizinkan traffic ke beban kerja layanan ELB ini.ProjectNetworkPolicy Kebijakan jaringan mengontrol akses ke beban kerja Anda, bukan load balancer itu sendiri. ELB mengekspos workload ke jaringan pelanggan Anda, sehingga memerlukan kebijakan jaringan eksplisit untuk mengizinkan traffic eksternal ke port workload, seperti 8080.

Tentukan alamat CIDR eksternal untuk mengizinkan traffic ke workload ELB ini:

kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
apiVersion: networking.gdc.goog/v1
kind: ProjectNetworkPolicy
metadata:
  namespace: PROJECT
  name: allow-inbound-traffic-from-external
spec:
  policyType: Ingress
  subject:
    subjectType: UserWorkload
  ingress:
  - from:
    - ipBlock:
        cidr: CIDR
    ports:
    - protocol: TCP
      port: PORT
EOF

Ganti kode berikut:

MANAGEMENT_API_SERVER: jalur kubeconfig server Management API. Jika Anda belum membuat file kubeconfig untuk server API di zona target, lihat Login untuk mengetahui detailnya.
PROJECT: nama project GDC Anda.
CIDR: CIDR eksternal yang diperlukan ELB untuk diakses. Kebijakan ini diperlukan karena load balancer eksternal menggunakan Direct Server Return (DSR), yang mempertahankan alamat IP eksternal sumber dan melewati load balancer di jalur kembali. Untuk mengetahui informasi selengkapnya, lihat Membuat aturan firewall ingress global untuk traffic eksternal organisasi.
PORT: port backend pada pod di belakang load balancer. Nilai ini ditemukan di kolom .spec.ports[].targetPort dari manifes untuk resource Service. Kolom ini bersifat opsional.

Membuat load balancer eksternal

Anda dapat membuat ELB global atau per zona. Cakupan ELB global mencakup seluruh semesta GDC. Cakupan ELB zonal terbatas pada zona yang ditentukan pada saat pembuatan. Untuk mengetahui informasi selengkapnya, lihat Load balancer global dan per zona.

Buat ELB menggunakan tiga metode berbeda di GDC:

Gunakan gdcloud CLI untuk membuat ELB global atau zonal.
Gunakan Networking Kubernetes Resource Model (KRM) API untuk membuat ELB global atau zonal.
Gunakan Layanan Kubernetes secara langsung di cluster Kubernetes. Metode ini hanya tersedia untuk ELB zona.

Anda dapat menargetkan workload pod atau VM menggunakan KRM API dan gdcloud CLI. Anda hanya dapat menargetkan workload di cluster tempat objek Service dibuat saat menggunakan Layanan Kubernetes secara langsung di cluster Kubernetes.

Membuat ELB zona

Buat ELB zonal menggunakan gdcloud CLI, KRM API, atau Layanan Kubernetes di cluster Kubernetes:

gdcloud

Buat ELB yang menargetkan beban kerja pod atau VM menggunakan gcloud CLI.

ELB ini menargetkan semua workload dalam project yang cocok dengan label yang ditentukan dalam objek Backend.

Untuk membuat ELB menggunakan gdcloud CLI, ikuti langkah-langkah berikut:

Buat resource Backend untuk menentukan endpoint bagi ELB:
```
gdcloud compute backends create BACKEND_NAME \
  --labels=LABELS \
  --project=PROJECT_NAME \
  --zone=ZONE \
  --cluster=CLUSTER_NAME
```
Ganti kode berikut:
- BACKEND_NAME: nama yang Anda pilih untuk resource backend, seperti my-backend.
- LABELS: Pemilih yang menentukan endpoint antara pod dan VM yang akan digunakan untuk resource backend ini. Contoh, app=web.
- PROJECT_NAME: nama project Anda.
- ZONE: zona yang akan digunakan untuk pemanggilan ini. Untuk menyetel flag zona untuk semua perintah yang memerlukannya, jalankan: gdcloud config set core/zone ZONE. Flag zona hanya tersedia di lingkungan multi-zona. Kolom ini bersifat opsional.
- CLUSTER_NAME: cluster yang menjadi batas cakupan pemilih yang ditentukan. Jika kolom ini tidak ditentukan, semua endpoint dengan label tertentu akan dipilih. Kolom ini bersifat opsional.
Lewati langkah ini jika ELB ini ditujukan untuk workload pod. Jika Anda mengonfigurasi ELB untuk workload VM, tentukan health check untuk ELB:
```
gdcloud compute health-checks create tcp HEALTH_CHECK_NAME \
  --check-interval=CHECK_INTERVAL \
  --healthy-threshold=HEALTHY_THRESHOLD \
  --timeout=TIMEOUT \
  --unhealthy-threshold=UNHEALTHY_THRESHOLD \
  --port=PORT \
  --zone=ZONE
```
Ganti kode berikut:
- HEALTH_CHECK_NAME: nama yang Anda pilih untuk resource pemeriksaan kondisi, seperti my-health-check.
- CHECK_INTERVAL: jumlah waktu dalam detik dari awal satu pemeriksaan hingga awal pemeriksaan berikutnya. Nilai defaultnya adalah 5. Kolom ini bersifat opsional.
- HEALTHY_THRESHOLD: waktu yang harus ditunggu sebelum mengklaim kegagalan. Nilai defaultnya adalah 5. Kolom ini bersifat opsional.
- TIMEOUT: jumlah waktu dalam detik untuk menunggu sebelum menyatakan kegagalan. Nilai defaultnya adalah 5. Kolom ini bersifat opsional.
- UNHEALTHY_THRESHOLD: jumlah pemeriksaan berurutan yang harus gagal agar endpoint dianggap tidak responsif. Nilai defaultnya adalah 2. Kolom ini bersifat opsional.
- PORT: port tempat health check dilakukan. Nilai defaultnya adalah 80. Kolom ini bersifat opsional.
- ZONE: zona tempat Anda membuat ELB ini.
Buat resource BackendService dan tambahkan resource Backend yang dibuat sebelumnya ke resource tersebut:
```
gdcloud compute backend-services create BACKEND_SERVICE_NAME \
  --project=PROJECT_NAME \
  --target-ports=TARGET_PORTS \
  --zone=ZONE \
  --health-check=HEALTH_CHECK_NAME
```
Ganti kode berikut:
- BACKEND_SERVICE_NAME: nama yang dipilih untuk layanan backend ini.
- TARGET_PORT: daftar port target yang dipisahkan koma yang diterjemahkan oleh layanan backend ini, dengan setiap port target menentukan protokol, port pada aturan penerusan, dan port pada instance backend. Anda dapat menentukan beberapa port target. Kolom ini harus dalam format protocol:port:targetport, seperti TCP:80:8080. Kolom ini bersifat opsional.
- HEALTH_CHECK_NAME: nama resource pemeriksaan kesehatan. Kolom ini bersifat opsional. Sertakan kolom ini hanya jika Anda mengonfigurasi ELB untuk workload VM.

Tambahkan resource BackendService ke resource Backend yang dibuat sebelumnya:

gdcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --backend=BACKEND_NAME \
  --project=PROJECT_NAME \
  --zone=ZONE

Opsional: Gunakan afinitas sesi untuk ELB guna memastikan bahwa permintaan dari klien yang sama dirutekan secara konsisten ke backend yang sama. Untuk mengaktifkan afinitas sesi untuk load balancer, buat kebijakan layanan backend menggunakan perintah gdcloud compute load-balancer-policy create:
```
 gdcloud compute load-balancer-policy create POLICY_NAME
 --session-affinity=MODE
 --selectors=RESOURCE_LABEL
```
Ganti kode berikut:
- POLICY_NAME: nama yang Anda pilih untuk kebijakan layanan backend.
- MODE: mode afinitas sesi. Dua mode didukung:
  - NONE: Afinitas sesi dinonaktifkan. Permintaan dirutekan ke backend yang tersedia. Ini adalah mode defaultnya.
  - CLIENT_IP_DST_PORT_PROTO: Permintaan dari empat tuple yang sama (alamat IP sumber, alamat IP tujuan, port tujuan, dan protokol) akan dirutekan ke backend yang sama.
- RESOURCE_LABEL: pemilih label yang memilih layanan backend mana yang diterapkan resource BackendServicePolicy di namespace project. Jika beberapa BackendServicePolicy resource cocok dengan layanan backend yang sama, dan setidaknya salah satu kebijakan ini mengaktifkan afinitas sesi, maka afinitas sesi untuk resource BackendService ini akan diaktifkan.
Buat resource ForwardingRule eksternal yang menentukan VIP tempat layanan tersedia:
```
gdcloud compute forwarding-rules create FORWARDING_RULE_EXTERNAL_NAME \
  --backend-service=BACKEND_SERVICE_NAME \
  --cidr=CIDR \
  --ip-protocol-port=PROTOCOL_PORT \
  --load-balancing-scheme=EXTERNAL \
  --zone=ZONE \
  --project=PROJECT_NAME
```
Ganti kode berikut:
- BACKEND_SERVICE_NAME: nama Service backend Anda.
- FORWARDING_RULE_EXTERNAL_NAME: nama yang Anda pilih untuk aturan penerusan.
- CIDR: kolom ini bersifat opsional. Jika tidak ditentukan, CIDR IPv4/32 akan otomatis dicadangkan dari kumpulan IP zonal. Tentukan nama resource Subnet dalam namespace yang sama dengan aturan penerusan ini. Resource Subnet merepresentasikan informasi permintaan dan alokasi subnet zonal. Untuk mengetahui informasi selengkapnya tentang resource Subnet, lihat Contoh resource kustom.
- PROTOCOL_PORT: protokol dan port yang akan diekspos pada aturan penerusan. Kolom ini harus dalam format ip-protocol=TCP:80. Port yang diekspos harus sama dengan yang diekspos oleh aplikasi sebenarnya di dalam container.
Untuk memverifikasi ELB yang dikonfigurasi, konfirmasi kondisi Ready pada setiap objek yang dibuat. Untuk mendapatkan alamat IP yang ditetapkan dari load balancer, deskripsikan aturan penerusan:
```
gdcloud compute forwarding-rules describe FORWARDING_RULE_EXTERNAL_NAME
```
Untuk memvalidasi ELB yang dikonfigurasi, konfirmasi kondisi Ready pada setiap objek yang dibuat. Verifikasi traffic dengan permintaan curl ke VIP:
1. Untuk mendapatkan VIP yang ditetapkan, jelaskan aturan penerusan:
```
gdcloud compute forwarding-rules describe FORWARDING_RULE_EXTERNAL_NAME
```
2. Verifikasi traffic dengan permintaan curl ke VIP di port yang ditentukan di kolom PROTOCOL_PORT dalam aturan penerusan:
```
curl http://FORWARDING_RULE_VIP:PORT
```
  Ganti kode berikut:
  - FORWARDING_RULE_VIP: VIP aturan penerusan.
  - PORT: nomor port dari kolom PROTOCOL_PORT dalam aturan penerusan.

API

Buat ELB yang menargetkan workload pod atau VM menggunakan KRM API. ELB ini menargetkan semua workload dalam project yang cocok dengan label yang ditentukan dalam objek Backend.

Untuk membuat ELB zona menggunakan KRM API, ikuti langkah-langkah berikut:

Buat resource Backend untuk menentukan endpoint bagi ELB. Buat resource Backend untuk setiap zona tempat workload ditempatkan:
```
kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
apiVersion: networking.gdc.goog/v1
kind: Backend
metadata:
  namespace: PROJECT_NAME
  name: BACKEND_NAME
spec:
  clusterName: CLUSTER_NAME
  endpointsLabels:
    matchLabels:
      app: server
EOF
```
Ganti kode berikut:
- MANAGEMENT_API_SERVER: jalur kubeconfig server Management API zonal. Untuk mengetahui informasi selengkapnya, lihat Beralih ke konteks zona.
- PROJECT_NAME: nama project Anda.
- BACKEND_NAME: nama resource Backend.
- CLUSTER_NAME: Ini adalah kolom opsional. Kolom ini menentukan cluster yang menjadi batas cakupan pemilih yang ditentukan. Kolom ini tidak berlaku untuk beban kerja VM. Jika resource Backend tidak menyertakan kolom clusterName, label yang ditentukan akan berlaku untuk semua workload dalam project.
Lewati langkah ini jika ELB ini ditujukan untuk workload pod. Jika Anda mengonfigurasi ELB untuk workload VM, tentukan health check untuk ELB:
```
kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
apiVersion: networking.gdc.goog/v1
kind: HealthCheck
metadata:
  namespace: PROJECT_NAME
  name: HEALTH_CHECK_NAME
spec:
  tcpHealthCheck:
    port: PORT
  timeoutSec: TIMEOUT
  checkIntervalSec: CHECK_INTERVAL
  healthyThreshold: HEALTHY_THRESHOLD
  unhealthyThreshold: UNHEALTHY_THRESHOLD
EOF
```
Ganti kode berikut:
- HEALTH_CHECK_NAME: nama yang Anda pilih untuk resource pemeriksaan kondisi, seperti my-health-check.
- PORT: port tempat health check dilakukan. Nilai defaultnya adalah 80.
- TIMEOUT: jumlah waktu dalam detik untuk menunggu sebelum menyatakan kegagalan. Nilai defaultnya adalah 5.
- CHECK_INTERVAL: jumlah waktu dalam detik dari awal satu pemeriksaan hingga awal pemeriksaan berikutnya. Nilai defaultnya adalah 5.
- HEALTHY_THRESHOLD: jumlah pemeriksaan berurutan yang harus berhasil agar endpoint dianggap responsif. Nilai defaultnya adalah 2.
- UNHEALTHY_THRESHOLD: jumlah pemeriksaan berurutan yang harus gagal agar endpoint dianggap tidak responsif. Nilai defaultnya adalah 2.
Buat objek BackendService menggunakan resource Backend yang dibuat sebelumnya. Jika Anda mengonfigurasi ELB untuk workload VM, sertakan resource HealthCheck.
```
kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
apiVersion: networking.gdc.goog/v1
kind: BackendService
metadata:
  namespace: PROJECT_NAME
  name: BACKEND_SERVICE_NAME
spec:
  backendRefs:
  - name: BACKEND_NAME
  healthCheckName: HEALTH_CHECK_NAME
EOF
```
Ganti kode berikut:
- BACKEND_SERVICE_NAME: nama yang dipilih untuk resource BackendService.
- HEALTH_CHECK_NAME: nama resource HealthCheck yang Anda buat sebelumnya. Jangan sertakan kolom ini jika Anda mengonfigurasi ELB untuk workload pod.
Opsional: Gunakan afinitas sesi untuk ELB guna memastikan bahwa permintaan dari klien yang sama dirutekan secara konsisten ke backend yang sama. Untuk mengaktifkan afinitas sesi untuk load balancer, buat resource BackendServicePolicy. Resource ini menentukan setelan afinitas sesi dan menerapkan resource BackendServicePolicy ke resource BackendService. Buat dan terapkan resource BackendServicePolicy:
```
 kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
 apiVersion: networking.global.gdc.goog/v1
 kind: BackendServicePolicy
 metadata:
     namespace: PROJECT_NAME
     name: POLICY_NAME
 spec:
     sessionAffinity: MODE
     selector:
         matchLabels:
           RESOURCE_LABEL
```
Ganti kode berikut:
- POLICY_NAME: nama yang Anda pilih untuk kebijakan layanan backend.
- MODE: mode afinitas sesi. Dua mode didukung:
  - NONE: Afinitas sesi dinonaktifkan. Permintaan dirutekan ke backend yang tersedia. Ini adalah mode defaultnya.
  - CLIENT_IP_DST_PORT_PROTO: Permintaan dari empat tuple yang sama (alamat IP sumber, alamat IP tujuan, port tujuan, dan protokol) akan dirutekan ke backend yang sama.
- RESOURCE_LABEL: pemilih label yang memilih layanan backend mana yang diterapkan resource BackendServicePolicy di namespace project. Jika beberapa BackendServicePolicy resource cocok dengan layanan backend yang sama, dan setidaknya salah satu kebijakan ini mengaktifkan afinitas sesi, maka afinitas sesi untuk resource BackendService ini akan diaktifkan.
Buat resource ForwardingRule eksternal yang menentukan VIP tempat layanan tersedia.
```
kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
apiVersion: networking.gdc.goog/v1
kind: ForwardingRuleExternal
metadata:
  namespace: PROJECT_NAME
  Name: FORWARDING_RULE_EXTERNAL_NAME
spec:
  cidrRef: CIDR
  ports:
  - port: PORT
    Protocol: PROTOCOL
  backendServiceRef:
    name: BACKEND_SERVICE_NAME
EOF
```
Ganti kode berikut:
- BACKEND_SERVICE_NAME: nama resource BackendService.
- FORWARDING_RULE_EXTERNAL_NAME: nama yang Anda pilih untuk resource ForwardingRuleExternal.
- CIDR: kolom ini bersifat opsional. Jika tidak ditentukan, CIDR IPv4/32 akan otomatis dicadangkan dari kumpulan IP zona. Tentukan nama resource Subnet dalam namespace yang sama dengan aturan penerusan ini. Resource Subnet merepresentasikan informasi permintaan dan alokasi subnet zonal. Untuk mengetahui informasi selengkapnya tentang Subnet resource, lihat Contoh resource kustom.
- PORT: Gunakan kolom ports untuk menentukan array port L4 yang paketnya diteruskan ke backend yang dikonfigurasi dengan aturan penerusan ini. Setidaknya satu port harus ditentukan. Gunakan kolom port untuk menentukan nomor port. Port yang diekspos harus sama dengan port yang diekspos oleh aplikasi sebenarnya di dalam container.
- PROTOCOL: protokol yang akan digunakan untuk aturan penerusan, seperti TCP. Entri dalam array ports harus terlihat seperti berikut:
```
ports:
- port: 80
  protocol: TCP
```
Untuk memvalidasi ELB yang dikonfigurasi, konfirmasi kondisi Ready pada setiap objek yang dibuat. Verifikasi traffic dengan permintaan curl ke VIP:
1. Untuk mendapatkan VIP, gunakan kubectl get:
```
kubectl get forwardingruleexternal -n PROJECT_NAME
```
  Outputnya akan terlihat seperti berikut:
```
NAME           BACKENDSERVICE                               CIDR              READY
elb-name       BACKEND_SERVICE_NAME        10.200.32.59/32   True
```
2. Verifikasi traffic dengan permintaan curl ke VIP di port yang ditentukan di kolom PORT dalam aturan penerusan:
```
curl http://FORWARDING_RULE_VIP:PORT
```
  Ganti FORWARDING_RULE_VIP dengan VIP aturan penerusan.

Layanan Kubernetes

Anda dapat membuat ELB di GDC dengan membuat Service Kubernetes berjenis LoadBalancer di cluster Kubernetes.

Untuk membuat layanan ELB, lakukan hal berikut:

Buat file YAML untuk definisi Service dari jenis LoadBalancer.

Catatan: Berbeda dengan proses untuk load balancer internal, jangan tambahkan anotasi pada file. Jika Anda tidak menentukan anotasi internal, maka layanan akan bersifat eksternal secara default.

Objek Service berikut adalah contoh layanan ELB:
```
apiVersion: v1
kind: Service
metadata:
  name: ELB_SERVICE_NAME
  namespace: PROJECT_NAME
spec:
  ports:
  - port: 1235
    protocol: TCP
    targetPort: 1235
  selector:
    k8s-app: my-app
  type: LoadBalancer
```
Ganti kode berikut:
- ELB_SERVICE_NAME: nama layanan ELB.
- PROJECT_NAME: namespace project Anda yang berisi backend workload.
Kolom port mengonfigurasi port frontend yang Anda ekspos pada alamat VIP. Kolom targetPort mengonfigurasi port backend yang ingin Anda teruskan traffic-nya pada beban kerja backend. Load balancer mendukung Network Address Translation (NAT). Port frontend dan backend dapat berbeda.
Di kolom selector pada definisi Service, tentukan pod atau mesin virtual sebagai beban kerja backend.

Pemilih menentukan workload mana yang akan diambil sebagai workload backend untuk layanan ini, berdasarkan pencocokan label yang Anda tentukan dengan label pada workload. Service hanya dapat memilih workload backend dalam project yang sama dan cluster yang sama tempat Anda menentukan Service.

Untuk mengetahui informasi selengkapnya tentang pemilihan layanan, lihat https://kubernetes.io/docs/concepts/services-networking/service/.
Simpan file definisi Service di project yang sama dengan beban kerja backend.
Terapkan file definisi Service ke cluster:
```
kubectl apply -f ELB_FILE
```
Ganti ELB_FILE dengan nama file definisi Service untuk layanan ELB.

Saat Anda membuat ELB, layanan akan mendapatkan dua alamat IP. Salah satunya adalah alamat IP internal yang hanya dapat diakses dari dalam cluster yang sama. Alamat IP lainnya adalah alamat IP eksternal, yang dapat diakses dari dalam dan luar organisasi. Anda dapat memperoleh alamat IP layanan ELB dengan melihat status layanan:
```
kubectl -n PROJECT_NAME get svc ELB_SERVICE_NAME
```
Ganti kode berikut:
- PROJECT_NAME: namespace project Anda yang berisi backend workload.
- ELB_SERVICE_NAME: nama layanan ELB.
Anda harus mendapatkan output yang mirip dengan contoh berikut:
```
NAME                    TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)          AGE
elb-service             LoadBalancer   10.0.0.1      20.12.1.11      1235:31931/TCP   22h
```
EXTERNAL-IP adalah alamat IP layanan yang dapat diakses dari luar organisasi.

Jika Anda tidak mendapatkan output, pastikan Anda telah berhasil membuat layanan ELB.

Buat ELB global

Buat ELB global menggunakan gcloud CLI atau KRM API.