Kondisi Private Service Connect

1. Pengantar

Codelab ini membahas kesehatan Private Service Connect (PSC) untuk failover regional otomatis. Kesehatan PSC adalah fitur jaringan yang memberikan peningkatan ketahanan dan ketersediaan layanan.

Kesehatan PSC memungkinkan produsen layanan menentukan kebijakan kesehatan yang disesuaikan (status yang menentukan layanan responsif atau tidak responsif) dan secara otomatis menyebarkan sinyal ini ke konsumen layanan yang terhubung ke layanan dengan backend PSC. Fitur ini dirancang khusus untuk mendukung failover lintas region otomatis. Jika layanan produsen regional menjadi tidak responsif, load balancer konsumen akan otomatis menghentikan pemilihan rute traffic ke region tersebut dan mengarahkan traffic ke layanan yang responsif di region lain.

Dibandingkan dengan metode sebelumnya untuk failover lintas region, seperti deteksi pencilan, kesehatan PSC menawarkan sinyal failover yang lebih akurat karena didasarkan langsung pada kesehatan gabungan backend layanan produsen (grup instance VM atau endpoint jaringan). Produsen dapat menentukan logika responsivitasnya sendiri, sehingga memastikan produsen hanya menerima traffic saat layanan benar-benar memenuhi kriteria responsivitas yang diperlukan.

Yang Anda pelajari

• Komponen kesehatan PSC dan cara kerjanya bersama-sama untuk menentukan status kesehatan layanan produser
• Menerapkan health PSC untuk layanan produsen menggunakan perintah gcloud
• Konfigurasi load balancer akses konsumen PSC lintas region untuk menggunakan sinyal kondisi dari kebijakan kondisi PSC produsen
• Menguji skenario kegagalan layanan dan memvalidasi failover lintas-region otomatis

Yang Anda perlukan

• Project Google Cloud
• Izin IAM yang diberikan ke peran roles/compute.admin bawaan atau peran dasar yang luas seperti roles/admin atau roles/owner lama
• Memahami konsep jaringan Google Cloud dan menggunakan Google Cloud CLI

2. Konsep

Jaringan PSC

Topologi jaringan Codelab ini mencakup jaringan VPC konsumen dan produsen di dua region Google Cloud yang aktif.

Sisi konsumen memiliki subnet regional dengan instance VM klien yang digunakan untuk mengakses layanan produsen melalui Load Balancer Aplikasi internal lintas regional dengan backend grup endpoint jaringan (NEG) PSC. Ada dua aturan penerusan load balancer regional, dengan alamat IP regional, untuk ingress klien global (lintas region). Layanan backend adalah resource global yang mendukung NEG di berbagai region. Dalam skenario failover, klien yang terhubung ke aturan penerusan frontend regional dapat diarahkan ke backend global yang berfungsi dengan baik.

Gambar 1. Topologi jaringan codelab

Sisi produsen memiliki subnet regional dengan Load Balancer Jaringan passthrough internal regional yang mengekspos layanan melalui resource lampiran layanan PSC regional. Layanan backend berisi Managed Instance Group (MIG) regional dan diperiksa kondisinya dengan menyelidiki permintaan http dan memvalidasi respons 200 (OK).

Lihat dokumentasi terbaru tentang kompatibilitas Private Service Connect untuk Konfigurasi produsen guna melihat load balancer mana yang mendukung pemeriksaan kondisi PSC.

Tingkat respons layanan

Health check layanan backend produsen, yang dikonfigurasi selama pembuatan load balancer, berfungsi sebagai sinyal asal untuk fitur kesehatan PSC. Resource sumber kesehatan menggunakan sinyal tersebut bersama dengan batasan tambahan yang ditentukan dalam resource kebijakan agregasi kesehatan untuk menentukan status kesehatan untuk satu layanan backend.

Secara default, layanan dianggap responsif jika kedua batasan ini terpenuhi:

• minimum x persen backend responsif (default 60)
• minimum y jumlah backend responsif (default 1)

Health check gabungan mereferensikan semua sumber kesehatan untuk semua layanan backend guna menentukan kesehatan keseluruhan seluruh layanan produsen regional. Dalam kasus lab ini, setiap layanan produsen regional hanya memiliki satu sumber kondisi layanan backend yang di-roll up ke satu health check gabungan.

Gambar 2. Model resource kesehatan PSC

Definisi resource health check gabungan juga merujuk pada aturan penerusan load balancer layanan produsen. Backend PSC NEG load balancer akses konsumen terhubung secara logis ke lampiran layanan PSC produsen dan aturan penerusan load balancer produsen. Hal ini mengikat load balancer akses konsumen ke status health check komposit layanan produsen. Kondisi layanan keseluruhan untuk layanan produsen regional kemudian dipropagasi ke load balancer konsumen untuk melakukan pemilihan backend yang sesuai.

