Melakukan migrasi ke jaringan multi-cluster dengan cluster Autopilot dan cluster Standard Google Kubernetes Engine (GKE)

Menyiapkan lingkungan

Dalam panduan ini, Anda menggunakan Cloud Shell untuk memasukkan perintah. Cloud Shell memberi Anda akses ke command line di Konsol Google Cloud dan mencakup Google Cloud SDK serta alat lainnya, seperti Google Cloud CLI. Cloud Shell akan muncul sebagai jendela di bagian bawah Konsol Google Cloud. Perlu waktu beberapa menit untuk melakukan inisialisasi, tetapi jendela akan segera muncul.

1. Di konsol Google Cloud, aktifkan Cloud Shell.

   Aktifkan Cloud Shell

2. Di Cloud Shell, tentukan variabel lingkungan yang digunakan dalam panduan ini. Ganti PROJECT_ID dengan project ID Anda:

   export PROJECT=PROJECT_ID
   gcloud config set project ${PROJECT}
   

3. Aktifkan layanan yang diperlukan untuk dokumen ini:

   gcloud services enable \
       gkehub.googleapis.com \
       multiclusteringress.googleapis.com \
       dns.googleapis.com \
       trafficdirector.googleapis.com \
       cloudresourcemanager.googleapis.com \
       multiclusterservicediscovery.googleapis.com \
       container.googleapis.com
   
   gcloud container fleet multi-cluster-services enable
   

   Layanan Multi-cluster mengelola komponen Google Cloud seperti Cloud DNS, aturan firewall, dan Cloud Service Mesh, sehingga API ini juga harus diaktifkan. Untuk mengetahui informasi selengkapnya, lihat Ringkasan Cloud Service Mesh.

   Outputnya mirip dengan contoh berikut:

   Operation "operations/acf.p2-822685001869-ee4ebe78-6dd8-465e-b0fd-3b0e5f964bad"
   finished successfully.
   
   Waiting for Feature Multi-cluster Services to be created...done.
   

4. Verifikasi bahwa Service multi-cluster menampilkan status ACTIVE:

   gcloud container fleet multi-cluster-services describe
   

   Outputnya mirip dengan contoh berikut:

   createTime: '2021-11-30T21:59:25.245190894Z'
   name: projects/PROJECT_ID/locations/global/features/multiclusterservicediscovery
   resourceState:
     state: ACTIVE
   spec: {}
   updateTime: '2021-11-30T21:59:27.459063070Z'
   

   Jika nilai state tidak state, lihat bagian pemecahan masalah dalam dokumentasi MCS.

Membuat dan mengonfigurasi cluster GKE

Untuk mendemonstrasikan pola multi-cluster dalam panduan ini, Anda harus menggunakan tiga cluster aplikasi di tiga region cloud terpisah, dan satu cluster untuk menghosting konfigurasi untuk resource Gateway. Anda mendaftarkan semua cluster ke fleet yang terkait dengan proyek Anda. Project Google Cloud hanya dapat memiliki satu fleet yang terkait dengannya. Project ini dikenal sebagai project host fleet.

1. Buat cluster GKE Standard dan Autopilot:

   gcloud container clusters create std-west \
       --zone us-west1-a \
       --num-nodes=6 \
       --enable-ip-alias \
       --release-channel regular \
       --workload-pool=${PROJECT}.svc.id.goog \
       --async
   
   gcloud container clusters create-auto auto-east \
       --region us-east1 \
       --release-channel regular \
       --async
   
   gcloud container clusters create-auto auto-central \
       --region us-central1 \
       --release-channel regular \
       --async
   
   gcloud container clusters create config-central \
       --region us-central1 \
       --num-nodes=1 \
       --enable-ip-alias \
       --release-channel regular \
       --workload-pool=${PROJECT}.svc.id.goog \
       --async
   

   Workload Identity Federation for GKE diaktifkan secara default di cluster GKE Autopilot sehingga Anda tidak perlu menggunakan flag --workload-pool saat membuat cluster tersebut seperti yang Anda lakukan dengan cluster GKE Standard.

