Usar o Private Service Connect para acessar predições em lote da Vertex AI no local

Crie as redes VPC

Nesta seção, você cria duas redes VPC: uma para acessar APIs do Google para previsão 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 do 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 do 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 do 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 arrow_back 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 do 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 do 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 do 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 arrow_back 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 divulgações de rota personalizadas para vertex-networking-vpc

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

1. No console do Google Cloud, acesse a página do 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 editEditar.

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 do 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 previsão 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=http://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 previsão 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 previsão 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 do 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 play_arrow 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 add Inserir uma célula abaixo, cole o código na célula e clique emplay_arrow 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}"
   !gsutil mb -l {REGION} -p {PROJECT_ID} {BUCKET_URI}
   

Preparar os dados de treinamento

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

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:

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

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

   !gsutil 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 [http://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 previsão em lote.

   Using endpoint [http://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 do 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 previsões em lote do modelo

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

Criar a solicitação de previsão 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 previsões 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 seguinte comando para enviar a solicitação de previsão em lote:

   curl -X POST \
      -H "Authorization: Bearer $(gcloud auth print-access-token)" \
      -H "Content-Type: application/json; charset=utf-8" \
      -d @request.json \
      "http://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 previsão 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 previsão 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 previsão em lote (income-classification-batch-job) e, em seguida, clique no link Exportar local 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 storageVisualizar saída da previsão no Cloud Storage (entre a coluna Última atualização e more_vertAçõ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 previsão 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"}