3. Penyiapan project

Mengakses project Anda

Codelab ini ditulis untuk menggunakan satu project Google Cloud. Langkah-langkah konfigurasi menggunakan perintah shell gcloud dan Linux.

CATATAN: Dalam deployment produksi, resource konsumen PSC dan layanan produsen biasanya berada dalam project yang berbeda.

Mulailah dengan mengakses command line project Google Cloud Anda, menggunakan:

• Cloud Shell http://shell.cloud.google.com/, atau
• Terminal lokal dengan gcloud CLI terinstal

Menetapkan Project ID

gcloud config set project YOUR_PROJECT_ID_HERE

Menetapkan variabel lingkungan shell

export PROJECT_ID=$(gcloud config list --format="value(core.project)")
export REGION_1="us-west1"
export ZONE_1="us-west1-c"
export REGION_2="us-east1"
export ZONE_2="us-east1-c"
echo ${PROJECT_ID}
echo ${REGION_1}
echo ${ZONE_1}
echo ${REGION_2}
echo ${ZONE_2}

Mengaktifkan layanan API

gcloud services enable compute.googleapis.com
gcloud services enable dns.googleapis.com

CATATAN: Fitur pra-GA dapat menggunakan perintah gcloud beta. Jika belum diinstal, jalankan gcloud components install beta untuk mengaktifkan.

4. Layanan produsen

Membuat resource bersama

Buat jaringan

gcloud compute networks create vnet-producer --subnet-mode=custom

Membuat subnet

# create subnet for service workload in region 1
gcloud compute networks subnets create subnet-foo \
  --network=vnet-producer \
  --region=${REGION_1} \
  --range=172.16.1.0/24 \
  --enable-private-ip-google-access

# create subnet for psc nat in region 1
gcloud compute networks subnets create subnet-foo-pscnat \
  --network=vnet-producer \
  --region=${REGION_1} \
  --range=192.168.1.0/29 \
  --purpose=PRIVATE_SERVICE_CONNECT

# create subnet for service workload in region 2
gcloud compute networks subnets create subnet-bar \
  --network=vnet-producer \
  --region=${REGION_2} \
  --range=172.16.2.0/24 \
  --enable-private-ip-google-access

# create subnet for psc nat in region 2
gcloud compute networks subnets create subnet-bar-pscnat \
  --network=vnet-producer \
  --region=${REGION_2} \
  --range=192.168.2.0/29 \
  --purpose=PRIVATE_SERVICE_CONNECT

Membuat komponen firewall

Aturan firewall diperlukan untuk mengizinkan traffic ke resource VM (aturan firewall default yang tersirat adalah menolak ingress dan mengizinkan egress). Kebijakan adalah cara yang lebih disukai untuk men-deploy aturan firewall dengan membuat resource kebijakan firewall jaringan, membuat dan menambahkan aturan ke kebijakan, lalu mengaitkan kebijakan ke jaringan VPC.

# create fw policy
gcloud compute network-firewall-policies create fw-policy-producer --global

# create fw policy rules
gcloud compute network-firewall-policies rules create 1001 \
  --description="allow iap for ssh" \
  --firewall-policy=fw-policy-producer \
  --global-firewall-policy \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp:22  \
  --src-ip-ranges=35.235.240.0/20

gcloud compute network-firewall-policies rules create 1002 \
  --description="allow health checks" \
  --firewall-policy=fw-policy-producer \
  --global-firewall-policy \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp,udp,icmp  \
  --src-ip-ranges=130.211.0.0/22,35.191.0.0/16

gcloud compute network-firewall-policies rules create 1003 \
  --description="allow psc nat clients" \
  --firewall-policy=fw-policy-producer \
  --global-firewall-policy \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp:80  \
  --src-ip-ranges=192.168.1.0/29,192.168.2.0/29

# associate fw policy to vnet
gcloud compute network-firewall-policies associations create \
  --firewall-policy=fw-policy-producer \
  --network=vnet-producer \
  --name=fw-policy-association-producer \
  --global-firewall-policy

Membuat Cloud Router dan Gateway NAT

# create routers for nat in each region
gcloud compute routers create cr-nat-foo \
  --network=vnet-producer \
  --asn=16550 \
  --region=${REGION_1}

gcloud compute routers create cr-nat-bar \
  --network=vnet-producer \
  --asn=16550 \
  --region=${REGION_2}

# create nat gateways in each region
gcloud compute routers nats create natgw-foo \
  --router=cr-nat-foo \
  --region=${REGION_1} \
  --auto-allocate-nat-external-ips \
  --nat-all-subnet-ip-ranges

