Analisar dados no GKE usando o BigQuery, o Cloud Run e o Gemma

Autopilot Standard

---

Este tutorial demonstra como extrair insights de grandes conjuntos de dados usando o BigQuery, o Cloud Run e o LLM Gemma. Neste tutorial, você vai implantar um aplicativo de exemplo no Google Kubernetes Engine (GKE). O app de exemplo usa o BigQuery para armazenamento e processamento de dados, o Cloud Run para processamento de solicitações e o LLM Gemma para analisar dados e gerar previsões com base em solicitações recebidas.

Este tutorial é destinado a administradores e arquitetos de plataformas de nuvem, especialistas em dados e IA, engenheiros de ML e profissionais de MLOps (DevOps). Antes de ler esta página, confira se você tem familiaridade com o Kubernetes e um ambiente de notebook, como o Jupyter.

Como pré-requisito para este tutorial, você precisa concluir o tutorial Disponibilizar modelos abertos do Gemma usando GPUs no GKE com o TGI do Hugging Face. O framework TGI facilita o processo de disponibilização do modelo.

Por que o GKE e o BigQuery?

O BigQuery é uma plataforma como serviço (PaaS), um data warehouse sem servidor e totalmente gerenciado que possibilita análises escalonáveis em petabytes de dados. Com o BigQuery, você pode se concentrar na análise de dados para encontrar insights relevantes usando o SQL conhecido e o machine learning integrado.

Com o uso de GPUs no GKE com o TGI, é possível implantar um modelo de linguagem Gemma para analisar e resumir as interações do usuário em linguagem natural. Em seguida, ao integrar o BigQuery ao GKE, você pode usar o BigQuery para processar conjuntos de dados massivos (como o Google Analytics) e os recursos de compreensão de linguagem natural do modelo para gerar insights significativos.

Por exemplo, como cientista de dados ou analista ou como responsável pela tomada de decisões de negócios em uma empresa de e-commerce, você pode querer entender o comportamento do usuário no seu site ou app. Esse insight pode ajudar a otimizar e personalizar as jornadas dos usuários e a tomar decisões de negócios mais informadas para aumentar as vendas.

Nesse cenário, você pode usar dados brutos do Google Analytics do BigQuery, alimentá-los no modelo Gemma e receber resumos de visitas a páginas e insights em linguagem natural. O modelo Gemma, que é executado em infraestrutura escalonável com aceleração de GPU do GKE, processa rapidamente os dados da jornada do usuário, identificando padrões e tendências. Você pode obter insights para identificar combinações de produtos populares, revelar pontos de abandono comuns no processo de finalização da compra e destacar campanhas de marketing bem-sucedidas que geram tráfego para páginas de destino específicas.

Vantagens

Essa solução oferece um fluxo de trabalho simplificado com as seguintes vantagens:

• Integração do BigQuery: use o BigQuery para armazenar e processar grandes conjuntos de dados, como os dados do Google Analytics neste tutorial. Isso permite consultar e agregar os dados necessários para a análise do modelo.
• Aceleração de GPU: execute o modelo Gemma em um cluster do GKE com suporte a GPU para acelerar o processo de inferência, gerando previsões muito mais rápidas do que com os processadores baseados em CPU.
• Redução de custos e tempo: economize tempo e recursos usando o modelo de linguagem Gemma de código aberto e pré-treinado, eliminando a necessidade de criar um modelo personalizado do zero.

Objetivos

Neste tutorial, você aprenderá a realizar as seguintes tarefas:

