Usar o Private Service Connect para acessar pipelines de treinamento no local

O Vertex AI Pipelines é um serviço gerenciado para criar, implantar e gerenciar fluxos de trabalho completos de machine learning (ML) na plataforma Google Cloud. É um ambiente sem servidor para executar pipelines, para que você não precise se preocupar com o gerenciamento da infraestrutura.

Neste tutorial, você vai usar o Vertex AI Pipelines para executar um job de treinamento personalizado e implantar o modelo treinado na Vertex AI, em um ambiente de rede híbrida.

O processo inteiro leva de duas a três horas, incluindo cerca de 50 minutos para a execução do pipeline.

Este tutorial é destinado a administradores de redes empresariais, cientistas de dados e pesquisadores que estão familiarizados com a Vertex AI, a nuvem privada virtual (VPC), o console do Google Cloud e o Cloud Shell. Conhecer o Vertex AI Workbench é útil, mas não é obrigatório.

Diagrama de arquitetura do uso do Private Service Connect para acessar pipelines de treinamento.

Objetivos

Crie duas redes de nuvem privada virtual (VPC):
- Uma delas (vertex-networking-vpc) é para usar a API Vertex AI Pipelines para criar e hospedar um modelo de pipeline, que será usado para treinar um modelo de machine learning e implantá-lo em um endpoint.
- A outra (onprem-dataservice-vpc) representa uma rede local.
Conecte as duas redes VPC da seguinte maneira:
- Implante gateways de VPN de alta disponibilidade, túneis do Cloud VPN e Cloud Routers para conectar vertex-networking-vpc e onprem-dataservice-vpc.
- Crie um endpoint do Private Service Connect (PSC) para encaminhar solicitações particulares à API REST Vertex AI Pipelines.
- Configure uma divulgação de rota personalizada do Cloud Router em vertex-networking-vpc para anunciar rotas para o endpoint do Private Service Connect para onprem-dataservice-vpc.
Crie uma instância do Filestore na rede VPC onprem-dataservice-vpc e adicione dados de treinamento a ela em um compartilhamento NFS.
Crie um aplicativo de pacote Python para o job de treinamento.
Crie um modelo de job do Vertex AI Pipelines para fazer o seguinte:
- Criar e executar o job de treinamento com os dados do compartilhamento NFS.
- Importar o modelo treinado e fazer o upload dele no Vertex AI Model Registry.
- Criar um endpoint da Vertex AI para previsões on-line.
- Implantar o modelo no endpoint.
Fazer upload do modelo de pipeline em um repositório do Artifact Registry.
Usar a API REST Vertex AI Pipelines para acionar uma execução de pipeline em um host de serviço de dados local (on-prem-dataservice-host).

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

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

Go to project selector
Select or create a Google Cloud project.
Make sure that billing is enabled for your Google Cloud project.
Abra o Cloud Shell para executar os comandos listados neste tutorial. O Cloud Shell é um ambiente shell interativo para o Google Cloud que permite gerenciar projetos e recursos a partir do navegador da Web.
No Cloud Shell, defina o projeto atual como o ID do projeto do Google Cloud e armazene o mesmo ID do projeto na variável de shell projectid:
```
  projectid="PROJECT_ID"
  gcloud config set project ${projectid}
```
Substitua PROJECT_ID pelo ID do projeto. Se necessário, localize o ID do projeto no console do Google Cloud. Para mais informações, consulte Encontrar o ID do projeto.
Se você não é proprietário do projeto, peça ao proprietário que conceda a você o papel Administrador de IAM do projeto (roles/resourcemanager.projectIamAdmin). É preciso ter esse papel para conceder papéis do IAM na próxima etapa.
Grant roles to your user account. Run the following command once for each of the following IAM roles: 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
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
- Replace PROJECT_ID with your project ID.
- Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.
- Replace ROLE with each individual role.

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

gcloud services enable dns.googleapis.com artifactregistry.googleapis.com iam.googleapis.com compute.googleapis.com logging.googleapis.com networkconnectivity.googleapis.com notebooks.googleapis.com file.googleapis.com servicenetworking.googleapis.com serviceusage.googleapis.com aiplatform.googleapis.com

