Usar o Private Service Connect para acessar inferências em lote da Vertex AI no local

As inferências em lote são solicitações assíncronas que solicitam inferências diretamente do recurso do modelo, sem a necessidade de implantá-lo em um endpoint.

Neste tutorial, você usa a VPN de alta disponibilidade para enviar solicitações de inferência em lote a um modelo treinado de maneira particular, entre duas redes de nuvem privada virtual que podem servir como base para várias nuvens e conectividade particular no local.

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 inferências em lote.

Crie as redes VPC

Nesta seção, você cria duas redes VPC: uma para acessar APIs do Google para inferência em lote 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. Crie a rede VPC vertex-networking-vpc:

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

  2. Na rede vertex-networking-vpc, crie uma sub-rede chamada workbench-subnet, com um intervalo IPv4 principal de 10.0.1.0/28:

    gcloud compute networks subnets create workbench-subnet \
  --range=10.0.1.0/28 \
  --network=vertex-networking-vpc \
  --region=us-central1 \
  --enable-private-ip-google-access

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

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

  4. Na rede onprem-vpc, crie uma sub-rede chamada onprem-vpc-subnet1, com um intervalo IPv4 principal de 172.16.10.0/29:

    gcloud compute networks subnets create onprem-vpc-subnet1 \
  --network onprem-vpc \
  --range 172.16.10.0/29 \
  --region us-central1

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

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

  4. Na lista de sub-redes VPC, verifique se as sub-redes workbench-subnet e onprem-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-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-vpc:

    gcloud compute vpn-gateways create onprem-vpn-gw1 \
   --network onprem-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ê cria dois Cloud Routers: um geral e outro regional. Em cada Cloud Router regional, você cria um gateway do Cloud NAT. Os gateways do Cloud NAT fornecem conectividade de saída para instâncias de máquina virtual (VM) do Compute Engine que não têm endereços IP externos.

  1. No Cloud Shell, crie um Cloud Router para a rede VPC vertex-networking-vpc:

    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-vpc:

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

  3. Crie um Cloud Router regional para a rede VPC vertex-networking-vpc:

    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 regional:

    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 regional para a rede VPC onprem-vpc:

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

  6. Configure um gateway do Cloud NAT no Cloud Router regional:

    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-vpc-router1
    • vertex-networking-vpc-router1

    Talvez seja necessário atualizar a guia do navegador do console Google Cloud para visualizar os novos valores.

  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 roteadores, 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-vpc, crie um túnel de VPN chamado onprem-vpc-tunnel0:

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

  4. Na rede onprem-vpc, crie um túnel de VPN chamado onprem-vpc-tunnel1:

    gcloud compute vpn-tunnels create onprem-vpc-tunnel1 \
  --peer-gcp-gateway vertex-networking-vpn-gw1 \
  --region us-central1\
  --ike-version 2 \
  --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
  --router onprem-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-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-vpc.

Depois de 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-vpc

  1. Na rede onprem-vpc, crie uma interface do BGP para onprem-vpc-tunnel0:

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

  2. Na rede onprem-vpc, crie um peering do BGP para bgp-vertex-networking-vpc-tunnel0:

    gcloud compute routers add-bgp-peer onprem-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-vpc, crie uma interface do BGP para onprem-vpc-tunnel1:

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

  4. Na rede onprem-vpc, crie um peering do BGP para bgp-vertex-networking-vpc-tunnel1:

    gcloud compute routers add-bgp-peer onprem-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 vertex-networking-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 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-vpc-subnet1 (172.16.10.0/29) aparece duas vezes.

Validar as onprem-vpc rotas aprendidas

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

  2. Na lista de redes VPC, clique em onprem-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 de sub-rede workbench-subnet (10.0.1.0/28) aparece duas vezes.

Criar o endpoint do consumidor do Private Service Connect

  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 rotas divulgadas personalizadas para vertex-networking-vpc