1. Implantar e expor o modelo: crie um arquivo YAML de serviço para definir um balanceador de carga interno para acessar o modelo Gemma.
2. Criar uma função remota do BigQuery: execute o código Python para definir uma função remota que use os dados do Google Analytics, crie solicitações para o modelo, envie solicitações para o endpoint do modelo usando o balanceador de carga e retorne a resposta do modelo.
3. Configure a rede de nuvem privada virtual (VPC): configure uma rede VPC e um conector VPC para ativar a comunicação segura entre o BigQuery e o cluster do GKE. Isso é crucial para que a função remota acesse o endpoint do modelo.
4. Analisar dados: analise os dados usando DataFrames do BigQuery ou diretamente no SQL com a ferramenta de linha de comando bq. Execute os snippets de código fornecidos em um notebook do Colab Enterprise para:
   • Consultar dados do Google Analytics no BigQuery usando SQL.
   • Aplique a função remota aos dados para gerar insights do modelo Gemma.
   • Mostre os resultados.

Arquitetura

O diagrama de arquitetura a seguir mostra os componentes envolvidos e como eles interagem:

• Use um notebook do Colab Enterprise para executar seu código Python. Com o Python, você pode usar a biblioteca BigFrames para simplificar suas interações SQL.
• O BigQuery funciona como um mecanismo de processamento de Big Data, permitindo o uso do SQL para interagir com os dados.
• A função remota invoca uma função do Cloud Run. Os dados são roteados automaticamente para a função remota, onde são preparados e enviados para o GKE para inferência.
• Os resultados são enviados de volta ao BigQuery e mostrados em uma tabela.

Custos

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

• Compute Engine instances used by GKE
• GPU resources used by GKE
• BigQuery
• Cloud Load Balancing
• Cloud Run functions

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

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

Antes de começar

Siga os seguintes pré-requisitos:

Escolha ou crie um projeto

Você pode usar um projeto existente ou criar um novo para fins deste tutorial.

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Make sure that billing is enabled for your Google Cloud project.

Ativar as APIs

Enable the Artifact Registry, Compute Engine, GKE, IAM Service Account Credentials, Cloud Functions, Cloud Build, Cloud Run Admin, Cloud Logging, Serverless VPC Access, BigQuery, Dataform, Vertex AI APIs.

Enable the APIs

Configurar o Cloud Shell

Neste tutorial, você vai usar o Cloud Shell para executar comandos gcloud e kubectl. O Cloud Shell é um ambiente shell para gerenciar recursos hospedados no Google Cloud. Ele vem pré-instalado com a Google Cloud CLI e a ferramenta de linha de comando kubectl.

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

Uma sessão do Cloud Shell é aberta dentro de um quadro inferior no console.

Antes de executar comandos neste tutorial, verifique se o projeto padrão está definido como ID do projeto em que você quer implantar o aplicativo de amostra. Execute o seguinte comando no Cloud Shell, caso ele ainda não esteja definido:

gcloud config set project PROJECT_ID

Substitua PROJECT_ID pelo ID do projeto.

Conceder papéis do IAM

Verifique se a conta de usuário e a conta de serviço padrão do Compute Engine no projeto têm os papéis de gerenciamento de identidade e acesso (IAM) necessários para este tutorial.

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/aiplatform.colabEnterpriseAdmin, roles/run.invoker, roles/container.admin, roles/iam.serviceAccountAdmin, roles/logging.logWriter

gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE

• Replace PROJECT_ID with your project ID.

• Replace USER_IDENTIFIER with the identifier for your user account. For example, user:[e-mail].

• Replace ROLE with each individual role.

Conceda papéis à conta de serviço padrão do Compute Engine. Execute o comando a seguir uma vez para cada um dos seguintes papéis do IAM: roles/logging.logWriter, roles/artifactregistry.writer, roles/storage.objectViewer

gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:[e-mail]" --role=ROLE

• Substitua PROJECT_ID pela ID do seu projeto.
• Substitua PROJECT_NUMBER pelo número do seu projeto para criar o domínio da conta de serviço padrão do Compute Engine para seu projeto. Por exemplo, [e-mail].
• Substitua ROLE por cada papel individual.

Disponibilizar um modelo Gemma

Acesse o tutorial Disponibilizar modelos abertos do Gemma usando GPUs no GKE com o TGI do Hugging Face e siga as instruções, começando em Antes de começar até Interagir com o modelo usando curl para garantir que o modelo Gemma seja implantado e que você possa interagir com ele.

