Codelab sobre la mutabilidad de Private Service Connect

1. Introducción

Private Service Connect es una función de las herramientas de redes de Google Cloud que permite a los consumidores acceder a los servicios administrados de forma privada desde su red de VPC. Del mismo modo, permite a los productores de servicios administrados alojar estos servicios en sus propias redes de VPC independientes y ofrecer una conexión privada a sus consumidores.

Hasta ahora, una vez que los servicios de PSC se exponían a través de un adjunto de servicio, no se podían realizar cambios en los balanceadores de cargas de servicio sin quitar el adjunto de servicio y, de este modo, interrumpir la conectividad del extremo de PSC del consumidor. Con la introducción de la mutabilidad de PSC, los productores pueden actualizar su balanceador de cargas y, al mismo tiempo, conservar la conexión del extremo de PSC. Mantener la conexión del extremo de PSC al adjunto de servicio mientras se cambia el balanceador de cargas tiene el beneficio de no requerir ninguna acción del lado del consumidor.

En este momento, la mutabilidad de PSC admitirá lo siguiente:

• Migración a una regla de reenvío del balanceador de cargas del mismo tipo (p. ej., Transferencia de red a transferencia de red)
• Migración a una regla de reenvío de balanceador de cargas de un tipo diferente (p. ej., Transferencia de red al balanceador de cargas de aplicaciones)

La mutabilidad de PSC no admite la edición de la regla de reenvío en su lugar.

En este lab, crearás un servicio web de productor expuesto a través de un balanceador de cargas de red de transferencia interno, te asegurarás de que el servicio tenga conectividad a través de un extremo de PSC y, luego, actualizarás la asociación del adjunto de servicio a una nueva regla de reenvío a un balanceador de cargas de aplicaciones interno.

Qué aprenderás

• Crea un servicio web simple de Apache expuesto como un servicio de productor de PSC.
• Crea un extremo de PSC.
• Crea una zona privada de Cloud DNS para las llamadas al servicio del consumidor.
• Actualiza la regla de reenvío asociada con el adjunto de servicio usando la mutabilidad de PSC.

Requisitos

• Un proyecto de Google Cloud con permisos de propietario
• Conocimientos básicos de las redes de Google Cloud

2. Entorno de pruebas

Tradicionalmente, los productores y los consumidores trabajan en proyectos diferentes. Para simplificar las cosas, realizaremos todas las acciones en el mismo proyecto, pero cada uno de los pasos se etiquetará con los proyectos de Producer o Consumer en caso de que el usuario prefiera trabajar en proyectos diferentes.

En este lab, comenzaremos por crear producer-vpc con tres subredes: una para alojar el servicio del productor y la VM de prueba, una para las reglas de reenvío del balanceador de cargas y una subred de NAT de PSC. Necesitaremos un Cloud Router y Cloud NAT para la accesibilidad a Internet y descargar paquetes de Linux. Expondremos nuestro servicio de Apache, configurado a través de un grupo de instancias no administrado, a través de un balanceador de cargas de red de transferencia interno regional y asociaremos la regla de reenvío a un adjunto de servicio.

Del lado del consumidor, crearemos consumer-vpc con una sola subred para alojar nuestro extremo de PSC y una VM de cliente de prueba. Configuraremos una zona privada de Cloud DNS para acceder al servicio a través de un nombre de host.

Para mostrar la función de mutabilidad de PSC, en el lado del productor, agregaremos dos subredes adicionales: una para alojar la nueva VM de servicio y otra para la subred de solo proxy del balanceador de cargas. Crearemos una nueva VM que aloje un servidor web de Apache, nuevamente configurado a través de un grupo de instancias no administrado, y la expondremos a través de un nuevo balanceador de cargas de aplicaciones interno regional. Actualizaremos el adjunto de servicio para que apunte a la nueva regla de reenvío y probaremos que la conectividad del lado del consumidor permanezca en su lugar.

3. Configuración y requisitos

Configuración del entorno de autoaprendizaje

1. Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.

• El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
• El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto.
• Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.

