Anthos Service Mesh 1.9 telah mencapai akhir siklus proses dan tidak lagi didukung. Lihat Mengupgrade dari versi sebelumnya.

Lihat dokumentasi terbaru atau pilih versi lain yang tersedia:

Versi yang tersedia

1.20 (terbaru)
1.19
1.18
1.17
1.16
1.15
1.14
1.13
1.12
1.12

219}

Konfigurasi GKE multi-cluster di Anthos Service Mesh

Panduan ini menjelaskan cara menggabungkan dua cluster ke dalam satu Anthos Service Mesh menggunakan Mesh CA atau Istio CA, dan mengaktifkan load balancing lintas cluster. Anda dapat dengan mudah memperluas proses ini untuk menggabungkan sejumlah cluster ke dalam mesh Anda.

Konfigurasi Anthos Service Mesh multi-cluster dapat menyelesaikan beberapa skenario perusahaan penting, seperti skala, lokasi, dan isolasi. Untuk mengetahui informasi selengkapnya, lihat Kasus penggunaan multi-cluster. Selain itu, Anda harus mengoptimalkan aplikasi untuk mendapatkan manfaat maksimal dari mesh layanan. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan aplikasi untuk Anthos Service Mesh.

Prasyarat

Panduan ini mengasumsikan bahwa Anda memiliki dua atau lebih cluster Google Cloud GKE yang memenuhi persyaratan berikut:

Anthos Service Mesh versi 1.6.8 atau yang lebih baru diinstal di cluster.
- Jika cluster Anda berada dalam project yang sama, lihat Ringkasan penginstalan untuk menginstal atau mengupgrade cluster ke versi yang diperlukan.
- Jika cluster Anda berada dalam project yang berbeda, lihat Penginstalan dan migrasi multi-project untuk menginstal atau mengupgrade cluster ke versi yang diperlukan.
Jika Anda bergabung dengan cluster yang tidak berada dalam project yang sama, cluster tersebut harus diinstal menggunakan profil asm-gcp-multiproject dan cluster harus berada dalam konfigurasi VPC bersama bersama di jaringan yang sama. Selain itu, sebaiknya Anda memiliki satu project untuk menghosting VPC bersama, dan dua project layanan untuk membuat cluster. Untuk mengetahui informasi selengkapnya, baca artikel Menyiapkan cluster dengan VPC Bersama.
Jika Anda menggunakan Istio CA, gunakan root certificate kustom yang sama untuk kedua cluster.
Jika Anthos Service Mesh Anda di-build di cluster pribadi, sebaiknya buat satu subnet di VPC yang sama. Jika tidak, Anda harus memastikan bahwa:
1. Pesawat kontrol dapat menjangkau bidang kontrol cluster pribadi jarak jauh melalui IP pribadi cluster.
2. Anda dapat menambahkan rentang IP bidang kontrol panggilan ke jaringan yang diizinkan cluster pribadi jarak jauh. Untuk mengetahui informasi selengkapnya, lihat Mengonfigurasi penemuan endpoint antara cluster pribadi.

Menetapkan variabel project dan cluster

Tetapkan folder kerja untuk memudahkan Anda. Ini adalah folder tempat Anda mendownload dan mengekstrak file Anthos Service Mesh pada langkah prasyarat, Preparing to install Anthos Service Mesh.
```
export PROJECT_DIR=YOUR_WORKING_FOLDER
```

Buat variabel lingkungan berikut untuk project ID, zona atau region cluster, nama cluster, dan konteks.

export PROJECT_1=PROJECT_ID_1
export LOCATION_1=CLUSTER_LOCATION_1
export CLUSTER_1=CLUSTER_NAME_1
export CTX_1="gke_${PROJECT_1}_${LOCATION_1}_${CLUSTER_1}"

export PROJECT_2=PROJECT_ID_2
export LOCATION_2=CLUSTER_LOCATION_2
export CLUSTER_2=CLUSTER_NAME_2
export CTX_2="gke_${PROJECT_2}_${LOCATION_2}_${CLUSTER_2}"