gcloud compute routers nats create natgw-bar \
  --router=cr-nat-bar \
  --region=${REGION_2} \
  --auto-allocate-nat-external-ips \
  --nat-all-subnet-ip-ranges

Membuat konfigurasi startup VM dengan server HTTP

cat > vm-server-startup.sh << 'EOF'
#! /bin/bash
apt-get update
apt-get install apache2 -y
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://169.254.169.254/computeMetadata/v1/instance/name)"
vm_zone="$(curl -H "Metadata-Flavor:Google" \
http://169.254.169.254/computeMetadata/v1/instance/zone)"
echo "Page served from: $vm_hostname in zone $vm_zone" | \
tee /var/www/html/index.html
systemctl restart apache2
EOF

Siapkan layanan foo di region 1

Buat komputasi layanan

# create managed instance group template
gcloud compute instance-templates create mig-template-foo \
  --machine-type=e2-micro \
  --network=vnet-producer \
  --region=${REGION_1} \
  --subnet=subnet-foo \
  --no-address \
  --shielded-secure-boot \
  --metadata-from-file=startup-script=vm-server-startup.sh

# create regional managed instance group
gcloud compute instance-groups managed create mig-foo \
  --region=${REGION_1} \
  --size=2 \
  --template=mig-template-foo \
  --base-instance-name=service-foo

Membuat komponen load balancer layanan

# create lb health check
gcloud compute health-checks create http hc-foo-http \
  --region=${REGION_1} \
  --port=80 \
  --enable-logging

# create backend service
gcloud compute backend-services create ilb-foo \
  --load-balancing-scheme=INTERNAL \
  --protocol=tcp \
  --region=${REGION_1} \
  --health-checks=hc-foo-http \
  --health-checks-region=${REGION_1}

# add managed instance group to backend service
gcloud compute backend-services add-backend ilb-foo \
  --instance-group=mig-foo \
  --instance-group-region=${REGION_1} \
  --region=${REGION_1}

# create forwarding rule
gcloud compute forwarding-rules create fr-foo \
  --region=${REGION_1} \
  --load-balancing-scheme=INTERNAL \
  --network=vnet-producer \
  --subnet=subnet-foo \
  --address=172.16.1.99 \
  --ip-protocol=TCP \
  --ports=80 \
  --backend-service=ilb-foo \
  --backend-service-region=${REGION_1} \
  --allow-global-access

Memublikasikan layanan PSC

# create psc service attachment
gcloud compute service-attachments create psc-sa-foo \
  --region=${REGION_1} \
  --target-service=projects/${PROJECT_ID}/regions/${REGION_1}/forwardingRules/fr-foo \
  --connection-preference=ACCEPT_AUTOMATIC \
  --nat-subnets=subnet-foo-pscnat

Siapkan layanan bar di region 2

Buat komputasi layanan

# create managed instance group template
gcloud compute instance-templates create mig-template-bar \
  --machine-type=e2-micro \
  --network=vnet-producer \
  --region=${REGION_2} \
  --subnet=subnet-bar \
  --no-address \
  --shielded-secure-boot \
  --metadata-from-file=startup-script=vm-server-startup.sh

# create regional managed instance group
gcloud compute instance-groups managed create mig-bar \
  --region=${REGION_2} \
  --size=2 \
  --template=mig-template-bar \
  --base-instance-name=service-bar

Membuat komponen load balancer layanan

# create lb health check
gcloud compute health-checks create http hc-bar-http \
  --region=${REGION_2} \
  --port=80 \
  --enable-logging

# create backend service
gcloud compute backend-services create ilb-bar \
  --load-balancing-scheme=INTERNAL \
  --protocol=tcp \
  --region=${REGION_2} \
  --health-checks=hc-bar-http \
  --health-checks-region=${REGION_2}

# add managed instance group to backend service
gcloud compute backend-services add-backend ilb-bar \
  --instance-group=mig-bar \
  --instance-group-region=${REGION_2} \
  --region=${REGION_2}

# create forwarding rule
gcloud compute forwarding-rules create fr-bar \
  --region=${REGION_2} \
  --load-balancing-scheme=INTERNAL \
  --network=vnet-producer \
  --subnet=subnet-bar \
  --address=172.16.2.99 \
  --ip-protocol=TCP \
  --ports=80 \
  --backend-service=ilb-bar \
  --backend-service-region=${REGION_2} \
  --allow-global-access

Memublikasikan layanan PSC

