Vertex AI Pipelines PSC Interface SWP

1. Introduction

Une interface Private Service Connect est une ressource qui permet à un réseau cloud privé virtuel (VPC) de producteur d'initier des connexions avec différentes destinations dans un réseau VPC consommateur. Les réseaux de producteurs et les réseaux de clients peuvent appartenir à différents projets et organisations.

Si un rattachement de réseau accepte une connexion depuis une interface Private Service Connect, Google Cloud attribue à l'interface une adresse IP d'un sous-réseau client spécifié par le rattachement de réseau. Les réseaux utilisateur et producteur sont connectés et peuvent communiquer à l'aide d'adresses IP internes.

Une connexion entre un rattachement de réseau et une interface Private Service Connect est semblable à la connexion entre un point de terminaison Private Service Connect et un rattachement de service, avec toutefois deux différences majeures :

  • Un rattachement de réseau permet à un réseau producteur d'établir des connexions avec un réseau consommateur (sortie de service géré), tandis qu'un point de terminaison permet à un réseau consommateur d'établir des connexions avec un réseau producteur (entrée de service géré).
  • Une connexion d'interface Private Service Connect est transitive. Cela signifie qu'un réseau de producteur peut communiquer avec d'autres réseaux connectés au réseau du client.

d7dc28d6567e6283.pngFigure 1

Considérations concernant l'accessibilité de l'interface PSC Vertex AI

  • L'interface PSC Vertex AI est capable d'acheminer le trafic vers des destinations dans un VPC ou sur site au sein du bloc d'adresses RFC1918.
  • Le ciblage d'interface PSC de blocs d'adresses non-RFC 1918 nécessite un proxy explicite déployé dans le VPC du consommateur avec une adresse RFC 1918. Dans le déploiement Vertex AI, le proxy doit être défini avec un nom de domaine complet du point de terminaison cible. La figure 1 représente le mode proxy explicite Secure Web Proxy (SWP) configuré dans le VPC du consommateur pour faciliter le routage vers les CIDR non RFC-1918 suivants :
  1. 240.0.0.0/4
  2. 203.0.113.0/24
  3. 10.10.20.0/28 : aucun proxy requis, car cette plage appartient à la plage RFC-1918.
  4. Sortie Internet

Connexion à Internet pour le réseau de locataires géré par Google :

Interface PSC Vertex AI sans VPC-SC

  • Lorsque vous configurez votre déploiement avec une interface PSC uniquement, il conserve son accès Internet par défaut. Ce trafic sortant quitte directement le réseau locataire géré par Google.

Interface PSC Vertex AI avec VPC-SC

  • Lorsque votre projet fait partie d'un périmètre VPC Service Controls, l'accès Internet par défaut du locataire géré par Google est bloqué par le périmètre pour empêcher l'exfiltration de données.
  • Pour autoriser l'accès au déploiement à l'Internet public dans ce scénario, vous devez configurer explicitement un chemin de sortie sécurisé qui achemine le trafic via votre VPC connecté à Vertex AI. Pour ce faire, vous pouvez déployer un serveur proxy dans le réseau VPC avec une adresse RFC 1918, associé à une passerelle Cloud NAT. Notez que vous pouvez également utiliser le proxy Web sécurisé pour transférer le trafic vers Internet. La création d'un proxy Web sécurisé crée automatiquement une passerelle Cloud NAT.

Pour en savoir plus, consultez les ressources suivantes :

Configurer une interface Private Service Connect pour les ressources Vertex AI | Google Cloud

Ce que vous allez faire

Dans ce tutoriel, vous allez créer un déploiement complet de Vertex AI Pipelines avec une interface Private Service Connect (PSC) pour permettre la connectivité du producteur au calcul du consommateur, comme illustré à la figure 1, en ciblant un point de terminaison non RFC 1918 dans class-e-subnet.

2d095dc2f4de6b4b.pngFigure 2

Vous allez créer un seul psc-network-attachment dans le VPC consommateur en utilisant l'appairage DNS pour résoudre les VM des consommateurs dans le projet locataire hébergeant Vertex AI Training, ce qui entraînera les cas d'utilisation suivants :

Déployez Vertex AI Pipelines et configurez Secure Web Proxy en mode proxy explicite, ce qui lui permet d'effectuer un wget sur une VM du sous-réseau de classe E.

