Utiliser Private Service Connect pour accéder aux prédictions en ligne de Vertex AI sur site

Créer les réseaux VPC

Dans cette section, vous allez créer deux réseaux VPC, l'un pour créer un modèle de prédiction en ligne et le déployer sur un point de terminaison, l'autre pour l'accès privé à ce point de terminaison. Dans chacun des deux réseaux VPC, vous créez un routeur Cloud Router et une passerelle Cloud NAT. Une passerelle Cloud NAT fournit une connectivité sortante pour les instances de machines virtuelles (VM) Compute Engine sans adresse IP externe.

Créer le réseau VPC pour le point de terminaison de prédiction en ligne (aiml-vpc)

1. Créez le réseau VPC :

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

2. Créez un sous-réseau nommé workbench-subnet avec une plage IPv4 principale de 172.16.10.0/28 :

   gcloud compute networks subnets create workbench-subnet --project=$projectid --range=172.16.10.0/28 --network=aiml-vpc --region=us-central1 --enable-private-ip-google-access
   

3. Créez un routeur Cloud Router régional nommé cloud-router-us-central1-aiml-nat :

   gcloud compute routers create cloud-router-us-central1-aiml-nat --network aiml-vpc --region us-central1
   

4. Ajoutez une passerelle Cloud NAT au routeur Cloud Router :

   gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-us-central1-aiml-nat --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1
   

Créer le réseau VPC "sur site" (on-prem-vpc)

1. Créez le réseau VPC :

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

2. Créez un sous-réseau nommé nat-subnet avec une plage IPv4 principale de 192.168.10.0/28 :

   gcloud compute networks subnets create nat-subnet --project=$projectid --range=192.168.10.0/28 --network=on-prem-vpc --region=us-central1
   

3. Créez un sous-réseau nommé private-ip-subnet avec une plage IPv4 principale de 192.168.20.0/28 :

   gcloud compute networks subnets create private-ip-subnet --project=$projectid --range=192.168.20.0/28 --network=on-prem-vpc --region=us-central1
   

4. Créez un routeur Cloud Router régional nommé cloud-router-us-central1-on-prem-nat :

   gcloud compute routers create cloud-router-us-central1-on-prem-nat --network on-prem-vpc --region us-central1
   

5. Ajoutez une passerelle Cloud NAT au routeur Cloud Router :

   gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-us-central1-on-prem-nat --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1
   

Créer le point de terminaison Private Service Connect (PSC)

Dans cette section, vous créez le point de terminaison Private Service Connect (PSC) que les instances de VM du réseau on-prem-vpc utilisent pour accéder au point de terminaison de prédiction en ligne via l'API Vertex AI. Le point de terminaison Private Service Connect (PSC) est une adresse IP interne du réseau on-prem-vpc qui est accessible directement aux clients de ce réseau. Ce point de terminaison est créé en déployant une règle de transfert qui dirige le trafic réseau correspondant à l'adresse IP du point de terminaison PSC vers un groupe d'API Google. L'adresse IP du point de terminaison PSC (100.100.10.10) sera annoncée ultérieurement à partir du aiml-vpc-cloud-router-vpn en tant qu'annonce de routeur personnalisée sur le réseau sur site.

1. Réservez des adresses IP pour le point de terminaison PSC :

   gcloud compute addresses create psc-ip \
      --global \
      --purpose=PRIVATE_SERVICE_CONNECT \
      --addresses=100.100.10.10 \
      --network=aiml-vpc
   

2. Créez le point de terminaison PSC :

   gcloud compute forwarding-rules create pscvertex \
    --global \
    --network=aiml-vpc \
    --address=psc-ip \
    --target-google-apis-bundle=all-apis
   

3. Référencez les points de terminaison configurés PSC et vérifiez que le point de terminaison pscvertex a été créé :

   gcloud compute forwarding-rules list  \
    --filter target="(all-apis OR vpc-sc)" --global
   

4. Obtenez les détails du point de terminaison PSC configuré et vérifiez que l'adresse IP est 100.100.10.10 :

   gcloud compute forwarding-rules describe \
    pscvertex --global
   

Configurer la connectivité hybride

Dans cette section, vous allez créer deux passerelles (VPN haute disponibilité) connectées l'une à l'autre. Chaque passerelle contient un routeur Cloud Router et une paire de tunnels VPN.

1. Créez la passerelle VPN haute disponibilité pour le réseau VPC aiml-vpc :

   gcloud compute vpn-gateways create aiml-vpn-gw \
      --network=aiml-vpc\
      --region=us-central1
   

2. Créez la passerelle VPN haute disponibilité pour le réseau VPC on-prem-vpc :

   gcloud compute vpn-gateways create on-prem-vpn-gw \
      --network=on-prem-vpc\
      --region=us-central1
   

3. Dans Google Cloud Console, accédez à la page VPN.

   Accéder au VPN

4. Sur la page VPN, cliquez sur l'onglet Passerelles Cloud VPN.

5. Dans la liste des passerelles VPN, vérifiez qu'il existe deux passerelles et que chacune d'entre elles possède deux adresses IP.

6. Dans Cloud Shell, créez un routeur Cloud Router pour le réseau cloud privé virtuel aiml-vpc :

   gcloud compute routers create aiml-cr-us-central1 \
      --region=us-central1 \
      --network=aiml-vpc\
      --asn=65001
   