Precaución: El ID del proyecto es único a nivel global y no lo puede usar nadie más después de que lo hayas seleccionado. Eres el único usuario de ese ID. Incluso si se borra un proyecto, no se puede volver a usar el ID.

Nota: Si usas una cuenta de Gmail, puedes dejar la ubicación predeterminada como Sin organización. Si usas una cuenta de Google Workspace, elige una ubicación adecuada para tu organización.

2. A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.

Inicia Cloud Shell

Si bien Google Cloud y Spanner se pueden operar de manera remota desde tu laptop, en este codelab usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.

En Google Cloud Console, haz clic en el ícono de Cloud Shell en la barra de herramientas en la parte superior derecha:

El aprovisionamiento y la conexión al entorno deberían tomar solo unos minutos. Cuando termine el proceso, debería ver algo como lo siguiente:

Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitarás. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Todo tu trabajo en este codelab se puede hacer en un navegador. No es necesario que instales nada.

4. Antes de comenzar

Habilita las APIs

En Cloud Shell, asegúrate de que tu ID del proyecto esté configurado.

gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
export project=[YOUR-PROJECT-NAME]
export region=us-central1
export zone=$region-a
echo $project
echo $region
echo $zone

Habilita todos los servicios necesarios

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

5. Compila la red de productores [proyecto del productor]

Crear red de VPC

Desde Cloud Shell

gcloud compute networks create producer-vpc \
    --subnet-mode=custom

Crea subredes

Comenzaremos por implementar 3 subredes en la VPC del productor. Una será para implementar el servicio del productor, otra para las reglas de reenvío del balanceador de cargas y otra que se asociará con el adjunto de servicio de PSC para nuestra subred de NAT de PSC.

Desde Cloud Shell

gcloud compute networks subnets create producer-service-subnet \
    --network=producer-vpc \
    --range=10.0.0.0/28 \
    --region=$region

gcloud compute networks subnets create producer-fr-subnet \
        --network=producer-vpc \
        --range=192.168.0.0/28 \
        --region=$region

gcloud compute networks subnets create psc-nat-subnet \
    --network=producer-vpc \
    --range=10.100.0.0/28 \
    --region=$region \
    --purpose=PRIVATE_SERVICE_CONNECT

NOTA: Las subredes con el propósito PRIVATE_SERVICE_CONNECT solo se pueden usar para adjuntos de servicio de PSC. No puedes implementar cargas de trabajo en esta subred.

Crea Cloud NAT

Se requiere una Cloud NAT para instalar los paquetes adecuados para nuestros servicios de productores.

Desde Cloud Shell

gcloud compute routers create $region-cr \
    --network=producer-vpc \
    --region=$region

Desde Cloud Shell

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

Crea una política y reglas de firewall de red

Desde Cloud Shell

gcloud compute network-firewall-policies create producer-vpc-policy --global

gcloud compute network-firewall-policies associations create \
    --firewall-policy producer-vpc-policy \
    --network producer-vpc \
    --name network-producer-vpc \
    --global-firewall-policy

Para permitir que IAP se conecte a tus instancias de VM, crea una regla de firewall que cumpla con lo siguiente:

• Se aplica a todas las instancias de VM a las que deseas acceder mediante IAP.
• Permite el tráfico de entrada desde el rango de IP 35.235.240.0/20. Este rango contiene todas las direcciones IP que IAP usa para el reenvío de TCP.

Desde Cloud Shell

gcloud compute network-firewall-policies rules create 1000 \
    --action ALLOW \
    --firewall-policy producer-vpc-policy \
    --description "SSH with IAP" \
    --direction INGRESS \
    --src-ip-ranges 35.235.240.0/20 \
    --layer4-configs tcp:22  \
    --global-firewall-policy

Comenzaremos con tres reglas de firewall. Una permitirá el acceso a las VMs para las verificaciones de estado del balanceador de cargas (2000), otra permitirá el acceso a las VMs desde el rango de NAT del PSC (3000) y otra permitirá la conectividad entre las VMs en la subred de servicio para fines de prueba (4000). Crearemos todas las reglas para el puerto 80, ya que lo usaremos para nuestro servicio.

