Utiliser Private Service Connect pour accéder à des pipelines d'entraînement à partir d'un environnement sur site

Vertex AI Pipelines est un service géré qui vous aide à créer, déployer et gérer des workflows de machine learning (ML) de bout en bout sur Google Cloud Platform. Il fournit un environnement sans serveur pour exécuter vos pipelines. Vous n'avez donc pas à vous soucier de la gestion de l'infrastructure.

Dans ce tutoriel, vous allez utiliser Vertex AI Pipelines pour exécuter un job d'entraînement personnalisé et déployer le modèle entraîné dans Vertex AI, dans un environnement réseau hybride.

L'ensemble du processus prend deux à trois heures, dont environ 50 minutes pour l'exécution du pipeline.

Ce tutoriel est destiné aux administrateurs réseau d'entreprise, aux data scientists et aux chercheurs qui connaissent déjà Vertex AI, le cloud privé virtuel (VPC), la console Google Cloud et Cloud Shell. Une connaissance de Vertex AI Workbench est utile, mais pas obligatoire.

Objectifs

• Créez deux réseaux de cloud privé virtuel (VPC) :
  • L'un (vertex-networking-vpc) consiste à utiliser l'API Vertex AI Pipelines pour créer et héberger un modèle de pipeline permettant d'entraîner un modèle de machine learning et de le déployer sur un point de terminaison.
  • L'autre (onprem-dataservice-vpc) représente un réseau sur site.
• Connectez les deux réseaux VPC comme suit :
  • Déployer des passerelles VPN haute disponibilité, des tunnels Cloud VPN et des routeurs Cloud Router pour connecter vertex-networking-vpc et onprem-dataservice-vpc.
  • Créer un point de terminaison Private Service Connect (PSC) pour transférer des requêtes privées vers l'API REST de Vertex AI Pipelines
  • Configurer une annonce de routage personnalisée Cloud Router dans vertex-networking-vpc pour annoncer les routes du point de terminaison Private Service Connect à onprem-dataservice-vpc.
• Créez une instance Filestore dans le réseau VPC onprem-dataservice-vpc et ajoutez-y des données d'entraînement dans un partage NFS.
• Créez une application de package Python pour le job d'entraînement.
• Créez un modèle de job Vertex AI Pipelines pour effectuer les opérations suivantes :
  • Créez et exécutez le job d'entraînement sur les données du partage NFS.
  • Importez le modèle entraîné et transférez-le vers Vertex AI Model Registry.
  • Créez un point de terminaison Vertex AI pour les prédictions en ligne.
  • Déployez le modèle sur le point de terminaison.
• Importez le modèle de pipeline dans un dépôt Artifact Registry.
• Utilisez l'API REST Vertex AI Pipelines pour déclencher l'exécution d'un pipeline à partir d'un hôte de service de données sur site (on-prem-dataservice-host).

Coûts

Dans ce document, vous utilisez les composants facturables de Google Cloudsuivants :

• Cloud NAT
• Cloud Storage
• Cloud VPN
• Compute Engine
• Filestore
• Vertex AI
• Virtual Private Cloud

Vous pouvez obtenir une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais.

Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

1. In the Google Cloud console, go to the project selector page.

   Go to project selector

2. Select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

3. Verify that billing is enabled for your Google Cloud project.

4. Ouvrez Cloud Shell pour exécuter les commandes répertoriées dans ce tutoriel. Cloud Shell est un environnement shell interactif pour Google Cloud qui vous permet de gérer vos projets et vos ressources depuis un navigateur Web.
5. Dans Cloud Shell, définissez le projet actuel sur votre ID de projet Google Cloud , puis stockez le même ID de projet dans la variable de shell projectid :

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

   Remplacez PROJECT_ID par l'ID de votre projet. Si nécessaire, vous pouvez trouver l'ID de votre projet dans la console Google Cloud . Pour en savoir plus, consultez Trouver votre ID de projet.
6. Si vous n'êtes pas le propriétaire du projet, demandez-lui de vous accorder le rôle Administrateur de projet IAM (roles/resourcemanager.projectIamAdmin). Vous devez disposer de ce rôle pour attribuer des rôles IAM à l'étape suivante.

7. Make sure that you have the following role or roles on the project: roles/artifactregistry.admin, roles/artifactregistry.repoAdmin, roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/file.editor, roles/logging.viewer, roles/logging.admin, roles/notebooks.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/servicedirectory.editor, roles/servicemanagement.quotaAdmin, roles/serviceusage.serviceUsageAdmin, roles/storage.admin, roles/storage.objectAdmin, roles/aiplatform.admin, roles/aiplatform.user, roles/aiplatform.viewer, roles/iap.admin, roles/iap.tunnelResourceAccessor, roles/resourcemanager.projectIamAdmin

   Check for the roles

   1. In the Google Cloud console, go to the IAM page.

      Go to IAM
   2. Select the project.

   3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

   4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

   Grant the roles

   1. In the Google Cloud console, go to the IAM page.

      Accéder à IAM
   2. Sélectionnez le projet.
   3. Cliquez sur  Accorder l'accès.

   4. Dans le champ Nouveaux comptes principaux, saisissez votre identifiant utilisateur. Il s'agit généralement de l'adresse e-mail d'un compte Google.

   5. Dans la liste Sélectionner un rôle, sélectionnez un rôle.
   6. Pour attribuer des rôles supplémentaires, cliquez sur  Ajouter un autre rôle et ajoutez tous les rôles supplémentaires.
   7. Cliquez sur Enregistrer.

8. Enable the DNS, Artifact Registry, IAM, Compute Engine, Cloud Logging, Network Connectivity, Notebooks, Cloud Filestore, Service Networking, Service Usage, and Vertex AI APIs.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the APIs

Créer les réseaux VPC

Dans cette section, vous allez créer deux réseaux VPC : l'un pour accéder aux API Google pour Vertex AI Pipelines, et l'autre pour simuler un réseau sur site. 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.

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

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Créer le réseau VPC vertex-networking-vpc :

   gcloud compute networks create vertex-networking-vpc \
       --subnet-mode custom
   

3. Dans le réseau vertex-networking-vpc, créez un sous-réseau nommé pipeline-networking-subnet1, avec 10.0.0.0/24 comme plage d'adresses IPv4 principale :

   gcloud compute networks subnets create pipeline-networking-subnet1 \
       --range=10.0.0.0/24 \
       --network=vertex-networking-vpc \
       --region=us-central1 \
       --enable-private-ip-google-access
   

4. Créez le réseau VPC pour simuler le réseau sur site (onprem-dataservice-vpc) :

   gcloud compute networks create onprem-dataservice-vpc \
       --subnet-mode custom
   

5. Dans le réseau onprem-dataservice-vpc, créez un sous-réseau nommé onprem-dataservice-vpc-subnet1, avec 172.16.10.0/24 comme plage d'adresses IPv4 principale :

   gcloud compute networks subnets create onprem-dataservice-vpc-subnet1 \
       --network onprem-dataservice-vpc \
       --range 172.16.10.0/24 \
       --region us-central1 \
       --enable-private-ip-google-access
   

Vérifier que les réseaux VPC sont correctement configurés

1. Dans la console Google Cloud , accédez à l'onglet Réseaux du projet en cours sur la page Réseaux VPC.

   Accéder aux réseaux VPC

2. Dans la liste des réseaux VPC, vérifiez que les deux réseaux ont été créés : vertex-networking-vpc et onprem-dataservice-vpc.

3. Cliquez sur l'onglet Sous-réseaux dans le projet actuel.

4. Dans la liste des sous-réseaux VPC, vérifiez que les sous-réseaux pipeline-networking-subnet1 et onprem-dataservice-vpc-subnet1 ont été créés.

Configurer la connectivité hybride

Dans cette section, vous allez créer deux passerelles VPN haute disponibilité connectées l'une à l'autre. L'une réside dans le réseau VPC vertex-networking-vpc. L'autre réside dans le réseau VPC onprem-dataservice-vpc. Chaque passerelle contient un routeur Cloud Router et une paire de tunnels VPN.

