Estado de Private Service Connect

1. Introducción

En este codelab, se explora el estado de Private Service Connect (PSC) para la conmutación por error regional automática. El estado de PSC es una función de redes que proporciona una mayor disponibilidad y resiliencia del servicio.

El estado de PSC permite que los productores de servicios definan políticas de estado personalizadas (qué estado define un servicio en buen estado o en mal estado) y propaguen automáticamente estos indicadores a los consumidores de servicios que se conectan al servicio con backends de PSC. Esta función está diseñada específicamente para admitir la conmutación por error automática entre regiones. Si un servicio de productor regional se encuentra en mal estado, el balanceador de cargas del consumidor detiene automáticamente el enrutamiento del tráfico a esa región y lo dirige a un servicio en buen estado en otra región.

En comparación con los métodos anteriores para la conmutación por error entre regiones, como la detección de valores atípicos, el estado de PSC ofrece un indicador de conmutación por error más preciso porque se basa directamente en el estado agregado de los backends del servicio del productor (grupos de instancias de VM o extremos de red). Los productores pueden definir su propia lógica de estado, lo que garantiza que el productor solo reciba tráfico cuando el servicio realmente cumpla con los criterios de estado necesarios.

Qué aprenderá

  • Componentes del estado de PSC y cómo funcionan en conjunto para determinar el estado de un servicio de producción
  • Implementa el estado de PSC para un servicio de productor con comandos de gcloud
  • Configuración de un balanceador de cargas de acceso del consumidor de PSC entre regiones para usar los indicadores de estado de la política de estado de PSC del productor
  • Probar situaciones de falla del servicio y validar la conmutación por error automática entre regiones

Requisitos

  • Un proyecto de Google Cloud
  • Permisos de IAM otorgados al rol predefinido roles/compute.admin o a un rol básico amplio, como roles/admin o el rol heredado roles/owner
  • Conocimiento de los conceptos de redes de Google Cloud y el uso de Google Cloud CLI

2. Conceptos

Redes de PSC

La topología de red de este Codelab incluye una red de VPC de consumidor y una de productor en dos regiones activas de Google Cloud.

Del lado del consumidor, hay subredes regionales con instancias de VM de cliente que se usan para acceder al servicio del productor a través de un balanceador de cargas de aplicaciones interno entre regiones con backends de grupo de extremos de red (NEG) de PSC. Hay dos reglas de reenvío del balanceador de cargas regional, con direcciones IP regionales, para el ingreso de clientes globales (entre regiones). El servicio de backend es un recurso global que admite NEGs en diferentes regiones. En una situación de conmutación por error, un cliente que se conecte a cualquiera de las reglas de reenvío regionales de frontend se puede dirigir a un backend global en buen estado.

figure1

Fig. 1: Topología de red del codelab

El lado del productor tiene subredes regionales con balanceadores de cargas de red de transferencia internos regionales que exponen un servicio a través de un recurso de adjunto de servicio de PSC regional. Los servicios de backend contienen grupos de instancias administrados (MIG) regionales y se verifican sus estados con sondeos de solicitudes http y validaciones de respuestas 200 (OK).

Consulta la documentación más reciente sobre la compatibilidad de Private Service Connect para la configuración del productor y descubre qué balanceadores de cargas admiten el estado de PSC.

Calidad del servicio

La verificación de estado del servicio de backend del productor, configurada durante la creación del balanceador de cargas, sirve como señal de origen para la función de estado de PSC. El recurso fuente de estado usa ese indicador junto con las restricciones adicionales definidas en el recurso política de agregación de estado para determinar un estado de salud para un solo servicio de backend.

De forma predeterminada, un servicio se considera en buen estado cuando se cumplen estas dos restricciones:

  • Al menos el x% de los backends deben estar en buen estado (el valor predeterminado es 60).
  • La cantidad mínima de backends en buen estado es y (el valor predeterminado es 1).