# create psc service attachment
gcloud compute service-attachments create psc-sa-bar \
  --region=${REGION_2} \
  --target-service=projects/${PROJECT_ID}/regions/${REGION_2}/forwardingRules/fr-bar \
  --connection-preference=ACCEPT_AUTOMATIC \
  --nat-subnets=subnet-bar-pscnat

5. Akses konsumen

Menyiapkan resource klien

Membuat komponen jaringan

# create vpc network
gcloud compute networks create vnet-consumer --subnet-mode=custom

# create client subnet in each region
gcloud compute networks subnets create subnet-client-1 \
  --network=vnet-consumer \
  --region=${REGION_1} \
  --range=10.10.1.0/24 \
  --enable-private-ip-google-access

gcloud compute networks subnets create subnet-client-2 \
  --network=vnet-consumer \
  --region=${REGION_2} \
  --range=10.10.2.0/24 \
  --enable-private-ip-google-access

Load balancer Aplikasi (berbasis proxy) konsumen memerlukan subnet khusus proxy. Subnet ini menyediakan kumpulan alamat IP yang digunakan oleh load balancer berbasis proxy sebagai alamat sumber internal saat mengirim traffic ke backend.

# create proxy subnet in each region
gcloud compute networks subnets create subnet-proxy-1 \
  --purpose=GLOBAL_MANAGED_PROXY \
  --role=ACTIVE \
  --network=vnet-consumer \
  --region=${REGION_1} \
  --range=10.10.128.0/23

gcloud compute networks subnets create subnet-proxy-2 \
  --purpose=GLOBAL_MANAGED_PROXY \
  --role=ACTIVE \
  --network=vnet-consumer \
  --region=${REGION_2} \
  --range=10.10.130.0/23

Membuat komponen firewall

# create fw policy
gcloud compute network-firewall-policies create fw-policy-consumer --global

# create fw policy rules
gcloud compute network-firewall-policies rules create 1001 \
  --description="allow iap for ssh" \
  --firewall-policy=fw-policy-consumer \
  --global-firewall-policy \
  --action=allow \
  --direction=INGRESS \
  --layer4-configs=tcp:22  \
  --src-ip-ranges=35.235.240.0/20

# associate fw policy to vnet
gcloud compute network-firewall-policies associations create \
  --firewall-policy=fw-policy-consumer \
  --network=vnet-consumer \
  --name=fw-policy-association-consumer \
  --global-firewall-policy

Membuat komponen load balancer

# create psc network endpoint group per region
gcloud compute network-endpoint-groups create neg-foo \
  --network-endpoint-type=private-service-connect \
  --psc-target-service=projects/${PROJECT_ID}/regions/${REGION_1}/serviceAttachments/psc-sa-foo \
  --region=${REGION_1} \
  --network=vnet-consumer \
  --subnet=subnet-client-1

gcloud compute network-endpoint-groups create neg-bar \
  --network-endpoint-type=private-service-connect \
  --psc-target-service=projects/${PROJECT_ID}/regions/${REGION_2}/serviceAttachments/psc-sa-bar \
  --region=${REGION_2} \
  --network=vnet-consumer \
  --subnet=subnet-client-2

# verify psc connections
gcloud compute network-endpoint-groups list --format="value(selfLink, pscData.pscConnectionStatus)"

VERIFIKASI: Periksa dua koneksi PSC yang diterima...
.../regions/REGION_1/networkEndpointGroups/neg-foo ACCEPTED
.../regions/REGION_2/networkEndpointGroups/neg-bar ACCEPTED

# create global backend service
gcloud compute backend-services create bes-foobar \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --global

# add negs to backend service
gcloud compute backend-services add-backend bes-foobar \
  --network-endpoint-group=neg-foo \
  --network-endpoint-group-region=${REGION_1} \
  --global

gcloud compute backend-services add-backend bes-foobar \
  --network-endpoint-group=neg-bar \
  --network-endpoint-group-region=${REGION_2} \
  --global

# create global url map
gcloud compute url-maps create ilb-foobar \
  --default-service=bes-foobar \
  --global

# create global target proxy
gcloud compute target-http-proxies create proxy-foobar \
  --url-map=ilb-foobar \
  --global

# create global forwarding rule for region 1
gcloud compute forwarding-rules create fr-foobar-1 \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=vnet-consumer \
  --subnet=subnet-client-1 \
  --subnet-region=${REGION_1} \
  --address=10.10.1.99 \
  --ports=80 \
  --target-http-proxy=proxy-foobar \
  --global

# create global forwarding rule for region 2
gcloud compute forwarding-rules create fr-foobar-2 \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=vnet-consumer \
  --subnet=subnet-client-2 \
  --subnet-region=${REGION_2} \
  --address=10.10.2.99 \
  --ports=80 \
  --target-http-proxy=proxy-foobar \
  --global