Points abordés

  • Créer un rattachement de réseau
  • Comment un producteur peut utiliser un rattachement de réseau pour créer une interface PSC
  • Établir un appairage DNS pour résoudre les domaines privés configurés dans le réseau VPC consommateur à partir des réseaux VPC gérés par Google
  • Transférer le trafic de l'interface PSC Vertex AI vers Secure Web Proxy
  • Établir une communication avec un espace d'adresses IP non-RFC-1918 à partir de Vertex AI Pipelines

Prérequis

Projet Google Cloud

Autorisations IAM

2. Avant de commencer

Mettre à jour le projet pour qu'il soit compatible avec le tutoriel

Ce tutoriel utilise des $variables pour faciliter l'implémentation de la configuration gcloud dans Cloud Shell.

Dans Cloud Shell, procédez comme suit :

gcloud config list project
gcloud config set project [YOUR-PROJECT-ID]
projectid=YOUR-PROJECT-ID
echo $projectid

Activation de l'API

Dans Cloud Shell, procédez comme suit :

gcloud services enable "compute.googleapis.com"
gcloud services enable "aiplatform.googleapis.com"
gcloud services enable "dns.googleapis.com"
gcloud services enable "notebooks.googleapis.com"
gcloud services enable "storage.googleapis.com"
gcloud services enable "cloudresourcemanager.googleapis.com"
gcloud services enable "artifactregistry.googleapis.com"
gcloud services enable "cloudbuild.googleapis.com"
gcloud services enable "networkservices.googleapis.com"
gcloud services enable "networksecurity.googleapis.com"
gcloud services enable "certificatemanager.googleapis.com"

3. Configuration du client

Créer le VPC consommateur

Dans Cloud Shell, procédez comme suit :

gcloud compute networks create consumer-vpc --project=$projectid --subnet-mode=custom

Créer les sous-réseaux consommateurs

Dans Cloud Shell, procédez comme suit :

gcloud compute networks subnets create class-e-subnet --project=$projectid --range=240.0.0.0/4 --network=consumer-vpc --region=us-central1

Dans Cloud Shell, procédez comme suit :

gcloud compute networks subnets create rfc1918-subnet1 --project=$projectid --range=10.10.10.0/28 --network=consumer-vpc --region=us-central1 --enable-private-ip-google-access

Créer le sous-réseau proxy réservé

gcloud compute networks subnets create proxy-only-uscentral1 \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=us-central1 \
    --network=consumer-vpc \
    --range=10.10.100.0/26

Créer le sous-réseau de rattachement de réseau Private Service Connect

Dans Cloud Shell, procédez comme suit :

gcloud compute networks subnets create intf-subnet \
--project=$projectid \
--range=192.168.10.0/28 \
--network=consumer-vpc \
--region=us-central1 \
--enable-private-ip-google-access

Configuration de Cloud Router et de NAT

Le proxy Web sécurisé Google Cloud provisionne et gère automatiquement une passerelle Cloud NAT et un routeur Cloud Router associé dans la région où il est déployé.

4. Activer IAP

Pour permettre à IAP (Identity-Aware Proxy) de se connecter à vos instances de VM, créez une règle de pare-feu qui :

  • S'applique à toutes les instances de VM auxquelles vous souhaitez être accessible à l'aide d'IAP.
  • Autorise le trafic entrant à partir de la plage d'adresses IP 35.235.240.0/20. Cette plage contient toutes les adresses IP qu'IAP utilise pour le transfert TCP.

Dans Cloud Shell, créez la règle de pare-feu IAP.

gcloud compute firewall-rules create ssh-iap-consumer \
    --network consumer-vpc \
    --allow tcp:22 \
    --source-ranges=35.235.240.0/20

5. Créer des instances de VM consommateur

Dans Cloud Shell, créez l'instance de VM consommateur class-e-vm.

gcloud compute instances create class-e-vm \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --shielded-secure-boot \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=class-e-subnet \ 
    --private-network-ip=240.0.0.2

6. Proxy Web sécurisé

Le mode explicite (ou mode de routage de proxy explicite) de Secure Web Proxy est une méthode de déploiement dans laquelle les charges de travail client doivent être explicitement configurées pour utiliser l'adresse IP interne, le nom de domaine complet et le port de SWP comme proxy de transfert.

Dans les étapes ci-dessous, veillez à remplacer YOUR-PROJECT-ID par l'ID de votre projet.

Créez un proxy Web :

Dans Cloud Shell, créez le fichier policy.yaml à l'aide d'un éditeur de texte :

cat > policy.yaml << EOF
description: basic Secure Web Proxy policy
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
EOF

Dans Cloud Shell, générez la règle de proxy Web sécurisé :

