Private Service Connect: Uso de dominios personalizados para acceder a las APIs de Google globales con backends de PSC

1. Introducción

Private Service Connect (PSC) es una función de las redes de Google Cloud que permite a los consumidores acceder a los servicios administrados de forma privada desde su red de VPC. Los backends de PSC son un subconjunto de las funciones de PSC que permiten que un balanceador de cargas se encuentre frente a los servicios administrados por Google globales, como Google Cloud Storage, lo que permite que se apliquen otras integraciones de balanceo de cargas, como un FQDN diferente. En el momento de la publicación de este codelab, solo hay un subconjunto de servicios de Google que se pueden usar con backends de PSC globales. Puedes encontrar esa lista aquí.

En este codelab, se explorará cómo configurar back-ends de PSC para acceder a Google Cloud Storage con un FQDN interno.

Qué aprenderás

• Implementa la infraestructura básica de redes de VPC
• Implementa buckets básicos en Google Cloud Storage
• Implementa un balanceador de cargas de aplicaciones interno entre regiones con un backend de PSC en Google Cloud Storage

Requisitos

• Proyecto de Google Cloud con permisos de propietario
• Las siguientes políticas de la organización no se aplican en el proyecto de Google Cloud: VMs protegidas

2. Topología del codelab

En este codelab, implementarás una red de VPC, subredes, una zona de DNS privada, reglas de firewall, un bucket de Google Cloud Storage, un archivo de muestra y una VM de prueba. A continuación, implementarás un balanceador de cargas de aplicaciones multirregional con un backend de PSC para Google Cloud Storage. Por último, probarás la conectividad con el archivo en el bucket de Google Cloud Storage.

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 proyecto esté configurado y configura las variables.

gcloud auth login
gcloud config list project
gcloud config set project [YOUR-PROJECT-ID]
export projectid=[YOUR-PROJECT-ID]
export region1=us-central1
export zone1=us-central1-a
export region2=us-south1
echo $projectid
echo $region1
echo $zone1
echo $region2

Habilita todos los servicios necesarios

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

5. Cree la red de VPC

Crea la red de VPC en la que se alojarán tu VM cliente y los componentes de balanceo de cargas.

Red de VPC

Desde Cloud Shell

gcloud compute networks create myvpc \
    --subnet-mode=custom \
    --bgp-routing-mode=global 

Crea las subredes en la VPC. La primera subred será donde se alojará tu balanceador de cargas. La segunda subred es la subred de solo proxy para tu balanceador de cargas, y la tercera es donde se alojará tu cliente de VM.

Crear subredes

Desde Cloud Shell

gcloud compute networks subnets create $region2-subnet \
    --network=myvpc \
    --range=10.100.0.0/24 \
    --region=$region2

gcloud compute networks subnets create $region2-proxy-subnet \
    --network=myvpc \
    --range=10.100.100.0/24 \
    --region=$region2 \
    --purpose=GLOBAL_MANAGED_PROXY \
    --role=ACTIVE

gcloud compute networks subnets create $region1-subnet \
    --network=myvpc \
    --region=$region1 \
    --range=10.200.0.0/24 

Crea una política de firewall de red y reglas de firewall

Desde Cloud Shell

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

gcloud compute network-firewall-policies associations create \
    --firewall-policy my-vpc-policy \
    --network myvpc \
    --name network-myvpc \
    --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 my-vpc-policy \
    --description "SSH with IAP" \
    --direction INGRESS \
    --src-ip-ranges 35.235.240.0/20 \
    --layer4-configs tcp:22  \
    --global-firewall-policy

6. Crea un bucket de Google Cloud Storage, un archivo de muestra y otorga permisos

Desde Cloud Shell

gcloud storage buckets create gs://$projectid-pscbackend --location=us

echo "Here is my bucket file contents" > my-bucket-contents.txt 

gcloud storage cp my-bucket-contents.txt gs://$projectid-pscbackend/my-bucket-contents.txt

computesa=$(gcloud iam service-accounts list \
    --filter='displayName:Compute Engine default service account' \
    --format='value(email)')

echo $computesa