Desde Cloud Shell

gcloud compute network-firewall-policies rules create 2000 \
    --action ALLOW \
    --firewall-policy producer-vpc-policy \
    --description "LB healthchecks" \
    --direction INGRESS \
    --src-ip-ranges 130.211.0.0/22,35.191.0.0/16 \
    --layer4-configs tcp:80  \
    --global-firewall-policy

gcloud compute network-firewall-policies rules create 3000 \
    --action ALLOW \
    --firewall-policy producer-vpc-policy \
    --description "allow access from PSC NAT subnet" \
    --direction INGRESS \
    --src-ip-ranges 10.100.0.0/28 \
    --layer4-configs tcp:80  \
    --global-firewall-policy

 gcloud compute network-firewall-policies rules create 4000 \
    --action ALLOW \
    --firewall-policy producer-vpc-policy \
    --description "allow access between producer service VMs and testing client for testing purposes" \
    --direction INGRESS \
    --src-ip-ranges 10.0.0.0/28 \
    --layer4-configs tcp:80 \
    --global-firewall-policy

6. Crea un servicio de productor [proyecto del productor]

Crearemos un servicio web de Apache simple con un grupo de instancias no administrado que muestre el mensaje "Soy un servicio de Producer".

Crear instancia

Desde Cloud Shell

gcloud compute instances create producer-service-vm \
    --network producer-vpc \
    --subnet producer-service-subnet \
    --zone $zone \
    --no-address \
    --metadata startup-script='#! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    a2enmod ssl
    sudo a2ensite default-ssl
    echo "I am a Producer Service." | \
    tee /var/www/html/index.html
    systemctl restart apache2'

Crea un grupo de instancias no administrado

Desde Cloud Shell

gcloud compute instance-groups unmanaged create producer-uig \
  --zone=$zone

Agrega producer-service-vm al grupo de instancias no administrado que acabamos de crear.

Desde Cloud Shell

gcloud compute instance-groups unmanaged add-instances producer-uig \
  --zone=$zone \
  --instances=producer-service-vm

Crea componentes del balanceador de cargas

Para la versión 1 del servicio del productor, expondremos el servicio con un balanceador de cargas de red de transferencia en el puerto 80.

Esta implementación es solo para fines de laboratorio y no se recomienda para un entorno de producción.

Implementa la verificación de estado para el puerto 80.

Desde Cloud Shell

gcloud compute health-checks create http producer-hc \
        --region=$region

Implementa el servicio de backend y agrega el backend al servicio de backend.

Desde Cloud Shell

gcloud compute backend-services create producer-bes \
  --load-balancing-scheme=internal \
  --protocol=tcp \
  --region=$region \
  --health-checks=producer-hc \
  --health-checks-region=$region

gcloud compute backend-services add-backend producer-bes \
  --region=$region \
  --instance-group=producer-uig \
  --instance-group-zone=$zone

Crea la dirección IP estática que se usará para la regla de reenvío del balanceador de cargas.

Desde Cloud Shell

gcloud compute addresses create producer-fr-ip\
  --region $region \
  --subnet producer-fr-subnet \
  --addresses 192.168.0.2

Crea la regla de reenvío del balanceador de cargas que expone el puerto 80, con el servicio de backend y la dirección IP que creamos anteriormente.

Desde Cloud Shell

gcloud compute forwarding-rules create producer-fr \
  --region=$region \
  --load-balancing-scheme=internal \
  --network=producer-vpc \
  --subnet=producer-fr-subnet \
  --address=producer-fr-ip \
  --ip-protocol=TCP \
  --ports=80 \
  --backend-service=producer-bes \
  --backend-service-region=$region

7. Prueba el servicio de productor [proyecto del productor]

Crea una VM de prueba en la subred producer-service-subnet, accede a la VM y prueba una llamada al servicio Apache.

Desde Cloud Shell

 gcloud compute instances create producer-test-vm \
    --zone=$zone \
    --subnet=producer-service-subnet \
    --no-address