2. Tunggu hingga STATUS cluster berubah dari PROVISIONING menjadi RUNNING. Proses ini bisa menghabiskan waktu hingga 10 menit. Anda dapat memantau progresnya dengan menggunakan loop smartwatch sambil minum secangkir kopi atau melakukan beberapa latihan peregangan ringan sebelum melanjutkan aktivitas lain dalam dokumen:

   watch -n 20 --difference=permanent "gcloud container clusters list"
   

   Outputnya mirip dengan contoh berikut:

   NAME: auto-central
   LOCATION: us-central1
   MASTER_VERSION: 1.21.5-gke.1802
   MASTER_IP: 107.178.213.138
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.21.5-gke.1802
   NUM_NODES: 3
   STATUS: PROVISIONING
   
   NAME: config-central
   LOCATION: us-central1
   MASTER_VERSION: 1.21.5-gke.1802
   MASTER_IP:
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.21.5-gke.1802
   NUM_NODES: 9
   STATUS: PROVISIONING
   
   NAME: auto-east
   LOCATION: us-east1
   MASTER_VERSION: 1.21.5-gke.1802
   MASTER_IP: 35.229.88.209
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.21.5-gke.1802
   NUM_NODES: 3
   STATUS: PROVISIONING
   
   NAME: std-west
   LOCATION: us-west1-a
   MASTER_VERSION: 1.21.5-gke.1802
   MASTER_IP: 35.197.93.113
   MACHINE_TYPE: e2-medium
   NODE_VERSION: 1.21.5-gke.1802
   NUM_NODES: 6
   STATUS: PROVISIONING
   

3. Setelah semua cluster berada dalam status RUNNING, tekan CTRL-C untuk menginterupsi perintah.

4. Tambahkan binding kebijakan Identity and Access Management (IAM) yang memberikan peran Network User ke akun layanan MCS project host fleet untuk project-nya sendiri:

   gcloud projects add-iam-policy-binding ${PROJECT} \
       --member "serviceAccount:${PROJECT}.svc.id.goog[gke-mcs/gke-mcs-importer]" \
       --role "roles/compute.networkViewer"
   

   Anda menggunakan Workload Identity Federation for GKE untuk memberi layanan MCS akses baca ke konfigurasi jaringan VPC project Anda. Oleh karena itu, akun layanan Importer GKE MCS project yang menghosting fleet tersebut memerlukan peran ini.

   Outputnya mirip dengan contoh berikut:

   - members:
     - serviceAccount:PROJECT_ID.svc.id.goog[gke-mcs/gke-mcs-importer]
     role: roles/compute.networkViewer
   [...]
   

5. Daftarkan cluster GKE Standard dan Autopilot ke fleet project Anda. Lihat Mendaftarkan cluster untuk detail selengkapnya. Proses ini dapat memerlukan waktu hingga 5 menit:

   gcloud container fleet memberships register std-west \
       --gke-cluster us-west1-a/std-west \
       --enable-workload-identity \
       --project=${PROJECT}
   
   gcloud container fleet memberships register auto-east \
       --gke-cluster us-east1/auto-east \
       --enable-workload-identity \
       --project=${PROJECT}
   
   gcloud container fleet memberships register auto-central \
       --gke-cluster us-central1/auto-central \
       --enable-workload-identity \
       --project=${PROJECT}
   
   gcloud container fleet memberships register config-central \
       --gke-cluster us-central1/config-central \
       --enable-workload-identity \
       --project=${PROJECT}
   

   Untuk setiap perintah, output-nya mirip dengan contoh berikut:

   Waiting for membership to be created...done.
   Created a new membership [projects/PROJECT_ID/locations/global/memberships/std-west] for the cluster [std-west]
   Generating the Connect Agent manifest...
   Deploying the Connect Agent on cluster [std-west] in namespace [gke-connect]...
   Deployed the Connect Agent on cluster [std-west] in namespace [gke-connect].
   Finished registering the cluster [std-west] with the Hub.
   