gcloud storage buckets add-iam-policy-binding gs://$projectid-pscbackend \
    --member="serviceAccount:$computesa" \
    --role="roles/storage.objectViewer"

Resultado de muestra

Creating gs://xxxxxxxxxxx-pscbackend/...
Copying file://my-bucket-contents.txt to gs://xxxxxxxxxxx-pscbackend/my-bucket-contents.txt
  Completed files 1/1 | 32.0B/32.0B                                                                                                                                                                  
[e-mail]
bindings:
- members:
  - projectEditor:xxxxxxxxxxx
  - projectOwner:xxxxxxxxxxx
  role: roles/storage.legacyBucketOwner
- members:
  - projectViewer:xxxxxxxxxxx
  role: roles/storage.legacyBucketReader
- members:
  - projectEditor:xxxxxxxxxxx
  - projectOwner:xxxxxxxxxxx
  role: roles/storage.legacyObjectOwner
- members:
  - projectViewer:xxxxxxxxxxx
  role: roles/storage.legacyObjectReader
- members:
  - serviceAccount:[e-mail]
  role: roles/storage.objectViewer
etag: CAI=
kind: storage#policy
resourceId: projects/_/buckets/xxxxxxxxxxx-pscbackend
version: 1

NOTA: En este codelab, se supone que el nombre del bucket de GCS está disponible de forma global. Si el nombre del bucket ya está en uso, debes ajustar el nombre reemplazando "$projectid-pscbackend" en el código que se indicó anteriormente.

NOTA: Si tu organización no permite el uso de la cuenta de servicio predeterminada, deberás crear la tuya.

7. Expón Google Cloud Storage a través de un balanceador de cargas de aplicaciones interno entre regiones

Crea el balanceador de cargas de aplicaciones interno entre regiones

Primero, crea los componentes del balanceador de cargas. Crearás un NEG de PSC, un servicio de backend, un mapa de URL y proxies HTTP de destino.

En Cloud Shell, haga lo siguiente:

gcloud compute network-endpoint-groups create gcs-$region2-neg \
    --region=$region2 \
    --network-endpoint-type=private-service-connect \
    --psc-target-service=storage.googleapis.com

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

gcloud compute backend-services add-backend gcs-bes \
    --global \
    --network-endpoint-group=gcs-$region2-neg \
    --network-endpoint-group-region=$region2

gcloud compute url-maps create gcsilb \
    --default-service=gcs-bes \
    --global

gcloud compute target-http-proxies create gcs-http-proxy \
    --url-map=gcsilb \
    --global

Crea la regla de reenvío del balanceador de cargas.

En Cloud Shell, haga lo siguiente:

gcloud compute forwarding-rules create gcs-ilb-fr \
    --load-balancing-scheme=INTERNAL_MANAGED \
    --network=myvpc \
    --subnet=$region2-subnet \
    --target-http-proxy=gcs-http-proxy \
    --ports=80 \
    --subnet-region=$region2 \
    --global

NOTA: Para un diseño listo para la producción, se sugiere que uses proxies HTTPS de destino, el puerto 443 y un certificado en el balanceador de cargas.

8. Crea una zona privada de Cloud DNS para company.com

Primero, determinemos la dirección IP del balanceador de cargas para el registro A y exportémosla como una variable.

En Cloud Shell, haga lo siguiente:

gcloud compute forwarding-rules describe gcs-ilb-fr \
    --global

export lbip=$(gcloud compute forwarding-rules describe gcs-ilb-fr \
    --global \
    --format='value(IPAddress)')

echo $lbip

Resultado de muestra

IPAddress: 10.100.0.4
IPProtocol: TCP
creationTimestamp: 'xxxxxxxxxxxxxxx'
description: ''
fingerprint: xxxxxxxxxx
id: 'xxxxxxxxxxxxxx'
kind: compute#forwardingRule
labelFingerprint: xxxxxxxxxx
loadBalancingScheme: INTERNAL_MANAGED
name: gcs-ilb-fr
network: https://www.googleapis.com/compute/v1/projects/[projectID]/global/networks/myvpc
networkTier: PREMIUM
portRange: 80-80
selfLink: https://www.googleapis.com/compute/v1/projects/[projectID]/global/forwardingRules/gcs-ilb-fr
selfLinkWithId: https://www.googleapis.com/compute/v1/projects/[projectID]/global/forwardingRules/xxxxxxxxxxxxxx
subnetwork: https://www.googleapis.com/compute/v1/projects/[projectID]/regions/us-south1/subnetworks/us-south1-subnet
target: https://www.googleapis.com/compute/v1/projects/[projectID]/global/targetHttpProxies/gcs-http-proxy
10.100.0.4

