Use o Private Service Connect para aceder a pipelines de preparação a partir de instalações locais

---

O Vertex AI Pipelines é um serviço gerido que ajuda a criar, implementar e gerir fluxos de trabalho de aprendizagem automática (ML) completos na Google Cloud Platform. Oferece um ambiente sem servidores para executar os seus pipelines, para que não tenha de se preocupar com a gestão da infraestrutura.

Neste tutorial, vai usar o Vertex AI Pipelines para executar uma tarefa de preparação personalizada e implementar o modelo preparado no Vertex AI, num ambiente de rede híbrida.

Todo o processo demora duas a três horas a concluir, incluindo cerca de 50 minutos para a execução do pipeline.

Este tutorial destina-se a administradores de redes empresariais, cientistas de dados e investigadores que estão familiarizados com o Vertex AI, a nuvem virtual privada (VPC), a Google Cloud consola e oCloud Shell. A familiaridade com o Vertex AI Workbench é útil, mas não obrigatória.

Objetivos

• Crie duas redes da nuvem virtual privada (VPC):
  • Uma (vertex-networking-vpc) destina-se a usar a API Vertex AI Pipelines para criar e alojar um modelo de pipeline para preparar um modelo de aprendizagem automática e implementá-lo num ponto final.
  • O outro (onprem-dataservice-vpc) representa uma rede nas instalações.
• Associe as duas redes de VPC da seguinte forma:
  • Implemente gateways de VPN de alta disponibilidade, túneis de Cloud VPN e Cloud Routers para ligar vertex-networking-vpc e onprem-dataservice-vpc.
  • Crie um ponto final do Private Service Connect (PSC) para encaminhar pedidos privados para a API REST Vertex AI Pipelines.
  • Configure um anúncio de rota personalizada do Cloud Router em vertex-networking-vpc para anunciar rotas para o ponto final do Private Service Connect para onprem-dataservice-vpc.
• Crie uma instância do Filestore na rede onprem-dataservice-vpcVPC e adicione-lhe dados de preparação numa partilha NFS.
• Crie uma aplicação de pacote Python para a tarefa de preparação.
• Crie um modelo de tarefa do Vertex AI Pipelines para fazer o seguinte:
  • Crie e execute a tarefa de preparação nos dados da partilha NFS.
  • Importe o modelo preparado e carregue-o para o Registo de modelos Vertex AI.
  • Crie um ponto final do Vertex AI para previsões online.
  • Implemente o modelo no ponto final.
• Carregue o modelo de pipeline para um repositório do Artifact Registry.
• Use a API REST Vertex AI Pipelines para acionar uma execução de pipeline a partir de um anfitrião de serviço de dados no local (on-prem-dataservice-host).

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

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

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