7. Créez un routeur Cloud Router pour le réseau cloud privé virtuel on-prem-vpc :

   gcloud compute routers create on-prem-cr-us-central1 \
      --region=us-central1 \
      --network=on-prem-vpc \
      --asn=65002
   

Créer les tunnels VPN pour aiml-vpc

1. Créez un tunnel VPN appelé aiml-vpc-tunnel0 :

   gcloud compute vpn-tunnels create aiml-vpc-tunnel0 \
      --peer-gcp-gateway on-prem-vpn-gw \
      --region us-central1 \
      --ike-version 2 \
      --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
      --router aiml-cr-us-central1 \
      --vpn-gateway aiml-vpn-gw \
      --interface 0
   

2. Créez un tunnel VPN appelé aiml-vpc-tunnel1 :

   gcloud compute vpn-tunnels create aiml-vpc-tunnel1 \
      --peer-gcp-gateway on-prem-vpn-gw \
      --region us-central1 \
      --ike-version 2 \
      --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
      --router aiml-cr-us-central1 \
      --vpn-gateway aiml-vpn-gw \
      --interface 1
   

Créer les tunnels VPN pour on-prem-vpc

1. Créez un tunnel VPN appelé on-prem-vpc-tunnel0 :

   gcloud compute vpn-tunnels create on-prem-tunnel0 \
      --peer-gcp-gateway aiml-vpn-gw \
      --region us-central1 \
      --ike-version 2 \
      --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
      --router on-prem-cr-us-central1 \
      --vpn-gateway on-prem-vpn-gw \
      --interface 0
   

2. Créez un tunnel VPN appelé on-prem-vpc-tunnel1 :

   gcloud compute vpn-tunnels create on-prem-tunnel1 \
      --peer-gcp-gateway aiml-vpn-gw \
      --region us-central1 \
      --ike-version 2 \
      --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
      --router on-prem-cr-us-central1 \
      --vpn-gateway on-prem-vpn-gw \
      --interface 1
   

3. Dans Google Cloud Console, accédez à la page VPN.

   Accéder au VPN

4. Sur la page VPN, cliquez sur l'onglet Tunnels Cloud VPN.

5. Dans la liste des tunnels VPN, vérifiez que quatre tunnels VPN ont été établis.

Établir des sessions BGP

Cloud Router utilise le protocole BGP (Border Gateway Protocol) pour échanger des routes entre votre réseau VPC (dans ce cas, aiml-vpc) et votre réseau sur site (représenté par on-prem-vpc). Sur Cloud Router, vous configurez une interface et un pair BGP pour votre routeur sur site. Ensemble, l'interface et la configuration du pair BGP forment une session BGP. Dans cette section, vous allez créer deux sessions BGP pour aiml-vpc et deux pour on-prem-vpc.

Établir des sessions BGP pour aiml-vpc

1. Dans Cloud Shell, créez la première interface BGP :

   gcloud compute routers add-interface aiml-cr-us-central1 \
      --interface-name if-tunnel0-to-onprem \
      --ip-address 169.254.1.1 \
      --mask-length 30 \
      --vpn-tunnel aiml-vpc-tunnel0 \
      --region us-central1
   

2. Créez le premier pair BGP :

   gcloud compute routers add-bgp-peer aiml-cr-us-central1 \
      --peer-name bgp-on-premises-tunnel0 \
      --interface if-tunnel1-to-onprem \
      --peer-ip-address 169.254.1.2 \
      --peer-asn 65002 \
      --region us-central1
   

3. Créez la deuxième interface BGP :

   gcloud compute routers add-interface aiml-cr-us-central1 \
      --interface-name if-tunnel1-to-onprem \
      --ip-address 169.254.2.1 \
      --mask-length 30 \
      --vpn-tunnel aiml-vpc-tunnel1 \
      --region us-central1
   

4. Créez le deuxième pair BGP :

   gcloud compute routers add-bgp-peer aiml-cr-us-central1 \
      --peer-name bgp-on-premises-tunnel1 \
      --interface if-tunnel2-to-onprem \
      --peer-ip-address 169.254.2.2 \
      --peer-asn 65002 \
      --region us-central1
   

Établir des sessions BGP pour on-prem-vpc

1. Créez la première interface BGP :

   gcloud compute routers add-interface on-prem-cr-us-central1 \
      --interface-name if-tunnel0-to-aiml-vpc\
      --ip-address 169.254.1.2 \
      --mask-length 30 \
      --vpn-tunnel on-prem-tunnel0 \
      --region us-central1
   

2. Créez le premier pair BGP :

   gcloud compute routers add-bgp-peer on-prem-cr-us-central1 \
      --peer-name bgp-aiml-vpc-tunnel0 \
      --interface if-tunnel1-to-aiml-vpc\
      --peer-ip-address 169.254.1.1 \
      --peer-asn 65001 \
      --region us-central1
   

3. Créez la deuxième interface BGP :

   gcloud compute routers add-interface on-prem-cr-us-central1 \
      --interface-name if-tunnel1-to-aiml-vpc\
      --ip-address 169.254.2.2 \
      --mask-length 30 \
      --vpn-tunnel on-prem-tunnel1 \
      --region us-central1
   