Créer des passerelles VPN haute disponibilité

1. Dans Cloud Shell, créez la passerelle VPN haute disponibilité pour le réseau VPC vertex-networking-vpc :

   gcloud compute vpn-gateways create vertex-networking-vpn-gw1 \
       --network vertex-networking-vpc \
       --region us-central1
   

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

   gcloud compute vpn-gateways create onprem-vpn-gw1 \
       --network onprem-dataservice-vpc \
       --region us-central1
   

3. Dans la console Google Cloud , accédez à l'onglet Passerelles Cloud VPN sur la page VPN.

   Accéder au VPN

4. Vérifiez que les deux passerelles (vertex-networking-vpn-gw1 et onprem-vpn-gw1) ont été créées et que chacune dispose de deux adresses IP d'interface.

Créer des routeurs Cloud et des passerelles Cloud NAT

Dans chacun des deux réseaux VPC, vous créez deux routeurs Cloud Router : un à utiliser avec Cloud NAT et un autre pour gérer les sessions BGP du VPN haute disponibilité.

1. Dans Cloud Shell, créez un routeur Cloud Router pour le réseau VPC vertex-networking-vpc qui sera utilisé pour le VPN :

   gcloud compute routers create vertex-networking-vpc-router1 \
       --region us-central1 \
       --network vertex-networking-vpc \
       --asn 65001
   

2. Créez un routeur Cloud Router pour le réseau VPC onprem-dataservice-vpc qui sera utilisé pour le VPN :

   gcloud compute routers create onprem-dataservice-vpc-router1 \
       --region us-central1 \
       --network onprem-dataservice-vpc \
       --asn 65002
   

3. Créez un routeur Cloud Router pour le réseau VPC vertex-networking-vpc qui sera utilisé pour Cloud NAT :

   gcloud compute routers create cloud-router-us-central1-vertex-nat \
       --network vertex-networking-vpc \
       --region us-central1
   

4. Configurez une passerelle Cloud NAT sur le routeur Cloud Router :

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

5. Créez un routeur Cloud Router pour le réseau VPC onprem-dataservice-vpc qui sera utilisé pour Cloud NAT :

   gcloud compute routers create cloud-router-us-central1-onprem-nat \
       --network onprem-dataservice-vpc \
       --region us-central1
   

6. Configurez une passerelle Cloud NAT sur le routeur Cloud Router :

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

7. Dans la console Google Cloud , accédez à la page Routeurs cloud.

   Accéder aux routeurs cloud

8. Dans la liste des routeurs cloud, vérifiez que les routeurs suivants ont été créés:

   • cloud-router-us-central1-onprem-nat
   • cloud-router-us-central1-vertex-nat
   • onprem-dataservice-vpc-router1
   • vertex-networking-vpc-router1

   Vous devrez peut-être actualiser l'onglet du navigateur de la console Google Cloud pour afficher les nouvelles valeurs.

9. Dans la liste des routeurs Cloud Router, cliquez sur cloud-router-us-central1-vertex-nat.

10. Sur la page Détails du routeur, vérifiez que la passerelle Cloud NAT cloud-nat-us-central1 a été créée.

11. Cliquez sur la flèche de retour pour revenir à la page Routeurs cloud.

12. Dans la liste des routeurs Cloud Router, cliquez sur cloud-router-us-central1-onprem-nat.

13. Sur la page Détails du routeur, vérifiez que la passerelle Cloud NAT cloud-nat-us-central1-on-prem a été créée.

Créer des tunnels VPN

1. Dans Cloud Shell, dans le réseau vertex-networking-vpc, créez un tunnel VPN appelé vertex-networking-vpc-tunnel0:

   gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel0 \
       --peer-gcp-gateway onprem-vpn-gw1 \
       --region us-central1 \
       --ike-version 2 \
       --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
       --router vertex-networking-vpc-router1 \
       --vpn-gateway vertex-networking-vpn-gw1 \
       --interface 0
   

2. Dans le réseau vertex-networking-vpc, créez un tunnel VPN appelé vertex-networking-vpc-tunnel1 :

   gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel1 \
       --peer-gcp-gateway onprem-vpn-gw1 \
       --region us-central1 \
       --ike-version 2 \
       --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
       --router vertex-networking-vpc-router1 \
       --vpn-gateway vertex-networking-vpn-gw1 \
       --interface 1
   

3. Dans le réseau onprem-dataservice-vpc, créez un tunnel VPN appelé onprem-dataservice-vpc-tunnel0 :

   gcloud compute vpn-tunnels create onprem-dataservice-vpc-tunnel0 \
       --peer-gcp-gateway vertex-networking-vpn-gw1 \
       --region us-central1\
       --ike-version 2 \
       --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
       --router onprem-dataservice-vpc-router1 \
       --vpn-gateway onprem-vpn-gw1 \
       --interface 0
   

4. Dans le réseau onprem-dataservice-vpc, créez un tunnel VPN appelé onprem-dataservice-vpc-tunnel1 :

   gcloud compute vpn-tunnels create onprem-dataservice-vpc-tunnel1 \
       --peer-gcp-gateway vertex-networking-vpn-gw1 \
       --region us-central1\
       --ike-version 2 \
       --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
       --router onprem-dataservice-vpc-router1 \
       --vpn-gateway onprem-vpn-gw1 \
       --interface 1
   

5. Dans la console Google Cloud , accédez à la page VPN.

   Accéder au VPN

6. Dans la liste des tunnels VPN, vérifiez que les quatre tunnels VPN ont été créés.