6. Hubungkan ke cluster dan buat entri kubeconfig:

   gcloud container clusters get-credentials std-west \
       --zone us-west1-a --project $PROJECT
   
   gcloud container clusters get-credentials auto-east \
       --region us-east1 --project $PROJECT
   
   gcloud container clusters get-credentials auto-central \
       --region us-central1 --project $PROJECT
   
   gcloud container clusters get-credentials config-central \
       --region us-central1 --project $PROJECT
   

   Untuk setiap perintah, output-nya mirip dengan contoh berikut:

   Fetching cluster endpoint and auth data.
   kubeconfig entry generated for std-west.
   

7. Ganti nama konteks untuk cluster agar lebih mudah digunakan dalam bagian lain dokumen ini:

   kubectl config rename-context \
       gke_${PROJECT}_us-west1-a_std-west \
       std-west
   
   kubectl config rename-context \
       gke_${PROJECT}_us-east1_auto-east \
       auto-east
   
   kubectl config rename-context \
       gke_${PROJECT}_us-central1_auto-central \
       auto-central
   
   kubectl config rename-context \
       gke_${PROJECT}_us-central1_config-central \
       config-central
   

   Dalam panduan ini, konteks diberi nama berdasarkan lokasinya. Meskipun Anda dapat memberikan nama alternatif, langkah selanjutnya dalam panduan ini menggunakan nama yang digunakan dalam langkah ini.

Men-deploy Online Boutique di GKE Standard

Pada langkah pertama deployment demonstrasi, Anda akan men-deploy set lengkap layanan aplikasi Online Boutique ke satu cluster GKE Standard Standard std-west di us-west1.

1. Buat namespace onlineboutique di std-west:

   kubectl create namespace onlineboutique --context std-west
   

   Outputnya mirip dengan contoh berikut:

   namespace/onlineboutique created
   

2. Clone repositori GitHub Online Boutique dan siapkan variabel WORKDIR:

   cd ~
   
   git clone --branch release/v0.4.1 \
       https://github.com/GoogleCloudPlatform/microservices-demo.git
   
   cd microservices-demo/release && export WORKDIR=`pwd`
   

3. Mendeploy Online Boutique di std-west. Proses ini membuat Deployments dan Services untuk semua microservice Online Boutique, dan mencakup Layanan jenis LoadBalancer yang mengekspos layanan frontend Online Boutique secara eksternal:

   cd $WORKDIR
   
   kubectl apply -f kubernetes-manifests.yaml \
       -n onlineboutique --context=std-west
   

4. Tunggu Service LoadBalancer mendapatkan IP eksternal:

   watch -n 20 --difference=permanent \
        "kubectl get svc frontend-external -n onlineboutique --context=std-west"
   

   Pada awalanya, outputnya mirip dengan contoh berikut:

   NAME                TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
   frontend-external   LoadBalancer   10.60.5.62   <pending>     80:30359/TCP   43s
   

   Jika Service sudah siap, kolom EXTERNAL-IP akan menampilkan alamat IP publik load balancer.

5. Setelah Service siap, dapatkan alamat IP eksternal load balancer dan gunakan curl untuk memverifikasi bahwa frontend sudah siap. Jika perintah curl ini menampilkan error, tunggu beberapa saat sebelum Anda mencoba lagi:

     curl $(kubectl get svc frontend-external \
         -n onlineboutique --context=std-west \
         -o=jsonpath="{.status.loadBalancer.ingress[0].ip}") | \
           grep -e Cluster -e Zone -e Pod
   

   Output perintah curl yang berhasil mirip dengan contoh berikut:

   <b>Cluster: </b>std-west<br/>
   <b>Zone: </b>us-west1-a<br/>
   <b>Pod: </b>frontend-b7bddcc97-wdjsk
   