gcloud network-security gateway-security-policies import policy1 \
    --source=policy.yaml \
    --location=us-central1

Dans la section suivante, créez une règle pour autoriser l'accès à class-e-vm en fonction de l'hôte sessionMatcher.

Dans Cloud Shell, créez le fichier rule1.yaml à l'aide d'un éditeur de texte :

cat > rule1.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-nonrfc-classe
description: Allow nonrfc class-e
enabled: true
priority: 1
basicProfile: ALLOW
sessionMatcher: host() == 'class-e-vm.demo.com'
EOF

Dans la section suivante, créez une règle pour autoriser l'accès au notebook Jupyter afin d'autoriser l'installation d'Apache2 sur la VM "class-e".

Dans Cloud Shell, créez le fichier rule2.yaml à l'aide d'un éditeur de texte :

cat > rule2.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-apache2
description: Allow Apache2 install on class-e VM
enabled: true
priority: 2
basicProfile: ALLOW
sessionMatcher: inIpRange(source.ip,'240.0.0.2')
EOF

Dans Cloud Shell, générez la règle de stratégie de sécurité 1 :

gcloud network-security gateway-security-policies rules import allow-nonrfc-classe \
    --source=rule1.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

Dans Cloud Shell, générez la règle de stratégie de sécurité 2 :

gcloud network-security gateway-security-policies rules import allow-apache2 \
    --source=rule2.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

Pour prendre en charge Vertex AI Training, configurez la passerelle Secure Web Proxy avec les paramètres suivants :

  • Port d'écoute : utilisez le même port que celui configuré dans les paramètres de proxy explicites du code de l'application Vertex AI (par exemple, 8080).
  • Adresse : attribuez une adresse IP privée à partir de la plage RFC 1918.
  • Mode de routage : définissez-le sur EXPLICIT_ROUTING_MODE.

Dans Cloud Shell, créez un fichier gateway.yaml pour définir la passerelle Secure Web Proxy :

cat > gateway.yaml << EOF
name: projects/$projectid/locations/us-central1/gateways/swp1
type: SECURE_WEB_GATEWAY
addresses: ["10.10.10.5"]
ports: [8080]
gatewaySecurityPolicy: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
network: projects/$projectid/global/networks/consumer-vpc
subnetwork: projects/$projectid/regions/us-central1/subnetworks/rfc1918-subnet1
routingMode: EXPLICIT_ROUTING_MODE
EOF

Dans Cloud Shell, générez l'instance Secure Web Proxy :

gcloud network-services gateways import swp1 \
    --source=gateway.yaml \
    --location=us-central1

Le déploiement d'un proxy Web sécurisé peut prendre plusieurs minutes.

e8a4cf23bfc63030.png

7. Rattachement de réseau Private Service Connect

Les rattachements de réseau sont des ressources régionales qui représentent le côté utilisateur d'une interface Private Service Connect. Vous associez un seul sous-réseau à un rattachement de réseau, et le producteur attribue des adresses IP à l'interface Private Service Connect à partir de ce sous-réseau. Le sous-réseau doit se trouver dans la même région que le rattachement de réseau. Un rattachement réseau doit se trouver dans la même région que le service producteur.

Créer le rattachement de réseau

Dans Cloud Shell, créez le rattachement de réseau.

gcloud compute network-attachments create psc-network-attachment \
    --region=us-central1 \
    --connection-preference=ACCEPT_MANUAL \
    --subnets=intf-subnet

Remarque : Vous n'avez pas besoin de mentionner explicitement l'ID de projet accepté dans cette pièce jointe. Lorsque le projet locataire géré par Google est configuré, il est automatiquement ajouté comme s'il était configuré sur "Accepter automatiquement".

Lister les rattachements de réseau

Dans Cloud Shell, listez l'association réseau.

gcloud compute network-attachments list

Décrire les rattachements de réseau

Dans Cloud Shell, décrivez le rattachement de réseau.

gcloud compute network-attachments describe psc-network-attachment --region=us-central1

Notez le nom du rattachement de réseau PSC, psc-network-attachment, qui sera utilisé par le producteur lors de la création de l'interface Private Service Connect.

Pour afficher l'URL d'association au réseau PSC dans la console Cloud, accédez à :

Services réseau → Private Service Connect → Rattachement de réseau → psc-network-attachment

b969cca5242d9c8a.png

8. Zone DNS privée

