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

Last reviewed 2022-02-17 UTC

Jaringan multi-cluster adalah alat berharga yang memungkinkan kasus penggunaan seperti ketersediaan tinggi regional, jarak yang terdistribusi secara global dengan pengguna untuk latensi yang lebih rendah, dan isolasi organisasi antar-tim. Google Kubernetes Engine (GKE) menyediakan kemampuan bawaan untuk jaringan multi-cluster yang dapat Anda aktifkan dan digunakan dalam skala besar di fleet cluster GKE. Fitur ini juga memungkinkan Anda menggabungkan, atau memigrasikan infrastruktur yang di-deploy antara GKE Standard dan Autopilot untuk memenuhi kebutuhan arsitektur setiap aplikasi.

Dokumen ini menunjukkan fitur tersebut melalui beberapa topologi deployment. Anda akan mempelajari cara mengambil aplikasi yang di-deploy dalam satu cluster GKE dan memigrasikannya ke deployment multi-cluster di seluruh cluster GKE Standard dan Autopilot. Anda menggunakan GKE Layanan multi-cluster untuk lalu lintas timur-barat dan Gateway multi-cluster untuk mengaktifkan jaringan multi-cluster north-south.

Dokumen ini ditujukan untuk tim operasi dan arsitek cloud yang menggunakan, atau merencanakan untuk digunakan, GKE untuk men-deploy layanan di beberapa Kubernetes klaster. Sebelum membaca dokumen ini, pastikan Anda sudah memahami Kubernetes.

GKE Standard dan GKE Autopilot

GKE menyediakan deployment Kubernetes terkelola dengan set fitur lengkap, termasuk bidang kontrol dengan ketersediaan tinggi. Cluster GKE dapat dimulai dengan cepat dan diskalakan hingga 15.000 node. Dengan GKE Autopilot cluster, Google mengelola infrastruktur, termasuk bidang kontrol dan node tersebut. Jika Anda ingin mengonfigurasi dan mengelola node, GKE menyediakan mode Standard.

Untuk mengetahui informasi selengkapnya tentang perbedaan antara mode, lihat Memilih mode operasi cluster.

Service Multi-cluster dan Gateway multi-cluster

Kubernetes dapat berjalan menggunakan satu bidang kontrol di berbagai zona cloud untuk memberikan ketahanan dan ketersediaan yang lebih tinggi untuk layanan Anda. GKE mengambil satu langkah lebih maju dan memberikan GKE Layanan multi-cluster (MCS) yang menyediakan mekanisme penemuan dan pemanggilan layanan lintas cluster. Layanan yang menggunakan fitur ini dapat ditemukan dan diakses di seluruh cluster dengan IP virtual, yang sesuai dengan perilaku Service ClusterIP yang dapat diakses dalam cluster. Pendekatan ini memungkinkan Anda mendapatkan manfaat berikut:

  • Layanan dapat di-load balance di beberapa cluster di region yang sama atau region yang berbeda (traffic east-west).
  • Opsi ketersediaan tinggi layanan lintas region dapat dicapai.
  • Workload stateful dan stateless dapat di-deploy dan dikelola di berbagai cluster yang terpisah.
  • Layanan bersama tersedia di seluruh cluster.

Untuk mempelajari cara men-deploy MCS lebih lanjut, lihat Mengonfigurasi Service multi-cluster.

GKE menyediakan penerapan Kubernetes Gateway API yang menggunakan GKE Gateway Controller. Dengan Gateway, GKE dapat men-deploy load balancer Google Cloud untuk menyediakan perutean traffic masuk (north-south) bagi layanan yang di-deploy di GKE. GKE juga menyediakan Gateway multi-cluster (MCG) yang memperluas Pengontrol Gateway GKE untuk menyediakan beban yang mengarahkan traffic ke layanan yang di-deploy pada Cluster GKE.

Diagram berikut menunjukkan bagaimana saat Anda menggabungkan MCS dan MCG, Anda dapat mengelola aspek komplementer deployment layanan dan pemilihan rute traffic dari satu bidang kontrol:

Layanan Multi-cluster memfasilitasi komunikasi antara layanan dalam Gateway cluster dan multi-cluster men-deploy load balancer untuk mengarahkan traffic di berbagai cluster.