Anda kini memiliki versi Online Boutique satu zona yang berjalan di us-west1-a. Anda juga dapat menggunakan browser web untuk membuka IP eksternal yang ditetapkan ke Service LoadBalancer frontend-external guna mengakses aplikasi dan mengamati perilakunya. Deployment tunggal awal ini ditampilkan dalam diagram berikut:

Mengekspor cartservice sebagai Service multi-cluster

Di bagian ini, Anda akan mulai menambahkan elemen ketersediaan tinggi ke aplikasi. Anda mengekspor cartservice backend sebagai Service multi-cluster ke cluster GKE Autopilot.

1. Buat namespace onlineboutique di cluster yang tersisa:

   kubectl create namespace onlineboutique --context auto-east
   
   kubectl create namespace onlineboutique --context auto-central
   
   kubectl create namespace onlineboutique --context config-central
   

   Untuk setiap perintah, output-nya mirip dengan contoh berikut:

   namespace/onlineboutique created
   

2. Ekspor cartservice dari cluster std-west ke semua cluster lain di ClusterSet. Objek ServiceExport mendaftarkan Service cartservice, dengan Service multi-cluster GKE, untuk diekspor ke semua cluster dalam fleet yang memiliki namespace onlineboutique saat ini. Untuk mengetahui detail selengkapnya, lihat mendaftarkan layanan untuk ekspor.

   cat <<EOF>> $WORKDIR/cartservice-export.yaml
   kind: ServiceExport
   apiVersion: net.gke.io/v1
   metadata:
    namespace: onlineboutique
    name: cartservice
   
   EOF
   
   kubectl apply -f $WORKDIR/cartservice-export.yaml \
       -n onlineboutique --context=std-west
   

Menerapkan manifes aplikasi untuk pola multi-cluster

Di bagian ini, Anda akan menerapkan dua manifes pilihan untuk men-deploy pola multi-cluster. Manifes ini berisi bagian yang dipilih dari kubernetes-manifests.yaml yang sebelumnya Anda terapkan ke cluster std-west:

• Manifes pertama digunakan untuk frontend Deployment, Service, dan ServiceExport.
• Manifes kedua digunakan untuk men-deploy middleware Services (emailservice, checkoutservice, recommendationservice, paymentservice, productcatalogservice, currencyservice, shippingservice, dan adservice) ke semua region yang menjalankan frontend. Dengan menyimpan permintaan secara lokal ke suatu region selama mungkin, Anda akan terhindar dari biaya traffic jaringan antar-region yang tidak perlu.

Pod yang berjalan di cluster mana pun di fleet dapat mengakses Service yang diekspor dengan mengirimkan permintaan ke URI ClusterSet untuk layanan tersebut dalam format SERVICE_NAME.NAMESPACE.svc.clusterset.local. Misalnya, Deployments frontend di ketiga cluster contoh dapat menggunakan cartservice, dalam namespace onlineboutique, dengan membuat permintaan ke cartservice.onlineboutique.svc.clusterset.local.

Oleh karena itu, di setiap manifes, nama host untuk cartservice telah diperbarui menjadi URI ClusterSet-nya. Langkah ini sangat penting. Jika nama host layanan ini tidak diperbarui, Service frontend akan meminta kube-dns untuk cartservice, bukan cartservice.onlineboutique.svc.clusterset.local. Perilaku ini akan menyebabkan error HTTP Status 500 pada cluster tempat versi lokal cartservice tidak tersedia, dan menyebabkan pod frontend menjadi tidak responsif.

1. Tetapkan variabel lingkungan untuk repositori GitHub yang berisi manifes:

   export MANIFEST_REPO_PATH=https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/master/gateway/docs/cluster-migration
   