Vous allez créer une zone Cloud DNS pour demo.com et la remplir avec des enregistrements A qui pointent vers les adresses IP de vos VM. L'appairage DNS sera ensuite déployé dans le job Vertex AI Pipelines, ce qui lui permettra d'accéder aux enregistrements DNS du consommateur.

Dans Cloud Shell, procédez comme suit :

gcloud dns --project=$projectid managed-zones create private-dns-codelab --description="" --dns-name="demo.com." --visibility="private" --networks="https://compute.googleapis.com/compute/v1/projects/$projectid/global/networks/consumer-vpc"

Dans Cloud Shell, créez l'ensemble d'enregistrements pour la VM, class-e-vm, en veillant à mettre à jour l'adresse IP en fonction de la sortie de votre environnement.

gcloud dns --project=$projectid record-sets create class-e-vm.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="240.0.0.2"

Dans Cloud Shell, créez l'ensemble d'enregistrements pour le proxy Web sécurisé, en veillant à mettre à jour l'adresse IP en fonction de la sortie de votre environnement.

gcloud dns --project=$projectid record-sets create explicit-swp.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="10.10.10.5"

Créer une règle Cloud Firewall pour autoriser l'accès depuis l'interface PSC

Dans la section suivante, créez une règle de pare-feu qui autorise le trafic provenant de l'accès au rattachement de réseau PSC vers les ressources de calcul RFC 1918 dans le VPC des consommateurs.

Dans Cloud Shell, créez la règle de pare-feu d'entrée qui autorise l'accès du sous-réseau proxy réservé au sous-réseau de classe E. Le processus d'effacement des données initie la connexion avec le sous-réseau proxy réservé en tant qu'adresse source.

gcloud compute firewall-rules create allow-access-to-class-e \
    --network=consumer-vpc \
    --action=ALLOW \
    --rules=ALL \
    --direction=INGRESS \
    --priority=1000 \
    --source-ranges="10.10.100.0/28" \
    --destination-ranges="240.0.0.0/4" \
    --enable-logging

9. Créer un notebook Jupyter

La section suivante vous explique comment créer un notebook Jupyter. Ce notebook sera utilisé pour déployer un job Vertex AI Pipelines qui envoie un wget de Vertex AI Pipelines aux instances de test. Le chemin de données entre Vertex AI Pipelines et le réseau consommateur contenant les instances utilise une interface Private Service Connect.

Créer un compte de service géré par l'utilisateur

Dans la section suivante, vous allez créer un compte de service qui sera associé à l'instance Vertex AI Workbench utilisée dans le tutoriel.

Dans le tutoriel, les rôles suivants seront appliqués au compte de service :

Connectez-vous à Cloud Shell et procédez comme suit :

Créez le compte de service.

gcloud iam service-accounts create notebook-sa \
    --display-name="notebook-sa"

Mettez à jour le compte de service avec le rôle Administrateur de l'espace de stockage.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/storage.admin"

Mettez à jour le compte de service avec le rôle "Utilisateur AI Platform".

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"

Mettez à jour le compte de service avec le rôle "Administrateur Artifact Registry".

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/artifactregistry.admin"

Mettez à jour le compte de service avec le rôle "Éditeur Cloud Build".

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/cloudbuild.builds.editor"

Autorisez le compte de service du notebook à utiliser le compte de service Compute Engine par défaut.