Desde Cloud Shell

gcloud compute ssh producer-test-vm \
    --zone=$zone \
    --command="curl -s 192.168.0.2/index.html"

Resultado esperado

I am a Producer Service.

8. Expón el servicio del productor a través del adjunto de servicio [proyecto del productor]

Crea el adjunto de servicio. Asóciala a la regla de reenvío que creamos con psc-nat-subnet.

Configuraremos este adjunto de servicio para que acepte automáticamente todas las conexiones, sin listas de aceptación o rechazo de consumidores. Esto no se recomienda para un entorno de producción.

Desde Cloud Shell

gcloud compute service-attachments create producer-attachment \
    --region=$region \
    --producer-forwarding-rule=producer-fr  \
    --connection-preference=ACCEPT_AUTOMATIC \
    --nat-subnets=psc-nat-subnet

Debes anotar el URI del adjunto de servicio (selfLink), ya que lo necesitarás en un paso posterior para la configuración del extremo de PSC. Para obtenerlo, ejecuta el siguiente comando en Cloud Shell.

Desde Cloud Shell

gcloud compute service-attachments describe producer-attachment --region=$region

Resultado de ejemplo

connectionPreference: ACCEPT_AUTOMATIC
creationTimestamp: '2026-02-10T07:50:04.250-08:00'
description: ''
enableProxyProtocol: false
fingerprint: xxx
id: 'xxx'
kind: compute#serviceAttachment
name: producer-attachment
natSubnets:
- https://www.googleapis.com/compute/v1/projects/$project/regions/$region/subnetworks/psc-nat-subnet
pscServiceAttachmentId:
  high: 'xxx'
  low: 'xxx'
reconcileConnections: false
region: https://www.googleapis.com/compute/v1/projects/$project/regions/$region
selfLink: https://www.googleapis.com/compute/v1/projects/$project/regions/$region/serviceAttachments/producer-attachment
targetService: https://www.googleapis.com/compute/v1/projects/$project/regions/$region/forwardingRules/producer-fr

Copia el URI a partir de projects.

Ejemplo: projects/$project/regions/$region/serviceAttachments/producer-attachment

9. Crea la red del consumidor [proyecto del consumidor]

Crea una red de VPC

Desde Cloud Shell

gcloud compute networks create consumer-vpc \
    --subnet-mode=custom

Crear subred

Se implementará una sola subred en la que implementaremos el extremo de PSC y una VM de cliente de prueba.

Desde Cloud Shell

gcloud compute networks subnets create consumer-subnet \
    --network=consumer-vpc \
    --range=10.0.0.0/28 \
    --region=$region

Crea una política y reglas de firewall de red

Desde Cloud Shell

gcloud compute network-firewall-policies create consumer-vpc-policy --global

gcloud compute network-firewall-policies associations create \
    --firewall-policy consumer-vpc-policy \
    --network consumer-vpc \
    --name network-consumer-vpc \
    --global-firewall-policy

También configuraremos la VPC del consumidor para que use IAP para SSH.

Desde Cloud Shell

gcloud compute network-firewall-policies rules create 1000 \
    --action ALLOW \
    --firewall-policy consumer-vpc-policy \
    --description "SSH with IAP" \
    --direction INGRESS \
    --src-ip-ranges 35.235.240.0/20 \
    --layer4-configs tcp:22  \
    --global-firewall-policy

10. Crea el extremo de Private Service Connect [proyecto del consumidor]

Reserva la dirección IP estática que se usará para el extremo de PSC.

Desde Cloud Shell

gcloud compute addresses create psc-endpoint-ip \
    --region=$region \
    --subnet=consumer-subnet \
    --addresses 10.0.0.2

Crea el extremo de PSC con la dirección IP estática reservada y el URI del adjunto de servicio que anotamos antes.

Desde Cloud Shell

gcloud compute forwarding-rules create psc-endpoint \
  --region=$region \
  --network=consumer-vpc \
  --address=psc-endpoint-ip \
  --target-service-attachment=projects/$project/regions/$region/serviceAttachments/producer-attachment