2. Terapkan manifes untuk men-deploy lapisan frontend ke ketiga cluster workload:

   kubectl apply -f ${MANIFEST_REPO_PATH}/onlineboutique-frontend-manifests.yaml \
       -n onlineboutique --context=std-west
   
   kubectl apply -f ${MANIFEST_REPO_PATH}/onlineboutique-frontend-manifests.yaml \
       -n onlineboutique --context=auto-east
   
   kubectl apply -f ${MANIFEST_REPO_PATH}/onlineboutique-frontend-manifests.yaml \
       -n onlineboutique --context=auto-central
   

3. Terapkan manifes untuk men-deploy lapisan middleware ke ketiga cluster workload:

   kubectl apply -f ${MANIFEST_REPO_PATH}/onlineboutique-middleware-manifests.yaml \
       -n onlineboutique --context=std-west
   
   kubectl apply -f ${MANIFEST_REPO_PATH}/onlineboutique-middleware-manifests.yaml \
       -n onlineboutique --context=auto-east
   
   kubectl apply -f ${MANIFEST_REPO_PATH}/onlineboutique-middleware-manifests.yaml \
       -n onlineboutique --context=auto-central
   

Anda kini memiliki frontend Deployment, Service, dan ServiceExport yang aktif dalam cluster std-west dan auto-east, danauto-central. Anda juga memiliki layanan middleware Online Boutique yang berjalan secara lokal di setiap cluster. Namun, traffic eksternal masih dirutekan hanya ke Service yang berjalan di cluster awal di us-west1, seperti yang ditunjukkan pada diagram berikut:

Mengaktifkan dan mengonfigurasi Gateway multi-cluster

Di bagian ini, Anda akan merutekan traffic ke dan melakukan load balancing pada traffic eksternal ke seluruh frontend pada ketiga cluster. Untuk mencapai konfigurasi ini, gunakan Gateway multi-cluster (MCG). Dokumen ini mengikuti petunjuk untuk menyiapkan MCG seperti yang dijelaskan dalam Mengaktifkan Gateway multi-cluster.

Dalam panduan ini, Anda akan menggunakan cluster config-central untuk menghosting konfigurasi untuk resource Gateway.

1. Konfirmasi bahwa semua cluster telah berhasil mendaftar ke fleet:

   gcloud container fleet memberships list --project=$PROJECT
   

   Contoh output berikut menunjukkan bahwa semua cluster berhasil didaftarkan:

   NAME: auto-central
   EXTERNAL_ID: 21537493-32ea-4a41-990d-02be2c1b319f
   
   NAME: config-central
   EXTERNAL_ID: 4369423e-ea7b-482d-a0eb-93b560e67b98
   
   NAME: std-west
   EXTERNAL_ID: 7fcb048b-c796-476b-9698-001a00f91ab3
   
   NAME: auto-east
   EXTERNAL_ID: aae2d2ff-b861-4a38-bcaf-612f14810012
   

2. Instal definisi resource kustom Gateway API di cluster config-central:

   kubectl --context=config-central kustomize "github.com/kubernetes-sigs/gateway-api/config/crd?ref=v0.5.0" \
       | kubectl apply -f -
   

   Langkah ini akan menginstal definisi resource kustom Gateway API, termasuk resource GatewayClass, Gateway, dan HTTPRoute. Definisi resource kustom dikelola oleh Network Special Interest Group Kubernetes. Setelah diinstal, Anda dapat menggunakan GKE Gateway Controller.

3. Aktifkan Multi Cluster Ingress untuk fleet jika Anda belum melakukannya. Jika fitur ini diaktifkan, pengontrol Gateway multi-cluster juga akan aktif.

   gcloud container fleet ingress enable \
       --config-membership=config-central \
       --project=$PROJECT
   
   gcloud container fleet ingress describe --project=$PROJECT
   

   Outputnya mirip dengan contoh berikut:

   createTime: '2021-12-08T23:10:52.505888854Z'
   name: projects/PROJECT_ID/locations/global/features/multiclusteringress
   resourceState:
     state: ACTIVE
   spec:
     multiclusteringress:
       configMembership: projects/zl-mcs-expf61cbd13/locations/global/memberships/config-central
   state:
     state:
       code: OK
       description: Ready to use
       updateTime: '2021-12-08T23:11:37.994971649Z'
   updateTime: '2021-12-08T23:11:38.098244178Z'
   

   Jika nilai state tidak state, lihat Pemecahan masalah dan operasi untuk Multi Cluster Ingress.