É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, vertex-networking-vpc) et votre réseau sur site (représenté par onprem-dataservice-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 vertex-networking-vpc et deux pour onprem-dataservice-vpc.

Une fois que vous avez configuré les interfaces et les pairs BGP entre vos routeurs, ils commencent automatiquement à échanger des routes.

Établir des sessions BGP pour vertex-networking-vpc

1. Dans Cloud Shell, dans le réseau vertex-networking-vpc, créez une interface BGP pour vertex-networking-vpc-tunnel0 :

   gcloud compute routers add-interface vertex-networking-vpc-router1 \
       --interface-name if-tunnel0-to-onprem \
       --ip-address 169.254.0.1 \
       --mask-length 30 \
       --vpn-tunnel vertex-networking-vpc-tunnel0 \
       --region us-central1
   

2. Dans le réseau vertex-networking-vpc, créez un pair BGP pour bgp-onprem-tunnel0 :

   gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
       --peer-name bgp-onprem-tunnel0 \
       --interface if-tunnel0-to-onprem \
       --peer-ip-address 169.254.0.2 \
       --peer-asn 65002 \
       --region us-central1
   

3. Dans le réseau vertex-networking-vpc, créez une interface BGP pour vertex-networking-vpc-tunnel1 :

   gcloud compute routers add-interface vertex-networking-vpc-router1 \
       --interface-name if-tunnel1-to-onprem \
       --ip-address 169.254.1.1 \
       --mask-length 30 \
       --vpn-tunnel vertex-networking-vpc-tunnel1 \
       --region us-central1
   

4. Dans le réseau vertex-networking-vpc, créez un pair BGP pour bgp-onprem-tunnel1 :

   gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
       --peer-name bgp-onprem-tunnel1 \
       --interface if-tunnel1-to-onprem \
       --peer-ip-address 169.254.1.2 \
       --peer-asn 65002 \
       --region us-central1
   

Établir des sessions BGP pour onprem-dataservice-vpc

1. Dans le réseau onprem-dataservice-vpc, créez une interface BGP pour onprem-dataservice-vpc-tunnel0 :

   gcloud compute routers add-interface onprem-dataservice-vpc-router1 \
       --interface-name if-tunnel0-to-vertex-networking-vpc \
       --ip-address 169.254.0.2 \
       --mask-length 30 \
       --vpn-tunnel onprem-dataservice-vpc-tunnel0 \
       --region us-central1
   

2. Dans le réseau onprem-dataservice-vpc, créez un pair BGP pour bgp-vertex-networking-vpc-tunnel0 :

   gcloud compute routers add-bgp-peer onprem-dataservice-vpc-router1 \
       --peer-name bgp-vertex-networking-vpc-tunnel0 \
       --interface if-tunnel0-to-vertex-networking-vpc \
       --peer-ip-address 169.254.0.1 \
       --peer-asn 65001 \
       --region us-central1
   

3. Dans le réseau onprem-dataservice-vpc, créez une interface BGP pour onprem-dataservice-vpc-tunnel1 :

   gcloud compute routers add-interface onprem-dataservice-vpc-router1  \
       --interface-name if-tunnel1-to-vertex-networking-vpc \
       --ip-address 169.254.1.2 \
       --mask-length 30 \
       --vpn-tunnel onprem-dataservice-vpc-tunnel1 \
       --region us-central1
   

4. Dans le réseau onprem-dataservice-vpc, créez un pair BGP pour bgp-vertex-networking-vpc-tunnel1 :

   gcloud compute routers add-bgp-peer onprem-dataservice-vpc-router1 \
       --peer-name bgp-vertex-networking-vpc-tunnel1 \
       --interface if-tunnel1-to-vertex-networking-vpc \
       --peer-ip-address 169.254.1.1 \
       --peer-asn 65001 \
       --region us-central1
   

Valider la création de la session BGP

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

   Accéder au VPN

2. Dans la liste des tunnels VPN, vérifiez que la valeur du champ État de la session BGP pour chacun des tunnels est passée de Configurer la session BGP à BGP établi. Vous devrez peut-être actualiser l'onglet du navigateur de la console Google Cloud pour afficher les nouvelles valeurs.

Valider les routes apprises onprem-dataservice-vpc

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

   Accéder aux réseaux VPC

2. Dans la liste des réseaux VPC, cliquez sur onprem-dataservice-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 la plage d'adresses IP du sous-réseau pipeline-networking-subnet1 (10.0.0.0/24) apparaît deux fois.

   Vous devrez peut-être actualiser l'onglet du navigateur de la console Google Cloud pour afficher les deux entrées.

Valider les routes apprises vertex-networking-vpc

1. Cliquez sur la flèche de retour pour revenir à la page Réseaux VPC.

2. Dans la liste des réseaux VPC, cliquez sur vertex-networking-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 la plage d'adresses IP du sous-réseau onprem-dataservice-vpc-subnet1 (172.16.10.0/24) apparaît deux fois.

Créer un point de terminaison Private Service Connect pour les API Google

Dans cette section, vous allez créer un point de terminaison Private Service Connect pour les API Google que vous utiliserez pour accéder à l'API REST Vertex AI Pipelines depuis votre réseau sur site.

1. Dans Cloud Shell, réservez une adresse IP de point de terminaison client qui servira à accéder aux API Google:

   gcloud compute addresses create psc-googleapi-ip \
       --global \
       --purpose=PRIVATE_SERVICE_CONNECT \
       --addresses=192.168.0.1 \
       --network=vertex-networking-vpc
   

2. Créez une règle de transfert pour connecter le point de terminaison aux API et services Google.

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

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

Dans cette section, vous allez créer une annonce de routage personnalisée pour vertex-networking-vpc-router1 (le routeur Cloud Router pour vertex-networking-vpc) afin d'annoncer l'adresse IP du point de terminaison PSC au réseau VPC onprem-dataservice-vpc.

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

   Accéder aux routeurs cloud

2. Dans la liste des routeurs Cloud Router, cliquez sur vertex-networking-vpc-router1.

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

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

5. Sélectionnez Diffuser tous les sous-réseaux visibles par Cloud Router pour continuer à annoncer les sous-réseaux disponibles pour le routeur cloud. Cette option imite le comportement de Cloud Router en mode d'annonce par défaut.

6. Cliquez sur Ajouter une route personnalisée.

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

8. Dans le champ Plage d'adresses IP, saisissez l'adresse IP suivante :

   192.168.0.1
   

9. Dans le champ Description, saisissez le texte suivant :

   Custom route to advertise Private Service Connect endpoint IP address
   

10. Cliquez sur OK, puis sur Enregistrer.

Vérifier que onprem-dataservice-vpc a appris les routes annoncées

1. Dans la console Google Cloud , accédez à la page Routes.

   Accéder à la page Routes

2. Dans l'onglet Routes effectives, procédez comme suit :

   1. Pour Réseau, choisissez onprem-dataservice-vpc.
   2. Dans le champ Région, choisissez us-central1 (Iowa).
   3. Cliquez sur Afficher.

   4. Dans la liste des routes, vérifiez qu'il existe deux entrées dont le nom commence par onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel0 et deux entrées dont le nom commenc par onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel1.

      Si ces entrées n'apparaissent pas immédiatement, attendez quelques minutes, puis actualisez l'onglet de navigateur de la console Google Cloud .

   5. Vérifiez que deux des entrées ont une plage d'adresses IP de destination de 192.168.0.1/32 et que deux entrées ont une plage d'adresses IP de destination de 10.0.0.0/24.

Créer une instance de VM dans onprem-dataservice-vpc

Dans cette section, vous allez créer une instance de VM qui simule un hôte de service de données sur site. En appliquant les bonnes pratiques de Compute Engine et d'IAM, cette VM utilise un compte de service géré par l'utilisateur au lieu du compte de service par défaut de Compute Engine.

Créez le compte de service géré par l'utilisateur pour l'instance de VM.

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

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Créez un compte de service nommé onprem-user-managed-sa :

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

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

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

4. Attribuez le rôle Lecteur Vertex AI (roles/aiplatform.viewer) :

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

5. Attribuez le rôle Filestore Editor (roles/file.editor) :

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

6. Attribuez le rôle Administrateur du compte de service (roles/iam.serviceAccountAdmin) :

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

7. Attribuez le rôle Utilisateur du compte de serviceroles/iam.serviceAccountUser () :

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

8. Attribuez le rôle Lecteur Artifact Registry (roles/artifactregistry.reader) :

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

9. Attribuez le rôle Administrateur des objets de l'espace de stockageroles/storage.objectAdmin () :

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

10. Attribuez le rôle Administrateur Logging (roles/logging.admin) :

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

Créer l'instance de VM on-prem-dataservice-host

L'instance de VM que vous créez ne possède pas d'adresse IP externe et n'autorise pas l'accès direct sur Internet. Pour activer l'accès administrateur à la VM, vous utilisez le transfert TCP d'Identity-Aware Proxy (IAP).

1. Dans Cloud Shell, créez l'instance de VM on-prem-dataservice-host:

   gcloud compute instances create on-prem-dataservice-host \
       --zone=us-central1-a \
       --image-family=debian-11 \
       --image-project=debian-cloud \
       --subnet=onprem-dataservice-vpc-subnet1 \
       --scopes=https://www.googleapis.com/auth/cloud-platform \
       --no-address \
       --shielded-secure-boot \
       --service-account=onprem-user-managed-sa@$projectid.iam.gserviceaccount.com \
       --metadata startup-script="#! /bin/bash
   sudo apt-get update
   sudo apt-get install tcpdump dnsutils -y"
   
   

2. Créez une règle de pare-feu pour autoriser IAP à se connecter à votre instance de VM:

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

Mettre à jour le fichier /etc/hosts pour qu'il pointe vers le point de terminaison PSC

Au cours de cette étape, vous allez ajouter une ligne au fichier /etc/hosts qui entraîne la redirection des requêtes envoyées au point de terminaison du service public (us-central1-aiplatform.googleapis.com) vers le point de terminaison PSC (192.168.0.1).

1. Dans Cloud Shell, connectez-vous à l'instance de VM on-prem-dataservice-host à l'aide d'IAP:

   gcloud compute ssh on-prem-dataservice-host \
     --zone=us-central1-a \
     --tunnel-through-iap
   

2. Dans l'instance de VM on-prem-dataservice-host, utilisez un éditeur de texte tel que vim ou nano pour ouvrir le fichier /etc/hosts, par exemple :

   sudo vim /etc/hosts
   

3. Ajoutez la ligne suivante au fichier :

   192.168.0.1 us-central1-aiplatform.googleapis.com
   

   Cette ligne attribue l'adresse IP du point de terminaison PSC (192.168.0.1) 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
   
   192.168.0.1 us-central1-aiplatform.googleapis.com  # Added by you
   172.16.10.6 on-prem-dataservice-host.us-central1-a.c.PROJECT_ID.internal on-prem-dataservice-host  # Added by Google
   169.254.169.254 metadata.google.internal  # Added by Google
   

4. 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.

5. Pinguez le point de terminaison de l'API Vertex AI comme suit :

   ping us-central1-aiplatform.googleapis.com
   

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

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

6. Saisissez Control+C pour quitter ping.

7. Saisissez exit pour quitter l'instance de VM on-prem-dataservice-host et revenir à l'invite Cloud Shell.

Configurer la mise en réseau pour une instance Filestore

Dans cette section, vous allez activer l'accès aux services privés pour votre réseau VPC, en vue de créer une instance Filestore et de l'installer en tant que partage Network File System (NFS). Pour comprendre ce que vous faites dans cette section et la suivante, consultez les pages Installer un partage NFS pour l'entraînement personnalisé et Configurer l'appairage de réseaux VPC.

Activer l'accès aux services privés sur un réseau VPC

Dans cette section, vous allez créer une connexion Service Networking et l'utiliser pour activer l'accès aux services privés au réseau VPC onprem-dataservice-vpc via l'appairage de réseaux VPC.

1. Dans Cloud Shell, définissez une plage d'adresses IP réservées à l'aide de gcloud compute addresses create :

   gcloud compute addresses create filestore-subnet \
      --global \
      --purpose=VPC_PEERING \
      --addresses=10.243.208.0 \
      --prefix-length=24 \
      --description="filestore subnet" \
      --network=onprem-dataservice-vpc
   

2. Établissez une connexion d'appairage entre le réseau VPC onprem-dataservice-vpc et Service Networking de Google à l'aide de gcloud services vpc-peerings connect :

   gcloud services vpc-peerings connect \
       --service=servicenetworking.googleapis.com \
       --ranges=filestore-subnet \
       --network=onprem-dataservice-vpc
   

3. Mettez à jour l'appairage de réseaux VPC pour activer l'importation et l'exportation des routes apprises personnalisées :

   gcloud compute networks peerings update servicenetworking-googleapis-com \
       --network=onprem-dataservice-vpc \
       --import-custom-routes \
       --export-custom-routes
   

4. Dans la console Google Cloud , accédez à la page Appairage de réseaux VPC.

   Accéder à la page "Appairage de réseaux VPC"

5. Dans la liste des appairages de VPC, vérifiez qu'il existe une entrée pour l'appairage entre servicenetworking.googleapis.com et le réseau VPC onprem-dataservice-vpc.

Créer des annonces de routage personnalisées pour filestore-subnet

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

   Accéder aux routeurs cloud

2. Dans la liste des routeurs Cloud Router, cliquez sur onprem-dataservice-vpc-router1.

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

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

5. Sélectionnez Diffuser tous les sous-réseaux visibles par Cloud Router pour continuer à annoncer les sous-réseaux disponibles pour le routeur cloud. Cette option imite le comportement de Cloud Router en mode d'annonce par défaut.

6. Cliquez sur Ajouter une route personnalisée.

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

8. Dans le champ Plage d'adresses IP, saisissez l'adresse IP suivante :

   10.243.208.0/24
   

9. Dans le champ Description, saisissez le texte suivant :

   Filestore reserved IP address range
   

10. Cliquez sur OK, puis sur Enregistrer.

Créer l'instance Filestore dans le réseau onprem-dataservice-vpc

Après avoir activé l'accès aux services privés pour votre réseau VPC, vous créez une instance Filestore et l'installez en tant que partage NFS pour votre job d'entraînement personnalisée. Vos jobs peuvent ainsi accéder à des fichiers distants comme s'ils étaient locaux, ce qui permet un haut débit et une latence faible.

Créez l'instance Filestore

1. Dans la console Google Cloud , accédez à la page Instances Filestore.

   Accéder aux instances Filestore

2. Cliquez sur Créer une instance et configurez l'instance comme suit :

   • Définissez le paramètre ID d'instance sur la valeur suivante :

     image-data-instance
     

   • Définissez Type d'instance sur De base.

   • Définissez Type de stockage sur HDD.

   • Définissez l'Allocation de la capacité sur 1 TiB.

   • Définissez la région sur us-central1 et la zone sur us-central1-a.

   • Définissez Réseau VPC sur onprem-dataservice-vpc.

   • Définissez Plage d'adresses IP allouée sur Utiliser une plage d'adresses IP allouée existante, puis sélectionnez filestore-subnet.

   • Définissez le nom du partage de fichiers sur :

     vol1
     

   • Définissez Contrôles des accès sur Accorder l'accès à tous les clients sur le réseau VPC.

3. Cliquez sur Créer.

4. Notez l'adresse IP de votre nouvelle instance Filestore. Vous devrez peut-être actualiser l'onglet du navigateur de la console Google Cloud pour afficher la nouvelle instance.

Installer le partage de fichiers Filestore

1. Dans Cloud Shell, 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 on-prem-dataservice-host :

   gcloud compute ssh on-prem-dataservice-host \
       --zone=us-central1-a \
       --tunnel-through-iap
   

3. Installez le package NFS sur l'instance de VM :

   sudo apt-get update -y
   sudo apt-get -y install nfs-common
   

4. Créez un répertoire d'installation pour le partage de fichiers Filestore :

   sudo mkdir -p /mnt/nfs
   

   Remarque : Assurez-vous que le nom du dossier du point d'installation dans /mnt/ est nfs. En effet, le partage de fichiers NFS est installé sous /mnt/nfs/ dans le job d'entraînement personnalisée.

5. Installez le partage de fichiers en remplaçant FILESTORE_INSTANCE_IP par l'adresse IP de votre instance Filestore :

   sudo mount FILESTORE_INSTANCE_IP:/vol1 /mnt/nfs
   

   Si la connexion expire, assurez-vous que vous fournissez l'adresse IP correcte de l'instance Filestore.

6. Vérifiez que l'installation NFS a réussi en exécutant la commande suivante :

   df -h
   

   Vérifiez que le partage de fichiers /mnt/nfs apparaît dans le résultat :

   Filesystem           Size  Used Avail Use% Mounted on
   udev                 1.8G     0  1.8G   0% /dev
   tmpfs                368M  396K  368M   1% /run
   /dev/sda1            9.7G  1.9G  7.3G  21% /
   tmpfs                1.8G     0  1.8G   0% /dev/shm
   tmpfs                5.0M     0  5.0M   0% /run/lock
   /dev/sda15           124M   11M  114M   9% /boot/efi
   tmpfs                368M     0  368M   0% /run/user
   10.243.208.2:/vol1  1007G     0  956G   0% /mnt/nfs
   

7. Rendez le partage de fichiers accessible en modifiant les autorisations :

   sudo chmod go+rw /mnt/nfs
   

   Remarque : Dans un environnement de production, nous vous recommandons de définir des autorisations plus précises. Pour plus d'informations, consultez la section Configurer l'accès sur un partage de fichiers.

Télécharger l'ensemble de données sur le partage de fichiers

1. Dans l'instance de VM on-prem-dataservice-host, téléchargez l'ensemble de données sur le partage de fichiers :

   gcloud storage cp gs://cloud-samples-data/vertex-ai/dataset-management/datasets/fungi_dataset /mnt/nfs/ --recursive
   

   Le téléchargement prend plusieurs minutes.

2. Pour vérifier que l'ensemble de données a bien été copié, exécutez la commande suivante :

   sudo du -sh /mnt/nfs
   

   Le résultat attendu est :

   104M    /mnt/nfs
   

3. Saisissez exit pour quitter l'instance de VM on-prem-dataservice-host et revenir à l'invite Cloud Shell.

Créer un bucket de préproduction pour votre pipeline

Vertex AI Pipelines stocke les artefacts des exécutions de votre pipeline à l'aide de Cloud Storage. Avant d'exécuter le pipeline, vous devez créer un bucket Cloud Storage pour les exécutions de pipeline de préproduction.

Dans Cloud Shell, créez un bucket Cloud Storage.

gcloud storage buckets create gs://pipelines-staging-bucket-$projectid --location=us-central1

Créer un compte de service géré par l'utilisateur pour Vertex AI Workbench

1. Dans Cloud Shell, créez un compte de service à l'aide des commandes suivantes :

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

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

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

3. Attribuez le rôle Administrateur Artifact Registry (artifactregistry.admin) :

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

4. Attribuez le rôle Administrateur de l'espace de stockage (storage.admin) :

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

Créer l'application d'entraînement Python

Dans cette section, vous allez créer une instance Vertex AI Workbench et l'utiliser pour créer un package d'application d'entraînement personnalisé Python.

Créer une instance Vertex AI Workbench

1. Dans la console Google Cloud , accédez à l'onglet Instances de la page Vertex AI Workbench.

   Accéder à Vertex AI Workbench

2. Cliquez sur  Créer, puis sélectionnez Options avancées.

   La page Nouvelle instance s'ouvre.

3. Dans la section Détails de la page Nouvelle instance, fournissez les informations suivantes pour la nouvelle instance, puis cliquez sur Continuer :

   • Nom : saisissez le code suivant en remplaçant PROJECT_ID par l'ID du projet :

     pipeline-tutorial-PROJECT_ID
     

   • Région : sélectionnez us-central1.

   • Zone : sélectionnez us-central1-a.

   • Décochez la case Activer les sessions interactives de Dataproc sans serveur.

4. Dans la section Environnement, cliquez sur Continuer.

5. Dans la section Type de machine, fournissez les informations suivantes, puis cliquez sur Continuer :

   • Type de machine : sélectionnez N1, puis n1-standard-4 dans le menu Type de machine.

   • VM protégée : cochez les cases suivantes :

     • Démarrage sécurisé
     • Module vTPM (Virtual Trusted Platform Module)
     • Surveillance de l'intégrité

6. Dans la section Disques, assurez-vous que l'option Google-managed encryption key est sélectionnée, puis cliquez sur Continuer :

7. Dans la section Mise en réseau, fournissez les informations suivantes, puis cliquez sur Continuer :

   • Mise en réseau : sélectionnez Réseau dans ce projet et procédez comme suit :

     1. Dans le champ Réseau, sélectionnez vertex-networking-vpc.

     2. Dans le champ Sous-réseau, sélectionnez pipeline-networking-subnet1.

     3. Décochez la case Attribuer une adresse IP externe. Le fait de ne pas attribuer d'adresse IP externe empêche l'instance de recevoir des communications non sollicitées en provenance d'Internet ou d'autres réseaux VPC.

     4. Cochez la case Autoriser l'accès proxy.

8. Dans la section IAM et sécurité, spécifiez les éléments suivants, puis cliquez sur Continuer :

   • IAM et sécurité : pour accorder à un seul utilisateur l'accès à l'interface JupyterLab de l'instance, procédez comme suit :

     1. Sélectionnez Service Account (Compte de service).
     2. Décochez la case Utiliser le compte de service Compute Engine par défaut. Cette étape est importante, car le compte de service Compute Engine par défaut (et donc l'utilisateur que vous venez de spécifier) peut disposer du rôle Éditeur (roles/editor) sur votre projet.

     3. Dans le champ Adresse e-mail du compte de service, saisissez l'adresse suivante en remplaçant PROJECT_ID par l'ID de projet :

        workbench-sa@PROJECT_ID.iam.gserviceaccount.com
        

        (Il s'agit de l'adresse e-mail du compte de service personnalisé que vous avez créé précédemment.) Ce compte de service dispose d'autorisations limitées.

        Pour en savoir plus sur l'attribution d'autorisations d'accès, consultez la section Gérer l'accès à l'interface JupyterLab d'une instance Vertex AI Workbench.

   • Options de sécurité : décochez la case suivante :

     • Accès root à l'instance

     Cochez la case suivante :

     • nbconvert : nbconvert permet aux utilisateurs d'exporter et de télécharger un fichier notebook sous un type de fichier différent, tel que HTML, PDF ou LaTeX. Ce paramètre est requis par certains notebooks du dépôt GitHub Google Cloud Generative AI.

     Décochez la case suivante :

     • Téléchargement de fichiers

     Cochez la case suivante, sauf si vous êtes dans un environnement de production :

     • Accès au terminal : cette option permet d'accéder au terminal de votre instance à partir de l'interface utilisateur de JupyterLab.

9. Dans la section État du système, supprimez l'option Mise à niveau automatique de l'environnement et fournissez les informations suivantes :

   • Dans Création de rapports, cochez les cases suivantes :

     • Rendez compte de l'état du système
     • Transmettre des métriques personnalisées à Cloud Monitoring
     • Installer Cloud Monitoring
     • Signaler l'état DNS des domaines Google requis

10. Cliquez sur Créer et attendez quelques minutes que l'instance Vertex AI Workbench soit créée.

Exécuter l'application 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.

   Accéder à Vertex AI Workbench

2. À côté du nom de votre instance Vertex AI Workbench (pipeline-tutorial-PROJECT_ID), où PROJECT_ID correspond à l'ID du projet, cliquez sur Ouvrir JupyterLab.

   Votre instance Vertex AI Workbench ouvre JupyterLab.

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 :

   projectid=PROJECT_ID
   

5. Créez les répertoires parents de l'application d'entraînement (toujours dans le terminal JupyterLab) :

   mkdir fungi_training_package
   mkdir fungi_training_package/trainer
   

6. Dans l'explorateur de fichiers , double-cliquez sur le dossier fungi_training_package, puis sur le dossier trainer.

7. Dans l'explorateur de fichiers , effectuez un clic droit sur la liste de fichiers vide (sous l'en-tête Nom), puis sélectionnez Nouveau fichier.

8. Effectuez un clic droit sur le nouveau fichier, puis sélectionnez Renommer le fichier.

9. Renommez le fichier untitled.txt en task.py.

10. Double-cliquez sur le fichier task.py pour l'ouvrir.

11. Copiez le code suivant dans task.py :

    # Import the libraries
    import tensorflow as tf
    from tensorflow.python.client import device_lib
    import argparse
    import os
    import sys
    # add parser arguments
    parser = argparse.ArgumentParser()
    parser.add_argument('--data-dir', dest='dataset_dir', type=str, 
                     help='Dir to access dataset.')
    parser.add_argument('--model-dir', dest='model_dir', default=os.getenv("AIP_MODEL_DIR"), type=str,
                     help='Dir to save the model.')
    parser.add_argument('--epochs', dest='epochs', default=10, type=int,
                     help='Number of epochs.')
    parser.add_argument('--batch-size', dest='batch_size', default=32, type=int,
                     help='Number of images per batch.')
    parser.add_argument('--distribute', dest='distribute', default='single', type=str, 
                     help='distributed training strategy.')
    args = parser.parse_args()
    # print the tf version and config
    print('Python Version = {}'.format(sys.version))
    print('TensorFlow Version = {}'.format(tf.__version__))
    print('TF_CONFIG = {}'.format(os.environ.get('TF_CONFIG', 'Not found')))
    print('DEVICES', device_lib.list_local_devices())
    
    # Single Machine, single compute device
    if args.distribute == 'single':
        if tf.test.is_gpu_available():
            strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
        else:
            strategy = tf.distribute.OneDeviceStrategy(device="/cpu:0")
    # Single Machine, multiple compute device
    elif args.distribute == 'mirror':
        strategy = tf.distribute.MirroredStrategy()
    # Multiple Machine, multiple compute device
    elif args.distribute == 'multi':
        strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
    
    # Multi-worker configuration
    print('num_replicas_in_sync = {}'.format(strategy.num_replicas_in_sync))
    
    # Preparing dataset
    BUFFER_SIZE = 1000
    IMG_HEIGHT = 224
    IMG_WIDTH = 224
    
    def make_datasets_batched(dataset_path, global_batch_size):
        # Configure the training data generator
        train_data_dir = os.path.join(dataset_path,"train/")
        train_ds = tf.keras.utils.image_dataset_from_directory(
                             train_data_dir,
                             seed=36,
                             image_size=(IMG_HEIGHT, IMG_WIDTH),
                             batch_size=global_batch_size
                   )
        # Configure the validation data generator
        val_data_dir = os.path.join(dataset_path,"valid/")
        val_ds = tf.keras.utils.image_dataset_from_directory(
                           val_data_dir,
                           seed=36,
                           image_size=(IMG_HEIGHT, IMG_WIDTH),
                           batch_size=global_batch_size
                 )
        # get the number of classes in the data
        num_classes = len(train_ds.class_names)
    
        # Configure the dataset for performance
        AUTOTUNE = tf.data.AUTOTUNE
        train_ds = train_ds.cache().shuffle(BUFFER_SIZE).prefetch(buffer_size=AUTOTUNE)
        val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
        return train_ds, val_ds, num_classes
    
    # Build the Keras model
    def build_and_compile_cnn_model(num_classes):
        # build a CNN model
        model = tf.keras.models.Sequential([
          tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
          tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
          tf.keras.layers.MaxPooling2D(),
          tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
          tf.keras.layers.MaxPooling2D(),
          tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
          tf.keras.layers.MaxPooling2D(),
          tf.keras.layers.Flatten(),
          tf.keras.layers.Dense(128, activation='relu'),
          tf.keras.layers.Dense(num_classes)
        ])
        # compile the CNN model
        model.compile(optimizer='adam',
                   loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                   metrics=['accuracy'])
        return model
    
    # Get the strategy data
    NUM_WORKERS = strategy.num_replicas_in_sync
    # Here the batch size scales up by number of workers
    GLOBAL_BATCH_SIZE = args.batch_size * NUM_WORKERS
    
    # Create dataset generator objects
    train_ds, val_ds, num_classes = make_datasets_batched(args.dataset_dir, GLOBAL_BATCH_SIZE)
    # Compile the model
    with strategy.scope():
        # Creation of dataset, and model building/compiling need to be within
        # `strategy.scope()`.
        model = build_and_compile_cnn_model(num_classes)
    # fit the model on the data
    history = model.fit(train_ds, validation_data=val_ds, epochs=args.epochs)
    # save the model to the output dir
    model.save(args.model_dir)
    

12. Sélectionnez Fichier > Enregistrer le fichier Python.

13. Dans le terminal JupyterLab, créez un fichier __init__.py dans chaque sous-répertoire pour en faire un package :

    touch fungi_training_package/__init__.py
    touch fungi_training_package/trainer/__init__.py
    

14. Dans l'explorateur de fichiers , double-cliquez sur le nouveau dossier fungi_training_package.

15. Sélectionnez Fichier > Nouveau > Fichier Python.

16. Effectuez un clic droit sur le nouveau fichier, puis sélectionnez Renommer le fichier.

17. Renommez le fichier untitled.py en setup.py.

18. Double-cliquez sur le fichier setup.py pour l'ouvrir.

19. Copiez le code suivant dans setup.py :

    from setuptools import find_packages
    from setuptools import setup
    setup(
       name='trainer',
       version='0.1',
       packages=find_packages(),
       include_package_data=True,
       description='Training application package for fungi-classification.'
    )
    

20. Sélectionnez Fichier > Enregistrer le fichier Python.

21. Dans le terminal, accédez au répertoire fungi_training_package :

    cd fungi_training_package
    

22. Exécutez la commande sdist pour créer la distribution source de l'application d'entraînement:

    python setup.py sdist --formats=gztar
    

23. Accédez au répertoire parent :

    cd ..
    

24. Vérifiez que vous êtes dans le bon répertoire :

    pwd
    

    Le résultat ressemble à ceci :

    /home/jupyter
    

25. Copiez le package Python dans le bucket de préproduction:

    gcloud storage cp fungi_training_package/dist/trainer-0.1.tar.gz gs://pipelines-staging-bucket-$projectid/training_package/
    

26. Vérifiez que le bucket de préproduction contient le package :

    gcloud storage ls gs://pipelines-staging-bucket-$projectid/training_package
    

    Voici le résultat :

    gs://pipelines-staging-bucket-PROJECT_ID/training_package/trainer-0.1.tar.gz
    

Créer la connexion Service Networking pour Vertex AI Pipelines

Dans cette section, vous allez créer une connexion Service Networking qui permet d'établir des services producteurs connectés au réseau VPC vertex-networking-vpc via l'appairage de réseaux VPC. Pour en savoir plus, consultez la section Appairage de réseaux VPC.

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

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Définissez une plage d'adresses IP réservées à l'aide de gcloud compute addresses create :

   gcloud compute addresses create vertex-pipeline-subnet \
       --global \
       --purpose=VPC_PEERING \
       --addresses=192.168.10.0 \
       --prefix-length=24 \
       --description="pipeline subnet" \
       --network=vertex-networking-vpc
   

3. Établissez une connexion d'appairage entre le réseau VPC vertex-networking-vpc et Service Networking de Google à l'aide de gcloud services vpc-peerings connect :

   gcloud services vpc-peerings connect \
       --service=servicenetworking.googleapis.com \
       --ranges=vertex-pipeline-subnet \
       --network=vertex-networking-vpc
   

4. Mettez à jour la connexion d'appairage de VPC pour activer l'importation et l'exportation des routes apprises personnalisées :

   gcloud compute networks peerings update servicenetworking-googleapis-com \
       --network=vertex-networking-vpc \
       --import-custom-routes \
       --export-custom-routes
   

Annoncer le sous-réseau de pipeline à partir du routeur Cloud Router pipeline-networking

1. Dans la console Google Cloud , accédez à la page Cloud Router.

   Accéder aux routeurs cloud

2. Dans la liste des routeurs Cloud Router, cliquez sur vertex-networking-vpc-router1.

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

4. Cliquez sur Ajouter une route personnalisée.

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

6. Dans le champ Plage d'adresses IP, saisissez l'adresse IP suivante :

   192.168.10.0/24
   

7. Dans le champ Description, saisissez le texte suivant :

   Vertex AI Pipelines reserved subnet
   

8. Cliquez sur OK, puis sur Enregistrer.

Créer un modèle de pipeline et l'importer dans Artifact Registry

Dans cette section, vous allez créer et importer un modèle de pipeline Kubeflow Pipelines (KFP). Ce modèle contient une définition de workflow qui peut être réutilisée plusieurs fois, par un seul utilisateur ou par plusieurs utilisateurs.

Définir et compiler le pipeline

1. Dans JupyterLab, dans l'explorateur de fichiers , double-cliquez sur le dossier de premier niveau.

2. Sélectionnez Fichier > Nouveau > Notebook.

3. Dans le menu Sélectionner le kernel, sélectionnez Python 3 (ipykernel), puis cliquez sur Sélectionner.

4. Dans une nouvelle cellule de notebook, exécutez la commande suivante pour vous assurer que vous disposez de la dernière version de pip :

   !python -m pip install --upgrade pip
   

5. Exécutez la commande suivante pour installer le SDK des composants du pipeline Google Cloud à partir de l'index de packages Python (PyPI) :

   !pip install --upgrade google-cloud-pipeline-components
   

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

7. Exécutez le code suivant dans une nouvelle cellule de notebook pour définir le pipeline :

   from kfp import dsl
   # define the train-deploy pipeline
   @dsl.pipeline(name="custom-image-classification-pipeline")
   def custom_image_classification_pipeline(
    project: str,
    training_job_display_name: str,
    worker_pool_specs: list,
    base_output_dir: str,
    model_artifact_uri: str,
    prediction_container_uri: str,
    model_display_name: str,
    endpoint_display_name: str,
    network: str = '',
    location: str="us-central1",
    serving_machine_type: str="n1-standard-4",
    serving_min_replica_count: int=1,
    serving_max_replica_count: int=1
    ):
    from google_cloud_pipeline_components.types import artifact_types
    from google_cloud_pipeline_components.v1.custom_job import CustomTrainingJobOp
    from google_cloud_pipeline_components.v1.model import ModelUploadOp
    from google_cloud_pipeline_components.v1.endpoint import (EndpointCreateOp,
                                                              ModelDeployOp)
    from kfp.dsl import importer
   
    # Train the model task
    custom_job_task = CustomTrainingJobOp(
         project=project,
         display_name=training_job_display_name,
         worker_pool_specs=worker_pool_specs,
         base_output_directory=base_output_dir,
         location=location,
         network=network
         )
   
    # Import the model task
    import_unmanaged_model_task = importer(
         artifact_uri=model_artifact_uri,
         artifact_class=artifact_types.UnmanagedContainerModel,
         metadata={
            "containerSpec": {
               "imageUri": prediction_container_uri,
               },
            },
            ).after(custom_job_task)
    # Model upload task
    model_upload_op = ModelUploadOp(
         project=project,
         display_name=model_display_name,
         unmanaged_container_model=import_unmanaged_model_task.outputs["artifact"],
         )
    model_upload_op.after(import_unmanaged_model_task)
    # Create Endpoint task
    endpoint_create_op = EndpointCreateOp(
         project=project,
         display_name=endpoint_display_name,
         )
    # Deploy the model to the endpoint
    ModelDeployOp(
         endpoint=endpoint_create_op.outputs["endpoint"],
         model=model_upload_op.outputs["model"],
         dedicated_resources_machine_type=serving_machine_type,
         dedicated_resources_min_replica_count=serving_min_replica_count,
         dedicated_resources_max_replica_count=serving_max_replica_count,
         )
   

8. Exécutez le code suivant dans une nouvelle cellule de notebook pour compiler la définition du pipeline :

   from kfp import compiler 
   PIPELINE_FILE = "pipeline_config.yaml"
   compiler.Compiler().compile(
       pipeline_func=custom_image_classification_pipeline,
       package_path=PIPELINE_FILE,
   )
   

   Dans l'explorateur de fichiers , un fichier nommé pipeline_config.yaml s'affiche dans la liste des fichiers.

Créer un dépôt Artifact Registry

1. Exécutez le code suivant dans une nouvelle cellule de notebook pour créer un dépôt d'artefacts de type KFP :

   REPO_NAME="fungi-repo"
   REGION="us-central1"
   !gcloud artifacts repositories create $REPO_NAME --location=$REGION --repository-format=KFP
   

Importer le modèle de pipeline dans Artifact Registry

Dans cette section, vous allez configurer un client de registre du SDK Kubeflow Pipelines et importer votre modèle de pipeline compilé dans Artifact Registry à partir de votre notebook JupyterLab.

1. Dans votre notebook JupyterLab, exécutez le code suivant pour importer le modèle de pipeline, en remplaçant PROJECT_ID par l'ID de votre projet :

   PROJECT_ID = "PROJECT_ID"
   from kfp.registry import RegistryClient
   host = f"https://{REGION}-kfp.pkg.dev/{PROJECT_ID}/{REPO_NAME}"
   client = RegistryClient(host=host)
   TEMPLATE_NAME, VERSION_NAME = client.upload_pipeline(
      file_name=PIPELINE_FILE,
      tags=["v1", "latest"],
      extra_headers={"description":"This is an example pipeline template."})
   

2. Dans la console Google Cloud , pour vérifier que votre modèle a été importé, accédez à Modèles Vertex AI Pipelines.

   Accéder à la page Pipelines

3. Pour ouvrir le volet Sélectionner un dépôt, cliquez sur Sélectionner un dépôt.

4. Dans la liste des dépôts, cliquez sur le dépôt que vous avez créé (fungi-repo), puis sur Sélectionner.

5. Vérifiez que votre pipeline (custom-image-classification-pipeline) apparaît dans la liste.

Déclencher une exécution de pipeline à partir d'un environnement sur site

Dans cette section, maintenant que votre modèle de pipeline et votre package d'entraînement sont prêts, vous allez utiliser cURL pour déclencher une exécution de pipeline à partir de votre application sur site.

Fournir les paramètres du pipeline

1. Dans votre notebook JupyterLab, exécutez la commande suivante pour vérifier le nom du modèle de pipeline :

   print (TEMPLATE_NAME)
   

   Le nom du modèle renvoyé est le suivant :

   custom-image-classification-pipeline
   

2. Exécutez la commande suivante pour obtenir la version du modèle de pipeline :

   print (VERSION_NAME)
   

   Le nom de la version du modèle de pipeline renvoyé se présente comme suit :

   sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7
   

   Notez la chaîne complète du nom de la version.

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

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

4. Connectez-vous à l'instance de VM on-prem-dataservice-host :

   gcloud compute ssh on-prem-dataservice-host \
       --zone=us-central1-a \
       --tunnel-through-iap
   

5. Dans l'instance de VM on-prem-dataservice-host, utilisez un éditeur de texte tel que vim ou nano pour créer le fichier request_body.json, par exemple :

   sudo vim request_body.json
   

6. Ajoutez le texte suivant au fichier request_body.json :

   {
   "displayName": "fungi-image-pipeline-job",
   "serviceAccount": "onprem-user-managed-sa@PROJECT_ID.iam.gserviceaccount.com",
   "runtimeConfig":{
   "gcsOutputDirectory":"gs://pipelines-staging-bucket-PROJECT_ID/pipeline_root/",
   "parameterValues": {
      "project": "PROJECT_ID",
      "training_job_display_name": "fungi-image-training-job",
      "worker_pool_specs": [{
         "machine_spec": {
            "machine_type": "n1-standard-4"
         },
         "replica_count": 1,
         "python_package_spec":{
            "executor_image_uri":"us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-8.py310:latest", 
            "package_uris": ["gs://pipelines-staging-bucket-PROJECT_ID/training_package/trainer-0.1.tar.gz"],
            "python_module": "trainer.task",
            "args": ["--data-dir","/mnt/nfs/fungi_dataset/", "--epochs", "10"],
            "env": [{"name": "AIP_MODEL_DIR", "value": "gs://pipelines-staging-bucket-PROJECT_ID/model/"}]
         },
         "nfs_mounts": [{
            "server": "FILESTORE_INSTANCE_IP",
            "path": "/vol1",
            "mount_point": "/mnt/nfs/"
         }]
      }],
      "base_output_dir":"gs://pipelines-staging-bucket-PROJECT_ID",
      "model_artifact_uri":"gs://pipelines-staging-bucket-PROJECT_ID/model/",
      "prediction_container_uri":"us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest",
      "model_display_name":"fungi-image-model",
      "endpoint_display_name":"fungi-image-endpoint",
      "location": "us-central1",
      "serving_machine_type":"n1-standard-4",
      "network":"projects/PROJECT_NUMBER/global/networks/vertex-networking-vpc"
        }
   },
   "templateUri": "https://us-central1-kfp.pkg.dev/PROJECT_ID/fungi-repo/custom-image-classification-pipeline/latest",
   "templateMetadata": {
      "version":"VERSION_NAME"
   }
   }
   

   Remplacez les valeurs suivantes :

   • PROJECT_ID : ID de votre projet.
   • PROJECT_NUMBER : Numéro du projet Cette valeur est différente de l'ID du projet. Vous pouvez trouver le numéro de projet sur la page Paramètres du projet du projet dans la consoleGoogle Cloud .
   • FILESTORE_INSTANCE_IP : adresse IP de l'instance Filestore, par exemple 10.243.208.2. Vous le trouverez sur la page "Instances Filestore" de votre instance.
   • VERSION_NAME : nom de la version du modèle de pipeline (sha256:...) que vous avez noté à l'étape 2.

7. 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.

Créer une exécution de pipeline à partir de votre modèle

1. Dans l'instance de VM on-prem-dataservice-host, exécutez la commande suivante en remplaçant PROJECT_ID par l'ID de votre projet :

   curl -v -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json; charset=utf-8" \
   -d @request_body.json \
   https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/pipelineJobs
   

   La sortie est longue, mais l'élément principal à rechercher est la ligne suivante, qui indique que le service se prépare à exécuter le pipeline :

   "state": "PIPELINE_STATE_PENDING"
   

   L'exécution complète du pipeline prend environ 45 à 50 minutes.

2. Dans la section Vertex AI de la console Google Cloud , accédez à l'onglet Exécutions de la page Pipelines.

   Accédez à "Exécutions".

3. Cliquez sur le nom de l'exécution de votre pipeline (custom-image-classification-pipeline).

   La page d'exécution du pipeline apparaît et affiche le graphique d'exécution du pipeline. Le résumé du pipeline s'affiche dans le volet Analyse de l'exécution du pipeline.

   Pour comprendre les informations affichées dans le graphique d'exécution, y compris comment afficher les journaux et utiliser Vertex ML Metadata pour en savoir plus sur les artefacts de votre pipeline, consultez Visualiser et analyser les résultats du pipeline.

Effectuer un nettoyage

Pour éviter que les ressources utilisées dans ce tutoriel ne soient facturées sur votre compte Google Cloud , supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Vous pouvez supprimer les ressources individuelles du projet comme suit :

1. Supprimez toutes les exécutions de pipeline comme suit :

   1. Dans la section Vertex AI de la console Google Cloud , accédez à l'onglet Exécutions de la page Pipelines.

      Accédez à "Exécutions".

   2. Sélectionnez les exécutions de pipeline à supprimer, puis cliquez sur Supprimer.

2. Supprimez le modèle de pipeline comme suit :

   1. Dans la section Vertex AI, accédez à l'onglet Vos modèles sur la page Pipelines.

      Accéder à la page Pipelines

   2. À côté du modèle de pipeline custom-image-classification-pipeline, cliquez sur Actions, puis sélectionnez Supprimer.

3. Supprimez le dépôt d'Artifact Registry comme suit :

   1. Sur la page Artifact Registry, accédez à l'onglet Dépôts.

      Accédez aux dépôts.

   2. Sélectionnez le dépôt fungi-repo, puis cliquez sur Supprimer.

4. Annulez le déploiement du modèle sur le point de terminaison comme suit :

   1. Dans la section Vertex AI, accédez à l'onglet Points de terminaison de la page Prédictions en ligne.

      Accéder à Endpoints

   2. Cliquez sur fungi-image-endpoint pour accéder à la page d'informations du point de terminaison.

   3. Sur la ligne correspondant à votre modèle, fungi-image-model, cliquez sur Actions, puis sélectionnez Annuler le déploiement du modèle sur le point de terminaison.

   4. Dans la boîte de dialogue Annuler le déploiement du modèle sur le point de terminaison, cliquez sur Annuler le déploiement.

5. Supprimez le point de terminaison comme suit :

   1. Dans la section Vertex AI, accédez à l'onglet Points de terminaison de la page Prédictions en ligne.

      Accéder à Endpoints

   2. Sélectionnez fungi-image-endpoint, puis cliquez sur Supprimer.

6. Supprimez le modèle comme suit :

   1. Accédez à la page Registre de modèles.

      Accéder à la page Modèles

   2. Sur la ligne correspondant à votre modèle, fungi-image-model, cliquez sur Actions, puis sélectionnez Supprimer le modèle.

7. Supprimez le bucket d'aiguillage comme suit :

   1. Accédez à la page Cloud Storage.

      Accéder à Cloud Storage

   2. Sélectionnez pipelines-staging-bucket-PROJECT_ID, où PROJECT_ID correspond à l'ID du projet, puis cliquez sur Supprimer.

8. Supprimez l'instance Vertex AI Workbench comme suit:

   1. Dans la section Vertex AI, accédez à l'onglet Instances de la page Workbench.

      Accéder à Vertex AI Workbench

   2. Sélectionnez l'instance Vertex AI Workbench pipeline-tutorial-PROJECT_ID, où PROJECT_ID correspond à l'ID du projet, puis cliquez sur Supprimer.

9. Supprimez l'instance de VM Compute Engine comme suit:

   1. Accédez à la page Compute Engine.

      Accéder à Compute Engine

   2. Sélectionnez l'instance de VM on-prem-dataservice-host, puis cliquez sur Supprimer.

10. Supprimez les tunnels VPN comme suit:

    1. 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, sélectionnez les quatre tunnels VPN que vous avez créés dans ce tutoriel, puis cliquez sur Supprimer.

11. Supprimez les passerelles VPN haute disponibilité comme suit:

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

       Accéder à la page "Passerelles Cloud VPN"

    2. Dans la liste des passerelles VPN, cliquez sur onprem-vpn-gw1.

    3. Sur la page Informations sur la passerelle Cloud VPN, cliquez sur Supprimer la passerelle VPN.

    4. Si nécessaire, cliquez sur la flèche de retour pour revenir à la liste des passerelles VPN, puis cliquez sur vertex-networking-vpn-gw1.

    5. Sur la page Informations sur la passerelle Cloud VPN, cliquez sur Supprimer la passerelle VPN.

12. Supprimez les routeurs cloud comme suit:

    1. Accédez à la page Routeurs cloud.

       Accéder aux routeurs cloud

    2. Dans la liste des routeurs cloud, sélectionnez les quatre routeurs que vous avez créés dans ce tutoriel.

    3. Pour supprimer les routeurs, cliquez sur Supprimer.

       Cela supprimera également les deux passerelles Cloud NAT connectées aux routeurs Cloud.

13. Supprimez les connexions de Service Networking aux réseaux VPC vertex-networking-vpc et onprem-dataservice-vpc comme suit :

    1. Accédez à la page Appairage de réseaux VPC.

       Accéder à la page "Appairage de réseaux VPC"

    2. Sélectionnez servicenetworking-googleapis-com.

    3. Pour supprimer les connexions, cliquez sur Supprimer.

14. Supprimez la règle de transfert pscvertex pour le réseau VPC vertex-networking-vpc comme suit:

    1. Accédez à l'onglet Interfaces de la page Équilibrage de charge.

       Accéder à la page "Interfaces"

    2. Dans la liste des règles de transfert, cliquez sur pscvertex.

    3. Sur la page Détails de la règle de transfert globale, cliquez sur Supprimer.

15. Supprimez l'instance Filestore comme suit :

    1. Accédez à la page Filestore.

       Accédez à Filestore.

    2. Sélectionnez l'instance image-data-instance.

    3. Pour supprimer l'instance, cliquez sur Actions, puis sur Supprimer l'instance.

16. Supprimez les réseaux VPC comme suit:

    1. Accédez à la page des réseaux VPC.

       Accéder aux réseaux VPC

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

    3. Sur la page Détails du réseau VPC, cliquez sur  Supprimer le réseau VPC.

       Lorsque vous supprimez un réseau, ses sous-réseaux, ses routes et ses règles de pare-feu sont également supprimés.

    4. Dans la liste des réseaux VPC, cliquez sur vertex-networking-vpc.

    5. Sur la page Détails du réseau VPC, cliquez sur  Supprimer le réseau VPC.

17. Supprimez les comptes de service workbench-sa et onprem-user-managed-sa comme suit:

    1. Accédez à la page Comptes de service.

       Accéder à la page "Comptes de service"

    2. Sélectionnez les comptes de service onprem-user-managed-sa et workbench-sa, puis cliquez sur Supprimer.

Étape suivante

• Découvrez comment utiliser Vertex AI Pipelines pour orchestrer le processus de création et de déploiement de vos modèles de machine learning.

• Apprenez-en plus sur l'ensemble de données deFungi.