Jika cluster ini baru dibuat, pastikan untuk mengambil kredensial untuk setiap cluster dengan perintah gcloud berikut. Jika tidak, context terkait tidak akan tersedia untuk digunakan dalam langkah berikutnya dalam panduan ini:
```
gcloud container clusters get-credentials ${CLUSTER_1}
gcloud container clusters get-credentials ${CLUSTER_2}
```

Buat aturan firewall

Dalam beberapa kasus, Anda perlu membuat aturan firewall untuk mengizinkan traffic lintas cluster. Misalnya, Anda perlu membuat aturan firewall jika:

Anda menggunakan subnet yang berbeda untuk cluster di mesh.
Pod Anda membuka port selain 443 dan 15002.

GKE otomatis menambahkan aturan firewall ke setiap node untuk mengizinkan traffic dalam subnet yang sama. Jika mesh Anda berisi beberapa subnet, Anda harus secara eksplisit menyiapkan aturan firewall untuk mengizinkan traffic lintas subnet. Anda harus menambahkan aturan firewall baru untuk setiap subnet agar dapat mengizinkan blok CIDR IP sumber dan menarget port dari semua traffic masuk.

Petunjuk berikut memungkinkan komunikasi antara semua cluster dalam project Anda atau hanya antara $CLUSTER_1 dan $CLUSTER_2.

Kumpulkan informasi tentang jaringan cluster Anda.

Semua cluster project

Jika cluster berada dalam project yang sama, Anda dapat menggunakan perintah berikut untuk memungkinkan komunikasi antara semua cluster dalam project Anda. Jika ada cluster dalam project yang tidak ingin diekspos, gunakan perintah di tab Specific cluster.

function join_by { local IFS="$1"; shift; echo "$*"; }
ALL_CLUSTER_CIDRS=$(gcloud container clusters list --project $PROJECT_1 --format='value(clusterIpv4Cidr)' | sort | uniq)
ALL_CLUSTER_CIDRS=$(join_by , $(echo "${ALL_CLUSTER_CIDRS}"))
ALL_CLUSTER_NETTAGS=$(gcloud compute instances list --project $PROJECT_1 --format='value(tags.items.[0])' | sort | uniq)
ALL_CLUSTER_NETTAGS=$(join_by , $(echo "${ALL_CLUSTER_NETTAGS}"))

Cluster spesifik

Perintah berikut memungkinkan komunikasi antara $CLUSTER_1 dan $CLUSTER_2 serta tidak mengekspos cluster lain dalam project Anda.

function join_by { local IFS="$1"; shift; echo "$*"; }
ALL_CLUSTER_CIDRS=$(for P in $PROJECT_1 $PROJECT_2; do gcloud --project $P container clusters list --filter="name:($CLUSTER_1,$CLUSTER_2)" --format='value(clusterIpv4Cidr)'; done | sort | uniq)
ALL_CLUSTER_CIDRS=$(join_by , $(echo "${ALL_CLUSTER_CIDRS}"))
ALL_CLUSTER_NETTAGS=$(for P in $PROJECT_1 $PROJECT_2; do gcloud --project $P compute instances list  --filter="name:($CLUSTER_1,$CLUSTER_2)" --format='value(tags.items.[0])' ; done | sort | uniq)
ALL_CLUSTER_NETTAGS=$(join_by , $(echo "${ALL_CLUSTER_NETTAGS}"))

Buat aturan firewall.

GKE

gcloud compute firewall-rules create istio-multicluster-pods \
    --allow=tcp,udp,icmp,esp,ah,sctp \
    --direction=INGRESS \
    --priority=900 \
    --source-ranges="${ALL_CLUSTER_CIDRS}" \
    --target-tags="${ALL_CLUSTER_NETTAGS}" --quiet \
    --network=YOUR_NETWORK

Autopilot

TAGS=""
for CLUSTER in ${CLUSTER_1} ${CLUSTER_2}
do
    TAGS+=$(gcloud compute firewall-rules list --filter="Name:$CLUSTER*" --format="value(targetTags)" | uniq) && TAGS+=","
done
TAGS=${TAGS::-1}
echo "Network tags for pod ranges are $TAGS"

gcloud compute firewall-rules create asm-multicluster-pods \
    --allow=tcp,udp,icmp,esp,ah,sctp \
    --network=gke-cluster-vpc \
    --direction=INGRESS \
    --priority=900 --network=VPC_NAME \
    --source-ranges="${ALL_CLUSTER_CIDRS}" \
    --target-tags=$TAGS