Criar as redes VPC

Nesta seção, você vai criar duas redes VPC: uma para acessar as APIs do Google do Vertex AI Pipelines e outra para simular uma rede local. Em cada uma das duas redes VPC, você vai criar um Cloud Router e um gateway do Cloud NAT. O gateway do Cloud NAT permite que instâncias de máquina virtual (VM) do Compute Engine sem endereços IP externos iniciem conexões externas.

No Cloud Shell, execute os seguintes comandos, substituindo PROJECT_ID pelo ID do projeto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Crie a rede VPC vertex-networking-vpc:

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

Na rede vertex-networking-vpc, crie uma sub-rede chamada 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

Crie a rede VPC para simular a rede local (onprem-dataservice-vpc):

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

Na rede onprem-dataservice-vpc, crie uma sub-rede chamada 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

Verificar se as redes VPC estão configuradas corretamente

No console do Google Cloud, acesse a guia Redes no projeto atual na página Redes VPC.

Acessar redes VPC
Na lista de redes VPC, verifique se as duas redes foram criadas: vertex-networking-vpc e onprem-dataservice-vpc.
Clique na guia Sub-redes no projeto atual.
Na lista de sub-redes VPC, verifique se as sub-redes pipeline-networking-subnet1 e onprem-dataservice-vpc-subnet1 foram criadas.

Configurar conectividade híbrida

Nesta seção, você cria dois gateways de VPN de alta disponibilidade conectados entre si. Um fica na rede VPC vertex-networking-vpc. O outro fica na rede VPC onprem-dataservice-vpc. Cada gateway contém um Cloud Router e um par de túneis VPN.

Criar os gateways de VPN de alta disponibilidade

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

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

No console do Google Cloud, acesse a guia Gateways do Cloud VPN na página VPN.

Acessar a VPN
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.

Criar Cloud Routers e gateways do Cloud NAT

Em cada uma das duas redes VPC, você vai criar dois Cloud Routers: um para usar com o Cloud NAT e outro para gerenciar as sessões BGP da VPN de alta disponibilidade.

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

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

Crie um Cloud Router para a rede VPC onprem-dataservice-vpc, que será usada para a VPN:

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

Crie um Cloud Router para a rede VPC vertex-networking-vpc, que será usada para o Cloud NAT:

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

Configure um 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

Crie um Cloud Router para a rede VPC onprem-dataservice-vpc, que será usada para o Cloud NAT:

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

Configure um 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

No console do Google Cloud, acesse a página do Cloud Routers.

Acesse o Cloud Routers
Na lista Cloud Routers, verifique se os seguintes roteadores foram criados:
- cloud-router-us-central1-onprem-nat
- cloud-router-us-central1-vertex-nat
- onprem-dataservice-vpc-router1
- vertex-networking-vpc-router1
Talvez seja necessário atualizar a guia do console do Google Cloud para que os novos valores apareçam.
Na lista de Cloud Routers, clique em cloud-router-us-central1-vertex-nat.
Na página Detalhes do roteador, verifique se o gateway cloud-nat-us-central1 do Cloud NAT foi criado.
Clique na seta para voltar e retorne à página Cloud Routers.
Na lista de Cloud Routers, clique em cloud-router-us-central1-onprem-nat.
Na página Detalhes do roteador, verifique se o gateway cloud-nat-us-central1-on-prem do Cloud NAT foi criado.

Criar túneis VPN

No Cloud Shell, na rede vertex-networking-vpc, crie um túnel VPN chamado 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

Na rede vertex-networking-vpc, crie um túnel de VPN chamado 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

Na rede onprem-dataservice-vpc, crie um túnel de VPN chamado 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

Na rede onprem-dataservice-vpc, crie um túnel de VPN chamado 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

No Console do Google Cloud, acesse a página VPN.

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

Criar sessões do BGP

O Cloud Router usa o protocolo de gateway de borda (BGP) para trocar rotas entre a rede VPC (neste caso, vertex-networking-vpc) e a rede local (representada por onprem-dataservice-vpc). No Cloud Router, você configura uma interface e um peering do BGP para o roteador local. A interface e a configuração de peering do BGP formam uma sessão do BGP. Nesta seção, você vai criar duas sessões do BGP para vertex-networking-vpc e duas para onprem-dataservice-vpc.