La verificación de estado compuesta hace referencia a todas las fuentes de estado de todos los servicios de backend para determinar el estado general de todo el servicio regional del productor. En el caso de este lab, cada servicio de productor regional tiene solo una fuente de estado del servicio de backend que se acumula en una verificación de estado compuesta.

figure2

Fig. 2: Modelo de recursos de estado de PSC

La definición del recurso de verificación de estado compuesta también hace referencia a la regla de reenvío del balanceador de cargas del servicio de productor. El NEG de PSC del backend del balanceador de cargas de acceso del consumidor está conectado lógicamente al adjunto de servicio de PSC del productor y a la regla de reenvío del balanceador de cargas del productor. Esto vincula el balanceador de cargas de acceso del consumidor al estado de la verificación de estado compuesta del servicio del productor. Luego, el estado general del servicio del productor regional se propaga al balanceador de cargas del consumidor para realizar la selección de backend adecuada.

3. Configura el proyecto

Accede a tu proyecto

Este codelab está escrito para usar un solo proyecto de Google Cloud. En los pasos de configuración, se usan comandos de gcloud y de shell de Linux.

NOTA: En una implementación de producción, los recursos del consumidor de PSC y los servicios del productor suelen estar en proyectos diferentes.

Para comenzar, accede a la línea de comandos de tu proyecto de Google Cloud con el siguiente comando:

Establece tu ID del proyecto

gcloud config set project YOUR_PROJECT_ID_HERE

Establece variables de entorno de 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}

Habilita los servicios de la API

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

4. Servicio de productor

Crea recursos compartidos

Crear red

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

Crea subredes

# 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 componentes de firewall

Se necesitan reglas de firewall para permitir el tráfico a los recursos de VM (las reglas de firewall predeterminadas implícitas son rechazar la entrada y permitir la salida). Las políticas son la forma preferida de implementar reglas de firewall. Para ello, se crea un recurso de política de firewall de red, se crean y agregan reglas a la política y, luego, se asocia la política a una red de 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 Cloud Routers y puertas de enlace 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 configuración de inicio de VM con un servidor 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 el servicio foo en la región 1

Crea recursos de procesamiento de servicio

# 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 componentes del balanceador de cargas de servicio

# 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

Publica el servicio de 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 el servicio bar en la región 2

Crea recursos de procesamiento de servicio

# 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 componentes del balanceador de cargas de servicio

# 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

Publica el servicio de 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. Acceso del consumidor

Configura los recursos del cliente

Crea componentes de red

# 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

El balanceador de cargas de aplicaciones (basado en proxy) del consumidor requiere subredes de solo proxy. Estas subredes proporcionan un grupo de direcciones IP que los balanceadores de cargas basados en proxy usan como direcciones de origen internas cuando envían tráfico a los backends.

# 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 componentes de 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

Crear componentes del balanceador de cargas

# 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 registros 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 recursos de procesamiento

# 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

Referencia del servicio de prueba

Conéctate a la VM del cliente en la región 1 a través de SSH

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

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

# exit vm ssh
exit

Opcional: Prueba los mismos tests desde la VM del cliente en la región 2: gcloud compute ssh client-2 --zone=${ZONE_2}

PUNTO CLAVE: El comportamiento normal del balanceador de cargas para las solicitudes de clientes que ingresan a una regla de reenvío en region-x es preferir los backends en el mismo region-x. Si todos los recursos de backend están en buen estado, gana la región con la latencia más baja. Los backends globales conmutarán por error a la otra región con el indicador de estado adecuado.

Sin embargo, debido a que los recursos de servicio del productor real se encuentran detrás del balanceador de cargas del productor en la red de VPC del productor, estos indicadores de estado eran opacos para el balanceador de cargas del consumidor, por lo que el lado del consumidor no podía tomar esas determinaciones de conmutación por error del backend. El estado de PSC aborda este problema propagando la información del estado del servicio desde el lado del productor al lado del consumidor.

6. Recursos de salud