gcloud iam service-accounts add-iam-policy-binding \
    $(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')-compute@developer.gserviceaccount.com \
    --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountUser"

10. Créer une instance Vertex AI Workbench

Dans la section suivante, créez une instance Vertex AI Workbench qui intègre le compte de service notebook-sa créé précédemment.

Dans Cloud Shell, créez l'instance de client privé.

gcloud workbench instances create workbench-tutorial --vm-image-project=cloud-notebooks-managed --vm-image-family=workbench-instances --machine-type=n1-standard-4 --location=us-central1-a --subnet-region=us-central1 --subnet=rfc1918-subnet1 --disable-public-ip --shielded-secure-boot=true --shielded-integrity-monitoring=true --shielded-vtpm=true --service-account-email=notebook-sa@$projectid.iam.gserviceaccount.com

11. Mise à jour de l'agent de service Vertex AI

Vertex AI agit en votre nom pour effectuer des opérations telles que l'obtention d'une adresse IP à partir du sous-réseau de rattachement au réseau PSC utilisé pour créer l'interface PSC. Pour ce faire, Vertex AI utilise un agent de service (listé ci-dessous) qui nécessite l'autorisation Administrateur réseau.

service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com

Remarque : Avant de mettre à jour les autorisations de l'agent de service, accédez à Vertex AI dans la console Cloud pour vous assurer que l'API Vertex AI est activée.

Dans Cloud Shell :

Obtenez votre numéro de projet.

gcloud projects describe $projectid | grep projectNumber

Définissez le numéro de votre projet.

projectnumber=YOUR-PROJECT-NUMBER

Créez un compte de service pour AI Platform. Ignorez cette étape si vous disposez déjà d'un compte de service dans votre projet.

gcloud beta services identity create --service=aiplatform.googleapis.com --project=$projectnumber

Attribuez le rôle compute.networkAdmin au compte de l'agent de service.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com" --role="roles/compute.networkAdmin"

Mettez à jour le compte de l'agent de service avec le rôle dns.peer.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com" --role="roles/dns.peer"

Mise à jour du compte de service par défaut

Activez l'API Compute Engine et accordez à votre compte de service par défaut l'accès à Vertex AI. Notez que la propagation de la modification d'accès peut prendre un certain temps.

Utilisez Cloud Shell pour mettre à jour le compte de service par défaut comme suit :

Mettez à jour le compte de service par défaut avec le rôle aiplatform.user.

gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:$projectnumber-compute@developer.gserviceaccount.com" \
    --role="roles/aiplatform.user"

Mettez à jour le compte de service par défaut avec le rôle storage.admin.

gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:$projectnumber-compute@developer.gserviceaccount.com" \
    --role="roles/storage.admin"

Mettez à jour le compte de service par défaut avec le rôle artifactregistry.admin.

gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:$projectnumber-compute@developer.gserviceaccount.com" \
    --role="roles/artifactregistry.admin"

12. Installez Apache2 et activez Tcpdump sur "class-e-vm" :

Depuis class-e-vm, installez apache2 via Secure Web Proxy :

Ouvrez un nouvel onglet Cloud Shell, mettez à jour la variable de votre projet et connectez-vous via SSH à la VM de classe E.

gcloud compute ssh --zone us-central1-a "class-e-vm" --tunnel-through-iap --project $projectid

sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" update
sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" install apache2 -y
sudo service apache2 restart
echo 'class-e Server !!' | sudo tee /var/www/html/index.html

Exécutez le filtrage tcpdump sur le sous-réseau proxy réservé, utilisé par le proxy Web sécurisé pour transférer le trafic vers les cibles.

À partir de l'OS de la VM class-e-vm, exécutez le filtrage tcpdump sur le sous-réseau proxy-vm.

sudo tcpdump -i any net 10.10.100.0/24 -nn

Remarque : Assurez-vous d'activer l'accès privé à Google sur le sous-réseau de l'instance workbench-tutorial pour que la session JupyterLab s'ouvre.

13. Déployer un job Vertex AI Pipelines

Dans la section suivante, vous allez créer un notebook pour effectuer un wget réussi de Vertex AI Pipelines vers le proxy explicite. Cela vous permet d'accéder aux VM non-RFC 1918, telles que class-e-vm. Un proxy explicite n'est pas nécessaire pour que Vertex AI Pipelines accède à rfc1918-vm, car sa cible est une adresse IP RFC 1918.

Exécutez le job d'entraînement dans l'instance Vertex AI Workbench.

  1. Dans la console Google Cloud, accédez à l'onglet "Instances" de la page Vertex AI Workbench.
  2. À côté du nom de votre instance Vertex AI Workbench (workbench-tutorial), cliquez sur "Ouvrir JupyterLab". Votre instance Vertex AI Workbench ouvre JupyterLab.
  3. Sélectionnez Fichier > Nouveau > Notebook.
  4. Sélectionnez Kernel > Python 3.

Dans votre notebook JupyterLab, créez une cellule, puis mettez à jour et exécutez le code suivant. Veillez à remplacer PROJECT_ID par les informations de votre environnement.

import json
import requests
import pprint

PROJECT_ID = 'YOUR-PROJECT-ID' #Enter your project ID
PROJECT_NUMBER=!gcloud projects list --filter="project_id:$PROJECT_ID" --format="value(PROJECT_NUMBER)"
PROJECT_NUMBER=str(PROJECT_NUMBER).strip('[').strip(']').strip("'")
print(PROJECT_NUMBER)

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

# us-central1 is used for the codelab
REGION = "us-central1" #@param {type:"string"}
SERVICE_NAME = "aiplatform" #@param {type:"string"}
SERVICE ="{}.googleapis.com".format(SERVICE_NAME)
ENDPOINT="{}-{}.googleapis.com".format(REGION, SERVICE_NAME)
API_VERSION = "v1" # @param {type: "string"}

LOCATION = REGION

Dans votre notebook JupyterLab, créez une cellule et exécutez la configuration ci-dessous. Notez les points suivants :

  • proxy_server = "http://explicit-swp.demo.com:8080"
  • Un nom de domaine complet est associé à la VM de proxy déployée dans le VPC consommateur. Nous utilisons le peering DNS pour résoudre le nom de domaine complet lors d'une étape ultérieure.
%%writefile main.py

import logging
import socket
import sys
import os

def make_api_request(url: str, proxy_vm_ip: str, proxy_vm_port: str):
    """
    Makes a GET request to a nonRFC-1918 API and saves the response.

    Args:
        url: The URL of the API to send the request to.
    """
    import requests

    try:
        # response = requests.get(url)
        proxy_server = f"http://explicit-swp.demo.com:8080" # replace it with your Secure Web proxy Ip-address and the port.

        proxies = {
          "http": proxy_server,
          "https": proxy_server,
        }

        response = requests.get(url, proxies=proxies)
        logging.info(response.text)

        response.raise_for_status()  # Raise an exception for bad status codes
        logging.info(f"Successfully fetched data from {url}")
    except requests.exceptions.RequestException as e:
        logging.error(f"An error occurred: {e}")
        raise e

if __name__ == '__main__':
  # Configure logging to print clearly to the console
  logging.basicConfig(
      level=logging.INFO,
      format='%(levelname)s: %(message)s',
      stream=sys.stdout
  )
  url_to_test = os.environ['NONRFC_URL']
  proxy_vm_ip = os.environ['PROXY_VM_IP']
  proxy_vm_port = os.environ['PROXY_VM_PORT']

  logging.info(f"url_to_test: {url_to_test}")
  logging.info(f"proxy_vm_ip: {proxy_vm_ip}")
  logging.info(f"proxy_vm_port: {proxy_vm_port}")
  make_api_request(url_to_test, proxy_vm_ip, proxy_vm_port)

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

%%writefile Dockerfile
FROM python:3.9-slim

RUN apt-get update && \
  apt-get install -y iputils-ping && \
  apt-get install -y wget

RUN pip install cloudml-hypertune requests kfp

COPY main.py /main.py

ENTRYPOINT ["python3", "/main.py"]

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

!gcloud artifacts repositories create pipelines-test-repo-psc --repository-format=docker --location=us-central1

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

IMAGE_PROJECT = PROJECT_ID
IMAGE_REPO = 'pipelines-test-repo-psc' 
IMAGE_NAME = 'nonrfc-ip-call'
TAG = 'v1'

IMAGE_URI= f'us-central1-docker.pkg.dev/{IMAGE_PROJECT}/{IMAGE_REPO}/{IMAGE_NAME}:{TAG}'
IMAGE_URI

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

!gcloud auth configure-docker us-docker.pkg.dev --quiet

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante. Ignorez l'erreur (gcloud.builds.submit) si elle s'affiche.

!gcloud builds submit --tag {IMAGE_URI} --region=us-central1

Dans votre notebook JupyterLab, créez et exécutez la cellule ci-dessous. Notez les points suivants :

  • L'appairage DNS aux VPC consommateurs est configuré à l'aide de dnsPeeringConfigs (dnsPeeringConfigs) pour le nom de domaine demo.com.
  • Le proxy Web en mode de routage explicite est explicit-swp.demo.com. La résolution est gérée par l'appairage DNS dans le VPC du consommateur.
  • Le port 8080 est le port d'écoute (par défaut) configuré dans Secure Web Proxy.
  • wget vers class-e-vm-demo.com est résolu via l'appairage DNS.
  • Le code spécifie le "psc-network-attachment" pour Vertex, ce qui lui permet d'utiliser le sous-réseau de rattachement de réseau pour déployer deux instances d'interface PSC.
import json
from datetime import datetime


JOB_ID_PREFIX='test_psci-nonRFC' #@param {type:"string"}
JOB_ID = '{}_{}'.format(JOB_ID_PREFIX, datetime.now().strftime("%Y%m%d%H%M%S"))

# PSC-I configs

PRODUCER_PROJECT_ID = PROJECT_ID
DNS_DOMAIN = 'class-e-vm.demo.com' #@param {type:"string"}
NON_RFC_URL = f"http://{DNS_DOMAIN}"

PROXY_VM_IP = "explicit-swp.demo.com" #@param {type:"string"}
PROXY_VM_PORT = "8080" #@param {type:"string"}

CUSTOM_JOB = {
  "display_name": JOB_ID,
  "job_spec": {
      "worker_pool_specs": [
          {
           "machine_spec": {
             "machine_type": "n1-standard-4",
           },
           "replica_count": 1,
           "container_spec": {
             "image_uri": IMAGE_URI,
             "env": [{
               "name": "NONRFC_URL",
               "value": NON_RFC_URL
             },
             {
               "name": "PROXY_VM_IP",
               "value": PROXY_VM_IP
             },
             {
               "name": "PROXY_VM_PORT",
               "value": PROXY_VM_PORT
             }]
           },
         },
      ],
      "enable_web_access": True,
      "psc_interface_config": {
        "network_attachment": "psc-network-attachment",
        "dns_peering_configs": [
          {
            "domain": "demo.com.",
            "target_project": PROJECT_ID,
            "target_network": "consumer-vpc"
          },
        ]
      },
  }
}

print(json.dumps(CUSTOM_JOB, indent=2))

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

import requests
bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/customJobs/"

print("request_uri: ", request_uri)

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

response_autopush = requests.post(request_uri, json=CUSTOM_JOB, headers=headers)
response = response_autopush
print("response:", response)
if response.reason == 'OK':
  job_name = response.json()['name']
  job_id = job_name.split('/')[-1]
  print("Created Job: ", response.json()['name'])
else:
  print(response.text)

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

# Print KFP SDK version (should be >= 1.6)
! python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"

# Print AI Platform version
! python3 -c "from google.cloud import aiplatform; print('AI Platform version: {}'.format(aiplatform.__version__))"

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

BUCKET_URI = "your-unique-bucket" # Provide a globally unique bucket name

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

!gcloud storage buckets create gs://{BUCKET_URI}

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

# pipeline parameters
CACHE_PIPELINE = False # @param {type: "string"}
_DEFAULT_IMAGE = IMAGE_URI
BUCKET_URI = "gs://{BUCKET_URI}"  # @param {type: "string"}
PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/intro"
PIPELINE_DISPLAY_NAME = "pipeline_nonRFCIP" # @param {type: "string"}

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

from re import S
import kfp
from kfp import dsl
from kfp.dsl import container_component, ContainerSpec
from kfp import compiler
from google.cloud import aiplatform


# ==== Component with env variable ====

@container_component
def dns_peering_test_op(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    return ContainerSpec(
        image=_DEFAULT_IMAGE,
        command=["bash", "-c"],
        args=[
            """
            apt-get update && apt-get install inetutils-traceroute inetutils-ping netcat-openbsd curl -y

            echo "Local IP(s): $(hostname -I)"

            echo "Attempting to trace route to %s"
            traceroute -w 1 -m 7 "%s"

            echo "Sending curl requests to http://%s via proxy %s:%s and recording trace..."
            if curl -L -v --trace-ascii /dev/stdout -x http://%s:%s "http://%s"; then
                echo "Curl request succeeded!"
            else
                echo "Curl request failed!"
                exit 1
            fi
            """ % (dns_domain, dns_domain, dns_domain, proxy_vm_ip, proxy_vm_port, proxy_vm_ip, proxy_vm_port, dns_domain)

        ]
    )

# ==== Pipeline ====
@dsl.pipeline(
    name="dns-peering-test-pipeline",
    description="Test DNS Peering using env variable",
    pipeline_root=PIPELINE_ROOT,
)
def dns_peering_test_pipeline(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    dns_test_task = dns_peering_test_op(dns_domain=dns_domain, proxy_vm_ip=proxy_vm_ip, proxy_vm_port=proxy_vm_port)
    dns_test_task.set_caching_options(enable_caching=CACHE_PIPELINE)

# ==== Compile pipeline ====
if __name__ == "__main__":
    aiplatform.init(project=PROJECT_ID, location=LOCATION)

    compiler.Compiler().compile(
        pipeline_func=dns_peering_test_pipeline,
        package_path="dns_peering_test_pipeline.yaml",
    )
    print("✅ Pipeline compiled to dns_peering_test_pipeline.yaml")

Dans votre notebook JupyterLab, créez une cellule et exécutez la commande suivante.

# Define the PipelineJob body; see API Reference https://cloud.google.com/vertex-ai/docs/reference/rest/v1/projects.locations.pipelineJobs/create

import requests, json
import datetime

bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/pipelineJobs/"

print("request_uri: ", request_uri)

14. Validation de l'interface PSC

Vous pouvez également afficher les adresses IP de l'association réseau utilisées par Vertex AI Pipelines en accédant à :

Services réseau → Private Service Connect → Rattachement de réseau → psc-network-attachment

Sélectionnez le projet locataire (nom de projet se terminant par "-tp").

a2e0b6d6243f26f1.png

Le champ en surbrillance indique l'adresse IP utilisée par Vertex AI Pipelines à partir du rattachement de réseau PSC.

11e411ea919d3bad.png

15. Validation de Cloud Logging

L'exécution de la tâche Vertex AI Pipelines prendra environ 14 minutes la première fois. Les exécutions suivantes seront beaucoup plus courtes. Pour vérifier que l'opération a réussi, procédez comme suit :

Accédez à Vertex AI > Entraînement > Tâches personnalisées.

Sélectionnez le job personnalisé exécuté.

2f467254aa0c2e3a.png

Sélectionnez "Afficher les journaux".

8d525d3b152bcc61.png

Une fois Cloud Logging disponible, sélectionnez "Exécuter la requête" qui génère la sélection mise en surbrillance ci-dessous, confirmant le succès de wget de Vertex AI Pipelines à class-e-vm.

a4f9e9167f4ce1ae.png

38972f834aa2bd1d.png

16. Validation de TCPDump

Examinons le résultat TCPDUMP qui valide davantage la connectivité aux instances de calcul :

À partir de class-e-vm, observez la requête HTTP GET et la réponse 200 OK.

XXXXXXXXX@class-e-vm:~$ sudo tcpdump -i any net 10.10.100.0/28 -nn
tcpdump: data link type LINUX_SLL2
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on any, link-type LINUX_SLL2 (Linux cooked v2), snapshot length 262144 bytes
05:51:14.173641 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [S], seq 1747181041, win 65535, options [mss 1420,sackOK,TS val 3942828403 ecr 0,nop,wscale 8], length 0
05:51:14.173668 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [S.], seq 3013226100, ack 1747181042, win 64768, options [mss 1420,sackOK,TS val 1886125065 ecr 3942828403,nop,wscale 7], length 0
05:51:14.174977 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [.], ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 0
05:51:14.175066 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [P.], seq 1:223, ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 222: HTTP: GET / HTTP/1.1
05:51:14.175096 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [.], ack 223, win 505, options [nop,nop,TS val 1886125066 ecr 3942828405], length 0
05:51:14.239042 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [P.], seq 1:246, ack 223, win 505, options [nop,nop,TS val 1886125130 ecr 3942828405], length 245: HTTP: HTTP/1.1 200 OK

17. Effectuer un nettoyage

Dans Cloud Shell, supprimez les composants du tutoriel.

gcloud workbench instances delete workbench-tutorial --project=$projectid --location=us-central1-a

gcloud network-security gateway-security-policies rules delete allow-nonrfc-classe \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies rules delete allow-apache2 \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies delete policy1 \
    --location=us-central1
gcloud network-services gateways delete swp1 \
    --location=us-central1

gcloud compute network-attachments delete psc-network-attachment --region=us-central1 --quiet

gcloud compute networks subnets delete intf-subnet rfc1918-subnet1 --region=us-central1 --quiet

gcloud dns record-sets delete class-e-vm.demo.com --zone=private-dns-codelab  --type=A
gcloud dns record-sets delete explicit-swp.demo.com --zone=private-dns-codelab  --type=A

gcloud dns managed-zones delete private-dns-codelab

gcloud computeinstances delete class-e-vm --project=$projectid --zone=us-central1-a --quiet
gcloud compute networks delete consumer-vpc --quiet

18. Félicitations

Félicitations ! Vous avez configuré et validé une connexion entre l'interface Private Service Connect de Vertex AI Pipelines et des plages d'adresses IP non RFC via un proxy Web sécurisé.

Vous avez créé l'infrastructure consommateur et ajouté un rattachement de réseau qui a permis au producteur de créer une VM à plusieurs cartes d'interface réseau pour faire le pont entre les communications consommateur et producteur. Vous avez appris à créer un appairage DNS lors du déploiement d'un proxy explicite dans le réseau VPC consommateur, ce qui a permis la connectivité à l'instance class-e-vm qui n'est pas directement routable depuis Vertex.

678ba30d64a76795.png

Et ensuite ?

Lectures et vidéos complémentaires

Documents de référence