4. Créez le deuxième pair BGP :

   gcloud compute routers add-bgp-peer on-prem-cr-us-central1 \
      --peer-name bgp-aiml-vpc-tunnel1\
      --interface if-tunnel2-to-aiml-vpc\
      --peer-ip-address 169.254.2.1 \
      --peer-asn 65001 \
      --region us-central1
   

Valider la création de la session BGP

1. Dans Google Cloud Console, accédez à la page VPN.

   Accéder au VPN

2. Sur la page VPN, cliquez sur l'onglet Tunnels Cloud VPN.

3. Dans la liste des tunnels VPN, vous devriez maintenant voir la valeur de la colonne État de la session BGP pour chacun des quatre tunnels passer de Configurer la session BGP à Session BGP établie. Vous devrez peut-être actualiser l'onglet du navigateur de la console Google Cloud pour afficher les nouvelles valeurs.

Vérifier que aiml-vpc a appris les routes de sous-réseau via un VPN haute disponibilité

1. Dans Google Cloud Console, accédez à la page Réseaux VPC.

   Accéder aux réseaux VPC

2. Dans la liste des réseaux VPC, cliquez sur aiml-vpc.

3. Cliquez sur l'onglet Routes.

4. Sélectionnez us-central1 (Iowa) dans la liste Région, puis cliquez sur Afficher.

5. Dans la colonne Plage d'adresses IP de destination, vérifiez que le réseau VPC aiml-vpc a appris les routes du sous-réseau nat-subnet (192.168.10.0/28) et du sous-réseau private-ip-subnet (192.168.20.0/28) des réseaux VPC on-prem-vpc.

Vérifier que on-prem-vpc a appris les routes de sous-réseau via un VPN haute disponibilité

1. Dans Google Cloud Console, accédez à la page Réseaux VPC.

   Accéder aux réseaux VPC

2. Dans la liste des réseaux VPC, cliquez sur on-prem-vpc.

3. Cliquez sur l'onglet Routes.

4. Sélectionnez us-central1 (Iowa) dans la liste Région, puis cliquez sur Afficher.

5. Dans la colonne Plage d'adresses IP de destination, vérifiez que le réseau VPC on-prem-vpc a appris les routes du sous-réseau workbench-subnet (172.16.10.0/28) des réseaux VPC aiml-vpc.

Créer des annonces de routage personnalisées pour aiml-vpc

L'adresse IP du point de terminaison Private Service Connect n'est pas automatiquement annoncée par le routeur cloud aiml-cr-us-central1, car le sous-réseau n'est pas configuré dans le réseau VPC.

Par conséquent, vous devrez créer une annonce de routage personnalisée à partir du routeur Cloud Router aiml-cr-us-central pour l'adresse IP du point de terminaison 100.100.10.10 qui sera annoncée dans l'environnement sur site via BGP vers on-prem-vpc

1. Dans Google Cloud Console, accédez à la page Routeurs cloud.

   Accéder aux routeurs cloud

2. Dans la liste des routeurs Cloud Router, cliquez sur aiml-cr-us-central1.

3. Sur la page Détails du routeur, cliquez sur edit Modifier.

4. Dans la section Routes annoncées, sélectionnez Créer des routes personnalisées pour le paramètre Routes.

5. Cliquez sur Ajouter une route personnalisée.

6. Dans Source, sélectionnez Plage d'adresses IP personnalisée.

7. Dans Plage d'adresses IP, saisissez 100.100.10.10.

8. Dans Description, saisissez Private Service Connect Endpoint IP.

9. Cliquez sur OK, puis sur Enregistrer.

Confirmez que on-prem-vpc a appris l'adresse IP du point de terminaison PSC via un VPN haute disponibilité

1. Dans Google Cloud Console, accédez à la page Réseaux VPC.

   Accéder aux réseaux VPC

2. Dans la liste des réseaux VPC, cliquez sur on-prem-vpc.

3. Cliquez sur l'onglet Routes.

4. Sélectionnez us-central1 (Iowa) dans la liste Région, puis cliquez sur Afficher.

5. Dans la colonne Plage d'adresses IP de destination, vérifiez que le réseau VPC on-prem-vpc a appris l'adresse IP du point de terminaison PSC (100.100.10.10).

Créer des annonces de routage personnalisées pour on-prem-vpc

Le routeur Cloud Router on-prem-vpc annonce tous les sous-réseaux par défaut, mais seul le sous-réseau private-ip-subnet est nécessaire.

Dans la section suivante, mettez à jour les annonces de routage à partir du routeur Cloud Router on-prem-cr-us-central1.

1. Dans Google Cloud Console, accédez à la page Routeurs cloud.

   Accéder aux routeurs cloud

2. Dans la liste des routeurs Cloud Router, cliquez sur on-prem-cr-us-central1.

3. Sur la page Détails du routeur, cliquez sur edit Modifier.

4. Dans la section Routes annoncées, sélectionnez Créer des routes personnalisées pour le paramètre Routes.

5. Si la case Diffuser tous les sous-réseaux visibles par Cloud Router est cochée, décochez-la.

6. Cliquez sur Ajouter une route personnalisée.

7. Dans Source, sélectionnez Plage d'adresses IP personnalisée.

8. Dans Plage d'adresses IP, saisissez 192.168.20.0/28.

9. Dans Description, saisissez Private Service Connect Endpoint IP subnet (private-ip-subnet).