Depois que você configurar as interfaces e os peerings do BGP entre os roteadores, eles começarão a trocar rotas de forma automática.

Estabelecer as sessões do BGP de `vertex-networking-vpc`

No Cloud Shell, na rede vertex-networking-vpc, crie uma interface do 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

Na rede vertex-networking-vpc, crie um peering do 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

Na rede vertex-networking-vpc, crie uma interface do 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

Na rede vertex-networking-vpc, crie um peering do 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 do BGP para `onprem-dataservice-vpc`

Na rede onprem-dataservice-vpc, crie uma interface do 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

Na rede onprem-dataservice-vpc, crie um peering do 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

Na rede onprem-dataservice-vpc, crie uma interface do 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

Na rede onprem-dataservice-vpc, crie um peering do 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 do BGP

No Console do Google Cloud, acesse a página VPN.

Acessar a VPN
Na lista de túneis de VPN, verifique se o valor na coluna Status da sessão do BGP de cada túnel mudou de Configurar sessão do BGP para O BGP foi estabelecido. Talvez seja necessário atualizar a guia do console do Google Cloud para que os novos valores apareçam.

Validar as rotas aprendidas de `onprem-dataservice-vpc`

No Console do Google Cloud, acesse a página Redes VPC.

Acessar redes VPC
Na lista de redes VPC, clique em onprem-dataservice-vpc.
Clique na guia Rotas.
Selecione us-central1 (Iowa) na lista Região e clique em Visualizar.
Na coluna Intervalo de IPs de destino, verifique se o intervalo de IP de sub-rede pipeline-networking-subnet1 (10.0.0.0/24) aparece duas vezes.

Talvez seja necessário atualizar a guia do console do Google Cloud para que as duas entradas apareçam.

Validar as rotas aprendidas de `vertex-networking-vpc`

Clique na seta para voltar e retorne à página Redes VPC.
Na lista de redes VPC, clique em vertex-networking-vpc.
Clique na guia Rotas.
Selecione us-central1 (Iowa) na lista Região e clique em Visualizar.
Na coluna Intervalo de IPs de destino, verifique se o intervalo de IP da sub-rede onprem-dataservice-vpc-subnet1 (172.16.10.0/24) aparece duas vezes.

Criar um endpoint do Private Service Connect para APIs do Google

Nesta seção, você vai criar um endpoint do Private Service Connect para APIs do Google que serão usadas para acessar a API REST Vertex AI Pipelines na rede local.

No Cloud Shell, reserve um endereço IP de endpoint do consumidor, que será usado para acessar as APIs do Google:

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

Crie uma regra de encaminhamento para conectar o endpoint aos serviços e APIs do Google.

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

Criar divulgações de rota personalizadas para `vertex-networking-vpc`

Nesta seção, você vai criar uma divulgação de rota personalizada para vertex-networking-vpc-router1 (o Cloud Router de vertex-networking-vpc) para divulgar o endereço IP do endpoint do PSC para a rede VPC onprem-dataservice-vpc.

No console do Google Cloud, acesse a página do Cloud Routers.

Acesse o Cloud Routers
Na lista de Cloud Routers, clique em vertex-networking-vpc-router1.
Na página Detalhes do Router, clique em Editar.
Na seção Rotas divulgadas, para Rotas, selecione Criar rotas personalizadas.
Selecione a caixa de seleção Divulgar todas as sub-redes visíveis para o Cloud Router para continuar divulgando as sub-redes disponíveis para o Cloud Router. A ativação dessa opção imita o comportamento do Cloud Router no modo de divulgação padrão.
Clique em Adicionar uma rota personalizada.
Em Origem, selecione Intervalo de IP personalizado.
Em Intervalo de endereços IP, insira o seguinte endereço IP:
```
192.168.0.1
```

Para Descrição, insira o seguinte texto:

Custom route to advertise Private Service Connect endpoint IP address

Clique em Concluído e depois em Salvar.

Valide se o `onprem-dataservice-vpc` aprendeu as rotas divulgadas