Mengonfigurasi penemuan endpoint antar-cluster

Konfigurasikan penemuan endpoint untuk load balancing lintas cluster menggunakan perintah berikut. Langkah ini melakukan tugas berikut:

Perintah istioctl membuat rahasia yang memberikan akses ke Server Kube API untuk cluster.
Perintah kubectl menerapkan rahasia ke cluster lain, sehingga cluster kedua dapat membaca endpoint layanan dari cluster pertama.

istioctl x create-remote-secret --context=${CTX_1} --name=${CLUSTER_1} | \
  kubectl apply -f - --context=${CTX_2}

istioctl x create-remote-secret --context=${CTX_2} --name=${CLUSTER_2} | \
  kubectl apply -f - --context=${CTX_1}

Mengonfigurasi penemuan endpoint di antara cluster pribadi

Saat menggunakan cluster pribadi, Anda harus mengonfigurasi IP pribadi cluster jarak jauh, bukan IP publik karena IP publik tidak dapat diakses.

Tulis secret dengan IP publik ke dalam file sementara:

istioctl x create-remote-secret --context=${CTX_1} --name=${CLUSTER_1} > ${CTX_1}.secret

istioctl x create-remote-secret --context=${CTX_2} --name=${CLUSTER_2} > ${CTX_2}.secret

Ambil IP pribadi untuk cluster pribadi, dan ganti IP publik dengan IP publik dalam secret dalam file sementara:

PRIV_IP=`gcloud container clusters describe "${CLUSTER_1}" --project "${PROJECT_1}" \
 --zone "${LOCATION_1}" --format "value(privateClusterConfig.privateEndpoint)"`

./istioctl x create-remote-secret --context=${CTX_1} --name=${CLUSTER_1} --server=https://${PRIV_IP} > ${CTX_1}.secret

PRIV_IP=`gcloud container clusters describe "${CLUSTER_2}" --project "${PROJECT_2}" \
 --zone "${LOCATION_2}" --format "value(privateClusterConfig.privateEndpoint)"`

./istioctl x create-remote-secret --context=${CTX_2} --name=${CLUSTER_2} --server=https://${PRIV_IP} > ${CTX_2}.secret

Terapkan rahasia baru ke dalam cluster:

kubectl apply -f ${CTX_1}.secret --context=${CTX_2}

kubectl apply -f ${CTX_2}.secret --context=${CTX_1}

Mengonfigurasi jaringan yang diizinkan untuk cluster pribadi

Ikuti bagian ini hanya jika semua kondisi berikut berlaku untuk mesh Anda:

Anda menggunakan cluster pribadi.
Cluster bukan milik subnet yang sama.
Cluster telah mengaktifkan jaringan yang diizinkan.

Saat men-deploy beberapa cluster di Anthos Service Mesh, Istiod di setiap cluster perlu memanggil bidang kontrol GKE dari cluster jarak jauh. Untuk mengizinkan traffic, Anda perlu menambahkan rentang alamat Pod di cluster panggilan ke jaringan resmi cluster jarak jauh.

Dapatkan blok CIDR IP Pod untuk setiap cluster:

POD_IP_CIDR_1=`gcloud container clusters describe ${CLUSTER_1} --project ${PROJECT_1} --zone ${LOCATION_1} \
 --format "value(ipAllocationPolicy.clusterIpv4CidrBlock)"`

POD_IP_CIDR_2=`gcloud container clusters describe ${CLUSTER_2} --project ${PROJECT_2} --zone ${LOCATION_2} \
 --format "value(ipAllocationPolicy.clusterIpv4CidrBlock)"`

Tambahkan blok CIDR IP Pod cluster Kubernetes ke cluster jarak jauh:

EXISTING_CIDR_1=`gcloud container clusters describe ${CLUSTER_1} --project ${PROJECT_1} --zone ${LOCATION_1} \
 --format "value(masterAuthorizedNetworksConfig.cidrBlocks.cidrBlock)"`