10. Cliquez sur OK, puis sur Enregistrer.

Confirmez que aiml-vpc a appris la route private-ip-subnet à partir de on-prem-vpc.

1. Dans Google Cloud Console, accédez à la page Réseaux VPC.

   Accéder aux réseaux VPC

2. Dans la liste des réseaux VPC, cliquez sur aiml-vpc.

3. Cliquez sur l'onglet Routes.

4. Sélectionnez us-central1 (Iowa) dans la liste Région, puis cliquez sur Afficher.

5. Dans la colonne Plage d'adresses IP de destination, vérifiez que le réseau VPC aiml-vpc a appris la route private-ip-subnet (192.168.20.0/28).

Créer les instances de VM de test

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

Si vous avez des applications qui doivent appeler les API Google Cloud, Google vous recommande d'associer un compte de service géré par l'utilisateur à la VM sur laquelle l'application ou la charge de travail est en cours d'exécution. Par conséquent, dans cette section, vous allez créer un compte de service géré par l'utilisateur à appliquer aux instances de VM que vous créerez plus loin dans ce tutoriel.

1. Dans Cloud Shell, créez le compte de service :

   gcloud iam service-accounts create gce-vertex-sa \
      --description="service account for vertex" \
      --display-name="gce-vertex-sa"
   

2. Attribuez le rôle IAM Administrateur d'instances Compute (v1) (roles/compute.instanceAdmin.v1) au compte de service :

   gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:gce-vertex-sa@$projectid.iam.gserviceaccount.com" --role="roles/compute.instanceAdmin.v1"
   

3. Attribuez le rôle IAM Utilisateur Vertex AI (roles/aiplatform.user) au compte de service :

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

Créer les instances de VM de test

Au cours de cette étape, vous allez créer des instances de VM de test pour valider différentes méthodes permettant d'accéder aux API AI Vertex, en particulier :

• L'instance nat-client utilise Cloud NAT pour résoudre les problèmes d'accès de Vertex AI au point de terminaison de prédiction en ligne via l'Internet public.
• L'instance private-client utilise l'adresse IP de Private Service Connect 100.100.10.10 pour accéder au point de terminaison de prédiction en ligne via un VPN haute disponibilité.

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

• S'applique à toutes les instances de VM que vous souhaitez rendre accessibles via IAP.
• Autorise le trafic TCP via le port 22 à partir de la plage d'adresses IP 35.235.240.0/20. Contient toutes les adresses IP qu'IAP utilise pour le transfert TCP.

1. Créez l'instance de VM nat-client :

   gcloud compute instances create nat-client \
      --zone=us-central1-a \
      --image-family=debian-11 \
      --image-project=debian-cloud \
      --subnet=nat-subnet \
      --service-account=gce-vertex-sa@$projectid.iam.gserviceaccount.com \
      --scopes=http://www.googleapis.com/auth/cloud-platform \
      --no-address \
      --metadata startup-script="#! /bin/bash
         sudo apt-get update
         sudo apt-get install tcpdump dnsutils -y"
   

2. Créez l'instance de VM private-client :

   gcloud compute instances create private-client \
      --zone=us-central1-a \
      --image-family=debian-11 \
      --image-project=debian-cloud \
      --subnet=private-ip-subnet \
      --service-account=gce-vertex-sa@$projectid.iam.gserviceaccount.com \
      --scopes=http://www.googleapis.com/auth/cloud-platform \
      --no-address \
      --metadata startup-script="#! /bin/bash
         sudo apt-get update
         sudo apt-get install tcpdump dnsutils -y"
   

3. Créez la règle de pare-feu IAP :

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

Créer une instance de notebooks gérés par l'utilisateur

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

Lorsque vous créez une instance de notebooks gérés par l'utilisateur Vertex AI Workbench, Google vous recommande vivement de spécifier un compte de service géré par l'utilisateur au lieu d'utiliser le compte de service Compute Engine par défaut. Le compte de service Compute Engine par défaut (et donc toute personne que vous spécifiez en tant qu'utilisateur d'instance) se voit attribuer le rôle Éditeur (roles/editor) sur votre projet. Vous pouvez désactiver ce comportement en désactivant les attributions automatiques de rôles pour les comptes de service par défaut.

1. Dans Cloud Shell, créez un compte de service nommé user-managed-notebook-sa :

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

2. Attribuez le rôle IAM Administrateur de l'espace de stockage (roles/storage.admin) au compte de service :

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

3. Attribuez le rôle IAM Utilisateur Vertex AI (roles/aiplatform.user) au compte de service :

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

4. Attribuez le rôle IAM Administrateur Artifact Registry au compte de service :

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

Créer l'instance de notebooks gérés par l'utilisateur

Créez une instance de notebooks gérés par l'utilisateur en spécifiant le compte de service user-managed-notebook-sa.

1. Créez l'instance de notebooks gérés par l'utilisateur :

   gcloud notebooks instances create workbench-tutorial \
      --vm-image-project=deeplearning-platform-release \
      --vm-image-family=common-cpu-notebooks \
      --machine-type=n1-standard-4 \
      --location=us-central1-a \
      --subnet-region=us-central1 \
      --subnet=workbench-subnet \
      --no-public-ip \
      --service-account=user-managed-notebook-sa@$projectid.iam.gserviceaccount.com
   

