Stato di Private Service Connect

1. Introduzione

Questo codelab esplora il controllo dell'integrità di Private Service Connect (PSC) per il failover regionale automatico. PSC health è una funzionalità di networking che offre una migliore resilienza e disponibilità del servizio.

Il controllo dell'integrità di PSC consente ai producer di servizi di definire policy di integrità personalizzate (quale stato definisce un servizio integro o non integro) e di propagare automaticamente questi indicatori ai consumer di servizi che si connettono al servizio con i backend PSC. Questa funzionalità è progettata appositamente per supportare il failover automatico tra regioni. Se un servizio di producer regionale non è integro, il bilanciatore del carico consumer interrompe automaticamente l'instradamento del traffico verso quella regione e lo indirizza a un servizio integro in un'altra regione.

Rispetto ai metodi precedenti per il failover tra regioni, come il rilevamento di outlier, il controllo dell'integrità PSC offre un segnale di failover più preciso perché si basa direttamente sull'integrità aggregata dei backend del servizio producer (gruppi di istanze VM o endpoint di rete). I produttori possono definire la propria logica di integrità, garantendo che il produttore riceva traffico solo quando il servizio soddisfa realmente i criteri di integrità necessari.

Cosa imparerai

• Componenti dell'integrità di PSC e come interagiscono per determinare lo stato di integrità di un servizio di produzione
• Implementazione del controllo di integrità PSC per un servizio producer utilizzando i comandi gcloud
• Configurazione di un bilanciatore del carico consumer PSC multiregionale per utilizzare gli indicatori di integrità della policy di integrità PSC del producer
• Testare scenari di errore del servizio e convalidare il failover automatico tra regioni

Cosa serve

• Un progetto Google Cloud
• Autorizzazioni IAM concesse al ruolo predefinito roles/compute.admin o a un ruolo di base ampio come roles/admin o roles/owner legacy
• Familiarità con i concetti di networking di Google Cloud e con l'utilizzo di Google Cloud CLI

2. Concetti

Networking PSC

Questa topologia di rete Codelab include una rete VPC consumer e producer in due regioni Google Cloud attive.

Il lato consumer ha subnet regionali con istanze VM client utilizzate per accedere al servizio di produzione tramite un bilanciatore del carico delle applicazioni interno cross-regionale con backend di gruppi di endpoint di rete (NEG) PSC. Esistono due regole di forwarding del bilanciatore del carico regionale, con indirizzi IP regionali, per l'ingresso dei client globali (tra regioni). Il servizio di backend è una risorsa globale che supporta i NEG in diverse regioni. In uno scenario di failover, un client che si connette a una regola di forwarding frontend regionale può essere indirizzato a un backend globale integro.

Fig. 1 Topologia di rete del codelab

Il lato produttore ha subnet regionali con bilanciatori del carico di rete passthrough interni regionali che espongono un servizio tramite una risorsa di collegamento del servizio PSC regionale. I servizi di backend contengono gruppi di istanze gestite (MIG) regionali e vengono controllati tramite il probing delle richieste http e la convalida delle risposte 200 (OK).

Consulta la documentazione più recente sulla compatibilità di Private Service Connect per la configurazione del producer per scoprire quali bilanciatori del carico supportano il controllo di integrità PSC.

Integrità del servizio

Il controllo di integrità del servizio di backend del produttore, configurato durante la creazione del bilanciatore del carico, funge da segnale di origine per la funzionalità integrità PSC. La risorsa origine integrità utilizza questo segnale insieme a vincoli aggiuntivi definiti nella risorsa policy di aggregazione dell'integrità per determinare uno stato di integrità per un singolo servizio di backend.

Per impostazione predefinita, un servizio viene considerato integro quando vengono soddisfatti entrambi i seguenti vincoli:

• Almeno il x percento dei backend è integro (valore predefinito 60)
• minimo di y backend integri (valore predefinito 1)

Il controllo di integrità composito fa riferimento a tutte le origini di integrità per tutti i servizi di backend per determinare l'integrità complessiva dell'intero servizio di produzione regionale. Nel caso di questo lab, ogni servizio di produzione regionale ha solo un'unica origine di integrità del servizio di backend che si accumula in un unico controllo di integrità composito.

Fig. 2. Modello di risorsa di integrità PSC