Membuat data DNS

# create dns zone
gcloud dns managed-zones create zone-foobar \
  --description="private zone for foobar" \
  --dns-name=foobar.com \
  --networks=vnet-consumer \
  --visibility=private

# create geo dns record
gcloud dns record-sets create www.foobar.com \
  --zone=zone-foobar \
  --type=A \
  --ttl=300 \
  --routing-policy-type=GEO \
  --routing-policy-item="location=${REGION_1},rrdatas=10.10.1.99" \
  --routing-policy-item="location=${REGION_2},rrdatas=10.10.2.99"

Membuat resource komputasi

# create client vm in region 1
gcloud compute instances create client-1 \
  --machine-type=e2-micro \
  --zone=${ZONE_1} \
  --subnet=subnet-client-1 \
  --no-address \
  --shielded-secure-boot

# create client vm in region 2
gcloud compute instances create client-2 \
  --machine-type=e2-micro \
  --zone=${ZONE_2} \
  --subnet=subnet-client-2 \
  --no-address \
  --shielded-secure-boot

Menguji dasar pengukuran layanan

SSH ke VM klien di region 1

gcloud compute ssh client-1 --zone=${ZONE_1}

# send request to service using hostname
curl -v www.foobar.com

# send request to load balancer forwarding rule region 1
curl 10.10.1.99

VERIFIKASI: Periksa apakah respons berasal dari layanan di region 1...
Page served from: service-foo-{UID} in zone projects/{PROJECT_NO}/zones/{REGION_1_ZONE}

# send request to load balancer forwarding rule region 2
curl 10.10.2.99

VERIFIKASI: Periksa apakah respons berasal dari layanan di region 1...
Page served from: service-bar-{UID} in zone projects/{PROJECT_NO}/zones/{REGION_2_ZONE}

# exit vm ssh
exit

Opsional: Coba pengujian yang sama dari VM klien di region 2: gcloud compute ssh client-2 --zone=${ZONE_2}

POIN UTAMA: Perilaku load balancer normal untuk permintaan klien yang masuk ke aturan penerusan di region-x adalah lebih memilih backend di region-x yang sama. Jika semua resource backend responsif, region dengan latensi terendah akan menang. Backend global akan melakukan failover ke region lain dengan sinyal kesehatan yang tepat.

Namun, karena resource layanan produsen yang sebenarnya berada di belakang load balancer produsen di jaringan VPC produsen, sinyal kondisi ini sebelumnya tidak terlihat oleh load balancer konsumen – dan oleh karena itu, sisi konsumen tidak dapat membuat penentuan failover backend tersebut. Kondisi PSC mengatasi hal ini dengan menyebarkan informasi kondisi layanan dari sisi produsen ke sisi konsumen.

6. Sumber informasi kesehatan

Resource Kesehatan PSC dikonfigurasi oleh produsen untuk menunjukkan kondisi keseluruhan layanan regional. Kebijakan kondisi didasarkan pada apa yang ditentukan oleh produsen layanan sebagai hal yang sesuai untuk mempertahankan tingkat layanan yang berfungsi. Nilai minimum ditetapkan untuk memberi tahu konsumen agar melakukan failover saat kondisi yang ditentukan produsen tidak lagi terpenuhi.

Siapkan kesehatan layanan foo di region 1

Membuat kebijakan agregasi kesehatan

gcloud beta compute health-aggregation-policies create foo-health-policy \
  --region=${REGION_1} \
  --healthy-percent-threshold=60 \
  --min-healthy-threshold=1

CATATAN: Kondisi menggunakan nilai default: --healthy-percent-threshold=60 dan --min-healthy-threshold=1

Membuat sumber kesehatan

gcloud beta compute health-sources create foo-health-source \
  --region=${REGION_1} \
  --source-type=BACKEND_SERVICE \
  --sources=ilb-foo \
  --health-aggregation-policy=foo-health-policy

CATATAN: Sumber kesehatan ditentukan oleh resource layanan backend dan kondisi kebijakan agregasi kesehatan.

Membuat health check gabungan

gcloud beta compute composite-health-checks create foo-health-composite \
  --region=${REGION_1} \
  --health-sources=foo-health-source \
  --health-destination=projects/${PROJECT_ID}/regions/${REGION_1}/forwardingRules/fr-foo

CATATAN: Pemeriksaan health check gabungan mereferensikan sumber kesehatan dan menentukan tujuan kesehatan... dan penautan kesehatan end-to-end antara layanan produsen dan akses konsumen kini telah selesai.

Memverifikasi konfigurasi kesehatan layanan foo

Konfigurasi resource kesehatan dapat dilihat dengan perintah daftar (dan describe) per region