Untuk mengetahui informasi selengkapnya, lihat Men-deploy Gateway multi-cluster.

Ringkasan migrasi

Kemampuan jaringan multi-cluster GKE menguntungkan workload dari berbagai profil. Misalnya, Anda mungkin memiliki komponen stateless dengan traffic burst yang ingin Anda pindahkan ke Autopilot karena model biayanya yang lebih efisien.

Atau, Anda mungkin ingin menempatkan frontend aplikasi lebih dekat dengan pengguna. Pendekatan ini memberikan latensi yang lebih rendah dan caching yang meningkatkan performa aplikasi dan pengalaman pengguna. Namun, Anda mungkin memiliki beberapa komponen stateful yang diandalkan aplikasi yang hanya dapat berada di satu lokasi. Konfigurasi ini memerlukan load balancing multi-cluster north-south untuk mengirim traffic klien ke cluster yang benar di lokasi tersebut. Anda juga memerlukan load balancing multi-cluster east-west untuk mengirim traffic antar-cluster untuk mencapai komponen stateful.

Dokumen ini menggunakan atribut Butik Online aplikasi demo microservice cloud untuk mendemonstrasikan pola multi-cluster yang dapat digunakan untuk meningkatkan deployment demo zona tunggal. Anda memulai dengan aplikasi versi zona tunggal. Kemudian, tambahkan elemen ketersediaan dan ketahanan tinggi menggunakan Service multi-cluster dan Gateway multi-cluster, serta mengurangi toil operasional dengan memanfaatkan Autopilot.

Deployment cluster tunggal awal

Dalam diagram berikut, aplikasi Butik Online awalnya di-deploy ke satu cluster mode GKE Standard bernama std-west, dan diekspos menggunakan Service LoadBalancer:

Satu cluster GKE mode Standard yang menjalankan semua layanan yang diekspos menggunakan layanan LoadBalancer eksternal HTTP reguler.

Bermigrasi ke Service multi-cluster

Pada langkah perantara berikutnya, Anda membuat dua cluster tambahan, dan layanan stateless akan di-deploy di region tambahan. Anda membuat dua cluster GKE Autopilot bernama auto-east dan auto-central di dua region terpisah yang berbeda dari std-west Cluster GKE Standard, dan daftarkan cluster ke Google Cloud fleet.

Fleet adalah konsep Google Cloud untuk mengatur cluster dan resource lainnya secara logis, serta memungkinkan Anda menggunakan dan mengelola kemampuan multi-cluster serta menerapkan kebijakan yang konsisten di seluruh sistem Anda.

Anda mengekspor cartservice di cluster std-west di namespace onlineboutique ke cluster fleet baru menggunakan ServiceExport. Anda men-deploy Layanan frontend Online Boutique pada ketiga cluster dan mengekspos melalui ClusterIP layanan. Kemudian, Anda mengekspor layanan ke fleet menggunakan ServiceExports. Service seperti lapisan middleware Online Boutique (seperti productcatalog, shipping, dan adservice) juga di-deploy ke ketiga cluster.

Pod yang berjalan di cluster mana pun di fleet dapat mengakses Service yang diekspor dengan mengirimkan permintaan ke URI ClusterSet untuk layanan tersebut. Permintaan ini diarahkan ke endpoint yang mendukung layanan.

Service frontend dapat menggunakan layanan middleware (seperti productcatalogservice atau currencyservice) secara lokal di cluster yang sama. Arsitektur ini membantu menjaga permintaan masuk tetap lokal untuk region yang frontend-nya merespons permintaan, dan menghindari biaya traffic jaringan antar-region yang tidak perlu.

Diagram berikut mengilustrasikan dua Service multi-cluster. Service frontend stateless di-deploy ke tiga cluster, dan cartservice backend stateful di-deploy ke satu cluster. Diagram juga menunjukkan bahwa dalam langkah perantara ini, traffic masuk untuk layanan frontend tetap dirutekan ke cluster GKE Standard asli di us-west1 menggunakan Load Balancer Jaringan passthrough eksternal yang dibuat oleh Service LoadBalancer frontend-eksternal:

Service multi cluster berjalan di tiga cluster GKE, tetapi traffic masih diarahkan ke satu cluster menggunakan layanan LoadBalancer eksternal HTTP reguler.