No console do Google Cloud, acesse a página Rotas.

Acessar a página Rotas
Na guia Rotas efetivas, faça o seguinte:
1. Em Rede, escolha onprem-dataservice-vpc.
2. Em Região, escolha us-central1 (Iowa).
3. Clique em Visualizar.
4. Na lista de rotas, verifique se há duas entradas com nomes que 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 essas entradas não aparecerem imediatamente, aguarde alguns minutos e atualize a guia do console do Google Cloud.
5. Verifique se duas das entradas têm o Intervalo de IP de destino 192.168.0.1/32 e duas têm o Intervalo de IP de destino 10.0.0.0/24.

Criar uma instância de VM em `onprem-dataservice-vpc`

Nesta seção, você vai criar uma instância de VM que simula um host de serviço de dados local. Seguindo as práticas recomendadas do Compute Engine e IAM, essa VM usa uma conta de serviço gerenciada pelo usuário em vez da conta padrão de serviço do Compute Engine.

Criar a conta de serviço gerenciada pelo usuário para a instância de VM

No Cloud Shell, execute os seguintes comandos, substituindo PROJECT_ID pelo ID do projeto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Crie uma conta de serviço chamada onprem-user-managed-sa:

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

Atribua o papel Usuário da 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"

Atribua o papel Leitor da 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"

Atribua o papel Editor do Cloud 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"

Atribua o papel 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"

Atribua o papel Usuário 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"

Atribua o papel 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"

Atribua o papel Administrador de objetos do Storage (roles/storage.objectAdmin):

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

Atribua o papel Administrador da geração de registros (roles/logging.admin):

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

Criar a instância de VM `on-prem-dataservice-host`

A instância de VM criada não tem um endereço IP externo e não permite acesso direto pela Internet. Para ativar o acesso administrativo à VM, use o encaminhamento de TCP do Identity-Aware Proxy (IAP).

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"

Crie uma regra de firewall para permitir que o IAP se conecte à 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

Atualizar o arquivo `/etc/hosts` para apontar para o endpoint do PSC

Nesta seção, você vai adicionar uma linha ao arquivo /etc/hosts que faz com que as solicitações enviadas ao endpoint de serviço público (us-central1-aiplatform.googleapis.com) sejam redirecionadas para o endpoint do PSC (192.168.0.1).

No Cloud Shell, faça login na instância de VM on-prem-dataservice-host usando o IAP:

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

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

Adicione a linha a seguir ao arquivo:

192.168.0.1 us-central1-aiplatform.googleapis.com

Essa linha atribui o endereço IP do endpoint do PSC (192.168.0.1) ao nome de domínio totalmente qualificado da API Vertex AI do Google (us-central1-aiplatform.googleapis.com).

O arquivo editado deve ficar assim:

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

Salve o arquivo da seguinte maneira:
- Se você estiver usando vim, pressione a tecla Esc e, em seguida, digite :wq para salvar o arquivo e sair.
- Se você estiver usando nano, digite Control+O e pressione Enter para salvar o arquivo. Em seguida, digite Control+X para sair.
Dê um ping no endpoint da API Vertex AI da seguinte maneira:
```
ping us-central1-aiplatform.googleapis.com
```
O comando ping vai mostrar a seguinte saída. 192.168.0.1 é o endereço IP do endpoint do PSC:
```
PING us-central1-aiplatform.googleapis.com (192.168.0.1) 56(84) bytes of data.
```
Digite Control+C para sair de ping.
Digite exit para sair da instância de VM on-prem-dataservice-host e retornar ao prompt do Cloud Shell.

Configurar a rede de uma instância do Filestore

Nesta seção, você vai ativar o acesso a serviços particulares para a rede VPC, uma etapa preparatória para criar uma instância do Filestore e montá-la como um compartilhamento do sistema de arquivos de rede (NFS, na sigla em inglês). Para entender o que você vai fazer nesta seção e na próxima, consulte Ativar um compartilhamento de NFS para treinamento personalizado e Configurar o peering de rede VPC.

Ativar o acesso a serviços particulares em uma rede VPC