11. Configura una zona de DNS privada para el extremo de PSC [proyecto del consumidor]

Con Cloud DNS, configuraremos una zona de DNS privada con el nombre de DNS myservice.com para usarla con nuestro extremo de PSC.

Desde Cloud Shell

gcloud dns managed-zones create "consumer-service" \
    --dns-name=myservice.com \
    --description="consumer service dns" \
    --visibility=private \
    --networks=consumer-vpc

gcloud dns record-sets transaction start \
   --zone="consumer-service"

Crea un registro A para myservice.com y haz que apunte a la dirección IP del extremo de PSC.

Desde Cloud Shell

gcloud dns record-sets transaction add 10.0.0.2 \
   --name=myservice.com \
   --ttl=300 \
   --type=A \
   --zone="consumer-service"

gcloud dns record-sets transaction execute \
   --zone="consumer-service"

12. Prueba el extremo de PSC [proyecto del consumidor]

Crea una VM cliente

Desde Cloud Shell

gcloud compute instances create consumer-client-vm \
    --zone=$zone \
    --subnet=consumer-subnet \
    --no-address

Prueba la conectividad del extremo de PSC

Desde Cloud Shell

gcloud compute ssh consumer-client-vm \
    --zone=$zone \
    --command="curl -s myservice.com/index.html"

Resultado esperado

I am a Producer Service.

En la siguiente parte del codelab, crearemos el nuevo servicio de productor y migraremos a él, y mostraremos la función de mutabilidad de PSC que permite esta actualización sin problemas sin necesidad de realizar actualizaciones en la configuración del consumidor.

13. Crea un servicio de Producer actualizado [proyecto de Producer]

Para actualizar nuestro servicio de productor, implementaremos una VM nueva que ejecute un servidor web Apache similar con el mensaje "Soy un servicio de productor NUEVO". Agregaremos esa VM a un nuevo grupo de instancias no administrado y usaremos ese grupo de instancias no administrado como backend para nuestro nuevo balanceador de cargas. En lugar de usar un balanceador de cargas de transferencia de red, actualizaremos nuestro balanceador de cargas a un balanceador de cargas de aplicaciones interno regional.

Actualiza la red

Crea una subred nueva que se usará para la subred de solo proxy del balanceador de cargas de aplicaciones.

Desde Cloud Shell

gcloud compute networks subnets create lb-proxy-subnet \
    --network=producer-vpc \
    --range=10.200.0.0/24 \
    --region=$region \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE

Crea una subred nueva en la que se alojará nuestro servicio nuevo.

Desde Cloud Shell

gcloud compute networks subnets create producer-service-new-subnet \
    --network=producer-vpc \
    --range=10.0.1.0/28 \
    --region=$region

Crea una regla de firewall nueva que permita la conectividad a nuestro nuevo servicio de productor desde la subred de solo proxy.

Desde Cloud Shell

 gcloud compute network-firewall-policies rules create 3001 \
    --action ALLOW \
    --firewall-policy producer-vpc-policy \
    --description "allow access from proxy only subnet" \
    --direction INGRESS \
    --src-ip-ranges 10.200.0.0/24 \
    --layer4-configs tcp:80  \
    --global-firewall-policy

Crear instancia

Desde Cloud Shell

gcloud compute instances create new-producer-service-vm \
    --network producer-vpc \
    --subnet producer-service-new-subnet \
    --zone $zone \
    --no-address \
    --metadata startup-script='#! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    a2enmod ssl
    sudo a2ensite default-ssl
    echo "I am a NEW Producer Service." | \
    tee /var/www/html/index.html
    systemctl restart apache2'

Crea un grupo de instancias no administrado

Desde Cloud Shell

gcloud compute instance-groups unmanaged create producer-new-uig \
  --zone=$zone

gcloud compute instance-groups unmanaged add-instances producer-new-uig \
  --zone=$zone \
  --instances=new-producer-service-vm

gcloud compute instance-groups unmanaged set-named-ports producer-new-uig \
    --named-ports=http:80 \
    --zone=$zone