Nesta seção, você configura o modo de divulgação personalizado do Cloud Router para Divulgar intervalos de IP personalizados para vertex-networking-vpc-router1 (o Cloud Router para vertex-networking-vpc) para anunciar o endereço IP do endpoint do PSC na rede onprem-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-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-vpc.
    2. Em Região, escolha us-central1 (Iowa).
    3. Clique em Visualizar.

    4. Na lista de rotas, verifique se há entradas com nomes que começam com onprem-vpc-router1-bgp-vertex-networking-vpc-tunnel0 e onprem-vpc-router1-bgp-vfertex-networking-vpc-tunnel1 e se ambas têm um Intervalo de IP de destino de 192.168.0.1.

      Se essas entradas não aparecerem imediatamente, aguarde alguns minutos e atualize a guia do navegador do console Google Cloud .

Criar uma VM em onprem-vpc que use uma conta de serviço gerenciada pelo usuário

Nesta seção, você cria uma instância de VM que simula um aplicativo cliente local que envia solicitações de inferência em lote. Ao seguir 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 doconta padrão de serviço.

Crie uma conta de serviço gerenciada pelo usuário

  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-onprem-client"

  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 do IAM de Leitor de objetos do Storage (storage.objectViewer) à conta de serviço:

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

Criar a instância de VM on-prem-client

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-client:

    gcloud compute instances create on-prem-client \
  --zone=us-central1-a \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --subnet=onprem-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-vpc \
  --allow tcp:22 \
  --source-ranges=35.235.240.0/20

Valide o acesso público à API Vertex AI

Nesta seção, você vai usar o utilitário dig para executar uma busca DNS da instância de VM on-prem-client para a API Vertex AI (us-central1-aiplatform.googleapis.com). A saída dig mostra que o acesso padrão usa apenas VIPs públicos para acessar a API Vertex AI.

Na próxima seção, você vai configurar o acesso particular à API Vertex AI.

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

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

  2. Na instância de VM on-prem-client, execute o comando dig:

    dig us-central1-aiplatform.googleapis.com

    Você vai ver uma saída dig semelhante à seguinte, em que os endereços IP na seção de resposta são endereços IP públicos:

    ; <<>> DiG 9.16.44-Debian <<>> us-central1.aiplatfom.googleapis.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 42506
;; flags: qr rd ra; QUERY: 1, ANSWER: 16, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;us-central1.aiplatfom.googleapis.com. IN A

;; ANSWER SECTION:
us-central1.aiplatfom.googleapis.com. 300 IN A  173.194.192.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.152.95
us-central1.aiplatfom.googleapis.com. 300 IN A  172.217.219.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.146.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.147.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.125.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.136.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.148.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.200.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.234.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.251.171.95
us-central1.aiplatfom.googleapis.com. 300 IN A  108.177.112.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.128.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.251.6.95
us-central1.aiplatfom.googleapis.com. 300 IN A  172.217.212.95
us-central1.aiplatfom.googleapis.com. 300 IN A  74.125.124.95

;; Query time: 8 msec
;; SERVER: 169.254.169.254#53(169.254.169.254)
;; WHEN: Wed Sep 27 04:10:16 UTC 2023
;; MSG SIZE  rcvd: 321

Configurar e validar o acesso privado à API Vertex AI

Nesta seção, você configura o acesso particular à API Vertex AI para que, quando você enviar solicitações de inferência em lote, elas sejam redirecionadas para o endpoint do PSC. O endpoint do PSC, por sua vez, encaminha essas solicitações particulares para a API REST de inferência em lote da Vertex AI.

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

Nesta etapa, você adiciona 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. Na instância de VM on-prem-client, use um editor de texto, como vim ou nano para abrir o arquivo /etc/hosts:

    sudo vim /etc/hosts

  2. 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-client.us-central1-a.c.vertex-genai-400103.internal on-prem-client  # Added by Google
169.254.169.254 metadata.google.internal  # Added by Google

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

  4. Dê um ping no endpoint da 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.

  5. Digite Control+C para sair de ping.

  6. Digite exit para sair da instância de VM on-prem-client.

Crie uma conta de serviço gerenciada pelo usuário para o Vertex AI Workbench no vertex-networking-vpc

Nesta seção, para controlar o acesso à sua instância do Vertex AI Workbench, crie uma conta de serviço gerenciada pelo usuário e atribua papéis do IAM à conta de serviço. Ao criar a instância, você especifica a conta de serviço.

  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 workbench-sa:

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

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

  4. Atribua o papel do IAM de Usuário do BigQuery (roles/bigquery.user) à conta de serviço:

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

  5. Atribua o papel do IAM Administrador de armazenamento (roles/storage.admin) à conta de serviço:

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

  6. Atribua o papel do IAM de Visualizador de registros (roles/logging.viewer) à conta de serviço:

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