4. Pastikan GatewayClasses tersedia di cluster config-central:

   kubectl get gatewayclasses --context=config-central
   

   Outputnya mirip dengan contoh berikut:

   NAME                                  CONTROLLER                  AGE
   gke-l7-global-external-managed        networking.gke.io/gateway   18s
   gke-l7-global-external-managed-mc     networking.gke.io/gateway   19s
   gke-l7-regional-external-managed      networking.gke.io/gateway   18s
   gke-l7-regional-external-managed-mc   networking.gke.io/gateway   19s
   gke-l7-gxlb                           networking.gke.io/gateway   74s
   gke-l7-gxlb-mc                        networking.gke.io/gateway   16s
   gke-l7-rilb                           networking.gke.io/gateway   74s
   gke-l7-rilb-mc                        networking.gke.io/gateway   16s
   

   Resource GatewayClass yang berbeda memiliki kemampuan yang berbeda. Untuk mengetahui informasi selengkapnya tentang kapan harus menggunakan jenis yang mana, lihat Kemampuan GatewayClass.

5. Deploy resource Gateway external-http ke config-central:

   cat <<EOF>> $WORKDIR/external-http-gateway.yaml
   kind: Gateway
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: external-http
     namespace: onlineboutique
   spec:
     gatewayClassName: gke-l7-global-external-managed-mc
     listeners:
     - protocol: HTTP
       port: 80
       name: http
   EOF
   
   kubectl apply -f external-http-gateway.yaml \
       -n onlineboutique --context=config-central
   

   Seperti yang ditunjukkan oleh kolom gatewayClassName, resource ini adalah dari GatewayClass gke-l7-global-external-managed-mc yang mengelola Cloud Load Balancing eksternal Layer 7 dan mengekspos aplikasi multi-cluster

6. Deploy HTTPRoute bernama public-frontend-route di config-central:

   cat <<EOF>> $WORKDIR/public-frontend-route.yaml
   kind: HTTPRoute
   apiVersion: gateway.networking.k8s.io/v1beta1
   metadata:
     name: public-frontend-route
     namespace: onlineboutique
   spec:
     parentRefs:
     - name: "external-http"
     hostnames:
     - "store.example.com"
     rules:
     - matches:
       - path:
           type: PathPrefix
           value: /
       backendRefs:
       - name: frontend
         group: net.gke.io
         kind: ServiceImport
         port: 80
   EOF
   
   kubectl apply -f public-frontend-route.yaml \
       -n onlineboutique --context=config-central
   

   Saat Anda men-deploy resource HTTPRoute, resource tersebut membuat resource Cloud Load Balancing Layer 7 eksternal dan mengekspos ServiceImport frontend yang didukung oleh layanan frontend yang berjalan di cluster std-west, auto-east, dan auto-central.

   Diagram berikut menunjukkan cara, setelah Gateway multi-cluster di-deploy, traffic dapat dirutekan ke salah satu Service multi-cluster frontend pada salah satu dari tiga cluster aplikasi:

   

7. Tunggu load balancer siap dengan alamat IP eksternal yang disediakan sebelum melanjutkan ke langkah berikutnya. Diperlukan waktu hingga 10 menit untuk menetapkan alamat IP. Anda dapat memantau progres menggunakan loop smartwatch. Load balancer tersebut memiliki nama dalam pola seperti gkemcg-onlineboutique-external-http-k09mfhk74gop:

   watch -n 20 --difference=permanent \
       "gcloud compute forwarding-rules list \
           | grep -A 5 NAME..*external-http"
   

   Outputnya mirip dengan contoh berikut:

   NAME: gkemcg-onlineboutique-external-http-k09mfhk74gop
   REGION:
   IP_ADDRESS: 34.149.29.176
   IP_PROTOCOL: TCP
   TARGET: gkemcg-onlineboutique-external-http-k09mfhk74gop
   