A continuación, crea la zona privada de DNS y el registro A para el balanceador de cargas interno que acabas de crear.

Desde Cloud Shell

gcloud dns managed-zones create "company-com" \
    --dns-name=company.com. \
    --description="company.com private dns zone" \
    --visibility=private \
    --networks=myvpc

gcloud dns record-sets create "storage.company.com" \
    --zone="company-com" \
    --type="A" \
    --ttl="300" \
    --rrdatas="$lbip"

9. Crea la VM de prueba

Crea una VM de cliente de consumidor

Desde Cloud Shell

gcloud compute instances create testvm \
    --zone="$zone1" \
    --subnet="$region1-subnet" \
    --no-address \
    --metadata "startup-script=#! /bin/bash
cat <<EOF > /etc/profile.d/gcp-startup-vars.sh
export MYBUCKET=\"$projectid-pscbackend\"
export computesa=\"$computesa\"
EOF
chmod +x /etc/profile.d/gcp-startup-vars.sh"

10. Prueba la conexión a Google Cloud Storage a través del balanceador de cargas

Conéctate a la VM de prueba

En Cloud Shell, haga lo siguiente:

gcloud compute ssh "testvm"\
    --zone "$zone1"\
    --tunnel-through-iap \
    --project $projectid

Probar la conectividad

En la VM de prueba

TOKEN=$(curl -s -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/$computesa/token" | jq -r .access_token)

curl -H "Authorization: Bearer $TOKEN" "http://storage.company.com/$MYBUCKET/my-bucket-contents.txt"

NOTA: [projectid-pscbackend] se debe reemplazar por el nombre del bucket que se usó cuando se configuró el bucket de Google Cloud Storage si se usó un nombre de bucket diferente.

Resultado esperado

Here is my bucket file contents

Sal de la VM.

En TestVM

exit

Operación exitosa

11. Pasos para la limpieza

Desde Cloud Shell

gcloud dns record-sets delete "storage.company.com" \
    --zone="company-com" \
    --type="A"

gcloud dns managed-zones delete "company-com"

gcloud compute forwarding-rules delete gcs-ilb-fr \
    --global \
    --quiet

gcloud compute target-http-proxies delete gcs-http-proxy \
    --global \
    --quiet

gcloud compute url-maps delete gcsilb \
    --global \
    --quiet

gcloud compute backend-services delete gcs-bes \
    --global \
    --quiet

gcloud compute network-endpoint-groups delete gcs-$region2-neg \
    --region=$region2 \
    --quiet

gcloud storage rm -r gs://$projectid-pscbackend \
    --quiet

gcloud compute instances delete testvm \
    --zone=$zone1 \
    --quiet

gcloud compute network-firewall-policies rules delete 1000 \
    --firewall-policy my-vpc-policy \
    --global-firewall-policy \
    --quiet

gcloud compute network-firewall-policies associations delete \
    --firewall-policy my-vpc-policy \
    --name=network-myvpc \
    --global-firewall-policy \
    --quiet

gcloud compute network-firewall-policies delete my-vpc-policy \
    --global \
    --quiet

gcloud compute networks subnets delete $region1-subnet \
    --region=$region1 \
    --quiet

gcloud compute networks subnets delete $region2-proxy-subnet \
    --region=$region2 \
    --quiet

gcloud compute networks subnets delete $region2-subnet \
    --region=$region2 \
    --quiet

gcloud compute networks delete myvpc \
    --quiet

12. ¡Felicitaciones!

Felicitaciones por completar el codelab.

Temas abordados

• Implementa archivos básicos en Google Cloud Storage
• Implementa un backend de PSC para Google Cloud Storage
• Implementa un balanceador de cargas de aplicaciones interno entre regiones