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ê usa 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íbrido.

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.

Crie 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ê cria um Cloud Router e um gateway do Cloud NAT. Um gateway do Cloud NAT fornece conectividade de saída para instâncias de máquina virtual (VM) do Compute Engine sem endereços IP externos.

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

    projectid=PROJECT_ID
gcloud config set project ${projectid}

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

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

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

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

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

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

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

    Acessar redes VPC

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

  3. Clique na guia Sub-redes no projeto atual.

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

  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. No console Google Cloud , acesse a guia Gateways do Cloud VPN na página VPN.

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

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.

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

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

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

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

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

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

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

    Acesse o Cloud Routers

  8. 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 navegador do console Google Cloud para que os novos valores apareçam.

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

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

  11. Clique na seta para voltar e retorne à página Cloud Routers.

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

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

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

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

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

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

  5. No console Google Cloud , acesse a página VPN.

    Acessar a VPN

  6. 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ê cria 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.

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

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

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

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

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

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

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

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

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

  1. No console Google Cloud , acesse a página VPN.

    Acessar a VPN

  2. Na lista de túneis de VPN, verifique se o valor na coluna Status da sessão do BGP para cada um dos túneis mudou de Configurar sessão do BGP para O BGP foi estabelecido. Talvez seja necessário atualizar a guia do navegador do console Google Cloud para visualizar os novos valores.

Validar as onprem-dataservice-vpc rotas aprendidas

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

    Acessar redes VPC

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

  3. Clique na guia Rotas.

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

  5. 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 navegador do console Google Cloud para que as duas entradas apareçam.

Validar as vertex-networking-vpc rotas aprendidas

  1. Clique na seta para voltar e retorne à página Redes VPC.

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

  3. Clique na guia Rotas.

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

  5. Na coluna Intervalo de IP 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.

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

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

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

    Acesse o Cloud Routers

  2. Na lista de Cloud Routers, clique em vertex-networking-vpc-router1.

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

  4. Na seção Rotas divulgadas, para Rotas, selecione Criar rotas personalizadas.

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

  6. Clique em Adicionar uma rota personalizada.

  7. Em Origem, selecione Intervalo de IP personalizado.

  8. Em Intervalo de endereços IP, insira o seguinte endereço IP:

    192.168.0.1

  9. Para Descrição, insira o seguinte texto:

    Custom route to advertise Private Service Connect endpoint IP address

  10. Clique em Concluído e depois em Salvar.

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

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

    Acessar a página Rotas

  2. 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 navegador do console 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 VM na instância 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

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

    projectid=PROJECT_ID
gcloud config set project ${projectid}

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

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

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

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

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

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

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

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

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

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

  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

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

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

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

  5. Dê um ping no endpoint de API Vertex AI da seguinte maneira:

    ping us-central1-aiplatform.googleapis.com

    O comando ping precisa retornar 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.

  6. Digite Control+C para sair de ping.

  7. Digite exit para sair da instância de VM on-prem-dataservice-host e voltar 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.

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

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

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

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

    Acessar o peering de rede VPC

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

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

    Acesse o Cloud Routers

  2. Na lista de Cloud Routers, clique em onprem-dataservice-vpc-router1.

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

  4. Na seção Rotas divulgadas, para Rotas, selecione Criar rotas personalizadas.

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

  6. Clique em Adicionar uma rota personalizada.

  7. Em Origem, selecione Intervalo de IP personalizado.

  8. Em Intervalo de endereços IP, digite o seguinte endereço IP:

    10.243.208.0/24

  9. Em Descrição, digite o seguinte:

    Filestore reserved IP address range

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

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

    Acesse Instâncias do Filestore

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

  3. Clique em Criar.

  4. Anote o endereço IP da nova instância do Filestore. Talvez seja necessário atualizar a guia do navegador do console Google Cloud para que a nova instância apareça.

Montar o compartilhamento de arquivos do Filestore

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

    projectid=PROJECT_ID
gcloud config set project ${projectid}

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

  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 o compartilhamento de arquivos do Filestore:

    sudo mkdir -p /mnt/nfs

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

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

  7. Mude as permissões para tornar o compartilhamento de arquivos acessível:

    sudo chmod go+rw /mnt/nfs