# show health aggregation policies
gcloud beta compute health-aggregation-policies list --regions=${REGION_1}

# show health sources
gcloud beta compute health-sources list --regions=${REGION_1}

# show composite health checks
gcloud beta compute composite-health-checks list --regions=${REGION_1}

Siapkan kesehatan layanan bar di region 2

Membuat kebijakan agregasi kesehatan

gcloud beta compute health-aggregation-policies create bar-health-policy \
  --region=${REGION_2} \
  --healthy-percent-threshold=60 \
  --min-healthy-threshold=1

Membuat sumber kesehatan

gcloud beta compute health-sources create bar-health-source \
  --region=${REGION_2} \
  --source-type=BACKEND_SERVICE \
  --sources=ilb-bar \
  --health-aggregation-policy=bar-health-policy

Membuat health check gabungan

gcloud beta compute composite-health-checks create bar-health-composite \
  --region=${REGION_2} \
  --health-sources=bar-health-source \
  --health-destination=projects/${PROJECT_ID}/regions/${REGION_2}/forwardingRules/fr-bar

Memverifikasi konfigurasi kesehatan layanan bar

# show health aggregation policies
gcloud beta compute health-aggregation-policies list --regions=${REGION_2}

# show health sources
gcloud beta compute health-sources list --regions=${REGION_2}

# show composite health checks
gcloud beta compute composite-health-checks list --regions=${REGION_2}

Bagian konfigurasi telah selesai... lanjut ke pengujian.

7. Pengujian failover

Layanan foo wilayah 1 tidak responsif

Skenario ini menyimulasikan kegagalan layanan produsen PSC foo di region 1 dengan menghentikan server web di salah satu dari dua instance VM.

Mendapatkan detail VM server

# set env var for a foo service vm name
export FOO_FAIL_NAME=$(gcloud compute instance-groups managed list-instances mig-foo \
  --limit=1 \
  --region=${REGION_1} \
  --format="value(name)")
echo ${FOO_FAIL_NAME}

# set env var for a foo service zone
export FOO_FAIL_ZONE=$(gcloud compute instance-groups managed list-instances mig-foo \
  --limit=1 \
  --region=${REGION_1} \
  --format="value(ZONE)")
echo ${FOO_FAIL_ZONE}

SSH ke VM server dan hentikan server http

gcloud compute ssh ${FOO_FAIL_NAME} --zone=${FOO_FAIL_ZONE}

# stop apache http server to fail service
sudo systemctl stop apache2

# verify service dead
sudo systemctl status apache2 | grep Active:

# exit vm ssh
exit

Memverifikasi layanan regional tidak responsif

# check health state of backend service
gcloud compute backend-services get-health ilb-foo --region=${REGION_1}

healthState: UNHEALTHY

Output-nya akan terlihat seperti ini...

backend: .../regions/<REGION_1>/instanceGroups/mig-foo
status:
  healthStatus:
  -   forwardingRule: .../regions/<REGION_1>/forwardingRules/fr-foo
    forwardingRuleIp: 172.16.1.99
    healthState: UNHEALTHY
    instance: .../zones/<ZONE_1x>/instances/<FOO_FAIL_NAME>
    ipAddress: <FOO_FAIL_IP>
    port: 80
  -   forwardingRule: .../regions/<REGION_1>/forwardingRules/fr-foo
    forwardingRuleIp: 172.16.1.99
    healthState: HEALTHY
    instance: .../zones/<ZONE_1y>/instances/<FOO_OTHER_NAME>
    ipAddress: <FOO_OTHER_IP>
    port: 80
  kind: compute#backendServiceGroupHealth

SSH ke VM klien region 1 dan uji failover

gcloud compute ssh client-1 --zone=${ZONE_1}

# send request to service using hostname
curl -v www.foobar.com

# curl to ilb vip in region 1
curl 10.10.1.99

# curl to ilb vip in region 2
curl 10.10.2.99

VERIFIKASI: Periksa apakah respons berasal dari layanan di region 2...
Page served from: service-bar-{UID} in zone projects/{PROJECT_NO}/zones/{REGION_2_ZONE}

Kesehatan PSC telah memperbarui load balancer konsumen dan mengarahkannya untuk menghindari layanan backend yang tidak sehat di region 1. Sebagai gantinya, traffic diarahkan ke layanan bar yang responsif di region 2.

# exit client vm ssh
exit

SSH ke VM server dan mulai ulang server http

# ssh to foo service vm
gcloud compute ssh ${FOO_FAIL_NAME} --zone=${FOO_FAIL_ZONE}

# start apache http server to return service to healthy
sudo systemctl start apache2