Créer et déployer un modèle de prédiction en ligne

Préparer votre environnement

1. Dans la console Google Cloud, accédez à l'onglet Notebooks gérés par l'utilisateur sur la page Vertex AI Workbench.

   Accéder à la page Notebooks gérés par l'utilisateur

2. À côté du nom de votre instance de notebooks gérés par l'utilisateur, cliquez sur Ouvrir JupyterLab.

   Votre instance de notebooks gérés par l'utilisateur ouvre JupyterLab.

   Dans la suite de cette section, jusqu'au déploiement de modèle inclus, vous allez travailler dans JupyterLab, et non dans la console Google Cloud ou Cloud Shell.

3. Sélectionnez Fichier > Nouveau > Terminal.

4. Dans le terminal JupyterLab (et non dans Cloud Shell), définissez une variable d'environnement pour votre projet. en remplaçant PROJECT_ID par votre ID de projet :

   PROJECT_ID=PROJECT_ID
   

5. Créez un répertoire nommé cpr-codelab et cd dans ce répertoire (toujours dans le terminal JupyterLab) :

   mkdir cpr-codelab
   cd cpr-codelab
   

6. Dans l'explorateur de fichiers folder, double-cliquez sur le nouveau dossier cpr-codelab.

   Si ce dossier n'apparaît pas dans l'explorateur de fichiers, actualisez l'onglet du navigateur de la console Google Cloud, puis réessayez.

7. Sélectionnez Fichier > Nouveau > Notebook.

8. Dans le menu Sélectionner le noyau, sélectionnez Python 3, puis cliquez sur Sélectionner.

9. Renommez le nouveau fichier notebook comme suit :

   Dans l'explorateur de fichiers folder, effectuez un clic droit sur l'icône de fichier Untitled.ipynb, puis saisissez task.ipynb.

   Votre répertoire cpr-codelab devrait se présenter comme suit :

   + cpr-codelab/
      + task.ipynb
   

   Dans les étapes suivantes, vous allez créer votre modèle dans le notebook JupyterLab en créant des cellules de notebook, en y collant du code, puis en exécutant les cellules.

10. Installez les dépendances comme suit.

    1. Lorsque vous ouvrez le nouveau notebook, une cellule de code par défaut vous permet de saisir du code. Elle se présente comme [ ]: suivi d'un champ de texte. Ce champ de texte vous permet de coller votre code.

       Collez le code suivant dans la cellule, puis cliquez sur play_arrow Run the selected cells and advance (Exécuter les cellules sélectionnées et avancer) pour créer un fichier requirements.txt à utiliser en entrée de l'étape suivante :

       %%writefile requirements.txt
       fastapi
       uvicorn==0.17.6
       joblib~=1.1.1
       numpy>=1.17.3, <1.24.0
       scikit-learn~=1.0.0
       pandas
       google-cloud-storage>=2.2.1,<3.0.0dev
       google-cloud-aiplatform[prediction]>=1.18.2
       

    2. À cette étape et à chacune des étapes suivantes, ajoutez une cellule de code en cliquant sur add Insert a cell below (Insérer une cellule ci-dessous), collez le code dans la cellule, puis cliquez sur play_arrow Run the selected cells and advance (Exécuter les cellules sélectionnées et avancer).

       Utilisez Pip pour installer des dépendances dans l'instance de notebooks :

       !pip install -U --user -r requirements.txt
       

    3. Une fois l'installation terminée, sélectionnez Kernel > Restart kernel (Noyau > Redémarrer le noyau) pour redémarrer le noyau et vous assurer que la bibliothèque est disponible pour l'importation.

    4. Collez le code suivant dans une nouvelle cellule de notebook pour créer les répertoires servant à stocker le modèle et prétraiter les artefacts :

       USER_SRC_DIR = "src_dir"
       !mkdir $USER_SRC_DIR
       !mkdir model_artifacts
       # copy the requirements to the source dir
       !cp requirements.txt $USER_SRC_DIR/requirements.txt
       

    Dans l'explorateur de fichiers folder, la structure de votre répertoire cpr-codelab doit maintenant se présenter comme suit :

    + cpr-codelab/
      + model_artifacts/
      + src_dir/
         + requirements.txt
      + requirements.txt
      + task.ipynb
    

Entraîner le modèle

Continuez à ajouter des cellules de code au notebook task.ipynb, puis collez et exécutez le code suivant dans chaque nouvelle cellule :

1. Importez les bibliothèques :

   import seaborn as sns
   import numpy as np
   import pandas as pd
   
   from sklearn import preprocessing
   from sklearn.ensemble import RandomForestRegressor
   from sklearn.pipeline import make_pipeline
   from sklearn.compose import make_column_transformer
   
   import joblib
   import logging
   
   # set logging to see the docker container logs
   logging.basicConfig(level=logging.INFO)
   

2. Définissez les variables suivantes en remplaçant PROJECT_ID par l'ID de votre projet :

   REGION = "us-central1"
   MODEL_ARTIFACT_DIR = "sklearn-model-artifacts"
   REPOSITORY = "diamonds"
   IMAGE = "sklearn-image"
   MODEL_DISPLAY_NAME = "diamonds-cpr"
   PROJECT_ID = "PROJECT_ID"
   BUCKET_NAME = "gs://PROJECT_ID-cpr-bucket"
   