Antes de começar

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 (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. Abra o Cloud Shell para executar os comandos indicados neste tutorial. O Cloud Shell é um ambiente de shell interativo para Google Cloud que lhe permite gerir os seus projetos e recursos a partir do navegador de Internet.
5. No Cloud Shell, defina o projeto atual para o seu Google Cloud ID do projeto e armazene o mesmo ID do projeto na variável do shell projectid:

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

   Substitua PROJECT_ID pelo ID do seu projeto. Se necessário, pode localizar o ID do projeto na Google Cloud consola. Para mais informações, consulte o artigo Encontre o ID do seu projeto.
6. Se não for o proprietário do projeto, peça-lhe que lhe conceda a função Project IAM Admin (roles/resourcemanager.projectIamAdmin). Tem de ter esta função para conceder funções da IAM no passo seguinte.

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.

      Aceder ao IAM
   2. Selecione o projeto.
   3. Clique em Conceder acesso.

   4. No campo Novos responsáveis, introduza o identificador do utilizador. Normalmente, este é o endereço de email de uma Conta Google.

   5. Na lista Selecionar uma função, selecione uma função.
   6. Para conceder funções adicionais, clique em Adicionar outra função e adicione cada função adicional.
   7. Clique em Guardar.

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

Crie as redes VPC

Nesta secção, cria duas redes VPC: uma para aceder às APIs Google para o Vertex AI Pipelines e outra para simular uma rede no local. Em cada uma das duas redes VPC, cria um Cloud Router e um gateway Cloud NAT. Um gateway Cloud NAT oferece conetividade de saída para instâncias de máquinas virtuais (VM) do Compute Engine sem endereços IP externos.

1. No Cloud Shell, execute os seguintes comandos, substituindo PROJECT_ID pelo ID do seu projeto:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Crie a vertex-networking-vpc rede de VPC:

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

3. Na rede vertex-networking-vpc, crie uma sub-rede denominada pipeline-networking-subnet1 com um intervalo IPv4 principal de 10.0.0.0/24:

   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. Crie a rede VPC para simular a rede no local (onprem-dataservice-vpc):

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

5. Na rede onprem-dataservice-vpc, crie uma sub-rede denominada onprem-dataservice-vpc-subnet1 com um intervalo IPv4 principal de 172.16.10.0/24:

   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
   

Verifique se as redes VPC estão configuradas corretamente

1. Na Google Cloud consola, aceda ao separador Redes no projeto atual na página Redes de VPC.

   Aceda a redes de VPC

2. Na lista de redes VPC, verifique se as duas redes foram criadas: vertex-networking-vpc e onprem-dataservice-vpc.

3. Clique no separador Sub-redes no projeto atual.

4. Na lista de sub-redes da VPC, verifique se as sub-redes pipeline-networking-subnet1 e onprem-dataservice-vpc-subnet1 foram criadas.

Configure a conetividade híbrida

Nesta secção, cria dois gateways de VPN de alta disponibilidade que estão ligados entre si. Uma reside na vertex-networking-vpc rede VPC. O outro reside na rede VPC onprem-dataservice-vpc. Cada gateway contém um Cloud Router e um par de túneis VPN.

Crie os gateways de VPN de alta disponibilidade

1. No Cloud Shell, crie o gateway de VPN de alta disponibilidade para a rede VPC vertex-networking-vpc:

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

2. Crie o gateway de VPN de alta disponibilidade para a rede VPC:onprem-dataservice-vpc

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

3. Na Google Cloud consola, aceda ao separador Gateways de VPN do Cloud na página VPN.

   Aceda à VPN

4. Verifique se os dois gateways (vertex-networking-vpn-gw1 e onprem-vpn-gw1) foram criados e se cada gateway tem dois endereços IP de interface.

Crie routers do Cloud Router e gateways do Cloud NAT

Em cada uma das duas redes VPC, cria dois Cloud Routers: um para usar com o Cloud NAT e outro para gerir sessões BGP para a VPN de HA.

1. No Cloud Shell, crie um Cloud Router para a vertex-networking-vpc rede VPC que vai ser usada para a VPN:

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

2. Crie um Cloud Router para a rede onprem-dataservice-vpcVPC que vai ser usada para a VPN:

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

3. Crie um Cloud Router para a vertex-networking-vpc rede VPC que vai ser usada para o Cloud NAT:

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

4. Configure uma gateway do Cloud NAT no 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. Crie um Cloud Router para a rede onprem-dataservice-vpcVPC que vai ser usada para o Cloud NAT:

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

6. Configure uma gateway do Cloud NAT no 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. Na Google Cloud consola, aceda à página Routers na nuvem.

   Aceder aos Cloud Routers

8. Na lista Routers do Cloud Router, verifique se os seguintes routers foram criados:

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

   Pode ter de atualizar o separador do navegador da Google Cloud consola para ver os novos valores.

9. Na lista de routers do Cloud Router, clique em cloud-router-us-central1-vertex-nat.

10. Na página Detalhes do router, verifique se o gateway cloud-nat-us-central1 Cloud NAT foi criado.

11. Clique na seta de retrocesso para regressar à página Cloud Routers.

12. Na lista de routers do Cloud Router, clique em cloud-router-us-central1-onprem-nat.

13. Na página Detalhes do router, verifique se o gateway do Cloud NAT foi criado.cloud-nat-us-central1-on-prem

Crie túneis de VPN

1. No Cloud Shell, na rede vertex-networking-vpc, crie um túnel de VPN denominado 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. Na rede vertex-networking-vpc, crie um túnel de VPN denominado 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. Na rede onprem-dataservice-vpc, crie um túnel de VPN denominado 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. Na rede onprem-dataservice-vpc, crie um túnel de VPN denominado 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. Na Google Cloud consola, aceda à página VPN.

   Aceda à VPN

6. Na lista de túneis VPN, verifique se os quatro túneis VPN foram criados.

Estabeleça sessões de BGP

O Cloud Router usa o protocolo de gateway de fronteira (BGP) para trocar rotas entre a sua rede VPC (neste caso, vertex-networking-vpc) e a sua rede nas instalações (representada por onprem-dataservice-vpc). No Cloud Router, configura uma interface e um par BGP para o seu router nas instalações. A interface e a configuração do par BGP formam em conjunto uma sessão de BGP. Nesta secção, cria duas sessões BGP para vertex-networking-vpc e duas para onprem-dataservice-vpc.

Depois de configurar as interfaces e os pares BGP entre os routers, estes começam automaticamente a trocar rotas.

Estabeleça sessões de BGP para vertex-networking-vpc

1. No Cloud Shell, na rede vertex-networking-vpc, crie uma interface BGP para 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. Na rede vertex-networking-vpc, crie um par BGP para 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. Na rede vertex-networking-vpc, crie uma interface BGP para 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. Na rede vertex-networking-vpc, crie um par BGP para 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
   

Estabeleça sessões de BGP para onprem-dataservice-vpc

1. Na rede onprem-dataservice-vpc, crie uma interface BGP para 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. Na rede onprem-dataservice-vpc, crie um par BGP para 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. Na rede onprem-dataservice-vpc, crie uma interface BGP para 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. Na rede onprem-dataservice-vpc, crie um par BGP para 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
   

Valide a criação da sessão de BGP

1. Na Google Cloud consola, aceda à página VPN.

   Aceda à VPN

2. Na lista de túneis VPN, verifique se o valor na coluna Estado da sessão de BGP de cada um dos túneis mudou de Configurar sessão de BGP para BGP estabelecido. Pode ter de atualizar o separador do navegador da consola para ver os novos valores. Google Cloud

Valide os onprem-dataservice-vpc trajetos aprendidos

1. Na Google Cloud consola, aceda à página Redes VPC.

   Aceda a redes de VPC

2. Na lista de redes de VPC, clique em onprem-dataservice-vpc.

3. Clique no separador Rotas.

4. Selecione us-central1 (Iowa) na lista Região e clique em Ver.

5. Na coluna Intervalo de IPs de destino, verifique se o intervalo de IPs da sub-rede pipeline-networking-subnet1 (10.0.0.0/24) aparece duas vezes.

   Pode ter de atualizar o separador do navegador da Google Cloud consola para ver ambas as entradas.

Valide os vertex-networking-vpc trajetos aprendidos

1. Clique na seta de retrocesso para regressar à página Redes de VPC.

2. Na lista de redes de VPC, clique em vertex-networking-vpc.

3. Clique no separador Rotas.

4. Selecione us-central1 (Iowa) na lista Região e clique em Ver.

5. Na coluna Intervalo IP de destino, verifique se o intervalo IP da sub-rede (172.16.10.0/24) aparece duas vezes.onprem-dataservice-vpc-subnet1

Crie um ponto final do Private Service Connect para as APIs Google

Nesta secção, vai criar um ponto final do Private Service Connect para as APIs Google que vai usar para aceder à API REST Vertex AI Pipelines a partir da sua rede no local.

1. No Cloud Shell, reserve um endereço IP do ponto final do consumidor que vai ser usado para aceder às APIs Google:

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

2. Crie uma regra de encaminhamento para ligar o ponto final às APIs e aos serviços Google.

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

Crie anúncios de rotas personalizadas para vertex-networking-vpc

Nesta secção, cria um anúncio de rota personalizado para vertex-networking-vpc-router1 (o Cloud Router para vertex-networking-vpc) anunciar o endereço IP do ponto final do PSC à rede VPC onprem-dataservice-vpc.

1. Na Google Cloud consola, aceda à página Routers na nuvem.

   Aceder aos Cloud Routers

2. Na lista do Cloud Router, clique em vertex-networking-vpc-router1.

3. Na página Detalhes do router, clique em Editar.

4. Na secção Rotas anunciadas, para Rotas, selecione Criar rotas personalizadas.

5. Selecione a caixa de verificação Anunciar todas as sub-redes visíveis para o Cloud Router para continuar a anunciar as sub-redes disponíveis para o Cloud Router. A ativação desta opção imita o comportamento do Cloud Router no modo de anúncio predefinido.

6. Clique em Adicionar um trajeto personalizado.

7. Para Origem, selecione Intervalo de IPs personalizado.

8. Para o Intervalo de endereços IP, introduza o seguinte endereço IP:

   192.168.0.1
   

9. Em Descrição, introduza o seguinte texto:

   Custom route to advertise Private Service Connect endpoint IP address
   

10. Clique em Concluído e, de seguida, clique em Guardar.

Valide se onprem-dataservice-vpc aprendeu os trajetos anunciados

1. Na Google Cloud consola, aceda à página Rotas.

   Aceda a Trajetos

2. No separador Rotas eficazes, faça o seguinte:

   1. Para Rede, escolha onprem-dataservice-vpc.
   2. Para Região, escolha us-central1 (Iowa).
   3. Clique em Ver.

   4. Na lista de trajetos, verifique se existem duas entradas cujos nomes começam com onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel0 e duas que começam com onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel1.

      Se estas entradas não aparecerem imediatamente, aguarde alguns minutos e, em seguida, atualize o separador do navegador da consola Google Cloud .

   5. Verifique se duas das entradas têm um Intervalo de IPs de destino de 192.168.0.1/32 e duas têm um Intervalo de IPs de destino de 10.0.0.0/24.

Crie uma instância de VM em onprem-dataservice-vpc

Nesta secção, cria uma instância de VM que simula um anfitrião de serviço de dados no local. Seguindo as práticas recomendadas do Compute Engine e do IAM, esta VM usa uma conta de serviço gerida pelo utilizador em vez da conta de serviço predefinida do Compute Engine.

Crie a conta de serviço gerida pelo utilizador para a instância de VM

1. No Cloud Shell, execute os seguintes comandos, substituindo PROJECT_ID pelo ID do seu projeto:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Crie uma conta de serviço com o nome onprem-user-managed-sa:

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

3. Atribua a função Utilizador do Vertex AI (roles/aiplatform.user) à conta de serviço:

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

4. Atribua a função Visitante do 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. Atribua a função Editor do Filestore (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. Atribua a função Administrador da conta de serviço (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. Atribua a função Utilizador da conta de serviço (roles/iam.serviceAccountUser):

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

8. Atribua a função Leitor do 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. Atribua a função Administrador de objetos de armazenamento (roles/storage.objectAdmin):

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

10. Atribua a função de administrador de registos (roles/logging.admin):

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

Crie a instância de VM on-prem-dataservice-host

A instância de VM que criar não tem um endereço IP externo e não permite o acesso direto através da Internet. Para ativar o acesso administrativo à VM, usa o encaminhamento TCP do Identity-Aware Proxy (IAP).

1. No Cloud Shell, crie a instância 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. Crie uma regra de firewall para permitir que o IAP se ligue à sua instância 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
   

Atualize o ficheiro /etc/hosts para apontar para o ponto final do PSC

Nesta secção, adiciona uma linha ao ficheiro /etc/hosts que faz com que os pedidos enviados para o ponto final do serviço público (us-central1-aiplatform.googleapis.com) sejam redirecionados para o ponto final do PSC (192.168.0.1).

1. No Cloud Shell, inicie sessão na instância de VM através do IAP:on-prem-dataservice-host

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

2. Na instância de VM, use um editor de texto, como o vim ou o nano para abrir o ficheiro /etc/hosts, por exemplo:on-prem-dataservice-host

   sudo vim /etc/hosts
   

3. Adicione a seguinte linha ao ficheiro:

   192.168.0.1 us-central1-aiplatform.googleapis.com
   

   Esta linha atribui o endereço IP do ponto final do PSC (192.168.0.1) ao nome de domínio totalmente qualificado para a API Google Vertex AI (us-central1-aiplatform.googleapis.com).

   O ficheiro editado deve ter o seguinte aspeto:

   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. Guarde o ficheiro da seguinte forma:

   • Se estiver a usar o vim, prima a tecla Esc e, de seguida, escreva :wq para guardar o ficheiro e sair.
   • Se estiver a usar o nano, escreva Control+O e prima Enter para guardar o ficheiro e, de seguida, escreva Control+X para sair.

5. Envie um ping para o ponto final da API Vertex AI da seguinte forma:

   ping us-central1-aiplatform.googleapis.com
   

   O comando ping deve devolver o seguinte resultado. 192.168.0.1 é o endereço IP do ponto final do PSC:

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

6. Escreva Control+C para sair de ping.

7. Introduza exit para sair da instância de VM on-prem-dataservice-host e regressar ao comando do Cloud Shell.

Configure a rede para uma instância do Filestore

Nesta secção, ativa o acesso a serviços privados para a sua rede da VPC, em preparação para criar uma instância do Filestore e montá-la como uma partilha do sistema de ficheiros de rede (NFS). Para compreender o que está a fazer nesta secção e na seguinte, consulte os artigos Monte uma partilha NFS para a preparação personalizada e Configure o peering de rede VPC.

Ative o acesso a serviços privados numa rede VPC

Nesta secção, cria uma ligação de rede de serviços e usa-a para ativar o acesso a serviços privados à rede da VPC através do intercâmbio da rede da VPC.onprem-dataservice-vpc

1. No Cloud Shell, defina um intervalo de endereços IP reservados com o comando 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. Estabeleça uma ligação de peering entre a rede onprem-dataservice-vpc VPC e a rede de serviços da Google, através de gcloud services vpc-peerings connect:

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

3. Atualize o peering de rede VPC para ativar a importação e a exportação de encaminhamentos aprendidos personalizados:

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

4. Na Google Cloud consola, aceda à página Interligação de redes VPC.

   Aceda ao intercâmbio da rede da VPC

5. Na lista de intercâmbios da VPC, verifique se existe uma entrada para o intercâmbio entre servicenetworking.googleapis.com e a rede da VPC onprem-dataservice-vpc.

Crie anúncios de rotas personalizadas para filestore-subnet

1. Na Google Cloud consola, aceda à página Routers na nuvem.

   Aceder aos Cloud Routers

2. Na lista do Cloud Router, clique em onprem-dataservice-vpc-router1.

3. Na página Detalhes do router, clique em Editar.

4. Na secção Rotas anunciadas, para Rotas, selecione Criar rotas personalizadas.

5. Selecione a caixa de verificação Anunciar todas as sub-redes visíveis para o Cloud Router para continuar a anunciar as sub-redes disponíveis para o Cloud Router. A ativação desta opção imita o comportamento do Cloud Router no modo de anúncio predefinido.

6. Clique em Adicionar um trajeto personalizado.

7. Para Origem, selecione Intervalo de IPs personalizado.

8. Para o Intervalo de endereços IP, introduza o seguinte intervalo de endereços IP:

   10.243.208.0/24
   

9. Em Descrição, introduza o seguinte texto:

   Filestore reserved IP address range
   

10. Clique em Concluído e, de seguida, clique em Guardar.

Crie a instância do Filestore na rede onprem-dataservice-vpc

Depois de ativar o acesso a serviços privados para a sua rede VPC, crie uma instância do Filestore e monte a instância como uma partilha NFS para a sua tarefa de preparação personalizada. Isto permite que as suas tarefas de preparação acedam a ficheiros remotos como se fossem locais, o que permite um elevado débito e uma baixa latência.

Crie a instância do Filestore

1. Na Google Cloud consola, aceda à página Instâncias do Filestore.

   Aceda às instâncias do Filestore

2. Clique em Criar instância e configure a instância da seguinte forma:

   • Defina o ID da instância para o seguinte:

     image-data-instance
     

   • Defina o Tipo de instância como Básico.

   • Defina o Tipo de armazenamento como HDD.

   • Defina Allocate capacity como 1 TiB.

   • Defina a região como us-central1 e a zona como us-central1-c.

   • Defina a rede de VPC como onprem-dataservice-vpc.

   • Defina Intervalo de IPs atribuídos como Usar um intervalo de IPs atribuídos existente e escolha filestore-subnet.

   • Defina o Nome da partilha de ficheiros para o seguinte:

     vol1
     

   • Defina os controlos de acesso como Conceder acesso a todos os clientes na rede VPC.

3. Clique em Criar.

4. Tome nota do endereço IP da nova instância do Filestore. Pode ter de atualizar o separador do navegador da consola para ver a nova instância. Google Cloud

Monte a partilha de ficheiros do Filestore

1. No Cloud Shell, execute os seguintes comandos, substituindo PROJECT_ID pelo ID do seu projeto:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Inicie sessão na instância de VM on-prem-dataservice-host:

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

3. Instale o pacote NFS na instância de VM:

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

4. Crie um diretório de montagem para a partilha de ficheiros do Filestore:

   sudo mkdir -p /mnt/nfs
   

   Nota: certifique-se de que o nome da pasta do ponto de montagem em /mnt/ é nfs. Isto deve-se ao facto de a partilha de ficheiros NFS estar montada em /mnt/nfs/ no trabalho de preparação personalizado.

5. Monte a partilha de ficheiros, substituindo FILESTORE_INSTANCE_IP pelo endereço IP da sua instância do Filestore:

   sudo mount FILESTORE_INSTANCE_IP:/vol1 /mnt/nfs
   

   Se a ligação expirar, verifique se está a fornecer o endereço IP correto da instância do Filestore.

6. Valide se a montagem do NFS foi bem-sucedida executando o seguinte comando:

   df -h
   

   Verifique se a partilha de ficheiros /mnt/nfs aparece no resultado:

   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. Altere as autorizações para tornar a partilha de ficheiros acessível:

   sudo chmod go+rw /mnt/nfs
   

   Nota: num ambiente de produção, recomendamos que defina autorizações mais detalhadas. Para mais informações, consulte o artigo Configurar o acesso numa partilha de ficheiros.

Transfira o conjunto de dados para a partilha de ficheiros

1. Na instância de VM on-prem-dataservice-host, transfira o conjunto de dados para a partilha de ficheiros:

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

   A transferência demora vários minutos.

2. Confirme que o conjunto de dados foi copiado com êxito executando o seguinte comando:

   sudo du -sh /mnt/nfs
   

   O resultado esperado é:

   104M    /mnt/nfs
   

3. Introduza exit para sair da instância de VM on-prem-dataservice-host e regressar ao comando do Cloud Shell.

Crie um contentor de preparação para o seu pipeline

O Vertex AI Pipelines armazena os artefactos das execuções de pipelines através do Cloud Storage. Antes de executar o pipeline, tem de criar um contentor do Cloud Storage para a preparação das execuções do pipeline.

No Cloud Shell, crie um contentor do Cloud Storage:

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

Crie uma conta de serviço gerida pelo utilizador para o Vertex AI Workbench

1. No Cloud Shell, crie uma conta de serviço:

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

2. Atribua a função Utilizador do Vertex AI (roles/aiplatform.user) à conta de serviço:

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

3. Atribua a função Administrador do Artifact Registry (artifactregistry.admin):

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

4. Atribua a função de administrador de armazenamento (storage.admin):

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

Crie a aplicação de preparação em Python

Nesta secção, cria uma instância do Vertex AI Workbench e usa-a para criar um pacote de aplicação de preparação personalizado em Python.

Crie uma instância do Vertex AI Workbench

1. Na Google Cloud consola, aceda ao separador Instâncias na página Vertex AI Workbench.

   Aceda ao Vertex AI Workbench

2. Clique em  Criar novo e, de seguida, clique em Opções avançadas.

   É apresentada a página Nova instância.

3. Na página Nova instância, na secção Detalhes, faculte as seguintes informações para a nova instância e, de seguida, clique em Continuar:

   • Nome: introduza o seguinte, substituindo PROJECT_ID pelo ID do projeto:

     pipeline-tutorial-PROJECT_ID
     

   • Região: selecione us-central1.

   • Zona: selecione us-central1-a.

   • Desmarque a caixa de verificação Ativar sessões interativas sem servidor do Dataproc.

4. Na secção Ambiente, clique em Continuar.

5. Na secção Tipo de máquina, indique o seguinte e, de seguida, clique em Continuar:

   • Tipo de máquina: escolha N1 e, de seguida, selecione n1-standard-4 no menu Tipo de máquina.

   • VM protegida: selecione as seguintes caixas de verificação:

     • Arranque seguro
     • Trusted Platform Module virtual (vTPM)
     • Monitorização da integridade

6. Na secção Discos, certifique-se de que Google-managed encryption key está selecionado e, de seguida, clique em Continuar:

7. Na secção Rede, indique o seguinte e, de seguida, clique em Continuar:

   • Redes: selecione Rede neste projeto e conclua os seguintes passos:

     1. No campo Rede, selecione vertex-networking-vpc.

     2. No campo Sub-rede, selecione pipeline-networking-subnet1.

     3. Desmarque a caixa de verificação Atribuir endereço IP externo. A não atribuição de um endereço IP externo impede que a instância receba comunicação não solicitada da Internet ou de outras redes de VPC.

     4. Selecione a caixa de verificação Permitir acesso por proxy.

8. Na secção IAM e segurança, indique o seguinte e, de seguida, clique em Continuar:

   • IAM e segurança: para conceder a um único utilizador acesso à interface do JupyterLab da instância, conclua os seguintes passos:

     1. Selecione Conta de serviço.
     2. Desmarque a caixa de verificação Usar conta de serviço predefinida do Compute Engine. Este passo é importante porque a conta de serviço predefinida do Compute Engine (e, por conseguinte, o único utilizador que acabou de especificar) pode ter a função de editor (roles/editor) no seu projeto.

     3. No campo Email da conta de serviço, introduza o seguinte, substituindo PROJECT_ID pelo ID do projeto:

        workbench-sa@PROJECT_ID.iam.gserviceaccount.com
        

        (Este é o endereço de email da conta de serviço personalizado que criou anteriormente.) Esta conta de serviço tem autorizações limitadas.

        Para saber como conceder acesso, consulte o artigo Faça a gestão do acesso à interface do JupyterLab de uma instância do Vertex AI Workbench.

   • Opções de segurança: desmarque a seguinte caixa de verificação:

     • Acesso root à instância

     Selecione a seguinte caixa de verificação:

     • nbconvert: nbconvert permite aos utilizadores exportar e transferir um ficheiro de bloco de notas como um tipo de ficheiro diferente, como HTML, PDF ou LaTeX. Esta definição é necessária para alguns dos blocos de notas no repositório do GitHub de Google Cloud IA generativa.

     Desmarque a seguinte caixa de verificação:

     • Transferência de ficheiros

     Selecione a seguinte caixa de verificação, a menos que esteja num ambiente de produção:

     • Acesso ao terminal: isto permite o acesso ao terminal à sua instância a partir da interface do utilizador do JupyterLab.

9. Na secção Estado de funcionamento do sistema, desmarque a opção Atualização automática do ambiente e faculte o seguinte:

   • Em Relatórios, selecione as seguintes caixas de verificação:

     • Comunique o estado do sistema
     • Comunique métricas personalizadas ao Cloud Monitoring
     • Instale o Cloud Monitoring
     • Comunique o estado do DNS para domínios Google necessários

10. Clique em Criar e aguarde alguns minutos para que a instância do Vertex AI Workbench seja criada.

Execute a aplicação de preparação na instância do Vertex AI Workbench

1. Na Google Cloud consola, aceda ao separador Instâncias na página Vertex AI Workbench.

   Aceda ao Vertex AI Workbench

2. Junto ao nome da instância do Vertex AI Workbench (pipeline-tutorial-PROJECT_ID), onde PROJECT_ID é o ID do projeto, clique em Abrir JupyterLab.

   A sua instância do Vertex AI Workbench é aberta no JupyterLab.

3. Selecione Ficheiro > Novo > Terminal.

4. No terminal do JupyterLab (não no Cloud Shell), defina uma variável de ambiente para o seu projeto. Substitua PROJECT_ID pelo ID do seu projeto:

   projectid=PROJECT_ID
   

5. Crie os diretórios principais para a aplicação de preparação (ainda no terminal do JupyterLab):

   mkdir fungi_training_package
   mkdir fungi_training_package/trainer
   

6. No  explorador de ficheiros, clique duas vezes na pasta fungi_training_package e, em seguida, clique duas vezes na pasta trainer.

7. No  explorador de ficheiros, clique com o botão direito do rato na lista de ficheiros vazia (abaixo do cabeçalho Nome) e selecione Novo ficheiro.

8. Clique com o botão direito do rato no novo ficheiro e selecione Mudar o nome do ficheiro.

9. Mude o nome do ficheiro de untitled.txt para task.py.

10. Clique duas vezes no ficheiro task.py para o abrir.

11. Copie o código seguinte para 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. Selecione Ficheiro > Guardar ficheiro Python.

13. No terminal do JupyterLab, crie um ficheiro __init__.py em cada subdiretório para o tornar um pacote:

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

14. No  explorador de ficheiros, clique duas vezes na pasta fungi_training_package.

15. Selecione Ficheiro > Novo > Ficheiro Python.

16. Clique com o botão direito do rato no novo ficheiro e selecione Mudar o nome do ficheiro.

17. Mude o nome do ficheiro de untitled.py para setup.py.

18. Clique duas vezes no ficheiro setup.py para o abrir.

19. Copie o código seguinte para 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. Selecione Ficheiro > Guardar ficheiro Python.

21. No terminal, navegue para o diretório fungi_training_package:

    cd fungi_training_package
    

22. Use o comando sdist para criar a distribuição de origem da aplicação de preparação:

    python setup.py sdist --formats=gztar
    

23. Navegue para o diretório principal:

    cd ..
    

24. Verifique se está no diretório correto:

    pwd
    

    O resultado tem o seguinte aspeto:

    /home/jupyter
    

25. Copie o pacote Python para o contentor de preparação:

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

26. Verifique se o contentor de preparação contém o pacote:

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

    O resultado é:

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

Crie a ligação de rede de serviços para o Vertex AI Pipelines

Nesta secção, cria uma ligação de rede de serviços que é usada para estabelecer serviços de produtor ligados à rede VPC vertex-networking-vpc através do peering de redes VPC. Para mais informações, consulte o artigo Intercâmbio da rede da VPC.

1. No Cloud Shell, execute os seguintes comandos, substituindo PROJECT_ID pelo ID do seu projeto:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Defina um intervalo de endereços IP reservados através 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. Estabeleça uma ligação de peering entre a rede vertex-networking-vpc VPC e a rede de serviços da Google, através de gcloud services vpc-peerings connect:

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

4. Atualize a ligação de peering de VPC para ativar a importação e a exportação de encaminhamentos aprendidos personalizados:

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

Anuncie a sub-rede do pipeline a partir do pipeline-networking Cloud Router

1. Na Google Cloud consola, aceda à página Cloud Router.

   Aceder aos Cloud Routers

2. Na lista do Cloud Router, clique em vertex-networking-vpc-router1.

3. Na página Detalhes do router, clique em Editar.

4. Clique em Adicionar um trajeto personalizado.

5. Para Origem, selecione Intervalo de IPs personalizado.

6. Para o Intervalo de endereços IP, introduza o seguinte intervalo de endereços IP:

   192.168.10.0/24
   

7. Em Descrição, introduza o seguinte texto:

   Vertex AI Pipelines reserved subnet
   

8. Clique em Concluído e, de seguida, clique em Guardar.

Crie um modelo de pipeline e carregue-o no Artifact Registry

Nesta secção, cria e carrega um modelo de pipeline do Kubeflow Pipelines (KFP). Este modelo contém uma definição de fluxo de trabalho que pode ser reutilizada várias vezes, por um único utilizador ou por vários utilizadores.

Defina e compile a pipeline

1. No Jupyterlab, no  explorador de ficheiros, clique duas vezes na pasta de nível superior.

2. Selecione Ficheiro > Novo > Bloco de notas.

3. No menu Selecionar kernel, selecione Python 3 (ipykernel) e clique em Selecionar.

4. Numa nova célula do bloco de notas, execute o seguinte comando para garantir que tem a versão mais recente do pip:

   !python -m pip install --upgrade pip
   

5. Execute o seguinte comando para instalar o Google Cloud SDK de componentes de pipeline a partir do índice de pacotes Python (PyPI):

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

6. Quando a instalação estiver concluída, selecione Kernel > Reiniciar kernel para reiniciar o kernel e garantir que a biblioteca está disponível para importação.

7. Execute o seguinte código numa nova célula do bloco de notas para definir o 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. Execute o seguinte código numa nova célula do bloco de notas para compilar a definição do pipeline:

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

   No  navegador de ficheiros, é apresentado um ficheiro denominado pipeline_config.yaml na lista de ficheiros.

Crie um repositório do Artifact Registry

1. Execute o seguinte código numa nova célula do notebook para criar um repositório de artefactos do tipo KFP:

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

Carregue o modelo de pipeline para o Artifact Registry

Nesta secção, configura um cliente de registo do SDK do Kubeflow Pipelines e carrega o modelo de pipeline compilado para o Artifact Registry a partir do bloco de notas do JupyterLab.

1. No bloco de notas do JupyterLab, execute o seguinte código para carregar o modelo de pipeline, substituindo PROJECT_ID pelo ID do seu projeto:

   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. Na Google Cloud consola, para verificar se o modelo foi carregado, aceda a Modelos de pipelines do Vertex AI.

   Aceda a Pipelines

3. Para abrir o painel Selecionar repositório, clique em Selecionar repositório.

4. Na lista de repositórios, clique no repositório que criou (fungi-repo) e, de seguida, clique em Selecionar.

5. Verifique se o seu pipeline (custom-image-classification-pipeline) aparece na lista.

Acione uma execução de pipeline a partir de um local

Nesta secção, agora que o modelo de pipeline e o pacote de preparação estão prontos, vai usar o cURL para acionar uma execução de pipeline a partir da sua aplicação no local.

Forneça os parâmetros da conduta

1. No bloco de notas do JupyterLab, execute o seguinte comando para validar o nome do modelo de pipeline:

   print (TEMPLATE_NAME)
   

   O nome do modelo devolvido é:

   custom-image-classification-pipeline
   

2. Execute o seguinte comando para obter a versão do modelo de pipeline:

   print (VERSION_NAME)
   

   O nome da versão do modelo de pipeline devolvido tem o seguinte aspeto:

   sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7
   

   Tome nota da string do nome da versão completa.

3. No Cloud Shell, execute os seguintes comandos, substituindo PROJECT_ID pelo ID do seu projeto:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

4. Inicie sessão na instância de VM on-prem-dataservice-host:

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

5. Na instância da VM on-prem-dataservice-host, use um editor de texto, como o vim ou o nano para criar o ficheiro request_body.json, por exemplo:

   sudo vim request_body.json
   

6. Adicione o seguinte texto ao ficheiro 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"
   }
   }
   

   Substitua os seguintes valores:

   • PROJECT_ID: o ID do seu projeto
   • PROJECT_NUMBER: o número do projeto. Isto é diferente do ID do projeto. Pode encontrar o número do projeto na página Definições do projeto do projeto na Google Cloud consola.
   • FILESTORE_INSTANCE_IP: o endereço IP da instância do Filestore, por exemplo, 10.243.208.2. Pode encontrar esta informação na página de instâncias do Filestore da sua instância.
   • VERSION_NAME: o nome da versão do modelo de pipeline (sha256:...) que anotou no passo 2.

7. Guarde o ficheiro da seguinte forma:

   • Se estiver a usar o vim, prima a tecla Esc e, de seguida, escreva :wq para guardar o ficheiro e sair.
   • Se estiver a usar o nano, escreva Control+O e prima Enter para guardar o ficheiro e, de seguida, escreva Control+X para sair.

Envie uma execução do pipeline a partir do seu modelo

1. Na instância de VM, execute o seguinte comando, substituindo PROJECT_ID pelo ID do seu projeto:on-prem-dataservice-host

   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
   

   O resultado apresentado é extenso, mas o principal que tem de procurar é a seguinte linha, que indica que o serviço está a preparar-se para executar o pipeline:

   "state": "PIPELINE_STATE_PENDING"
   

   A execução de todo o pipeline demora cerca de 45 a 50 minutos.

2. Na Google Cloud consola, na secção Vertex AI, aceda ao separador Execuções na página Pipelines.

   Aceda a Execuções

3. Clique no nome de execução da sua execução do pipeline (custom-image-classification-pipeline).

   É apresentada a página de execução do pipeline, que mostra o gráfico de tempo de execução do pipeline. O resumo do pipeline é apresentado no painel Análise da execução do pipeline.

   Para obter ajuda na compreensão das informações apresentadas no gráfico de tempo de execução, incluindo como ver registos e usar o Vertex ML Metadata para saber mais sobre os artefactos do seu pipeline, consulte o artigo Visualize e analise os resultados do pipeline.

Limpar

Para evitar incorrer em custos na sua Google Cloud conta pelos recursos usados neste tutorial, pode eliminar o projeto que contém os recursos ou manter o projeto e eliminar os recursos individuais.

Pode eliminar os recursos individuais no projeto da seguinte forma:

1. Elimine todas as execuções de pipelines da seguinte forma:

   1. Na Google Cloud consola, na secção Vertex AI, aceda ao separador Execuções na página Pipelines.

      Aceda a Execuções

   2. Selecione as execuções de pipelines a eliminar e clique em Eliminar.

2. Elimine o modelo de pipeline da seguinte forma:

   1. Na secção Vertex AI, aceda ao separador Os seus modelos na página Pipelines.

      Aceda a Pipelines

   2. Junto ao modelo de pipeline custom-image-classification-pipeline, clique em Ações e selecione Eliminar.

3. Elimine o repositório do Artifact Registry da seguinte forma:

   1. Na página Artifact Registry, aceda ao separador Repositórios.

      Aceda a Repositórios

   2. Selecione o repositório fungi-repo e clique em Eliminar.

4. Anule a implementação do modelo no ponto final da seguinte forma:

   1. Na secção Vertex AI, aceda ao separador Pontos finais na página Previsões online.

      Aceda a Pontos finais

   2. Clique em fungi-image-endpoint para aceder à página de detalhes do ponto final.

   3. Na linha do seu modelo, fungi-image-model, clique em Ações e selecione Anular implementação do modelo a partir do ponto final.

   4. Na caixa de diálogo Anular implementação do modelo a partir do ponto final, clique em Anular implementação.

5. Elimine o ponto final da seguinte forma:

   1. Na secção Vertex AI, aceda ao separador Pontos finais na página Previsões online.

      Aceda a Pontos finais

   2. Selecione fungi-image-endpoint e clique em Eliminar.

6. Elimine o modelo da seguinte forma:

   1. Aceda à página Registo de modelos.

      Aceda a Modelos

   2. Na linha do seu modelo, fungi-image-model, clique em Ações e selecione Eliminar modelo.

7. Elimine o contentor de preparação da seguinte forma:

   1. Aceda à página do Cloud Storage.

      Aceda ao Cloud Storage

   2. Selecione pipelines-staging-bucket-PROJECT_ID, onde PROJECT_ID é o ID do projeto, e clique em Eliminar.

8. Elimine a instância do Vertex AI Workbench da seguinte forma:

   1. Na secção Vertex AI, aceda ao separador Instâncias na página Workbench.

      Aceda ao Vertex AI Workbench

   2. Selecione a pipeline-tutorial-PROJECT_ID instância do Vertex AI Workbench, onde PROJECT_ID é o ID do projeto, e clique em Eliminar.

9. Elimine a instância de VM do Compute Engine da seguinte forma:

   1. Aceda à página Compute Engine.

      Aceder ao Compute Engine

   2. Selecione a instância de VM on-prem-dataservice-host e clique em Eliminar.

10. Elimine os túneis de VPN da seguinte forma:

    1. Aceda à página VPN.

       Aceda à VPN

    2. Na página VPN, clique no separador Túneis do Cloud VPN.

    3. Na lista de túneis de VPN, selecione os quatro túneis de VPN que criou neste tutorial e clique em Eliminar.

11. Elimine os gateways de VPN de alta disponibilidade da seguinte forma:

    1. Na página VPN, clique no separador Gateways de VPN na nuvem.

       Aceda a Gateways do Cloud VPN

    2. Na lista de gateways de VPN, clique em onprem-vpn-gw1.

    3. Na página Detalhes do gateway do Cloud VPN, clique em Eliminar gateway de VPN.

    4. Clique na seta para trás, se necessário, para regressar à lista de gateways de VPN e, de seguida, clique em vertex-networking-vpn-gw1.

    5. Na página Detalhes do gateway do Cloud VPN, clique em Eliminar gateway de VPN.

12. Elimine os routers do Cloud Router da seguinte forma:

    1. Aceda à página Routers na nuvem.

       Aceder aos Cloud Routers

    2. Na lista de Cloud Routers, selecione os quatro routers que criou neste tutorial.

    3. Para eliminar os routers, clique em Eliminar.

       Esta ação também elimina os dois gateways de NAT da nuvem ligados aos routers da nuvem.

13. Elimine as ligações de rede de serviços às redes VPC vertex-networking-vpc e onprem-dataservice-vpc da seguinte forma:

    1. Aceda à página Intercâmbio da rede da VPC.

       Aceda ao intercâmbio da rede da VPC

    2. Selecione servicenetworking-googleapis-com.

    3. Para eliminar as associações, clique em Eliminar.

14. Elimine a regra de encaminhamento pscvertex para a rede de VPC vertex-networking-vpc da seguinte forma:

    1. Aceda ao separador Front-ends da página Equilíbrio de carga.

       Aceda a Frontends

    2. Na lista de regras de encaminhamento, clique em pscvertex.

    3. Na página Detalhes da regra de encaminhamento global, clique em Eliminar.

15. Elimine a instância do Filestore da seguinte forma:

    1. Aceda à página Filestore.

       Aceda ao Filestore

    2. Selecione a instância image-data-instance.

    3. Para eliminar a instância, clique em Ações e, de seguida, em Eliminar instância.

16. Elimine as redes de VPC da seguinte forma:

    1. Aceda à página Redes VPC.

       Aceda a redes de VPC

    2. Na lista de redes de VPC, clique em onprem-dataservice-vpc.

    3. Na página Detalhes da rede de VPC, clique em Eliminar rede de VPC.

       A eliminação de cada rede também elimina as respetivas sub-redes, rotas e regras de firewall.

    4. Na lista de redes de VPC, clique em vertex-networking-vpc.

    5. Na página Detalhes da rede de VPC, clique em Eliminar rede de VPC.

17. Elimine as contas de serviço workbench-sa e onprem-user-managed-sa da seguinte forma:

    1. Aceda à página Contas de serviço.

       Aceda a Contas de serviço

    2. Selecione as contas de serviço onprem-user-managed-sa e workbench-sa e clique em Eliminar.

O que se segue?

• Saiba como usar o Vertex AI Pipelines para orquestrar o processo de criação e implementação dos seus modelos de aprendizagem automática.

• Saiba mais sobre o conjunto de dados deFungi.