Criar a instância do Vertex AI Workbench

  1. No Cloud Shell, crie uma instância do Vertex AI Workbench, especificando a conta de serviço workbench-sa:

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

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

    Acesse o Vertex AI Workbench

  3. Ao lado do nome da instância do Vertex AI Workbench (workbench-tutorial), clique em Abrir JupyterLab.

    Sua instância do Vertex AI Workbench abre o JupyterLab.

  4. Selecione File -> New -> Notebook.

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

  6. Quando o novo notebook é aberto, há uma célula de código padrão em que é possível inserir o código. Ela tem o formato [ ]:, seguido por um campo de texto. O campo de texto é onde você cola seu código.

    Para instalar o SDK da Vertex AI para Python, cole o código a seguir na célula e clique em  Executar as células selecionadas e avançar:

    !pip3 install --upgrade google-cloud-bigquery scikit-learn==1.2

  7. Nesta etapa e em cada uma das seguintes, adicione uma nova célula de código (se necessário) clicando em Inserir uma célula abaixo, cole o código na célula e clique em Executar as células selecionadas e avançar.

    Para usar os pacotes recém-instalados no ambiente de execução do Jupyter, é necessário reiniciar o ambiente de execução.

    # Restart kernel after installs so that your environment can access the new packages
import IPython

app = IPython.Application.instance()
app.kernel.do_shutdown(True)

  8. Defina as variáveis de ambiente a seguir no notebook do JupyterLab, substituindo PROJECT_ID pelo ID do projeto.

    # set project ID and location
PROJECT_ID = "PROJECT_ID"
REGION = "us-central1"

  9. Crie um bucket do Cloud Storage para a preparação do job de treinamento:

    BUCKET_NAME = f"{PROJECT_ID}-ml-staging"
BUCKET_URI = f"gs://{BUCKET_NAME}"
!gcloud storage buckets create {BUCKET_URI} --location={REGION} --project={PROJECT_ID}

Preparar os dados de treinamento

Nesta seção, você prepara os dados que serão usados para treinar um modelo de inferência.

  1. No notebook do JupyterLab, crie um cliente do BigQuery:

    from google.cloud import bigquery
bq_client = bigquery.Client(project=PROJECT_ID)

  2. Busque dados do conjunto de dados público ml_datasets do BigQuery:

    DATA_SOURCE = "bigquery-public-data.ml_datasets.census_adult_income"
# Define the SQL query to fetch the dataset
query = f"""
SELECT * FROM `{DATA_SOURCE}` LIMIT 20000
"""
# Download the dataset to a dataframe
df = bq_client.query(query).to_dataframe()
df.head()

  3. Use a biblioteca sklearn para dividir os dados para treinamento e teste:

    from sklearn.model_selection import train_test_split
# Split the dataset
X_train, X_test = train_test_split(df, test_size=0.3, random_state=43)
# Print the shapes of train and test sets
print(X_train.shape, X_test.shape)

  4. Exporte os dataframes de treinamento e teste para arquivos CSV no bucket de preparo:

    X_train.to_csv(f"{BUCKET_URI}/train.csv",index=False, quoting=1, quotechar='"')
X_test[[i for i in X_test.columns if i != "income_bracket"]].iloc[:20].to_csv(f"{BUCKET_URI}/test.csv",index=False,quoting=1, quotechar='"')

Preparar o aplicativo de treinamento

Nesta seção, mostramos como criar e desenvolver o aplicativo de treinamento em Python e salvá-lo no bucket de preparo.

  1. No notebook do JupyterLab, crie uma nova pasta para os arquivos de aplicativo de treinamento:

    !mkdir -p training_package/trainer

    Agora você verá uma pasta chamada training_package no menu de navegação do JupyterLab.

  2. Defina os recursos, o destino, o rótulo e as etapas para treinar e exportar o modelo para um arquivo:

    %%writefile training_package/trainer/task.py
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import FeatureUnion, Pipeline
from sklearn.preprocessing import LabelBinarizer
import pandas as pd
import argparse
import joblib
import os