Para este tutorial, implante o modelo Gemma 2B-it.

Configurar a rede VPC

Crie ou use a rede VPC na região us-central1 para que a função remota possa se conectar ao cluster do GKE. Neste tutorial, use a VPC Default.

Para garantir que o conjunto de dados do BigQuery, a função remota e as funções do Cloud Run subjacentes sejam implantados em locais compatíveis, a rede VPC precisa estar na mesma região que a função remota do BigQuery. Neste tutorial, ao definir as opções do BigQuery DataFrames ao criar uma função remota, você especifica US como um local para seu conjunto de dados, que é definido como a região us-central1 para suas funções do Cloud Run. Portanto, crie ou use a VPC na região us-central1.

Criar um balanceador de carga

Siga estas instruções para criar um balanceador de carga interno no cluster do GKE:

1. Crie o seguinte manifesto tgi-2b-lb-service.yaml:

   apiVersion: v1
   kind: Service
   metadata:
   name: llm-lb-service
   annotations:
       networking.gke.io/load-balancer-type: "Internal"
   spec:
   selector:
     app: gemma-server
   type: LoadBalancer
   ports:
   - protocol: TCP
     port: 8000
     targetPort: 8000
   

2. Abra um novo terminal do Cloud Shell e execute o seguinte comando para aplicar o manifesto:

   kubectl apply -f tgi-2b-lb-service.yaml
   

3. Anote o endereço IP do balanceador de carga. Talvez seja necessário aguardar de um a dois minutos para que esse endereço IP seja buscado:

   kubectl get service llm-lb-service --output yaml | grep ip:
   

Você vai usar esse endereço IP para se comunicar com o aplicativo gemma-server que está sendo executado por trás do balanceador de carga.

Criar um conector

Você usa um conector de acesso VPC sem servidor para enviar e receber solicitações pela rede VPC sem usar a Internet pública. Para mais informações, consulte Acesso VPC sem servidor.

Neste tutorial, você vai criar um conector com uma sub-rede dedicada nova para evitar conflitos de endereços IP com recursos existentes na VPC. Para instruções, consulte a seção Criar um conector e siga as instruções gcloud da seção Criar um conector e uma nova sub-rede.

Se preferir usar uma sub-rede existente, siga as instruções da seção Criar um conector usando uma sub-rede existente.

Observação: cada conector exige uma sub-rede /28 dedicada de finalidade PRIVATE com um intervalo de endereços IPv4 principal. Ela não pode ser usada por outros recursos, como VMs, Private Service Connect ou balanceadores de carga. Google Cloud impõe esse requisito para garantir um gerenciamento eficiente de endereços IP e evitar possíveis conflitos.

Para mais informações, consulte Requisitos de sub-rede do conector.

Criar um notebook

Neste tutorial, você vai usar um notebook do Colab Enterprise para executar todo o código para definir a função remota do BigQuery e realizar a análise.

Para criar um bloco do Colab Enterprise usando o console do Google Cloud :

1. No console do Google Cloud , acesse a página Notebooks do Colab Enterprise:

   Acesse o Notebooks

2. No menu Região, selecione us-central1. Essa é a mesma região em que você cria todos os serviços neste tutorial.

3. Ao lado de Arquivos, clique em Criar um notebook.

O novo notebook aparece na guia Meus notebooks.

Para executar o código no novo notebook, insira uma nova célula de código para cada comando ou um snippet de código que você quer executar.

Criar uma função remota do BigQuery

Uma das maneiras de definir uma função remota do BigQuery é usando a biblioteca bigframes. Nesta seção, use bigframes para criar uma função remota chamada process_incoming. Essa função remota usa os dados do Google Analytics como entrada, cria um comando e o envia ao modelo Gemma para análise.

No bloco do Colab Enterprise que você criou:

1. Clique em + Código para inserir uma nova célula de código.