# verify service running
sudo systemctl status apache2 | grep Active:

# exit vm ssh
exit

Mengubah kebijakan kesehatan

Produsen dapat menyesuaikan kebijakan kesehatan layanan berdasarkan kriteria yang berbeda. Resource kebijakan agregasi kesehatan menentukan nilai minimum yang diperlukan untuk mempertahankan status sehat di semua sumber kesehatan (layanan backend).

CATATAN: Perubahan ini menunjukkan pemanggilan kondisi yang berbeda dalam kebijakan agregasi kesehatan menggunakan --min-healthy-threshold

Memperbarui kebijakan agregasi kesehatan layanan bar

gcloud beta compute health-aggregation-policies update bar-health-policy \
  --region=${REGION_2} \
  --description="min 40% threshold" \
  --healthy-percent-threshold=40 \
  --min-healthy-threshold=2

# verify new policy is applied
gcloud beta compute health-aggregation-policies list --regions=${REGION_2}

Perubahan kebijakan kondisi produsen ini mencapai hal berikut:

1. Mengurangi persentase nilai minimum responsif dari 60% menjadi 40% – kini kegagalan satu instance VM tidak akan memicu status tidak responsif berdasarkan --healthy-percent-threshold (status kegagalan akan menjadi 50% dan hanya memerlukan 40% agar responsif)
2. Meningkatkan jumlah minimum backend yang responsif dari 1 menjadi 2 instance VM – kini kegagalan satu instance VM akan memicu status tidak responsif berdasarkan --min-healthy-threshold (status kegagalan adalah 1, tetapi perlu 2 agar responsif)

Skenario tidak responsif wilayah 2 layanan bar

Skenario ini menyimulasikan kegagalan layanan produsen PSC bar di region 2 dengan menghentikan server web di salah satu dari dua instance VM.

Mendapatkan detail VM server

# set env var for a bar service vm name
export BAR_FAIL_NAME=$(gcloud compute instance-groups managed list-instances mig-bar \
  --limit=1 \
  --region=${REGION_2} \
  --format="value(name)")
echo ${BAR_FAIL_NAME}

# set env var for a bar service zone
export BAR_FAIL_ZONE=$(gcloud compute instance-groups managed list-instances mig-bar \
  --limit=1 \
  --region=${REGION_2} \
  --format="value(ZONE)")
echo ${BAR_FAIL_ZONE}

SSH ke VM server dan hentikan server http

gcloud compute ssh ${BAR_FAIL_NAME} --zone=${BAR_FAIL_ZONE}

# stop apache http server to fail service
sudo systemctl stop apache2

# verify service dead
sudo systemctl status apache2 | grep Active:

# exit vm ssh
exit

Memverifikasi layanan regional tidak responsif

# check health state of backend service
gcloud compute backend-services get-health ilb-bar --region=${REGION_2}

healthState: UNHEALTHY

Output-nya akan terlihat seperti ini...

backend: .../regions/<REGION_2>/instanceGroups/mig-bar
status:
  healthStatus:
  -   forwardingRule: .../regions/<REGION_2>/forwardingRules/fr-bar
    forwardingRuleIp: 172.16.2.99
    healthState: UNHEALTHY
    instance: .../zones/<ZONE_2x>/instances/<BAR_FAIL_NAME>
    ipAddress: <BAR_FAIL_IP>
    port: 80
  -   forwardingRule: .../regions/<REGION_2>/forwardingRules/fr-bar
    forwardingRuleIp: 172.16.2.99
    healthState: HEALTHY
    instance: .../zones/<ZONE_2y>/instances/<BAR_OTHER_NAME>
    ipAddress: <BAR_OTHER_IP>
    port: 80
  kind: compute#backendServiceGroupHealth

SSH ke VM klien region 2 dan uji failover

gcloud compute ssh client-2 --zone=${ZONE_2}

# send request to service using hostname
curl -v www.foobar.com

# curl to ilb vip in region 1
curl 10.10.1.99

# curl to ilb vip in region 2
curl 10.10.2.99

VERIFIKASI: Periksa apakah respons berasal dari layanan di region 1...
Page served from: service-foo-{UID} in zone projects/{PROJECT_NO}/zones/{REGION_1_ZONE}

Health PSC telah memperbarui load balancer konsumen dan mengarahkannya untuk menghindari layanan backend yang tidak sehat di region 2. Sebagai gantinya, traffic telah diarahkan ke layanan foo yang responsif di region 1.

Dalam situasi di mana load balancer konsumen melihat semua layanan produsen sebagai tidak responsif, load balancer tidak dapat melakukan failover ke instance yang responsif. Perilaku yang diharapkan adalah load balancer mendistribusikan traffic ke semua backend yang tidak responsif (fail open).