TARGET = "income_bracket"
# Define the feature columns that you use from the dataset
COLUMNS = (
  "age",
  "workclass",
  "functional_weight",
  "education",
  "education_num",
  "marital_status",
  "occupation",
  "relationship",
  "race",
  "sex",
  "capital_gain",
  "capital_loss",
  "hours_per_week",
  "native_country",
)

# Categorical columns are columns that have string values and
# need to be turned into a numerical value to be used for training
CATEGORICAL_COLUMNS = (
  "workclass",
  "education",
  "marital_status",
  "occupation",
  "relationship",
  "race",
  "sex",
  "native_country",
)

# load the arguments
parser = argparse.ArgumentParser()
parser.add_argument('--training-dir', dest='training_dir', default=os.getenv('AIP_MODEL_DIR'), type=str,help='get the staging directory')
args = parser.parse_args()

# Load the training data
X_train = pd.read_csv(os.path.join(args.training_dir,"train.csv"))
# Remove the column we are trying to predict ('income-level') from our features list
# Convert the Dataframe to a lists of lists
train_features = X_train.drop(TARGET, axis=1).to_numpy().tolist()
# Create our training labels list, convert the Dataframe to a lists of lists
train_labels = X_train[TARGET].to_numpy().tolist()

# Since the census data set has categorical features, we need to convert
# them to numerical values. We'll use a list of pipelines to convert each
# categorical column and then use FeatureUnion to combine them before calling
# the RandomForestClassifier.
categorical_pipelines = []

# Each categorical column needs to be extracted individually and converted to a numerical value.
# To do this, each categorical column will use a pipeline that extracts one feature column via
# SelectKBest(k=1) and a LabelBinarizer() to convert the categorical value to a numerical one.
# A scores array (created below) will select and extract the feature column. The scores array is
# created by iterating over the COLUMNS and checking if it is a CATEGORICAL_COLUMN.
for i, col in enumerate(COLUMNS):
   if col in CATEGORICAL_COLUMNS:
      # Create a scores array to get the individual categorical column.
      # Example:
      #  data = [39, 'State-gov', 77516, 'Bachelors', 13, 'Never-married', 'Adm-clerical',
      #         'Not-in-family', 'White', 'Male', 2174, 0, 40, 'United-States']
      #  scores = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      #
      # Returns: [['Sate-gov']]
      scores = []
      # Build the scores array
      for j in range(len(COLUMNS)):
         if i == j:  # This column is the categorical column we want to extract.
            scores.append(1)  # Set to 1 to select this column
         else:  # Every other column should be ignored.
            scores.append(0)
      skb = SelectKBest(k=1)
      skb.scores_ = scores
      # Convert the categorical column to a numerical value
      lbn = LabelBinarizer()
      r = skb.transform(train_features)
      lbn.fit(r)
      # Create the pipeline to extract the categorical feature
      categorical_pipelines.append(
         (
            "categorical-{}".format(i),
            Pipeline([("SKB-{}".format(i), skb), ("LBN-{}".format(i), lbn)]),
         )
      )

# Create pipeline to extract the numerical features
skb = SelectKBest(k=6)
# From COLUMNS use the features that are numerical
skb.scores_ = [1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0]
categorical_pipelines.append(("numerical", skb))

# Combine all the features using FeatureUnion
preprocess = FeatureUnion(categorical_pipelines)

# Create the classifier
classifier = RandomForestClassifier()

# Transform the features and fit them to the classifier
classifier.fit(preprocess.transform(train_features), train_labels)

# Create the overall model as a single pipeline
pipeline = Pipeline([("union", preprocess), ("classifier", classifier)])

# Save the model pipeline
joblib.dump(pipeline, os.path.join(args.training_dir,"model.joblib"))

  3. Crie um arquivo __init__.py em cada subdiretório para torná-lo um pacote:

    !touch training_package/__init__.py
!touch training_package/trainer/__init__.py

  4. Crie um script de configuração de pacote do Python:

    %%writefile training_package/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 census income classification.'
)

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

    !cd training_package && python setup.py sdist --formats=gztar

  6. Copie o pacote do Python para o bucket de preparo:

    !gcloud storage cp training_package/dist/trainer-0.1.tar.gz $BUCKET_URI/

  7. Verifique se o bucket de preparo contém três arquivos:

    !gcloud storage ls $BUCKET_URI

    A saída precisa ser:

    gs://$BUCKET_NAME/test.csv