Bermigrasi ke Gateway multi-cluster

Pada langkah terakhir, arahkan traffic masuk untuk Service frontend dari permintaan klien eksternal ke layanan di beberapa cluster dalam fleet menggunakan Gateway multi-cluster.

Cluster keempat bernama config-central ditambahkan ke fleet untuk menghosting dan mengelola konfigurasi untuk Gateway dan HTTPRoute resource yang dibuat sebagai bagian dari konfigurasi ini. Resource HTTPRoute memetakan awalan / ke ServiceImport frontend. Traffic untuk frontend Online Boutique dikirim ke endpoint yang responsif di salah satu region yang tersedia. Pendekatan ini menambahkan elemen ketersediaan tinggi pada arsitektur aplikasi Online Boutique.

Dalam diagram berikut, Gateway multi-cluster men-deploy Load Balancer Cloud Global yang merutekan traffic eksternal ke Service frontend stateless yang di-deploy pada masing-masing dari tiga cluster aplikasi di fleet.

Service multi cluster yang berjalan di tiga cluster GKE dan traffic kini didistribusikan di seluruh layanan frontend di semua cluster menggunakan Gateway eksternal multi-cluster.

Pada status akhir, pola opini ini menunjukkan pengaitan longgar antara bagian stateful (cartservice dan redis-cart) dan bagian stateless dari aplikasi (frontend, emailservice, checkoutservice, recommendationservice, paymentservice, productcatalogservice , currencyservice, shippingservice, dan adservice). Meskipun berada di luar cakupan dokumen ini, pendekatan ini memberi Anda peluang pada masa mendatang untuk menambahkan ketahanan dan ketersediaan tinggi ke lapisan layanan stateful.

Tujuan

  • Membuat dan mengonfigurasi cluster GKE Standard dan Autopilot.
  • Men-deploy Online Boutique ke cluster GKE Standard zona.
  • Mengekspor Services multi-cluster.
  • Men-deploy manifes ke cluster Standard dan Autopilot.
  • Mengaktifkan dan mengonfigurasi Gateway multi-cluster.
  • Menguji perilaku aplikasi multi-region.

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Sebelum memulai

Batasan keamanan yang ditentukan oleh organisasi mungkin mencegah Anda menyelesaikan langkah-langkah berikut. Untuk mengetahui informasi pemecahan masalah, lihat Mengembangkan aplikasi di lingkungan Google Cloud yang terbatas.

Sebelum memulai, pastikan Anda memenuhi persyaratan berikut:

  • Sebaiknya gunakan project baru untuk panduan ini, karena cara termudah untuk melakukan pembersihan adalah dengan menghapus project setelah Anda selesai.
  • Panduan ini mengasumsikan bahwa Anda memiliki peran Owner IAM untuk project Google Cloud Anda. Untuk setelan produksi atau dunia nyata, praktik terbaiknya adalah menerapkan cakupan izin ke hak istimewa terendah. Untuk informasi selengkapnya, lihat Menggunakan IAM dengan aman dan Mengelola identitas dan akses.
  • Biasakan diri Anda dengan Butik Online dan arsitektur aplikasi demo microservice.

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 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 ACTIVE, lihat bagian pemecahan masalah 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 untuk GKE diaktifkan secara default di GKE Cluster autopilot sehingga Anda tidak perlu menggunakan --workload-pool saat Anda 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. 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 mengetahui 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 LoadBalancer jenis Layanan yang secara eksternal mengekspos layanan frontend Online Boutique:

    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:

Satu cluster GKE mode Standard yang menjalankan semua layanan yang diekspos melalui layanan LoadBalancer eksternal HTTP reguler.

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:

Service multi cluster berjalan di tiga cluster GKE, tetapi traffic masih diarahkan ke satu cluster menggunakan layanan LoadBalancer eksternal HTTP reguler.

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 status tidak ACTIVE, 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:

    Service multi cluster yang berjalan di tiga cluster GKE dan traffic kini didistribusikan di seluruh layanan frontend di semua cluster menggunakan Gateway eksternal multi-cluster.

  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.

Pembersihan

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

  1. Di konsol Google Cloud, buka halaman Manage resource.

    Buka Manage resource

  2. Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
  3. Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Langkah berikutnya