gcloud container clusters update ${CLUSTER_1} --project ${PROJECT_1} --zone ${LOCATION_1} \
 --enable-master-authorized-networks \
 --master-authorized-networks ${POD_IP_CIDR_2},${EXISTING_CIDR_1//;/,}

EXISTING_CIDR_2=`gcloud container clusters describe ${CLUSTER_2} --project ${PROJECT_2} --zone ${LOCATION_2} \
 --format "value(masterAuthorizedNetworksConfig.cidrBlocks.cidrBlock)"`
gcloud container clusters update ${CLUSTER_2} --project ${PROJECT_2} --zone ${LOCATION_2} \
 --enable-master-authorized-networks \
 --master-authorized-networks ${POD_IP_CIDR_1},${EXISTING_CIDR_2//;/,}

Untuk informasi selengkapnya, lihat Membuat cluster dengan jaringan yang diizinkan.

Pastikan jaringan yang diizinkan telah diperbarui:

gcloud container clusters describe ${CLUSTER_1} --project ${PROJECT_1} --zone ${LOCATION_1} \
 --format "value(masterAuthorizedNetworksConfig.cidrBlocks.cidrBlock)"

gcloud container clusters describe ${CLUSTER_2} --project ${PROJECT_2} --zone ${LOCATION_2} \
 --format "value(masterAuthorizedNetworksConfig.cidrBlocks.cidrBlock)"

Aktifkan akses global bidang kontrol

Ikuti bagian ini hanya jika semua kondisi berikut berlaku untuk mesh Anda:

Anda menggunakan cluster pribadi.
Anda menggunakan region yang berbeda untuk cluster di mesh Anda.

Anda harus mengaktifkan akses global bidang kontrol untuk mengizinkan istiod di setiap cluster memanggil bidang kontrol GKE dari cluster jarak jauh.

Aktifkan akses global bidang kontrol:

gcloud container clusters update ${CLUSTER_1} --project ${PROJECT_1} --zone ${LOCATION_1} \
 --enable-master-global-access

gcloud container clusters update ${CLUSTER_2} --project ${PROJECT_2} --zone ${LOCATION_2} \
 --enable-master-global-access

Pastikan akses global bidang kontrol telah diaktifkan:

gcloud container clusters describe ${CLUSTER_1} --zone ${LOCATION_1}

gcloud container clusters describe ${CLUSTER_2} --zone ${LOCATION_2}

Bagian privateClusterConfig dalam output menampilkan status masterGlobalAccessConfig.

Memverifikasi deployment Anda

Bagian ini menjelaskan cara men-deploy sampel layanan HelloWorld ke lingkungan multi-cluster Anda untuk memverifikasi bahwa load balancing lintas cluster berfungsi.

Aktifkan injeksi file bantuan

Gunakan perintah berikut untuk menemukan nilai label revisi dari layanan istiod, yang akan Anda gunakan di langkah-langkah berikutnya.

Catatan: Jika setiap cluster memiliki versi Anthos Service Mesh yang berbeda, Anda harus menjalankan perintah berikut untuk setiap cluster.
```
kubectl -n istio-system get pods -l app=istiod --show-labels
```
Outputnya terlihat mirip dengan yang berikut ini:
```
NAME                                READY   STATUS    RESTARTS   AGE   LABELS
istiod-asm-173-3-5788d57586-bljj4   1/1     Running   0          23h   app=istiod,istio.io/rev=asm-173-3,istio=istiod,pod-template-hash=5788d57586
istiod-asm-173-3-5788d57586-vsklm   1/1     Running   1          23h   app=istiod,istio.io/rev=asm-173-3,istio=istiod,pod-template-hash=5788d57586
```
Pada output, di kolom LABELS, catat nilai label revisi istiod, yang mengikuti awalan istio.io/rev=. Dalam contoh ini, nilainya adalah asm-173-3. Gunakan nilai revisi dalam langkah-langkah di bagian berikutnya.

Menginstal layanan HelloWorld

Buat contoh namespace dan Definisi Layanan di setiap cluster. Dalam perintah berikut, ganti REVISION dengan label revisi istiod yang Anda catat dari langkah sebelumnya.

for CTX in ${CTX_1} ${CTX_2}
  do
    kubectl create --context=${CTX} namespace sample
    kubectl label --context=${CTX} namespace sample \
      istio-injection- istio.io/rev=REVISION --overwrite
  done

Ganti REVISION dengan label revisi istiod yang sebelumnya Anda catat.

Output-nya adalah:

label "istio-injection" not found.
namespace/sample labeled

Anda dapat mengabaikan label "istio-injection" not found. dengan aman

Buat layanan HelloWorld di kedua cluster:

kubectl create --context=${CTX_1} \
 -f ${PROJECT_DIR}/samples/helloworld/helloworld.yaml \
 -l service=helloworld -n sample

kubectl create --context=${CTX_2} \
 -f ${PROJECT_DIR}/samples/helloworld/helloworld.yaml \
 -l service=helloworld -n sample

Men-deploy HelloWorld v1 dan v2 ke setiap cluster

Deploy HelloWorld v1 ke CLUSTER_1 dan v2 ke CLUSTER_2, yang nantinya akan membantu memverifikasi load balancing lintas cluster:

kubectl create --context=${CTX_1} \
 -f ${PROJECT_DIR}/samples/helloworld/helloworld.yaml \
 -l version=v1 -n sample

kubectl create --context=${CTX_2} \
 -f ${PROJECT_DIR}/samples/helloworld/helloworld.yaml \
 -l version=v2 -n sample

Pastikan HelloWorld v1 dan v2 berjalan menggunakan perintah berikut. Pastikan outputnya mirip dengan yang ditunjukkan.:

kubectl get pod --context=${CTX_1} -n sample

NAME                            READY     STATUS    RESTARTS   AGE
helloworld-v1-86f77cd7bd-cpxhv  2/2       Running   0          40s

kubectl get pod --context=${CTX_2} -n sample

NAME                            READY     STATUS    RESTARTS   AGE
helloworld-v2-758dd55874-6x4t8  2/2       Running   0          40s

Men-deploy layanan Tidur

Deploy layanan Sleep ke kedua cluster. Pod ini menghasilkan traffic jaringan buatan untuk tujuan demonstrasi:

for CTX in ${CTX_1} ${CTX_2}
  do
    kubectl apply --context=${CTX} \
      -f ${PROJECT_DIR}/samples/sleep/sleep.yaml -n sample
  done

Tunggu hingga layanan Sleep dimulai di setiap cluster. Pastikan outputnya mirip dengan yang ditunjukkan:

kubectl get pod --context=${CTX_1} -n sample -l app=sleep

NAME                             READY   STATUS    RESTARTS   AGE
sleep-754684654f-n6bzf           2/2     Running   0          5s

kubectl get pod --context=${CTX_2} -n sample -l app=sleep

NAME                             READY   STATUS    RESTARTS   AGE
sleep-754684654f-dzl9j           2/2     Running   0          5s

Memverifikasi load balancing lintas cluster

Panggil layanan HelloWorld beberapa kali dan periksa output untuk memverifikasi balasan alternatif dari v1 dan v2:

Panggil layanan HelloWorld:

kubectl exec --context="${CTX_1}" -n sample -c sleep \
   "$(kubectl get pod --context="${CTX_1}" -n sample -l \
   app=sleep -o jsonpath='{.items[0].metadata.name}')" \
   -- curl -sS helloworld.sample:5000/hello

Outputnya akan mirip dengan yang ditunjukkan:

Hello version: v2, instance: helloworld-v2-758dd55874-6x4t8
Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv
...

Panggil layanan HelloWorld lagi:

kubectl exec --context="${CTX_2}" -n sample -c sleep \
   "$(kubectl get pod --context="${CTX_2}" -n sample -l \
   app=sleep -o jsonpath='{.items[0].metadata.name}')" \
   -- curl -sS helloworld.sample:5000/hello

Outputnya akan mirip dengan yang ditunjukkan:

Hello version: v2, instance: helloworld-v2-758dd55874-6x4t8
Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv
...

Selamat, Anda telah memverifikasi Anthos Service Mesh multi-cluster yang di-load balanced.

Bersihkan layanan HelloWorld

Setelah selesai memverifikasi load balancing, hapus layanan HelloWorld dan Sleep dari cluster Anda.

kubectl delete ns sample --context ${CTX_1}
kubectl delete ns sample --context ${CTX_2}