2. Copie o seguinte código na nova célula de código:

   # Install the necessary packages on the notebook runtime
   %pip install --upgrade bigframes --quiet
   
   import bigframes.pandas as bpd
   import os
   import ast
   import requests
   
   # Replace the following  variables
   # Use the format ip:port
   # For example, "10.128.05:8000"
   lb_url = "LOADBALANCER_IP_ADDRESS:8000"
   
   # Set BigQuery DataFrames options
   bpd.options.bigquery.project = "PROJECT_ID"
   bpd.options.bigquery.location = "US"
   # Update the VPC connector name with the one you created
   vpc_connector_name = "VPC_CONNECTOR_NAME"
   
   # Create a remote function using bigframes
   # https://cloud.google.com/bigquery/docs/remote-functions#bigquery-dataframes
   
   @bpd.remote_function(
     [str],
     str,
     dataset="ga_demo",
     name="ga_explain_example",
     bigquery_connection="bigframes-rf-conn",
     reuse=True,
     packages=["requests"],
     cloud_function_vpc_connector=VPC_CONNECTOR_NAME
   
   )
   def process_incoming(data):
     ga_data = ast.literal_eval(data)
     USER_PROMPT = """
         'The following are the results from Google Analytics.
         They are reverse ranked.
         reverse_event_number 1 is the last page visited.
         reverse_event_number 2 is the second last page visited.
         You are given the following data.
         {}
         Can you summarize what was the most popular page people landed on and what page they came from?
     """.format(ga_data)
   
     url = 'http://{}/generate'.format(lb_url)
   
     myobj = {
         "inputs": USER_PROMPT,
         "temperature": 0.90,
         "top_p": 0.95,
         "max_tokens": 2048
     }
     x = requests.post(url, json=myobj)
     result = x.text
     return (result)
   
   function_name = process_incoming.bigframes_remote_function
   print (f"The function name is: {function_name}")
   
   

   Substitua:

   • LOADBALANCER_IP_ADDRESS: o endereço IP e a porta do balanceador de carga interno que você criou anteriormente, por exemplo, 10.128.05:8000.
   • PROJECT_ID: o ID do projeto.
   • VPC_CONNECTOR_NAME: o nome do conector de acesso VPC sem servidor que você criou anteriormente.

   Neste tutorial, o local do conjunto de dados do BigQuery é definido como US, que é a região padrão us-central1.

3. Clique em Executar célula.

A saída mostra o nome da função de forma semelhante a esta:

The function name is: PROJECT_ID.ga_demo.ga_explain_example

Analisar o comportamento do usuário

Nesta seção, você vai analisar o comportamento do usuário no seu site usando a função remota process_incoming de duas maneiras:

• usando DataFrames do BigQuery
• usando a ferramenta de linha de comando bq para executar uma consulta diretamente no SQL.

Usar DataFrames do BigQuery

Para executar a função remota usando o DataFrames do BigQuery no notebook do Colab Enterprise que você criou:

1. Clique em + Código para inserir uma nova célula de código.
2. Copie o código abaixo na nova célula de código e clique em Run cell.

# Generate a list of all matchups and their histories as a JSON

grouping_sql = """
with
data_table as (
 SELECT
 distinct
   user_pseudo_id,
   events.value.string_value,
   event_timestamp,
   rank() over (partition by user_pseudo_id order by event_timestamp desc) as reverse_event_number
 FROM
   `bigquery-public-data.ga4_obfuscated_sample_ecommerce.events_20210131` as events20210131,
   unnest (events20210131.event_params) as events
 where events.key = 'page_location'
 qualify reverse_event_number < 3
)
select
*,TO_JSON_STRING (data_table) as ga_history
from data_table
limit 10;

"""

ga_df = bpd.read_gbq(grouping_sql)
post_processed = ga_df.assign(results=ga_df['ga_history'].apply(process_incoming),axis=1)
post_processed.head(10)

A saída a seguir mostra os resultados de amostra da consulta:

user_pseudo_id	string_value	event_timestamp	reverse_event_number	ga_history	resultados	eixo
0	2342103247.0307162928	https://shop.googlemerchandisestore.com/Google...	1612096237169825	2	{"user_pseudo_id":"2342103247.0307162928","str...	{"generated_text":"\n 'The following are...
1	48976087,6959390698	https://www.googlemerchandisestore.com/	1612056537823270	2	{"user_pseudo_id":"48976087.6959390698","strin...	{"generated_text":"\n \n ```python\n imp...

Usar a ferramenta de linha de comando bq

Como alternativa, use a ferramenta de linha de comando bq para realizar a análise diretamente usando SQL.

Para executar a função remota usando a ferramenta de linha de comando bq no bloco do Colab Enterprise que você criou:

1. Clique em + Código para inserir uma nova célula de código.

2. Copie o código abaixo na nova célula de código e substitua PROJECT_ID pelo ID do projeto.

   # Update with your PROJECT_ID
   
   function_name = 'PROJECT_ID.ga_demo.ga_explain_example'
   
   new_sql = """'with \
   data_table as ( \
   SELECT \
   distinct \
     user_pseudo_id, \
     events.value.string_value, \
     event_timestamp, \
     rank() over (partition by user_pseudo_id order by event_timestamp desc) as reverse_event_number \
   FROM \
     `bigquery-public-data.ga4_obfuscated_sample_ecommerce.events_20210131` as events20210131, \
     unnest (events20210131.event_params) as events \
   where events.key = "page_location" \
   qualify reverse_event_number < 3 \
   ) \
   select \
   *, `{}`(TO_JSON_STRING (data_table)) as result \
   from data_table \
   limit 10;' \
   """.format(function_name)
   
   # Run query using bq cli directly in a notebook cell
   
   !bq query --use_legacy_sql=false \
   {new_sql}
   

3. Clique em Executar célula.

A saída a seguir mostra os resultados de amostra da consulta:

user_pseudo_id	string_value	event_timestamp	reverse_event_number	result
86037838.0267811614	https://shop.googlemerchandisestore.com/Google+Redesign/Apparel/Google+Dino+Game+Tee	1612128627715585	1	{"generated_text":"Resposta:\n A página mais acessada foi https://shop.googlemerchandisestore.com/Google+Redesign/Apparel/Google+Dino+Game+Tee\n A segunda página mais acessada foi a que eles acessaram antes.\n\n Explicação:\n\nOs dados fornecidos mostram que o usuário atual acessou a loja de produtos do Google especificamente para o produto "Google Dino Game Tee". \n \nConsiderações importantes: \n\n* Interpretação de dados:não é possível afirmar definitivamente que"
4024190.3037653934	https://shop.googlemerchandisestore.com/Google+Redesign/Apparel/Google+Black+Cloud+Zip+Hoodie	1612085948486438	1	{"generated_text":"\n ```python\n import pandas as pd\n\n data = {'user_pseudo_id': ['4024190.3037653934', '4024190.3037653934', '4024190.3037653934'],\n 'string_value': ['https://shop.googlemerchandisestore.com"}

Sucesso :você aplicou a função remota aos dados para gerar insights do modelo Gemma.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Para evitar cobranças dos recursos usados neste tutorial na sua conta do Google Cloud , exclua os recursos individuais.

1. Exclua o notebook do Colab Enterprise.
2. Exclua o ambiente de execução do Colab Enterprise.
3. Exclua a função do BigQuery. Verifique se a conta de serviço tem a permissão bigquery.routines.delete. Para mais informações, consulte Permissões do BigQuery.
4. Exclua sua conexão externa do BigQuery.
5. Exclua as funções do Cloud Run.
6. Exclua seu cluster do GKE.
7. Exclua o conector da VPC.

A seguir

• Teste um codelab prático para um caso de uso de análise de dados estruturados e não estruturados.
• Consulte as práticas recomendadas para executar cargas de trabalho em lote no GKE.
• Saiba mais sobre casos de uso de IA/ML no BigQuery.
• Saiba mais sobre casos de uso de IA/ML no GKE.