gs://$BUCKET_NAME/train.csv
gs://$BUCKET_NAME/trainer-0.1.tar.gz

Treinar o modelo

Nesta seção, você treinará o modelo criando e executando um job de treinamento personalizado.

  1. No notebook do JupyterLab, execute o seguinte comando para criar um job de treinamento personalizado:

    !gcloud ai custom-jobs create --display-name=income-classification-training-job \
   --project=$PROJECT_ID \
   --worker-pool-spec=replica-count=1,machine-type='e2-highmem-2',executor-image-uri='us-docker.pkg.dev/vertex-ai/training/sklearn-cpu.1-0:latest',python-module=trainer.task \
   --python-package-uris=$BUCKET_URI/trainer-0.1.tar.gz \
   --args="--training-dir","/gcs/$BUCKET_NAME" \
   --region=$REGION

    A saída será parecida com esta: O primeiro número em cada caminho de job personalizado é o número do projeto (PROJECT_NUMBER). O segundo número é o ID do job personalizado (CUSTOM_JOB_ID). Anote esses números para usá-los na próxima etapa.

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
CustomJob [projects/721032480027/locations/us-central1/customJobs/1100328496195960832] is submitted successfully.

Your job is still active. You may view the status of your job with the command

$ gcloud ai custom-jobs describe projects/721032480027/locations/us-central1/customJobs/1100328496195960832

or continue streaming the logs with the command

$ gcloud ai custom-jobs stream-logs projects/721032480027/locations/us-central1/customJobs/1100328496195960832

  2. Execute o job de treinamento personalizado e mostre o progresso fazendo streaming dos registros do job durante a execução:

    !gcloud ai custom-jobs stream-logs projects/PROJECT_NUMBER/locations/us-central1/customJobs/CUSTOM_JOB_ID

    Substitua os seguintes valores:

    • PROJECT_NUMBER: o número do projeto da saída do comando anterior.
    • CUSTOM_JOB_ID: o ID do job personalizado da saída do comando anterior.

    Seu job de treinamento personalizado está em execução. Ele leva cerca de 10 minutos.

    Quando o job for concluído, será possível importar o modelo do bucket de preparo para o Vertex AI Model Registry.

Importar o modelo

Seu job de treinamento personalizado faz upload do modelo treinado para o bucket de preparo. Quando o job for concluído, será possível importar o modelo do bucket para o Vertex AI Model Registry.

  1. No notebook do JupyterLab, importe o modelo executando o seguinte comando:

    !gcloud ai models upload --container-image-uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.1-2:latest" \
   --display-name=income-classifier-model \
   --artifact-uri=$BUCKET_URI \
   --project=$PROJECT_ID \
   --region=$REGION

  2. Liste os modelos da Vertex AI no projeto da seguinte maneira:

    !gcloud ai models list --region=us-central1

    Os resultados terão a seguinte aparência: Se dois ou mais modelos estiverem listados, o primeiro da lista é aquele que você importou mais recentemente.

    Anote o valor na coluna MODEL_ID. Você precisa dela para criar a solicitação de inferência em lote.

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
MODEL_ID             DISPLAY_NAME
1871528219660779520  income-classifier-model

    Como alternativa, é possível listar os modelos no seu projeto da seguinte maneira:

    No console Google Cloud , na seção "Vertex AI", acesse a página Vertex AI Model Registry.

    Acesse a página do Vertex AI Model Registry.

    Para ver os IDs e outros detalhes de um modelo, clique no nome dele e, em seguida, na guia Detalhes da versão.

Receber inferências em lote do modelo

Agora é possível solicitar inferências em lote do modelo. As solicitações de inferência em lote são feitas a partir da instância de VM on-prem-client.

Criar a solicitação de inferência em lote