3. Créez un bucket Cloud Storage :

   gsutil mb -l us-central1 $BUCKET_NAME
   

4. Chargez les données depuis la bibliothèque Seaborn, puis créez deux cadres de données, l'un avec les fonctionnalités et l'autre avec l'étiquette :

   data = sns.load_dataset('diamonds', cache=True, data_home=None)
   
   label = 'price'
   
   y_train = data['price']
   x_train = data.drop(columns=['price'])
   

5. Examinez les données d'entraînement et vérifiez que chaque ligne représente un losange.

   x_train.head()
   

6. Examinez les étiquettes, qui sont les prix correspondants.

   y_train.head()
   

7. Définissez une transformation de colonne sklearn pour effectuer un encodage one-hot des caractéristiques catégorielles et ajustez les caractéristiques numériques :

   column_transform = make_column_transformer(
      (preprocessing.OneHotEncoder(sparse=False), [1,2,3]),
      (preprocessing.StandardScaler(), [0,4,5,6,7,8]))
   

8. Définissez le modèle de forêt d'arbres décisionnels :

   regr = RandomForestRegressor(max_depth=10, random_state=0)
   

9. Créez un pipeline sklearn. Ce pipeline prend des données d'entrée, les encode et les met à l'échelle, puis les transmet au modèle.

   my_pipeline = make_pipeline(column_transform, regr)
   

10. Entraîner le modèle

    my_pipeline.fit(x_train, y_train)
    

11. Appelez la méthode de prédiction sur le modèle en transmettant un échantillon de test.

    my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])
    

    Des avertissements tels que "X does not have valid feature names, but" s'affichent, mais vous pouvez les ignorer.

12. Enregistrez le pipeline dans le répertoire model_artifacts et copiez-le dans votre bucket Cloud Storage :

    joblib.dump(my_pipeline, 'model_artifacts/model.joblib')
    
    !gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
    

Enregistrer un artefact de prétraitement

1. Créez un artefact de prétraitement. Cet artefact sera chargé dans le conteneur personnalisé au démarrage du serveur de modèles. Votre artefact de prétraitement peut se présenter sous n'importe quel format, par exemple un fichier pickle, mais dans ce cas, vous allez écrire un dictionnaire dans un fichier JSON :

   clarity_dict={"Flawless": "FL",
      "Internally Flawless": "IF",
      "Very Very Slightly Included": "VVS1",
      "Very Slightly Included": "VS2",
      "Slightly Included": "S12",
      "Included": "I3"}
   

Créer un conteneur de diffusion personnalisé à l'aide du serveur de modèles CPR

1. La caractéristique clarity de nos données d'entraînement était toujours au format abrégé (par exemple, "FL" au lieu de "Flawless"). Au moment de la diffusion, nous voulons vérifier que les données de cette caractéristique sont également abrégées. En effet, notre modèle sait comment effectuer un encodage one-hot de "FL", mais pas de "Flawless". Vous écrirez cette logique de prétraitement personnalisée plus tard. Pour le moment, il vous suffit d'enregistrer cette table de conversion dans un fichier JSON, puis de l'écrire dans votre bucket Cloud Storage :

   import json
   with open("model_artifacts/preprocessor.json", "w") as f:
      json.dump(clarity_dict, f)
   
   !gsutil cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
   

   Dans l'explorateur de fichiers folder, votre structure de répertoires doit maintenant ressembler à ceci :

   + cpr-codelab/
   + model_artifacts/
      + model.joblib
      + preprocessor.json
   + src_dir/
      + requirements.txt
   + requirements.txt
   + task.ipynb
   

2. Dans votre notebook, collez et exécutez le code suivant pour sous-classer le SklearnPredictor et écrivez-le dans un fichier Python dans le src_dir/. Notez que dans cet exemple, nous ne personnalisons que les méthodes de chargement, de prétraitement et de post-traitement, et non la méthode de prédiction.

   %%writefile $USER_SRC_DIR/predictor.py
   
   import joblib
   import numpy as np
   import json
   
   from google.cloud import storage
   from google.cloud.aiplatform.prediction.sklearn.predictor import SklearnPredictor
   
   class CprPredictor(SklearnPredictor):
   
    def __init__(self):
        return
   
    def load(self, artifacts_uri: str) -> None:
        """Loads the sklearn pipeline and preprocessing artifact."""
   
        super().load(artifacts_uri)
   
        # open preprocessing artifact
        with open("preprocessor.json", "rb") as f:
            self._preprocessor = json.load(f)
   
    def preprocess(self, prediction_input: np.ndarray) -> np.ndarray:
        """Performs preprocessing by checking if clarity feature is in abbreviated form."""
   
        inputs = super().preprocess(prediction_input)
   
        for sample in inputs:
            if sample[3] not in self._preprocessor.values():
                sample[3] = self._preprocessor[sample[3]]
        return inputs
   
    def postprocess(self, prediction_results: np.ndarray) -> dict:
        """Performs postprocessing by rounding predictions and converting to str."""
   
        return {"predictions": [f"${value}" for value in np.round(prediction_results)]}
   