8. Setelah load balancer siap, jalankan perintah berikut di Cloud Shell untuk mengekspor alamat IP eksternal load balancer yang dibuat melalui penerapan external-http-gateway.yaml dan manifes public-frontend-route.yaml:

   export EXTERNAL_LB_IP=$(kubectl --context=config-central \
                               -n onlineboutique get gateway external-http \
                               -o=jsonpath='{.status.addresses[0].value}')
   

9. Saat Anda mengirim permintaan ke load balancer dengan header yang sesuai, permintaan tersebut akan menampilkan konten HTML yang disajikan oleh layanan frontend. Misalnya, karena Anda mengonfigurasi resource HTTPRoute untuk memetakan nama host store.example.com ke ServiceImport frontend, Anda harus menyediakan header HOST saat Anda membuat permintaan HTTP. Jika contoh curl berikut menampilkan error, tunggu beberapa menit dan coba lagi:

   curl -H 'HOST: store.example.com' $EXTERNAL_LB_IP | \
       grep -e Cluster -e Zone -e Pod
   

   Output perintah curl yang berhasil mirip dengan contoh berikut:

   <b>Cluster: </b>auto-central<br/>
   <b>Zone: </b>us-central1-f<br/>
   <b>Pod: </b>frontend-7c7d596ddc-jdh8f
   

Menguji perilaku pemilihan rute multi-region aplikasi

Salah satu fitur canggih yang diperoleh dari penggunaan Service multi-cluster dan Gateway multi-cluster adalah permintaan eksternal dirutekan ke cluster yang paling dekat secara geografis.

Untuk menguji perilaku multi-region aplikasi, buat traffic yang berasal dari berbagai region tempat Anda men-deploy cluster. Buat tiga pod kecil, satu di setiap cluster penayangan (std-west, auto-east, dan auto-central), yang dapat Anda gunakan untuk mengirim permintaan HTTP ke endpoint load balancer. Hasilnya memungkinkan Anda melihat Pod frontend mana yang merespons.

1. Buat pod klien:

   kubectl run --context=std-west \
               --image=radial/busyboxplus:curl client-west \
               -- sh -c 'while sleep 3600; do :; done'
   
   kubectl run --context=auto-east \
               --image=radial/busyboxplus:curl client-east \
               -- sh -c 'while sleep 3600; do :; done'
   
   kubectl run --context=auto-central \
               --image=radial/busyboxplus:curl client-central \
               -- sh -c 'while sleep 3600; do :; done'
   

2. Setelah pod berjalan, gunakan perintah curl untuk mengirim permintaan ke endpoint load balancer dari Pod klien di cluster std-west dan tinjau responsnya:

   kubectl exec -it --context=std-west client-west \
       -- curl -H 'HOST: store.example.com' $EXTERNAL_LB_IP | \
              grep -e Cluster -e Zone -e Pod
   

   Output perintah curl yang berhasil mirip dengan contoh berikut:

   <b>Cluster: </b>std-west<br/>
   <b>Zone: </b>us-west1-a<br/>
   <b>Pod: </b>frontend-7cf48b79cf-trzc4
   