Nesta etapa, você usa ssh para fazer login na instância de VM on-prem-client. Na instância de VM, você cria um arquivo de texto chamado request.json que contém o payload de uma solicitação curl de amostra que você envia ao seu modelo para receber inferências em lote.

  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-client usando o ssh:

    gcloud compute ssh on-prem-client \
  --project=$projectid \
  --zone=us-central1-a

  3. Na instância de VM on-prem-client, use um editor de texto, como vim ou nano, para criar um novo arquivo chamado request.json que contenha o seguinte texto:

    {
  "displayName": "income-classification-batch-job",
  "model": "projects/PROJECT_ID/locations/us-central1/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": ["BUCKET_URI/test.csv"]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "BUCKET_URI"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "n1-standard-4",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": 1,
    "maxReplicaCount": 2
  }
}

    Substitua os seguintes valores:

    • PROJECT_ID: ID do projeto
    • MODEL_ID: o ID do seu modelo
    • BUCKET_URI: o URI do bucket de armazenamento em que você preparou o modelo

  4. Execute o comando a seguir para enviar a solicitação de inferência em lote:

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

    Substitua PROJECT_ID pela ID do seu projeto.

    A seguinte linha vai aparecer na resposta:

    "state": "JOB_STATE_PENDING"

    Seu job de inferência em lote agora está sendo executado de maneira assíncrona. Ela leva cerca de 20 minutos para ser executada.

  5. No console do Google Cloud , na seção "Vertex AI", acesse a página Previsões em lote.

    Acessar a página "Previsões em lote"

    Enquanto o job de inferência em lote estiver em execução, o status dele será Running. Quando ela for concluída, o status mudará para Finished.

  6. Clique no nome do job de inferência em lote (income-classification-batch-job) e, em seguida, clique no link Local de exportação na página de detalhes para ver os arquivos de saída do job em lote no Cloud Storage.

    Como alternativa, é possível clicar no ícone Visualizar saída da previsão no Cloud Storage (entre a coluna Última atualização e Ações).

  7. Clique no link do arquivo prediction.results-00000-of-00002 ou prediction.results-00001-of-00002 e, em seguida, clique no link URL autenticado para abrir o arquivo.

    A saída do job de inferência em lote precisa ser semelhante a este exemplo:

    {"instance": ["27", " Private", "391468", " 11th", "7", " Divorced", " Craft-repair", " Own-child", " White", " Male", "0", "0", "40", " United-States"], "prediction": " <=50K"}
{"instance": ["47", " Self-emp-not-inc", "192755", " HS-grad", "9", " Married-civ-spouse", " Machine-op-inspct", " Wife", " White", " Female", "0", "0", "20", " United-States"], "prediction": " <=50K"}
{"instance": ["32", " Self-emp-not-inc", "84119", " HS-grad", "9", " Married-civ-spouse", " Craft-repair", " Husband", " White", " Male", "0", "0", "45", " United-States"], "prediction": " <=50K"}
{"instance": ["32", " Private", "236543", " 12th", "8", " Divorced", " Protective-serv", " Own-child", " White", " Male", "0", "0", "54", " Mexico"], "prediction": " <=50K"}
{"instance": ["60", " Private", "160625", " HS-grad", "9", " Married-civ-spouse", " Prof-specialty", " Husband", " White", " Male", "5013", "0", "40", " United-States"], "prediction": " <=50K"}
{"instance": ["34", " Local-gov", "22641", " HS-grad", "9", " Never-married", " Protective-serv", " Not-in-family", " Amer-Indian-Eskimo", " Male", "0", "0", "40", " United-States"], "prediction": " <=50K"}
{"instance": ["32", " Private", "178623", " HS-grad", "9", " Never-married", " Other-service", " Not-in-family", " Black", " Female", "0", "0", "40", " ?"], "prediction": " <=50K"}
{"instance": ["28", " Private", "54243", " HS-grad", "9", " Divorced", " Transport-moving", " Not-in-family", " White", " Male", "0", "0", "60", " United-States"], "prediction": " <=50K"}
{"instance": ["29", " Local-gov", "214385", " 11th", "7", " Divorced", " Other-service", " Unmarried", " Black", " Female", "0", "0", "20", " United-States"], "prediction": " <=50K"}
{"instance": ["49", " Self-emp-inc", "213140", " HS-grad", "9", " Married-civ-spouse", " Exec-managerial", " Husband", " White", " Male", "0", "1902", "60", " United-States"], "prediction": " >50K"}