Nesta seção, você vai criar uma conexão de rede de serviços e usá-la para ativar o acesso a serviços particulares à rede VPC onprem-dataservice-vpc por meio do peering de rede VPC.

No Cloud Shell, defina um intervalo de endereços IP reservados usando 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

Estabeleça uma conexão de peering entre a rede VPC onprem-dataservice-vpc e a rede de serviços do Google usando gcloud services vpc-peerings connect:

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

Modifique o peering de rede VPC para ativar a importação e exportação de rotas aprendidas personalizadas:

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

No console do Google Cloud, acesse a página Peering de rede VPC.

Acessar o peering de rede VPC
Na lista de peerings de VPC, verifique se há uma entrada para o peering entre servicenetworking.googleapis.com e a rede VPC onprem-dataservice-vpc.

Criar divulgações de rota personalizadas para `filestore-subnet`

No console do Google Cloud, acesse a página do Cloud Routers.

Acesse o Cloud Routers
Na lista de Cloud Routers, clique em onprem-dataservice-vpc-router1.
Na página Detalhes do Router, clique em Editar.
Na seção Rotas divulgadas, para Rotas, selecione Criar rotas personalizadas.
Selecione a caixa de seleção Divulgar todas as sub-redes visíveis para o Cloud Router para continuar divulgando as sub-redes disponíveis para o Cloud Router. A ativação dessa opção imita o comportamento do Cloud Router no modo de divulgação padrão.
Clique em Adicionar uma rota personalizada.
Em Origem, selecione Intervalo de IP personalizado.
Em Intervalo de endereços IP, digite o seguinte endereço IP:
```
10.243.208.0/24
```
Em Descrição, digite o seguinte:
```
Filestore reserved IP address range
```
Clique em Concluído e depois em Salvar.

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

Depois de ativar o acesso a serviços particulares na sua rede VPC, crie uma instância do Filestore e monte a instância como um compartilhamento NFS para o job de treinamento personalizado. Isso permite que os jobs de treinamento acessem arquivos remotos como se fossem locais, permitindo alta capacidade de processamento e baixa latência.

Criar a instância do Filestore

No console do Google Cloud, acesse a página Instâncias do Filestore.

Acesse Instâncias do Filestore
Clique em Criar instância e configure a instância da seguinte maneira:
- Em ID da instância, digite o seguinte:
```
image-data-instance
```
- Em Tipo de instância, selecione Básico.
- Em Tipo de armazenamento, selecione HDD.
- Em Alocar capacidade, configure 1 TiB.
- Em Região, selecione us-central1. Em Zona, selecione us-central1-c.
- Defina a rede VPC como onprem-dataservice-vpc.
- Em Intervalo de IPs alocado, selecione Use um intervalo de IP alocado vigente e escolha filestore-subnet.
- Em Nome do compartilhamento de arquivos, digite:
```
vol1
```
- Em Controles de acesso, selecione Permitir acesso a todos os clientes na rede VPC.
Clique em Criar.
Anote o endereço IP da nova instância do Filestore. Talvez seja necessário atualizar a guia do console do Google Cloud para que a nova instância apareça.

Montar o compartilhamento de arquivos do Filestore

No Cloud Shell, execute os seguintes comandos, substituindo PROJECT_ID pelo ID do projeto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Faça login na instância de VM on-prem-dataservice-host:

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

Instale o pacote NFS na instância de VM:

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

Crie um diretório de montagem para o compartilhamento de arquivos do Filestore:
```
sudo mkdir -p /mnt/nfs
```
Observação: o nome da pasta do ponto de montagem dentro de /mnt/ precisa ser nfs. Isso porque o compartilhamento de arquivos NFS é montado em /mnt/nfs/ dentro do job de treinamento personalizado.
Monte o compartilhamento de arquivos, substituindo FILESTORE_INSTANCE_IP pelo endereço IP da sua instância do Filestore:
```
sudo mount FILESTORE_INSTANCE_IP:/vol1 /mnt/nfs
```
Se a conexão expirar, verifique se o endereço IP da instância do Filestore está correto.

Execute este comando para verificar se a montagem do NFS foi concluída:

df -h

Verifique se o compartilhamento de arquivos /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