3. Jalankan permintaan curl yang sama dari Pod klien di cluster auto-east, dan lihat responsnya:

   kubectl exec -it --context=auto-east client-east \
       -- curl -H 'HOST: store.example.com' $EXTERNAL_LB_IP | \
              grep -e Cluster -e Zone -e Pod
   

   Output perintah curl yang berhasil mirip dengan contoh berikut:

   <b>Cluster: </b>auto-east<br/>
   <b>Zone: </b>us-east1-d<br/>
   <b>Pod: </b>frontend-6784b6df98-scdws
   

   Karena ini adalah cluster Autopilot, cluster mungkin perlu menyediakan resource tambahan untuk menjadwalkan Pod. Jika Anda melihat output yang mirip dengan contoh berikut, tunggu sebentar dan coba lagi:

    Error from server (BadRequest): pod client-east does not have a host assigned
   

4. Jalankan curl dari Pod klien di cluster auto-central dan periksa responsnya:

   kubectl exec -it --context=auto-central client-central \
       -- curl -H 'HOST: store.example.com' $EXTERNAL_LB_IP | \
           grep -e Cluster -e Zone -e Pod
   

   Output perintah curl yang berhasil mirip dengan contoh berikut:

   <b>Cluster: </b>auto-central<br/>
   <b>Zone: </b>us-central1-b<br/>
   <b>Pod: </b>frontend-6784b6df98-x2fv4
   

   Hasil ini mengonfirmasi bahwa traffic dirutekan ke pod yang sesuai di lokasi yang paling dekat dengan asal permintaan.

Menguji ketahanan multi-region aplikasi

Selain pemilihan rute traffic yang efisien, menjalankan layanan Anda di beberapa region akan memberikan ketahanan dalam kasus kegagalan infrastruktur yang jarang terjadi, tetapi masih memungkinkan.

Uji perilaku dengan menghapus Deployments frontend di cluster tertentu, lalu coba lagi perintah curl dari Pod klien di region tersebut. Perhatikan bahwa aplikasi masih tersedia, dan lihat lokasi Pod yang merespons permintaan.

1. Jalankan perintah curl dari Pod client-west di cluster std-west, dan lihat bahwa hasilnya berasal dari frontend di us-west1:

   kubectl exec -it --context=std-west client-west \
       -- curl -H 'HOST: store.example.com' $EXTERNAL_LB_IP  | \
              grep -e Cluster -e Zone -e Pod
   

   Output perintah curl yang berhasil mirip dengan contoh berikut:

   <b>Cluster: </b>std-west<br/>
   <b>Zone: </b>us-west1-a<br/>
   <b>Pod: </b>frontend-7cf48b79cf-trzc4
   

2. Hapus Deployment frontend di cluster std-west:

   kubectl delete deploy frontend \
       -n onlineboutique --context=std-west
   

   Outputnya mirip dengan contoh berikut:

   deployment.apps "frontend" deleted
   

3. Kirim permintaan lain dari Pod client-west di cluster std-west. Anda akan melihat respons dari salah satu Deployments frontend lainnya yang terletak di cluster auto-east atau auto-central:

   kubectl exec -it --context=std-west client-west \
       -- curl -H 'HOST: store.example.com' $EXTERNAL_LB_IP | \
              grep -e Cluster -e Zone -e Pod
   

   Output yang mirip dengan contoh berikut menunjukkan lokasi Pod responsif yang merespons permintaan ini:

   <b>Cluster: </b>auto-central<br/>
   <b>Zone: </b>us-central1-b<br/>
   <b>Pod: </b>frontend-6784b6df98-x2fv4
   

   atau

   <b>Cluster: </b>auto-east<br/>
   <b>Zone: </b>us-east1-d<br/>
   <b>Pod: </b>frontend-6784b6df98-scdws
   

   Jalankan perintah beberapa kali untuk melihat hasil yang berbeda-beda.

Dengan deployment demonstrasi ini, Anda telah menambahkan elemen distribusi ketahanan dan geografis ke aplikasi Online Boutique menggunakan Service multi-cluster dan Gateway multi-cluster. Permintaan dirutekan ke region geografis terdekat, dan meskipun layanan frontend atau middleware di suatu region mengalami masalah, pengguna akhir masih dapat menggunakan aplikasi tersebut.