El productor configura los recursos de estado de PSC para representar el estado general del servicio regional. La política de estado se basa en lo que el productor del servicio define como adecuado para mantener un nivel de servicio funcional. Los umbrales se establecen para notificar a los consumidores que realicen una conmutación por error cuando ya no se cumplan las condiciones definidas por el productor.

Configura el servicio de verificación de estado foo en la región 1

Crea una política de agregación de estado

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

Crea una fuente de estado

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

Crea una verificación de estado compuesta

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

Verifica la configuración del estado del servicio foo

Las configuraciones de recursos de salud se pueden ver con los comandos list (y describe) por región.

# 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 el servicio de estado bar en la región 2

Crea una política de agregación de estado

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

Crea una fuente de estado

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 una verificación de estado compuesta

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

Verifica la configuración del estado del servicio 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}

Aquí concluye la parte de configuración… ahora vamos a probarla.

7. Prueba de conmutación por error

Situación de servicio foo en la región 1 en mal estado

En este caso, se simula una falla del servicio de productor de PSC foo en la región 1 deteniendo el servidor web en una de las dos instancias de VM.

Obtén detalles de la VM del servidor

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

Establece una conexión SSH a la VM del servidor y detén el servidor 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 que el servicio regional no esté en buen estado

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

El resultado debería ser similar a este…

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

Conéctate a la VM de cliente de la región 1 a través de SSH y prueba la conmutación por error

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

El estado del PSC actualizó el balanceador de cargas del consumidor y le indicó que evite el servicio de backend en mal estado de la región 1. En cambio, dirigió el tráfico al servicio bar en buen estado de la región 2.

# exit client vm ssh
exit

Establece una conexión SSH a la VM del servidor y reinicia el servidor 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

Cambiar la política de estado

Los productores pueden ajustar las políticas de estado del servicio según diferentes criterios. El recurso de política de agregación del estado especifica los umbrales mínimos necesarios para mantener un estado correcto en todas las diferentes fuentes de estado (servicios de backend).

Actualiza la política de agregación de estado del servicio 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}

Este cambio en la política de estado del productor logra lo siguiente:

  1. Se disminuye el porcentaje del umbral mínimo de buen estado del 60% al 40%. Ahora, una sola falla en una instancia de VM no activará un estado de mal funcionamiento según --healthy-percent-threshold (el estado de falla será del 50% y solo se necesita un 40% para que esté en buen estado).
  2. Aumenta la cantidad mínima de backends en buen estado de 1 a 2 instancias de VM. Ahora, una sola falla en una instancia de VM activará un estado de mal estado según --min-healthy-threshold (el estado de falla será 1, pero se necesitan 2 para estar en buen estado).

Situación de servicio bar en la región 2 en mal estado

En este caso, se simula una falla del servicio de productor de PSC bar en la región 2 deteniendo el servidor web en una de las dos instancias de VM.

Obtén detalles de la VM del servidor

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

Establece una conexión SSH a la VM del servidor y detén el servidor 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 que el servicio regional no esté en buen estado

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

El resultado debería ser similar a este…

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

Conéctate a la VM de cliente de la región 2 a través de SSH y prueba la conmutación por error

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

El estado de PSC actualizó el balanceador de cargas del consumidor y le indicó que evite el servicio de backend en mal estado de la región 2. En cambio, dirigió el tráfico al servicio foo en buen estado de la región 1.

En una situación en la que el balanceador de cargas del consumidor ve todos los servicios del productor como no saludables, el balanceador de cargas no puede conmutar por error a una instancia en buen estado. El comportamiento esperado es que el balanceador de cargas distribuya el tráfico entre todos los backends en mal estado (fail open).

# exit client vm ssh
exit

Aquí concluye la parte de las pruebas… ahora vamos a limpiar.

8. Limpieza 

# 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. Conclusión

¡Felicitaciones! Configuraste correctamente el estado de PSC y probaste la conmutación por error regional automática.

Si tienes comentarios, preguntas o correcciones, usa este formulario de comentarios.

¡Gracias!