La definizione della risorsa controllo di integrità composito fa riferimento anche alla regola di forwarding del bilanciatore del carico del servizio producer. Il NEG PSC di backend del bilanciatore del carico di accesso consumer è connesso logicamente al collegamento del servizio PSC del producer e alla regola di forwarding del bilanciatore del carico del producer. In questo modo, il bilanciatore del carico di accesso consumer viene collegato allo stato del controllo di integrità composito del servizio producer. L'integrità complessiva del servizio per il servizio di producer regionale viene quindi propagata al bilanciatore del carico consumer per effettuare la selezione del backend appropriato.

3. Configurazione del progetto

Accedere al progetto

Questo codelab è scritto per utilizzare un singolo progetto Google Cloud. I passaggi di configurazione utilizzano gcloud e i comandi della shell Linux.

NOTA:in un deployment di produzione, le risorse consumer PSC e i servizi di produzione si trovano in genere in progetti diversi.

Inizia accedendo alla riga di comando del progetto Google Cloud utilizzando:

• Cloud Shell http://shell.cloud.google.com/ o
• Un terminale locale con gcloud CLI installata

Imposta l'ID progetto

gcloud config set project YOUR_PROJECT_ID_HERE

Imposta le variabili di ambiente della 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}

Abilitare i servizi API

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

NOTA: le funzionalità pre-GA potrebbero utilizzare i comandi gcloud beta. Se non è installato, esegui gcloud components install beta per attivarlo.

4. Servizio producer

Creare risorse condivise

Crea rete

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

Crea 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

Crea i componenti del firewall

Le regole firewall sono necessarie per consentire il traffico verso le risorse VM (le regole firewall predefinite implicite sono per negare l'accesso in entrata e consentire l'uscita). Le policy sono il modo preferito per eseguire il deployment delle regole firewall creando una risorsa policy del firewall di rete, creando e aggiungendo regole alla policy e poi associando la policy a una rete 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

Crea router Cloud e 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

Crea una configurazione di avvio della VM con il 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

Configura il servizio foo nella regione 1

Crea un servizio di calcolo

# 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

Crea i componenti del bilanciatore del carico del servizio

# 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

Pubblica servizio 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

Configura il servizio bar nella regione 2

Crea un servizio di calcolo

# 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

Crea i componenti del bilanciatore del carico del servizio

# 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

Pubblica servizio 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. Accesso dei consumatori

Configurare le risorse del client

Crea componenti di rete

# 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

Il bilanciatore del carico dell'applicazione consumer (basato su proxy) richiede subnet solo proxy. Queste subnet forniscono un pool di indirizzi IP utilizzati dai bilanciatori del carico basati su proxy come indirizzi di origine interni quando inviano traffico ai 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

Crea i componenti del 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

Creare i componenti del bilanciatore del carico

# 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)"

VERIFICA:controlla se sono presenti due connessioni PSC accettate...
.../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

Crea record 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"

Crea risorse di computing

# 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

Test service baseline

Accedi tramite SSH alla VM client nella regione 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

VERIFICA: controlla che la risposta provenga dal servizio nella regione 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

VERIFICA: controlla che la risposta provenga dal servizio nella regione 1...
Page served from: service-bar-{UID} in zone projects/{PROJECT_NO}/zones/{REGION_2_ZONE}

# exit vm ssh
exit

(Facoltativo) Prova gli stessi test dalla VM client nella regione 2: gcloud compute ssh client-2 --zone=${ZONE_2}

PUNTO CHIAVE: il comportamento normale del bilanciatore del carico per le richieste client che entrano in una regola di forwarding in region-x è quello di preferire i backend nello stesso region-x. Se tutte le risorse di backend sono in stato integro, vince la regione con la latenza più bassa. I backend globali eseguiranno il failover all'altra regione con l'indicatore di integrità appropriato.

Tuttavia, poiché le risorse di servizio producer effettive si trovano dietro il bilanciatore del carico producer nella rete VPC producer, questi indicatori di integrità erano in precedenza opachi al bilanciatore del carico consumer e pertanto il lato consumer non era in grado di determinare il failover del backend. PSC health risolve questo problema propagando le informazioni sullo stato del servizio dal lato producer al lato consumer.

6. Risorse per la salute

Le risorse di monitoraggio della salute di PSC sono configurate dal producer per rappresentare lo stato generale del servizio regionale. La norma sull'integrità si basa su ciò che il producer del servizio definisce appropriato per mantenere un livello di servizio funzionante. Le soglie sono impostate per notificare ai consumatori il failover quando le condizioni definite dal produttore non sono più soddisfatte.

Configura il controllo dell'integrità del servizio foo nella regione 1

Creare una policy di aggregazione dell'integrità

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

NOTA:le condizioni utilizzano i valori predefiniti: --healthy-percent-threshold=60 e --min-healthy-threshold=1