# exit client vm ssh
exit

Ini mengakhiri bagian pengujian... lanjut ke pembersihan.

8. Pembersihan

# delete health resources
gcloud -q beta compute composite-health-checks delete foo-health-composite --region=${REGION_1}

gcloud -q beta compute health-sources delete foo-health-source --region=${REGION_1}

gcloud -q beta compute health-aggregation-policies delete foo-health-policy --region=${REGION_1}

gcloud -q beta compute composite-health-checks delete bar-health-composite --region=${REGION_2}

gcloud -q beta compute health-sources delete bar-health-source --region=${REGION_2}

gcloud -q beta compute health-aggregation-policies delete bar-health-policy --region=${REGION_2}

# delete consumer compute and load balancer resources
gcloud -q compute instances delete client-2 --zone=${ZONE_2}

gcloud -q compute instances delete client-1 --zone=${ZONE_1}

gcloud -q dns record-sets delete www.foobar.com --type=A --zone=zone-foobar

gcloud -q dns managed-zones delete zone-foobar

gcloud -q compute forwarding-rules delete fr-foobar-2 --global

gcloud -q compute forwarding-rules delete fr-foobar-1 --global

gcloud -q compute target-http-proxies delete proxy-foobar --global

gcloud -q compute url-maps delete ilb-foobar --global

gcloud -q compute backend-services delete bes-foobar --global

# delete consumer network resources
gcloud -q compute network-endpoint-groups delete neg-bar --region=${REGION_2}

gcloud -q compute network-endpoint-groups delete neg-foo --region=${REGION_1}

gcloud -q compute networks subnets delete subnet-proxy-2 --region=${REGION_2}

gcloud -q compute networks subnets delete subnet-proxy-1 --region=${REGION_1}

gcloud -q compute networks subnets delete subnet-client-2 --region=${REGION_2}

gcloud -q compute networks subnets delete subnet-client-1 --region=${REGION_1}

gcloud -q compute network-firewall-policies associations delete \
  --firewall-policy=fw-policy-consumer \
  --name=fw-policy-association-consumer \
  --global-firewall-policy

gcloud -q compute network-firewall-policies delete fw-policy-consumer --global

gcloud -q compute networks delete vnet-consumer

# delete producer load balancer resources
gcloud -q compute service-attachments delete psc-sa-bar --region=${REGION_2}

gcloud -q compute service-attachments delete psc-sa-foo --region=${REGION_1}

gcloud -q compute forwarding-rules delete fr-bar --region=${REGION_2}

gcloud -q compute forwarding-rules delete fr-foo --region=${REGION_1}

gcloud -q compute backend-services delete ilb-bar --region=${REGION_2}

gcloud -q compute backend-services delete ilb-foo --region=${REGION_1}

gcloud -q compute health-checks delete hc-bar-http --region=${REGION_2}

gcloud -q compute health-checks delete hc-foo-http --region=${REGION_1}

# delete producer compute resources
gcloud -q compute instance-groups managed delete mig-bar --region=${REGION_2}

gcloud -q compute instance-groups managed delete mig-foo --region=${REGION_1}

gcloud -q compute instance-templates delete mig-template-bar --global

gcloud -q compute instance-templates delete mig-template-foo --global

# delete producer network resources
gcloud -q compute networks subnets delete subnet-bar-pscnat --region=${REGION_2}

gcloud -q compute networks subnets delete subnet-foo-pscnat --region=${REGION_1}

gcloud -q compute networks subnets delete subnet-bar --region=${REGION_2}

gcloud -q compute networks subnets delete subnet-foo --region=${REGION_1}

gcloud -q compute routers delete cr-nat-bar --region=${REGION_2}

gcloud -q compute routers delete cr-nat-foo --region=${REGION_1}

gcloud -q compute network-firewall-policies associations delete \
  --firewall-policy=fw-policy-producer \
  --name=fw-policy-association-producer \
  --global-firewall-policy

gcloud -q compute network-firewall-policies delete fw-policy-producer --global

gcloud -q compute networks delete vnet-producer

# delete shell variables and script file
unset FOO_FAIL_NAME FOO_FAIL_ZONE BAR_FAIL_NAME BAR_FAIL_ZONE

unset PROJECT_ID REGION_1 ZONE_1 REGION_2 ZONE_2

rm vm-server-startup.sh
#

9. Kesimpulan

Selamat! Anda telah berhasil mengonfigurasi kesehatan PSC dan menguji failover regional otomatis.

Jangan ragu untuk memberikan komentar, pertanyaan, atau koreksi menggunakan formulir masukan ini.

Terima kasih!