Mude as permissões para tornar o compartilhamento de arquivos acessível:
```
sudo chmod go+rw /mnt/nfs
```
Observação: em um ambiente de produção, recomendamos que você defina permissões mais granulares. Para mais informações, consulte Como configurar o acesso em um compartilhamento de arquivos.

Baixar o conjunto de dados no compartilhamento de arquivos

Na instância de VM on-prem-dataservice-host, baixe o conjunto de dados para o compartilhamento de arquivos:
```
gcloud storage cp gs://cloud-samples-data/vertex-ai/dataset-management/datasets/fungi_dataset /mnt/nfs/ --recursive
```
O download leva alguns minutos.
Execute este comando para confirmar se o conjunto de dados foi copiado:
```
sudo du -sh /mnt/nfs
```
A resposta esperada é:
```
104M    /mnt/nfs
```
Digite exit para sair da instância de VM on-prem-dataservice-host e retornar ao prompt do Cloud Shell.

Criar um bucket de preparo para o pipeline

O Vertex AI Pipelines armazena os artefatos das execuções de pipeline usando o Cloud Storage. Antes de executar o pipeline, você precisa criar um bucket do Cloud Storage para preparar as execuções de pipeline.

No Cloud Shell, crie um bucket do Cloud Storage.

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

Criar uma conta de serviço gerenciada pelo usuário para o Vertex AI Workbench

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

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

Atribua o papel Usuário da 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"

Atribua o papel 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"

Atribua o papel Administrador de armazenamento (storage.admin):

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

Criar o aplicativo de treinamento Python

Nesta seção, você vai criar uma instância do Vertex AI Workbench e usá-la para criar um pacote de aplicativo de treinamento personalizado em Python.

Criar uma instância do Vertex AI Workbench

No console do Google Cloud, acesse a guia Instâncias na página do Vertex AI Workbench.

Acesse o Vertex AI Workbench
Clique em Criar novo e em Opções avançadas.

A página Nova instância será aberta.
Na página Nova instância, na seção Detalhes, digite as seguintes informações da nova instância e clique em Continuar:
- Nome: digite 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 seleção Ativar sessões interativas do Dataproc sem servidor.
Na seção Ambiente, clique em Continuar.
Na seção Tipo de máquina, preencha as seguintes informações e clique em Continuar:
- Tipo de máquina: escolha N1 e selecione n1-standard-4 no menu Tipo de máquina.
- VM protegida: marque as seguintes caixas de seleção:
  - inicialização segura;
  - Módulo de plataforma confiável e virtual (vTPM)
  - monitoramento de integridade
Na seção Discos, verifique se a Chave de criptografia gerenciada pelo Google está selecionada e clique em Continuar:
Na seção Rede, forneça as informações a seguir e clique em Continuar:
- Rede: selecione Rede neste projeto e siga as seguintes etapas:
  1. No campo Rede, selecione vertex-networking-vpc.
  2. No campo Sub-rede, selecione pipeline-networking-subnet1.
  3. Desmarque a caixa de seleção Atribuir endereço IP externo. A não atribuição de um endereço IP externo impede que a instância receba comunicações não solicitadas da Internet ou de outras redes VPC.
  4. Marque a caixa de seleção Permitir acesso ao proxy.
Na seção IAM e segurança, forneça as informações a seguir e clique em Continuar:
- IAM e segurança: para conceder a um único usuário acesso à interface do JupyterLab da instância, siga as seguintes etapas:
  1. Selecione Conta de serviço.
  2. Desmarque a caixa de seleção Usar conta de serviço padrão do Compute Engine. Essa etapa é importante porque a conta de serviço padrão do Compute Engine (e, portanto, o único usuário que você acabou de especificar) pode receber o papel de Editor (roles/editor) no projeto.
  3. No campo E-mail da conta de serviço, digite o seguinte, substituindo PROJECT_ID pelo ID do projeto:
```
workbench-sa@PROJECT_ID.iam.gserviceaccount.com
```
    Esse é o endereço de e-mail da conta de serviço personalizada que você criou anteriormente. Essa conta de serviço tem permissões limitadas.
    
    Para saber mais sobre como conceder acesso, consulte Gerenciar o acesso à interface do JupyterLab de uma instância do Vertex AI Workbench.
