Integrità composita per Private Service Connect

1. Introduzione

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

L'integrità composita consente ai produttori di servizi di definire policy di integrità personalizzate (quale stato definisce un servizio integro o non integro) e di propagare automaticamente questi indicatori ai consumatori 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, Composite Health offre un segnale di failover più accurato perché si basa direttamente sull'integrità aggregata dei backend del servizio producer (gruppi di istanze VM o endpoint di rete). I producer possono definire la propria logica di integrità, garantendo che il producer riceva traffico solo quando il servizio soddisfa realmente i criteri di integrità necessari.

Cosa imparerai

  • Componenti di integrità composita e come funzionano insieme per determinare lo stato di integrità di un servizio di produzione
  • Implementazione del controllo di integrità composito per PSC per un servizio producer utilizzando i comandi gcloud
  • Configurazione di un bilanciatore del carico di accesso consumer PSC cross-region per utilizzare gli indicatori di integrità della policy di integrità composita del produttore
  • 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 una producer in due regioni Google Cloud attive.

Il lato consumer ha subnet regionali con istanze VM client utilizzate per accedere al servizio producer tramite un bilanciatore del carico delle applicazioni interno tra regioni con backend del gruppo di endpoint di rete (NEG) PSC. Esistono due regole di forwarding del bilanciatore del carico regionale, con indirizzi IP regionali, per l'ingresso client globale (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.

figure1

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à composito per 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à composita per 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.

figure2

Fig. 2 Integrità composita per il modello di risorsa 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 è collegato logicamente al collegamento al 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 è collegato allo stato del controllo di integrità composito del servizio producer. L'integrità complessiva del servizio per il servizio producer regionale viene quindi propagata al bilanciatore del carico consumer per effettuare la selezione del backend appropriata.

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 tuo progetto Google Cloud utilizzando:

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

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 firewall

Le regole firewall sono necessarie per consentire il traffico alle risorse VM (le regole firewall predefinite implicite sono per negare l'ingresso e consentire l'uscita). Le policy sono il modo preferito per eseguire il deployment delle regole firewall creando una risorsa policy 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 consumer

Configurare le risorse 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 delle applicazioni (basato su proxy) consumer 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 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)"

# 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

Dalla VM client nella regione 1

# send request from vm to service using hostname
gcloud compute ssh client-1 --zone=${ZONE_1} --command='
  curl -s -v www.foobar.com'

# send request from vm to load balancer forwarding rule region 1
gcloud compute ssh client-1 --zone=${ZONE_1} --command='
  curl -s 10.10.1.99'

# send request from vm to load balancer forwarding rule region 2
gcloud compute ssh client-1 --zone=${ZONE_1} --command='
  curl -s 10.10.2.99'

(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 stato corretto.

Tuttavia, poiché le risorse di servizio producer effettive si trovano dietro il bilanciatore del carico producer nella rete VPC producer, questi indicatori di stato erano in precedenza opachi per il 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

L'integrità composita per le risorse PSC viene configurata dal produttore per rappresentare l'integrità complessiva del servizio regionale. La policy di integrità si basa su ciò che il produttore del servizio definisce come 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 vengono più soddisfatte.

Configura lo stato del servizio foo nella regione 1

Creare una policy di aggregazione dell'integrità

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

Creare un'origine integrità

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

Crea un controllo di integrità composito

gcloud 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

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

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

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

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

# show composite health checks
gcloud 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 compute health-aggregation-policies create bar-health-policy \
  --region=${REGION_2} \
  --healthy-percent-threshold=60 \
  --min-healthy-threshold=1

Creare un'origine integrità

gcloud 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 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

Verifica la configurazione del controllo dell'integrità del servizio bar

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

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

# show composite health checks
gcloud 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 per la regione 1 del servizio foo

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}

Arresta il server http della regione 1

# stop apache http server to fail service
gcloud compute ssh ${FOO_FAIL_NAME} --zone=${FOO_FAIL_ZONE} --command='
  sudo systemctl stop apache2'

# verify service dead
gcloud compute ssh ${FOO_FAIL_NAME} --zone=${FOO_FAIL_ZONE} --command='
  sudo systemctl status apache2 | grep Active:'

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}

L'output dovrebbe essere simile a questo:

backend: .../regions/us-west1/instanceGroups/mig-foo
status:
  healthStatus:
  -   forwardingRule: .../regions/us-west1/forwardingRules/fr-foo
    forwardingRuleIp: 172.16.1.99
    healthState: UNHEALTHY
    instance: .../zones/us-west1-a/instances/service-foo-<UID_1>
    ipAddress: 172.16.1.2
    port: 80
  -   forwardingRule: .../regions/us-west1/forwardingRules/fr-foo
    forwardingRuleIp: 172.16.1.99
    healthState: HEALTHY
    instance: .../zones/us-west1-b/instances/service-foo-<UID_2>
    ipAddress: 172.16.1.3
    port: 80
  kind: compute#backendServiceGroupHealth

# check health state of health source
gcloud compute health-sources get-health foo-health-source --region=${REGION_1}

L'output dovrebbe essere simile a questo:

healthState: UNHEALTHY
kind: compute#healthSourceHealth
sources:
- backends:
  - endpointCount: 1
    group: .../zones/us-west1-a/instanceGroups/mig-foo
    healthyEndpointCount: 0
  - endpointCount: 0
    group: .../zones/us-west1-c/instanceGroups/mig-foo
    healthyEndpointCount: 0
  - endpointCount: 1
    group: .../zones/us-west1-b/instanceGroups/mig-foo
    healthyEndpointCount: 1
  forwardingRule: .../regions/us-west1/forwardingRules/fr-foo
  source: .../regions/us-west1/backendServices/ilb-foo

Testa il failover del client della regione 1

# send request to service using hostname
gcloud compute ssh client-1 --zone=${ZONE_1} --command='
  curl -s -v www.foobar.com'

# curl to ilb vip in region 1
gcloud compute ssh client-1 --zone=${ZONE_1} --command='
  curl -s 10.10.1.99'

# curl to ilb vip in region 2
gcloud compute ssh client-1 --zone=${ZONE_1} --command='
  curl -s 10.10.2.99'

Composite Health per PSC 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.

Riavviare il server della regione 1 http

# start apache http server to return service to healthy
gcloud compute ssh ${FOO_FAIL_NAME} --zone=${FOO_FAIL_ZONE} --command='
  sudo systemctl start apache2'

# verify service running
gcloud compute ssh ${FOO_FAIL_NAME} --zone=${FOO_FAIL_ZONE} --command='
  sudo systemctl status apache2 | grep Active:'

# check health state of health source
gcloud compute health-sources get-health foo-health-source --region=${REGION_1}

L'output ora dovrebbe mostrare uno stato HEALTHY simile a questo…

healthState: HEALTHY
kind: compute#healthSourceHealth
sources:
- backends:
  - endpointCount: 1
    group: .../zones/us-west1-a/instanceGroups/mig-foo
    healthyEndpointCount: 1
  - endpointCount: 0
    group: .../zones/us-west1-c/instanceGroups/mig-foo
    healthyEndpointCount: 0
  - endpointCount: 1
    group: .../zones/us-west1-b/instanceGroups/mig-foo
    healthyEndpointCount: 1
  forwardingRule: .../regions/us-west1/forwardingRules/fr-foo
  source: .../regions/us-west1/backendServices/ilb-foo

Modificare la policy di integrità

I produttori possono ottimizzare le policy 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).

Aggiorna la policy di aggregazione dell'integrità del servizio bar

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

Arresta il server http della regione 2

# stop apache http server to fail service
gcloud compute ssh ${BAR_FAIL_NAME} --zone=${BAR_FAIL_ZONE} --command='
  sudo systemctl stop apache2'

# verify service dead
gcloud compute ssh ${BAR_FAIL_NAME} --zone=${BAR_FAIL_ZONE} --command='
  sudo systemctl status apache2 | grep Active:'

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}

L'output dovrebbe essere simile a questo:

backend: .../regions/us-east1/instanceGroups/mig-bar
status:
  healthStatus:
  -   forwardingRule: .../regions/us-east1/forwardingRules/fr-bar
    forwardingRuleIp: 172.16.2.99
    healthState: UNHEALTHY
    instance: .../zones/us-east1-b/instances/service-bar-<UID_1>
    ipAddress: 172.16.2.3
    port: 80
  -   forwardingRule: .../regions/us-east1/forwardingRules/fr-bar
    forwardingRuleIp: 172.16.2.99
    healthState: HEALTHY
    instance: .../zones/us-east1-d/instances/service-foo-<UID_2>
    ipAddress: 172.16.2.2
    port: 80
  kind: compute#backendServiceGroupHealth

# check health state of health source
gcloud compute health-sources get-health bar-health-source --region=${REGION_2}

L'output dovrebbe essere simile a questo:

healthState: UNHEALTHY
kind: compute#healthSourceHealth
sources:
- backends:
  - endpointCount: 1
    group: .../zones/us-east1-b/instanceGroups/mig-bar
    healthyEndpointCount: 0
  - endpointCount: 1
    group: .../zones/us-east1-d/instanceGroups/mig-bar
    healthyEndpointCount: 1
  - endpointCount: 0
    group: .../zones/us-east1-c/instanceGroups/mig-bar
    healthyEndpointCount: 0
  forwardingRule: .../regions/us-west1/forwardingRules/fr-bar
  source: .../regions/us-west1/backendServices/ilb-bar

Test del failover del client della regione 2

# send request to service using hostname
gcloud compute ssh client-2 --zone=${ZONE_2} --command='
  curl -s -v www.foobar.com'

# curl to ilb vip in region 1
gcloud compute ssh client-2 --zone=${ZONE_2} --command='
  curl -s 10.10.1.99'

# curl to ilb vip in region 2
gcloud compute ssh client-2 --zone=${ZONE_2} --command='
  curl -s 10.10.2.99'

Composite Health per 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 su tutti i backend non integri (fail open).

Con questo si conclude la parte relativa ai test. Passiamo al monitoraggio.

8. Monitora lo stato

Le modifiche dello stato di integrità vengono registrate per impostazione predefinita. I progetti producer possono visualizzare i log per le origini di integrità e i controlli di integrità compositi. I progetti consumer possono visualizzare i log per i NEG PSC connessi ai servizi pubblicati utilizzando Composite Health.

Sebbene questo lab implementi le risorse consumer e producer nello stesso progetto per semplicità, quando vengono implementate in progetti separati, i log mostreranno i due ruoli disaccoppiati.

Risorsa monitorata

Visualizza

Nome log

Origini di integrità e controlli compositi

Visualizzazione del produttore

.../logs/compute.googleapis.com%2Fcompositehealth

NEG Private Service Connect

Visualizzazione per i consumatori

.../logs/compute.googleapis.com%2Fservicehealthchecks

Log del producer

I log del producer mostrano il rollup interno dell'integrità dei servizi del producer:

  • HealthSource: lo stato di integrità dei singoli servizi di backend (ad es. gli stati VM di mig-bar e mig-foo)
  • CompositeHealthCheck: l'integrità regionale aggregata del servizio pubblicato mappato alla destinazione della regola di forwarding del produttore (ad es. fr-bar o fr-foo)
# query logs for producer
gcloud logging read \
  'logName="projects/'${PROJECT_ID}'/logs/compute.googleapis.com%2Fcompositehealth"' \
  --project=${PROJECT_ID} \
  --limit=10 \
  --format='table(
    timestamp.date(format="%I:%M:%S %p", tz=LOCAL):label=TIME,
    resource.type.basename():label=TYPE,
    resource.labels.location:label=REGION,
    jsonPayload.healthState:label=STATE,
    jsonPayload.sources[0].backends[].group.basename().join(","):label=BACKENDS,
    jsonPayload.sources[0].backends[].healthyEndpointCount.join(","):label=HEALTHY,
    jsonPayload.sources[0].backends[].endpointCount.join(","):label=TOTAL,
    jsonPayload.healthDestination.basename():label=DESTINATION
  )'

Log dei consumatori

I log dei consumatori mostrano lo stato di integrità propagato delle risorse dei consumatori:

  • NetworkEndpointGroup: lo stato di integrità propagato del NEG PSC connesso al servizio pubblicato (ad es. neg-bar e neg-foo)

In una configurazione separata di consumer e producer, utilizza questa query di log nel progetto consumer per scegliere come target gli eventi sanitari compositi per i NEG PSC…

# query logs for consumer
gcloud logging read \
  "logName=projects/${PROJECT_ID}/logs/compute.googleapis.com%2Fservicehealthchecks
  AND resource.type=\"compute.googleapis.com/NetworkEndpointGroupV2\"" \
  --project="${PROJECT_ID}" \
  --freshness=30m \
  --limit=10 \
  --format="table(
    timestamp.date(format='%I:%M:%S %p', tz=LOCAL):label=TIME,
    resource.labels.location:label=REGION,
    jsonPayload.serviceHealthCheckResult.healthState:label=STATE,
    jsonPayload.serviceHealthCheckResult.previousHealthState:label=PREV_STATE,
    resource.labels.network_endpoint_group_id:label=NEG_ID
  )"

Con questo si conclude la parte relativa al monitoraggio. Passiamo alla pulizia.

9. Esegui la pulizia 

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

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

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

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

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

gcloud -q 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
#

10. Conclusione

Complimenti! Hai configurato correttamente il controllo di integrità composito per PSC e testato il failover regionale automatico.

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

Grazie.