Baixar o conjunto de dados no compartilhamento de arquivos

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

  2. Execute este comando para confirmar se o conjunto de dados foi copiado:

    sudo du -sh /mnt/nfs

    A resposta esperada é:

    104M    /mnt/nfs

  3. Digite exit para sair da instância de VM on-prem-dataservice-host e voltar 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, crie um bucket do Cloud Storage para preparar as execuções de pipelines.

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

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

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

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

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

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

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

    Acesse o Vertex AI Workbench

  2. Clique em  Criar novo e em Opções avançadas.

    A página Nova instância será aberta.

  3. Na página Nova instância, na seção Detalhes, digite as seguintes informações da nova instância e clique em Continuar:

    • Nome: insira 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.

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

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

  6. Na seção Discos, verifique se Google-managed encryption key está selecionado e clique em Continuar:

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

  8. 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 Google Cloud IA generativa.

      Desmarque a caixa de seleção a seguir:

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

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

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

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

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

    Acesse o Vertex AI Workbench

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

  3. Selecione Arquivo > Novo > Terminal.

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

  5. Crie os diretórios pai do aplicativo de treinamento (ainda no terminal do JupyterLab):

    mkdir fungi_training_package
mkdir fungi_training_package/trainer

  6. No Navegador de arquivos, clique duas vezes na pasta fungi_training_package e depois na pasta trainer.

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

  8. Clique com o botão direito do mouse no novo arquivo e selecione Renomear arquivo.

  9. Renomeie o arquivo de untitled.txt para task.py.

  10. Clique duas vezes no arquivo task.py para abri-lo.

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

  12. Selecione Arquivo > Salvar arquivo Python.

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

  14. No  Navegador de arquivos, clique duas vezes na nova pasta fungi_training_package.

  15. Selecione Arquivo > Novo > Arquivo Python.

  16. Clique com o botão direito do mouse no novo arquivo e selecione Renomear arquivo.

  17. Renomeie o arquivo de untitled.py para setup.py.

  18. Clique duas vezes no arquivo setup.py para abri-lo.

  19. Copie o seguinte código em 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 Arquivo > Salvar arquivo Python.

  21. No terminal, acesse o diretório fungi_training_package:

    cd fungi_training_package

  22. Use o comando sdist para criar a distribuição de origem do aplicativo de treinamento:

    python setup.py sdist --formats=gztar

  23. Navegue até o diretório pai:

    cd ..

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

    pwd

    A saída será semelhante ao seguinte:

    /home/jupyter

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

  26. 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 usada para estabelecer serviços de produtor conectados à rede VPC vertex-networking-vpc por meio do peering de rede VPC. Para mais informações, consulte Peering de rede VPC.

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

    projectid=PROJECT_ID
gcloud config set project ${projectid}

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

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

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

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

    Acesse o Cloud Routers

  2. Na lista de Cloud Routers, clique em vertex-networking-vpc-router1.

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

  4. Clique em Adicionar uma rota personalizada.

  5. Em Origem, selecione Intervalo de IP personalizado.

  6. Em Intervalo de endereços IP, digite o seguinte endereço IP:

    192.168.10.0/24

  7. Em Descrição, digite o seguinte:

    Vertex AI Pipelines reserved subnet

  8. Clique em Concluído e depois em Salvar.

Criar um modelo de pipeline e fazer upload dele no 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

  1. No JupyterLab, no  Navegador de arquivos, clique duas vezes na pasta de nível superior.

  2. Selecione Arquivo -> Novo -> Notebook.

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

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

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

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

  7. Execute o código a seguir 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,
      )

  8. Execute o código a seguir 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

  1. Execute o código a seguir 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.

  1. 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."})

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

    Acessar "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 você criou (fungi-repo) e em Selecionar.

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

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

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

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

    projectid=PROJECT_ID
gcloud config set project ${projectid}

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

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

    sudo vim request_body.json

  6. Adicione o seguinte texto ao arquivo 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: ID do projeto;
    • PROJECT_NUMBER: o número do projeto. Ele é diferente do ID do projeto. Encontre esse número na página Configurações do projeto do projeto no console doGoogle Cloud .
    • FILESTORE_INSTANCE_IP: o endereço IP da instância do Filestore, por exemplo, 10.243.208.2. Essa informação está na página "Instâncias do Filestore" da instância.
    • VERSION_NAME: o nome da versão do modelo de pipeline (sha256:...) que você anotou na etapa 2.

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

Enviar uma execução de pipeline com base no modelo

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

    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

    A saída mostrada é longa, mas o principal que você precisa procurar é a seguinte linha, que indica que o serviço está se preparando para executar o pipeline:

    "state": "PIPELINE_STATE_PENDING"

    A execução completa do pipeline leva de 45 a 50 minutos.

  2. No console Google Cloud , na seção Vertex AI, acesse a guia Execuções na página Pipelines.

    Acessar "Execuções"

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

    Na página de execução do pipeline, será exibido o gráfico de tempo de execução. O resumo do pipeline é exibido no painel Análise da execução do pipeline.

    Para entender melhor as informações do gráfico de execução, saber como conferir logs e usar o Vertex ML Metadata para saber mais sobre os artefatos do pipeline, consulte Visualizar e analisar resultados de pipeline.