3. Utilisez le SDK Vertex AI pour Python pour créer l'image à l'aide de routines de prédiction personnalisées. Le fichier Dockerfile est généré et une image est créée automatiquement.

   from google.cloud import aiplatform
   
   aiplatform.init(project=PROJECT_ID, location=REGION)
   
   import os
   
   from google.cloud.aiplatform.prediction import LocalModel
   
   from src_dir.predictor import CprPredictor  # Should be path of variable $USER_SRC_DIR
   
   local_model = LocalModel.build_cpr_model(
      USER_SRC_DIR,
      f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}",
      predictor=CprPredictor,
      requirements_path=os.path.join(USER_SRC_DIR, "requirements.txt"),
   )
   

4. Écrivez un fichier de test avec deux exemples de prédiction. L'une des instances porte le nom abrégé, mais l'autre doit d'abord être convertie.

   import json
   
   sample = {"instances": [
      [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
      [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
   
   with open('instances.json', 'w') as fp:
      json.dump(sample, fp)
   

5. Testez le conteneur localement en déployant un modèle local.

   with local_model.deploy_to_local_endpoint(
      artifact_uri = 'model_artifacts/', # local path to artifacts
   ) as local_endpoint:
      predict_response = local_endpoint.predict(
         request_file='instances.json',
         headers={"Content-Type": "application/json"},
      )
   
      health_check_response = local_endpoint.run_health_check()
   

6. Vous pouvez afficher les résultats de la prédiction avec :

   predict_response.content
   

Déployer le modèle sur le point de terminaison du modèle de prédiction en ligne

Maintenant que vous avez testé le conteneur localement, il est temps de transférer l'image vers Artifact Registry et d'importer le modèle dans Vertex AI Model Registry.

1. Configurer Docker pour accéder à Artifact Registry

   !gcloud artifacts repositories create {REPOSITORY} --repository-format=docker \
   --location=us-central1 --description="Docker repository"
   
   !gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet
   

2. Transférez l'image.

   local_model.push_image()
   

3. Importez le modèle.

   model = aiplatform.Model.upload(local_model = local_model,
                                   display_name=MODEL_DISPLAY_NAME,
                                   artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)
   

4. Déployez le modèle :

   endpoint = model.deploy(machine_type="n1-standard-2")
   

   Attendez que votre modèle soit déployé avant de passer à l'étape suivante. Le déploiement prend au moins 10 à 15 minutes.

5. Testez le modèle déployé en obtenant une prédiction :

   endpoint.predict(instances=[[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43]])
   

Valider l'accès Internet public aux API Vertex AI

Dans cette section, vous vous connectez à l'instance de VM nat-client dans un onglet de session Cloud Shell, puis utilisez un autre onglet de session pour valider la connectivité aux API Vertex AI en exécutant la commande dig et tcpdump sur le domaine us-central1-aiplatform.googleapis.com.

1. Dans Cloud Shell (onglet 1), exécutez les commandes suivantes, en remplaçant PROJECT_ID par votre ID de projet :

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Connectez-vous à l'instance de VM nat-client à l'aide d'IAP :

   gcloud compute ssh nat-client --project=$projectid --zone=us-central1-a --tunnel-through-iap
   

3. Exécutez la commande dig :

   dig us-central1-aiplatform.googleapis.com
   

4. Depuis la VM nat-client (onglet 1), exécutez la commande suivante pour valider la résolution DNS lorsque vous envoyez une requête de prédiction en ligne au point de terminaison.

    sudo tcpdump -i any port 53 -n
   

5. Ouvrez une nouvelle session Cloud Shell (onglet 2) en cliquant sur add ouvrir un nouvel onglet dans Cloud Shell.

6. Dans la nouvelle session Cloud Shell (onglet 2), exécutez les commandes suivantes, en remplaçant PROJECT_ID par votre ID de projet :

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

7. Connectez-vous à l'instance de VM nat-client :

   gcloud compute ssh --zone "us-central1-a" "nat-client" --project "$projectid"
   

8. Depuis la VM nat-client (onglet 2), utilisez un éditeur de texte tel que vim ou nano pour créer un fichier instances.json. Vous devez ajouter sudo pour pouvoir écrire dans le fichier, par exemple :

   sudo vim instances.json
   

9. Ajoutez la chaîne de données suivante au fichier :

   {"instances": [
      [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
      [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
   

10. Enregistrez le fichier comme suit :

    • Si vous utilisez vim, appuyez sur la touche Esc, puis saisissez :wq pour enregistrer le fichier et quitter.
    • Si vous utilisez nano, saisissez Control+O et appuyez sur Enter pour enregistrer le fichier, puis saisissez Control+X pour quitter.

11. Recherchez l'ID de point de terminaison de prédiction en ligne pour le point de terminaison PSC :

    1. Dans la console Google Cloud, dans la section Vertex AI, accédez à l'onglet Points de terminaison de la page Prédiction en ligne.

       Accéder à Endpoints

    2. Recherchez la ligne du point de terminaison que vous avez créé, nommée diamonds-cpr_endpoint.

    3. Recherchez l'ID du point de terminaison à 19 chiffres dans la colonne ID et copiez-le.

12. Dans Cloud Shell, à partir de la VM nat-client (onglet 2), exécutez les commandes suivantes, en remplaçant PROJECT_ID par l'ID de votre projet et ENDPOINT_ID par l'ID de point de terminaison PSC :

    projectid=PROJECT_ID
    gcloud config set project ${projectid}
    ENDPOINT_ID=ENDPOINT_ID
    

13. Depuis la VM nat-client (onglet 2), exécutez la commande suivante pour envoyer une requête de prédiction en ligne :

    curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" http://us-central1-aiplatform.googleapis.com/v1/projects/${projectid}/locations/us-central1/endpoints/${ENDPOINT_ID}:predict -d @instances.json
    

Maintenant que vous avez exécuté la prédiction, vous constatez que les résultats tcpdump (onglet 1) montrent l'instance de VM nat-client (192.168.10.2) en train d'exécuter une requête Cloud DNS sur le serveur DNS local (169.254.169.254) pour le domaine API Vertex AI (us-central1-aiplatform.googleapis.com). La requête DNS renvoie les adresses IP virtuelles publiques (VIP) pour les API Vertex AI.

Valider l'accès privé aux API Vertex AI

Dans cette section, vous vous connectez à l'instance de VM private-client à l'aide d'Identity-Aware Proxy dans une nouvelle session Cloud Shell (onglet 3), puis vous validez la connectivité aux API Vertex AI en exécutant la commande suivante dig sur le domaine Vertex AI (us-central1-aiplatform.googleapis.com).

1. Ouvrez une nouvelle session Cloud Shell (onglet 3) en cliquant sur add Ouvrir un nouvel onglet dans Cloud Shell. Il s'agit de l'onglet 3.

2. Dans la nouvelle session Cloud Shell (onglet 3), exécutez les commandes suivantes, en remplaçant PROJECT_ID par l'ID de votre projet :

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

3. Connectez-vous à l'instance de VM private-client à l'aide d'IAP :

   gcloud compute ssh private-client --project=$projectid --zone=us-central1-a --tunnel-through-iap
   

4. Exécutez la commande dig :

   dig us-central1-aiplatform.googleapis.com
   

5. Dans l'instance de VM private-client (onglet 3), utilisez un éditeur de texte tel que vim ou nano pour ajouter la ligne suivante au fichier /etc/hosts :

   100.100.10.10 us-central1-aiplatform.googleapis.com
   

   Cette ligne attribue l'adresse IP du point de terminaison PSC (100.100.10.10) au nom de domaine complet de l'API Google Vertex AI (us-central1-aiplatform.googleapis.com). Le fichier modifié doit se présenter comme suit :

   127.0.0.1       localhost
   ::1             localhost ip6-localhost ip6-loopback
   ff02::1         ip6-allnodes
   ff02::2         ip6-allrouters
   
   100.100.10.10 us-central1-aiplatform.googleapis.com # Added by you
   192.168.20.2 private-client.c.$projectid.internal private-client  # Added by Google
   169.254.169.254 metadata.google.internal  # Added by Google
   

6. Depuis la VM private-client (onglet 3), pinguez le point de terminaison Vertex AI et Control+C pour quitter lorsque le résultat s'affiche :

   ping us-central1-aiplatform.googleapis.com
   

   La commande ping doit renvoyer le résultat suivant contenant l'adresse IP du point de terminaison PSC :

   PING us-central1-aiplatform.googleapis.com (100.100.10.10) 56(84) bytes of data.
   

7. Depuis la VM private-client (onglet 3), utilisez tcpdump pour exécuter la commande suivante afin de valider la résolution DNS et le chemin d'accès aux données IP lorsque vous envoyez une requête de prédiction en ligne au point de terminaison :

    sudo tcpdump -i any port 53 -n or host 100.100.10.10
   

8. Ouvrez une nouvelle session Cloud Shell (onglet 4) en cliquant sur add Ouvrir un nouvel onglet dans Cloud Shell.

9. Dans la nouvelle session Cloud Shell (onglet 4), exécutez les commandes suivantes en remplaçant PROJECT_ID par l'ID de votre projet :

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

10. Dans l'onglet 4, connectez-vous à l'instance private-client :

    gcloud compute ssh --zone "us-central1-a" "private-client" --project "$projectid"
    

11. Depuis la VM private-client (onglet 4), à l'aide d'un éditeur de texte tel que vim ou nano, créez un fichier instances.json contenant la chaîne de données suivante :

    {"instances": [
       [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
       [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
    

12. Depuis la VM private-client (onglet 4), exécutez les commandes suivantes, en remplaçant PROJECT_ID par le nom de votre projet et ENDPOINT_ID par l'ID de point de terminaison PSC :

    projectid=PROJECT_ID
    echo $projectid
    ENDPOINT_ID=ENDPOINT_ID
    

13. Depuis la VM private-client (onglet 4), exécutez la commande suivante pour envoyer une requête de prédiction en ligne :

    curl -v -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" http://us-central1-aiplatform.googleapis.com/v1/projects/${projectid}/locations/us-central1/endpoints/${ENDPOINT_ID}:predict -d @instances.json
    

14. Depuis la VM private-client dans Cloud Shell (onglet 3), vérifiez que l'adresse IP du point de terminaison PSC (100.100.10.10) a été utilisée pour accéder aux API Vertex AI.

    Depuis le terminal private-client tcpdump dans Cloud Shell (onglet 3), vous constatez qu'une résolution DNS vers us-central1-aiplatform.googleapis.com n'est pas nécessaire, car la ligne que vous avez ajoutée à /etc/hosts est prioritaire, et l'adresse IP PSC 100.100.10.10 est utilisée dans le chemin d'accès aux données.