Crea componentes nuevos del balanceador de cargas

Crea el servicio de backend. Ten en cuenta que usamos el esquema de balanceo de cargas INTERNAL_MANAGED porque estamos actualizando a un balanceador de cargas de aplicaciones interno.

Desde Cloud Shell

gcloud compute backend-services create producer-new-bes \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=http \
  --region=$region \
  --health-checks=producer-hc \
  --health-checks-region=$region

Agrega el grupo de instancias no administrado como backend al servicio de backend.

Desde Cloud Shell

gcloud compute backend-services add-backend producer-new-bes \
  --region=$region \
  --instance-group=producer-new-uig \
  --instance-group-zone=$zone

Crea el mapa de URL y los proxies HTTP de destino.

Desde Cloud Shell

gcloud compute url-maps create producer-url-map \
  --default-service=producer-new-bes \
  --region=$region

gcloud compute target-http-proxies create http-proxy \
  --url-map=producer-url-map \
  --region=$region

Crea la dirección IP estática que usaremos para nuestra regla de reenvío. Esta dirección provendrá de la misma subred que usamos para la regla de reenvío original.

Desde Cloud Shell

gcloud compute addresses create producer-fr-new-ip\
  --region $region \
  --subnet producer-fr-subnet \
  --addresses 192.168.0.3

Crea la regla de reenvío.

Desde Cloud Shell

gcloud compute forwarding-rules create new-producer-fr \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=producer-vpc \
  --subnet=producer-fr-subnet \
  --address=producer-fr-new-ip \
  --ports=80 \
  --region=$region \
  --target-http-proxy=http-proxy \
  --target-http-proxy-region=$region

14. Prueba el servicio de productor actualizado [proyecto del productor]

Usaremos la misma VM de prueba que creamos para probar el servicio implementado originalmente.

Desde Cloud Shell

gcloud compute ssh producer-test-vm \
    --zone=$zone \
    --command="curl -s 192.168.0.3/index.html"

Ten en cuenta que estamos llamando a una dirección IP actualizada. 192.168.0.3 es la dirección IP de nuestro balanceador de cargas de aplicaciones interno regional.

Resultado esperado

I am a NEW Producer Service.

15. Actualiza el adjunto del servicio [proyecto del productor]

Tu versión de gcloud debe ser al menos la 558.0.0. Verifica tu versión del SDK de Google Cloud con gcloud --version antes de intentar ejecutar el comando de actualización.

La actualización de la regla de reenvío del adjunto de servicio es la nueva función de mutabilidad de PSC.

Para visualizar mejor la actualización de la regla de reenvío de Service Attachment, podemos ejecutar una descripción del Service Attachment antes y después del cambio.

Desde Cloud Shell

gcloud compute service-attachments describe producer-attachment \
    --region=$region \
    --format="value(targetService)"

Resultado esperado

https://www.googleapis.com/compute/v1/projects/$project/regions/$region/forwardingRules/producer-fr

Actualiza el adjunto de servicio.

La pérdida de tráfico puede ocurrir durante una operación de mutabilidad. Se espera que esta pérdida dure alrededor de 1 minuto mientras se completa la actualización. Se recomienda programar un período de cambio para estos cambios en el tráfico de producción.

Desde Cloud Shell

gcloud compute service-attachments update producer-attachment \
  --region=$region \
  --target-service=projects/$project/regions/$region/forwardingRules/new-producer-fr

Ahora, vuelve a ejecutar la descripción para ver la nueva regla de reenvío.

Desde Cloud Shell

gcloud compute service-attachments describe producer-attachment \
    --region=$region \
    --format="value(targetService)"

Resultado esperado

https://www.googleapis.com/compute/v1/projects/$project/regions/$region/forwardingRules/new-producer-fr

16. Vuelve a probar la conexión de PSC del consumidor [proyecto del consumidor]

Accede al mismo cliente consumidor.

Desde Cloud Shell

gcloud compute ssh consumer-client-vm \
    --zone=$zone \
    --command="curl -s myservice.com/index.html"

Resultado esperado

 I am a NEW Producer Service.