Creare un'origine integrità

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

NOTA:l'origine dell'integrità è definita dalla risorsa del servizio di backend e dalle condizioni della policy di aggregazione dell'integrità.

Crea un controllo di integrità composito

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

NOTA:il controllo di integrità composito fa riferimento alle origini di integrità e definisce la destinazione di integrità… e il collegamento di integrità end-to-end tra il servizio producer e l'accesso consumer è ora completo.

Verificare la configurazione del controllo dell'integrità del servizio foo

Le configurazioni delle risorse di integrità possono essere visualizzate con i comandi list (elenco) e describe (descrivi) per regione

# 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}

Configura lo stato del servizio bar nella regione 2

Creare una policy di aggregazione dell'integrità

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

Creare un'origine integrità

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

Crea un controllo di integrità composito

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

Verificare la configurazione del controllo dell'integrità del servizio 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}

Con questo si conclude la parte di configurazione. Passiamo ai test.

7. Test del failover

Scenario non integro del servizio foo regione 1

Questo scenario simula un errore del servizio di produzione PSC foo nella regione 1 arrestando il server web su una delle due istanze VM.

Visualizza i dettagli della 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}

Accedi tramite SSH alla VM server e arresta il 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

Verifica che il servizio regionale non sia integro

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

healthState: UNHEALTHY

L'output dovrebbe essere simile a questo…

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

Accedi tramite SSH alla VM client della regione 1 e testa il 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

VERIFICA: controlla che la risposta provenga dal servizio nella regione 2...
Page served from: service-bar-{UID} in zone projects/{PROJECT_NO}/zones/{REGION_2_ZONE}

PSC health ha aggiornato il bilanciatore del carico consumer e gli ha indicato di evitare il servizio di backend non integro nella regione 1. Ha invece indirizzato il traffico al servizio integro bar nella regione 2.

# exit client vm ssh
exit

Accedi tramite SSH alla VM server e riavvia il 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

Modificare la policy di integrità

I produttori possono ottimizzare i criteri di integrità del servizio in base a criteri diversi. La risorsa policy di aggregazione dell'integrità specifica le soglie minime necessarie per mantenere uno stato integro in tutte le diverse origini di integrità (servizi di backend).

NOTA: questa modifica mostra l'invocazione di una condizione diversa nella norma di aggregazione dei dati sanitari utilizzando --min-healthy-threshold

Aggiorna la policy di aggregazione dell'integrità del servizio 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}

Questa modifica alle norme relative all'integrità del produttore consente di:

1. Diminuisce la percentuale della soglia minima di integrità dal 60% al 40%. Ora un singolo errore dell'istanza VM non attiverà uno stato non integro in base a --healthy-percent-threshold (lo stato di errore sarà del 50% e sarà necessario solo il 40% per essere integro)
2. Aumenta il numero minimo di backend integri da 1 a 2 istanze VM. Ora un singolo errore dell'istanza VM attiverà uno stato non integro in base a --min-healthy-threshold (lo stato di errore sarà 1, ma ne servono 2 per essere integri)

Scenario non integro della regione 2 del servizio bar

Questo scenario simula un errore del servizio di produzione PSC bar nella regione 2 arrestando il server web su una delle due istanze VM.

Visualizza i dettagli della 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}

Accedi tramite SSH alla VM server e arresta il 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

Verifica che il servizio regionale non sia integro

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

healthState: UNHEALTHY

L'output dovrebbe essere simile a questo…

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

Accedi tramite SSH alla VM client della regione 2 e testa il 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

VERIFICA: controlla che la risposta provenga dal servizio nella regione 1...
Page served from: service-foo-{UID} in zone projects/{PROJECT_NO}/zones/{REGION_1_ZONE}

PSC ha aggiornato il bilanciatore del carico consumer e gli ha indicato di evitare il servizio di backend non integro nella regione 2. Ha invece indirizzato il traffico al servizio integro foo nella regione 1.

In una situazione in cui il bilanciatore del carico consumer vede tutti i servizi di produzione come non integri, il bilanciatore del carico non può eseguire il failover a un'istanza integra. Il comportamento previsto è che il bilanciatore del carico distribuisca il traffico tra tutti i backend non integri (fail open).

# exit client vm ssh
exit

Con questo si conclude la parte di test. Passiamo alla pulizia.

8. Esegui la pulizia

# 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. Conclusione

Complimenti! Hai configurato correttamente l'integrità di PSC e testato il failover regionale automatico.

Non esitare a inviare commenti, domande o correzioni utilizzando questo modulo di feedback.

Grazie.