- Opções de segurança: desmarque a caixa de seleção a seguir:
  - Acesso raiz à instância
  Marque a seguinte caixa de seleção:
  - O nbconvert nbconvert permite que os usuários exportem e baixem um arquivo de notebook como outro tipo de arquivo, como HTML, PDF ou LaTeX. Essa configuração é exigida por alguns dos notebooks no repositório do GitHub da IA generativa do Google Cloud.
  Desmarque a seguinte caixa de seleção:
  - Permitir downloads do arquivo
  Marque a seguinte caixa de seleção, a menos que você esteja em um ambiente de produção:
  - Acesso ao terminal: permite acessar a instância pelo terminal na interface de usuário do JupyterLab.
Na seção Integridade do sistema, remova Upgrade automático do ambiente e preencha o seguinte:
- Em Relatórios, marque as seguintes caixas de seleção:
  - Relatar a integridade do sistema
  - Relatar métricas personalizadas para o Cloud Monitoring
  - Instalar o Cloud Monitoring
  - Informar o status de DNS dos domínios obrigatórios do Google
Clique em Criar e aguarde alguns minutos para que a instância do Vertex AI Workbench seja criada.

Executar o aplicativo de treinamento na instância do Vertex AI Workbench

No console do Google Cloud, acesse a guia Instâncias na página do Vertex AI Workbench.

Acesse o Vertex AI Workbench
Ao lado do nome da instância do Vertex AI Workbench (pipeline-tutorial-PROJECT_ID), em que PROJECT_ID é o ID do projeto, clique em Abrir JupyterLab.

A instância do Vertex AI Workbench será aberta no JupyterLab.
Selecione Arquivo > Novo > Terminal.
No terminal JupyterLab (não no Cloud Shell), defina uma variável de ambiente para o projeto. Substitua PROJECT_ID pelo código do projeto:
```
projectid=PROJECT_ID
```
Crie os diretórios pai do aplicativo de treinamento (ainda no terminal do JupyterLab):
```
mkdir fungi_training_package
mkdir fungi_training_package/trainer
```
No Navegador de arquivos, clique duas vezes na pasta fungi_training_package e depois na pasta trainer.
No File Browser, clique com o botão direito do mouse na lista de arquivos vazia (sob o título Nome) e selecione Novo arquivo.
Clique com o botão direito do mouse no novo arquivo e selecione Renomear arquivo.
Renomeie o arquivo de untitled.txt para task.py.
Clique duas vezes no arquivo do task.py para abri-lo.

Copie o seguinte código em 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)

Selecione Arquivo > Salvar arquivo Python.
No terminal do JupyterLab, crie um arquivo __init__.py em cada subdiretório para torná-lo um pacote:
```
touch fungi_training_package/__init__.py
touch fungi_training_package/trainer/__init__.py
```
No Navegador de arquivos, clique duas vezes na nova pasta fungi_training_package.
Selecione Arquivo > Novo > Arquivo Python.
Clique com o botão direito do mouse no novo arquivo e selecione Renomear arquivo.
Renomeie o arquivo de untitled.py para setup.py.
Clique duas vezes no arquivo setup.py para abri-lo.

Copie o seguinte código 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.'
)

Selecione Arquivo > Salvar arquivo Python.
No terminal, acesse o diretório fungi_training_package:
```
cd fungi_training_package
```
Use o comando sdist para criar a distribuição de origem do aplicativo de treinamento:
```
python setup.py sdist --formats=gztar
```
Navegue até o diretório pai:
```
cd ..
```
Verifique se você está no diretório correto:
```
pwd
```
A saída será semelhante ao seguinte:
```
/home/jupyter
```

Copie o pacote Python para o bucket de preparo:

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

Verifique se o bucket de preparo contém o pacote:

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

A resposta é:

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

Criar a conexão de rede de serviços para o Vertex AI Pipelines

Nesta seção, você vai criar uma conexão de rede de serviços que é usada para estabelecer serviços de produtor conectados à rede VPC vertex-networking-vpc pelo peering de rede VPC. Para mais informações, consulte Peering de rede VPC.