¡Felicitaciones! Actualizaste correctamente un balanceador de cargas del servicio de productor de PSC y no se requirieron cambios de configuración del lado del consumidor.

17. Pasos para realizar la limpieza [Proyecto de consumidor]

Borra los componentes del lab desde una sola terminal de Cloud Shell

gcloud dns record-sets delete myservice.com --zone="consumer-service" --type=A -q

gcloud dns managed-zones delete "consumer-service" -q

gcloud compute forwarding-rules delete psc-endpoint --region=$region -q

gcloud compute addresses delete psc-endpoint-ip --region=$region -q

gcloud compute instances delete consumer-client-vm --zone=$zone --project $project -q

gcloud compute network-firewall-policies rules delete 1000 --firewall-policy consumer-vpc-policy --global-firewall-policy -q

gcloud compute network-firewall-policies associations delete --firewall-policy=consumer-vpc-policy  --name=network-consumer-vpc --global-firewall-policy -q

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

gcloud compute networks subnets delete consumer-subnet --region $region -q

gcloud compute networks delete consumer-vpc -q

18. Pasos para realizar la limpieza [Proyecto del productor]

Borra los componentes del lab desde una sola terminal de Cloud Shell

gcloud compute service-attachments delete producer-attachment --region=$region -q

gcloud compute instances delete producer-test-vm --zone=$zone --project $project -q

gcloud compute forwarding-rules delete new-producer-fr --region=$region -q

gcloud compute addresses delete producer-fr-new-ip --region $region -q

gcloud compute target-http-proxies delete http-proxy --region $region -q

gcloud compute url-maps delete producer-url-map --region $region -q

gcloud compute backend-services delete producer-new-bes --region $region -q

gcloud compute instance-groups unmanaged delete producer-new-uig --zone $zone -q

gcloud compute instances delete new-producer-service-vm --zone $zone --project $project -q

gcloud compute networks subnets delete producer-service-new-subnet --region $region -q

gcloud compute networks subnets delete lb-proxy-subnet --region $region -q

gcloud compute forwarding-rules delete producer-fr --region=$region -q

gcloud compute addresses delete producer-fr-ip --region $region -q

gcloud compute backend-services delete producer-bes --region $region -q

gcloud compute health-checks delete producer-hc --region $region -q

gcloud compute instance-groups unmanaged delete producer-uig --zone $zone -q

gcloud compute instances delete producer-service-vm --zone $zone --project $project -q

gcloud compute network-firewall-policies rules delete 4000 --firewall-policy producer-vpc-policy --global-firewall-policy -q

gcloud compute network-firewall-policies rules delete 3001 --firewall-policy producer-vpc-policy --global-firewall-policy -q

gcloud compute network-firewall-policies rules delete 3000 --firewall-policy producer-vpc-policy --global-firewall-policy -q

gcloud compute network-firewall-policies rules delete 2000 --firewall-policy producer-vpc-policy --global-firewall-policy -q

gcloud compute network-firewall-policies rules delete 1000 --firewall-policy producer-vpc-policy --global-firewall-policy -q

gcloud compute network-firewall-policies associations delete --firewall-policy=producer-vpc-policy  --name=network-producer-vpc --global-firewall-policy -q

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

gcloud compute routers nats delete $region-nat --router=$region-cr --region=$region -q

gcloud compute routers delete $region-cr --region=$region -q

gcloud compute networks subnets delete psc-nat-subnet --region=$region -q

gcloud compute networks subnets delete producer-fr-subnet --region=$region -q

gcloud compute networks subnets delete producer-service-subnet --region=$region -q

gcloud compute networks delete producer-vpc -q

19. ¡Felicitaciones!

Felicitaciones por completar el codelab.

Temas abordados

• Crea un servicio web simple de Apache expuesto como un servicio de productor de PSC.
• Crea un extremo de PSC.
• Crea una zona privada de Cloud DNS para las llamadas al servicio del consumidor.
• Actualiza la regla de reenvío asociada con el adjunto de servicio usando la mutabilidad de PSC.