No Cloud Shell, execute os seguintes comandos, substituindo PROJECT_ID pelo ID do projeto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Defina um intervalo de endereços IP reservado usando 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

Estabeleça uma conexão de peering entre a rede VPC vertex-networking-vpc e a rede de serviços do Google usando gcloud services vpc-peerings connect:

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

Modifique a conexão de peering de VPC para ativar a importação e exportação de rotas aprendidas personalizadas:

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

Anunciar a sub-rede do pipeline no Cloud Router `pipeline-networking`

No console do Google Cloud, acesse a página do Cloud Router.

Acessar Cloud Routers
Na lista de Cloud Routers, clique em vertex-networking-vpc-router1.
Na página Detalhes do roteador, clique em Editar.
Clique em Adicionar uma rota personalizada.
Em Origem, selecione Intervalo de IP personalizado.
Em Intervalo de endereços IP, digite o seguinte endereço IP:
```
192.168.10.0/24
```
Em Descrição, digite o seguinte:
```
Vertex AI Pipelines reserved subnet
```
Clique em Concluído e depois em Salvar.

Criar um modelo de pipeline e fazer upload dele para o Artifact Registry

Nesta seção, você vai criar e fazer upload de um modelo de pipeline do Kubeflow Pipelines (KFP). Esse modelo contém uma definição de fluxo de trabalho que pode ser reutilizada várias vezes por um ou vários usuários.

Definir e compilar o pipeline

No JupyterLab, no Navegador de arquivos, clique duas vezes na pasta de nível superior.
Selecione Arquivo -> Novo -> Notebook.
No menu Selecionar kernel, selecione Python 3 (ipykernel) e clique em Selecionar.
Em uma nova célula do notebook, execute o seguinte comando para usar a versão mais recente do pip:
```
!python -m pip install --upgrade pip
```
Execute o seguinte comando para instalar o SDK dos componentes do Google Cloud Pipeline pelo índice de pacotes do Python (PyPI):
```
!pip install --upgrade google-cloud-pipeline-components
```
Quando a instalação estiver concluída, selecione Kernel -> Reiniciar kernel para reiniciar o kernel e garantir que a biblioteca esteja disponível para importação.

Execute o seguinte código em uma nova célula do notebook 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,
      )

Execute o código abaixo em uma nova célula do notebook 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 arquivos , um arquivo chamado pipeline_config.yaml vai aparecer na lista de arquivos.

Criar um repositório do Artifact Registry

Execute o código abaixo em uma nova célula do notebook para criar um repositório de artefatos do tipo KFP:

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

Fazer upload do modelo de pipeline para o Artifact Registry

Nesta seção, você vai configurar um cliente de registro do SDK do Kubeflow Pipelines e fazer upload do modelo de pipeline compilado para o Artifact Registry pelo notebook do JupyterLab.

No notebook do JupyterLab, execute o seguinte código para fazer upload do modelo de pipeline, substituindo PROJECT_ID pelo ID do 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."})

No console do Google Cloud, para verificar se o modelo foi enviado, acesse modelos do Vertex AI Pipelines.

Acessar "Pipelines"
Para abrir o painel Selecionar repositório, clique em Selecionar repositório.
Na lista de repositórios, clique no repositório que você criou (fungi-repo) e em Selecionar.
Verifique se seu pipeline (custom-image-classification-pipeline) aparece na lista.

Acionar uma execução de pipeline no local

Nesta seção, agora que o modelo de pipeline e o pacote de treinamento estão prontos, você vai usar o cURL para acionar uma execução de pipeline pelo aplicativo local.

Informar os parâmetros do pipeline

No notebook do JupyterLab, execute o seguinte comando para verificar qual é nome do modelo do pipeline:
```
print (TEMPLATE_NAME)
```
O nome do modelo retornado é:
```
custom-image-classification-pipeline
```
Execute o seguinte comando para conferir a versão do modelo do pipeline:
```
print (VERSION_NAME)
```
O nome da versão do modelo de pipeline retornado é parecido com este:
```
sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7
```
Anote a string inteira do nome da versão.
No Cloud Shell, execute os seguintes comandos, substituindo PROJECT_ID pelo ID do projeto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```