Esta página foi traduzida pela API Cloud Translation.

Criar e implantar um planejador de dieta com tecnologia de IA usando Streamlit, Gemini Pro, Vertex AI e BigQuery

1. Introdução

Neste codelab, você vai aprender a criar e implantar um planejador de dieta com tecnologia de IA. Para a interface do usuário, use o Streamlit, o modelo de LLM com o Gemini Pro 2.5, o orquestrador do mecanismo de IA generativa com a Vertex AI para desenvolvimento de IA generativa, o BigQuery para armazenar dados e o Cloud Run para implantação.

Durante o codelab, você vai usar uma abordagem gradual da seguinte forma:

Prepare seu projeto do Google Cloud e ative todas as APIs necessárias nele.
Criar um planejador de dieta com IA usando o Streamlit, a Vertex AI e o BigQuery
Implante o aplicativo no Cloud Run.

Visão geral da arquitetura

Pré-requisito

Um projeto do Google Cloud Platform (GCP) com o faturamento ativado.
Conhecimento básico de Python

O que você vai aprender

Como criar um planejador de dieta com IA de agente usando o Streamlit, a Vertex AI e armazenar dados no BigQuery
Como implantar o aplicativo no Cloud Run

O que é necessário

Navegador da Web Google Chrome
Uma conta do Gmail
Um projeto do Cloud com faturamento ativado

2. Configuração básica e requisitos

Configuração de ambiente personalizada

Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

O nome do projeto é o nome de exibição para os participantes dele. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
O ID do projeto é exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto.
Para sua informação, há um terceiro valor, um número de projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.

Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

3. Antes de começar

Configurar o projeto do Cloud no editor do Cloud Shell

Este codelab pressupõe que você já tenha um projeto do Google Cloud com o faturamento ativado. Se você ainda não tem uma, siga as instruções abaixo para começar.

No console do Google Cloud, na página de seletor de projetos, selecione ou crie um projeto do Google Cloud.
Verifique se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto .
Você vai usar o Cloud Shell, um ambiente de linha de comando executado no Google Cloud que vem pré-carregado com bq. Clique em "Ativar o Cloud Shell" na parte de cima do console do Google Cloud.

Depois de se conectar ao Cloud Shell, verifique se sua conta já está autenticada e se o projeto está configurado com seu ID do projeto usando o seguinte comando:

gcloud auth list

Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto.

gcloud config list project

Se o projeto não estiver definido, use este comando:

gcloud config set project <YOUR_PROJECT_ID>

Também é possível ver o ID do PROJECT_ID no console.

Clique nele para ver todos os seus projetos e o ID do projeto no lado direito.

Ative as APIs necessárias com o comando mostrado abaixo. Isso pode levar alguns minutos.

gcloud services enable aiplatform.googleapis.com \
                           run.googleapis.com \
                           cloudbuild.googleapis.com \
                           cloudresourcemanager.googleapis.com \
                    bigquery.googleapis.com

Após a execução do comando, você vai ver uma mensagem semelhante a esta:

Operation "operations/..." finished successfully.

A alternativa ao comando gcloud é pesquisar cada produto no console ou usar este link.

Se alguma API for esquecida, você sempre poderá ativá-la durante a implementação.

Consulte a documentação para ver o uso e os comandos gcloud.

Configurar o diretório de trabalho do aplicativo

Clique no botão "Abrir editor" para abrir um editor do Cloud Shell. Podemos escrever nosso código aqui
Verifique se o projeto do Cloud Code está definido no canto inferior esquerdo (barra de status) do editor do Cloud Shell, conforme destacado na imagem abaixo, e se ele está definido como o projeto ativo do Google Cloud em que o faturamento está ativado. Clique em Autorizar se for solicitado. Pode levar um tempo depois de inicializar o editor do Cloud Shell para que o botão Cloud Code - Sign In apareça. Aguarde.

Em seguida, vamos preparar nosso ambiente Python.

Configuração do ambiente

Preparar o ambiente virtual do Python

A próxima etapa é preparar o ambiente de desenvolvimento. Vamos usar o Python 3.12 neste codelab e o python virtualenv para simplificar a necessidade de criar e gerenciar a versão do Python e o ambiente virtual.

Se você ainda não abriu o terminal, clique em Terminal -> Novo terminal ou use Ctrl + Shift + C.

Crie uma pasta e mude o local para ela com o seguinte comando:

mkdir agent_diet_planner
cd agent_diet_planner

Crie um novo virtualenv com o seguinte comando:

python -m venv .env

Ative o virtualenv com o seguinte comando:

source .env/bin/activate

Criar requirements.txt. Clique em "Arquivo" → "Novo arquivo de texto" e preencha com o conteúdo abaixo. e salve como requirements.txt.

streamlit==1.33.0
google-cloud-aiplatform
google-cloud-bigquery
pandas==2.2.2
db-dtypes==1.2.0
pyarrow==16.1.0

Em seguida, instale todas as dependências de requirements.txt com o comando a seguir:

pip install -r requirements.txt

Digite o comando abaixo para verificar se todas as dependências das bibliotecas Python estão instaladas.

pip list

Configurar arquivos de configuração

Agora precisamos configurar os arquivos de configuração para esse projeto. Os arquivos de configuração são usados para armazenar variáveis e credenciais de contas de serviço.

A primeira etapa é criar uma conta de serviço. Digite "conta de serviço" na pesquisa e clique em "Conta de serviço".
Clique em + Criar conta de serviço. Insira o nome da conta de serviço e clique em "Criar e continuar".
Em "Permissão", escolha o papel "Usuário da conta de serviço". Clique em + Adicionar outro papel e escolha Papel do IAM : administrador do BigQuery, administrador do Cloud Run, invocador do Cloud Run, agente de serviço da Vertex AI e usuário da Vertex AI. Em seguida, clique em Concluído .
Clique em "E-mail da conta de serviço", pressione a tecla Tab e clique em "Adicionar chave" → "Criar nova chave".
Escolha "json" e clique em "Criar". Salve o arquivo da conta de serviço localmente para a próxima etapa
Crie uma pasta chamada .streamlit com a seguinte configuração. Clique com o botão direito do mouse, clique em "Nova pasta" e digite o nome da pasta .streamlit.
Clique com o botão direito do mouse na pasta .streamlit, clique em "Novo arquivo" e preencha com o valor abaixo. e salve como secrets.toml.

# secrets.toml (for Streamlit sharing)
# Store in .streamlit/secrets.toml

[gcp]
project_id = "your_gcp_project"
location = "us-central1"

[gcp_service_account]
type = "service_account"
project_id = "your-project-id"
private_key_id = "your-private-key-id"
private_key = '''-----BEGIN PRIVATE KEY-----
YOUR_PRIVATE_KEY_HERE
-----END PRIVATE KEY-----'''
client_email = "your-sa@project-id.iam.gserviceaccount.com"
client_id = "your-client-id"
auth_uri = "https://accounts.google.com/o/oauth2/auth"
token_uri = "https://oauth2.googleapis.com/token"
auth_provider_x509_cert_url = "https://www.googleapis.com/oauth2/v1/certs"
client_x509_cert_url = "https://www.googleapis.com/robot/v1/metadata/x509/your-sa%40project-id.iam.gserviceaccount.com"

Atualize o valor de project_id, private_key_id, private_key, client_email e client_id , and auth_provider_x509_cert_url com base na conta de serviço criada na etapa anterior.

Preparar o conjunto de dados do BigQuery

A próxima etapa é criar um conjunto de dados do BigQuery para salvar os resultados da geração no BigQuery.

Digite "BigQuery" na pesquisa e clique em "BigQuery".
Clique em e em "Criar conjunto de dados".
Insira o ID do conjunto de dados diet_planner_data e clique em Criar conjunto de dados .

4. Criar apps de planejamento de dieta com agente

Vamos criar uma interface da Web simples com quatro entradas, que terá esta aparência:

Mude peso, altura, idade e sexo com base no seu perfil e clique em "Gerar". Ele vai chamar o modelo de LLM Gemini Pro 2.5 na biblioteca da Vertex AI e armazenar os resultados gerados no BigQuery.

O código será separado em seis partes para não ficar muito longo.

Criar função calculate bmi status

Clique com o botão direito do mouse na pasta agent_diet_planner → Novo arquivo… → insira o nome do arquivo bmi_calc.py e pressione Enter.
Preencha o código com o seguinte

# Add this function to calculate BMI and health status
def calculate_bmi_status(weight, height):
   """
   Calculate BMI and return status message
   """
   height_m = height / 100  # Convert cm to meters
   bmi = weight / (height_m ** 2)
  
   if bmi < 18.5:
       status = "underweight"
       message = "⚠️ Your BMI suggests you're underweight. Consider increasing calorie intake with nutrient-dense foods."
   elif 18.5 <= bmi < 25:
       status = "normal"
       message = "✅ Your BMI is in the healthy range. Let's maintain this balance!"
   elif 25 <= bmi < 30:
       status = "overweight"
       message = "⚠️ Your BMI suggests you're overweight. Focus on gradual weight loss through balanced nutrition."
   else:
       status = "obese"
       message = "❗ Your BMI indicates obesity. Please consult a healthcare provider for personalized guidance."
  
   return {
       "value": round(bmi, 1),
       "status": status,
       "message": message
   }

Criar apps principais de planejamento de dieta com agente

Clique com o botão direito do mouse na pasta agent_diet_planner → Novo arquivo… → insira o nome do arquivo app.py e pressione Enter.
Preencha o código com o seguinte

import os
from google.oauth2 import service_account
import streamlit as st
from google.cloud import bigquery
from vertexai.preview.generative_models import GenerativeModel
import vertexai
import datetime
import time
import pandas as pd
from bmi_calc import calculate_bmi_status

# Get configuration from environment
PROJECT_ID = os.environ.get("GCP_PROJECT_ID", "your_gcp_project_id")
LOCATION = os.environ.get("GCP_LOCATION", "us-central1")

#CONSTANTS Dataset and table in BigQuery
DATASET = "diet_planner_data"
TABLE = "user_plans"

# Initialize Vertex AI
vertexai.init(project=PROJECT_ID, location=LOCATION)

# Initialize BigQuery client
try:
   # For Cloud Run, use default credentials
   bq_client = bigquery.Client()
except:
   # For local development, use service account from secrets
   if "gcp_service_account" in st.secrets:
       service_account_info = dict(st.secrets["gcp_service_account"])
       credentials = service_account.Credentials.from_service_account_info(service_account_info)
       bq_client = bigquery.Client(credentials=credentials, project=PROJECT_ID)
   else:
       st.error("BigQuery client initialization failed")
       st.stop()

Mude o valor your_gcp_project_id pelo ID do projeto.

Criar apps principais do planejador de dieta do agente: setup_bq_tables

Nesta seção, vamos criar uma função chamada setup_bq_table com um parâmetro de entrada bq_client. Essa função define o esquema na tabela do BigQuery e cria uma tabela se ela não existir.

Preencha o código com o seguinte abaixo do código anterior em app.py

# Create BigQuery table if not exists
def setup_bq_table(bq_client):
   dataset_id = f"{st.secrets['gcp']['project_id']}.{DATASET}"
   table_id = f"{dataset_id}.{TABLE}"
  
   schema = [
       bigquery.SchemaField("user_id", "STRING", mode="REQUIRED"),
       bigquery.SchemaField("timestamp", "TIMESTAMP", mode="REQUIRED"),
       bigquery.SchemaField("weight", "FLOAT", mode="REQUIRED"),
       bigquery.SchemaField("height", "INTEGER", mode="REQUIRED"),
       bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
       bigquery.SchemaField("gender", "STRING", mode="REQUIRED"),
       bigquery.SchemaField("diet_plan", "STRING", mode="REQUIRED")
   ]
  
   try:
       bq_client.get_table(table_id)
   except:
       table = bigquery.Table(table_id, schema=schema)
       bq_client.create_table(table)
       st.toast("BigQuery table created successfully")

Criar os principais apps do planejador de dieta do agente: generate_diet_plan

Nesta seção, vamos criar uma função chamada generate_diet_plan com um parâmetro de entrada. Essa função vai chamar o modelo de LLM Gemini Pro 2.5 com o comando "definir" e gerar resultados.

Preencha o código com o seguinte abaixo do código anterior em app.py

# Generate diet plan using Gemini Pro
def generate_diet_plan(params):
   try:
       model = GenerativeModel("gemini-2.5-pro")
       prompt = f"""
       Create a personalized 7-day diet plan for:
       - {params['gender']}, {params['age']} years old
       - Weight: {params['weight']} kg
       - Height: {params['height']} cm
      
       Include:
       1. Daily calorie target
       2. Macronutrient breakdown (carbs, protein, fat)
       3. Meal timing and frequency
       4. Food recommendations
       5. Hydration guidance
      
       Make the plan:
       - Nutritionally balanced
       - Practical for daily use
       - Culturally adaptable
       - With portion size guidance
       """
      
       response = model.generate_content(prompt)
       return response.text
   except Exception as e:
       st.error(f"AI generation error: {str(e)}")
       return None

Criar os principais apps do planejador de dieta do agente: save_to_bq

Nesta seção, vamos criar uma função chamada save_to_bq com três parâmetros de entrada : bq_client, user_id e plan. Essa função salva o resultado da geração na tabela do BigQuery.

Preencha o código com o seguinte abaixo do código anterior em app.py

# Save user data to BigQuery
def save_to_bq(bq_client, user_id, plan):
   try:
       dataset_id = f"{st.secrets['gcp']['project_id']}.{DATASET}"
       table_id = f"{dataset_id}.{TABLE}"
      
       row = {
           "user_id": user_id,
           "timestamp": datetime.datetime.utcnow().isoformat(),
           "weight": st.session_state.user_data["weight"],
           "height": st.session_state.user_data["height"],
           "age": st.session_state.user_data["age"],
           "gender": st.session_state.user_data["gender"],
           "diet_plan": plan
       }
      
       errors = bq_client.insert_rows_json(table_id, [row])
       if errors:
           st.error(f"BigQuery error: {errors}")
       else:
           return True
   except Exception as e:
       st.error(f"Data saving error: {str(e)}")
       return False

Criar apps principais do planejador de dieta do agente - main

Nesta seção, vamos criar uma função chamada main sem parâmetro de entrada. Essa função processa principalmente o script da interface do Streamlit, mostra o resultado gerado e o resultado histórico gerado da tabela do BigQuery e faz o download dos dados para um arquivo Markdown.

Preencha o código com o seguinte abaixo do código anterior em app.py

# Streamlit UI
def main():
   st.set_page_config(page_title="AI Diet Planner", page_icon="🍏", layout="wide")
  
   # Initialize session state
   if "user_data" not in st.session_state:
       st.session_state.user_data = None
   if "diet_plan" not in st.session_state:
       st.session_state.diet_plan = None
  
   # Initialize clients
   #bq_client = init_clients()
   setup_bq_table(bq_client)
  
   st.title("🍏 AI-Powered Diet Planner")
   st.markdown("""
   <style>
   .stProgress > div > div > div > div {
       background-color: #4CAF50;
   }
   [data-testid="stForm"] {
       background: #f0f5ff;
       padding: 20px;
       border-radius: 10px;
       border: 1px solid #e6e9ef;
   }
   </style>
   """, unsafe_allow_html=True)
  
   # User input form
   with st.form("user_profile", clear_on_submit=False):
       st.subheader("Your Profile")
       col1, col2 = st.columns(2)
      
       with col1:
           weight = st.number_input("Weight (kg)", min_value=30.0, max_value=200.0, value=70.0)
           height = st.number_input("Height (cm)", min_value=100, max_value=250, value=170)
          
       with col2:
           age = st.number_input("Age", min_value=18, max_value=100, value=30)
           gender = st.selectbox("Gender", ["Man", "Woman"])
      
       submitted = st.form_submit_button("Generate Diet Plan")
      
       if submitted:
           user_data = {
               "weight": weight,
               "height": height,
               "age": age,
               "gender": gender
           }

           st.session_state.user_data = user_data
           # Calculate BMI
           bmi_result = calculate_bmi_status(weight, height)

           # Display BMI results in a visually distinct box
           with st.container():
               st.subheader("📊 Your Health Assessment")
               col1, col2 = st.columns([1, 3])
      
               with col1:
                   st.metric("BMI", bmi_result["value"])
          
               with col2:
                   if bmi_result["status"] != "normal":
                       st.warning(bmi_result["message"])
                   else:
                       st.success(bmi_result["message"])
      
           # Add BMI scale visualization
           st.markdown(f"""
           <div style="background:#f0f2f6;padding:10px;border-radius:10px;margin-top:10px">
           <small>BMI Scale:</small><br>
           <div style="display:flex;height:20px;background:linear-gradient(90deg,
           #4e79a7 0%,
           #4e79a7 18.5%,
           #60bd68 18.5%,
           #60bd68 25%,
           #f28e2b 25%,
           #f28e2b 30%,
           #e15759 30%,
           #e15759 100%);position:relative">
           <div style="position:absolute;left:{min(100, max(0, (bmi_result["value"]/40)*100))}%;top:-5px">
               ▼
           </div>
           </div>
           <div style="display:flex;justify-content:space-between">
           <span>Underweight (<18.5)</span>
           <span>Healthy (18.5-25)</span>
           <span>Overweight (25-30)</span>
           <span>Obese (30+)</span>
           </div>
           </div>
           """, unsafe_allow_html=True)

           # Store BMI in session state
           st.session_state.bmi = bmi_result         
  
   # Plan generation and display
   if submitted and st.session_state.user_data:
       with st.spinner("🧠 Generating your personalized diet plan using Gemini AI..."):
           #diet_plan = generate_diet_plan(st.session_state.user_data)
           diet_plan = generate_diet_plan({**st.session_state.user_data,"bmi": bmi_result["value"],
                                           "bmi_status": bmi_result["status"]
           })

           if diet_plan:
               st.session_state.diet_plan = diet_plan
              
               # Generate unique user ID
               user_id = f"user_{int(time.time())}"
              
               # Save to BigQuery
               if save_to_bq(bq_client, user_id, diet_plan):
                   st.toast("✅ Plan saved to database!")
  
   # Display generated plan
   if st.session_state.diet_plan:
       st.subheader("Your Personalized Diet Plan")
       st.markdown("---")
       st.markdown(st.session_state.diet_plan)
      
       # Download button
       st.download_button(
           label="Download Plan",
           data=st.session_state.diet_plan,
           file_name="my_diet_plan.md",
           mime="text/markdown"
       )
      
       # Show history
       st.subheader("Your Plan History")
       try:
           query = f"""
               SELECT timestamp, weight, height, age, gender
               FROM `{st.secrets['gcp']['project_id']}.{DATASET}.{TABLE}`
               WHERE user_id LIKE 'user_%'
               ORDER BY timestamp DESC
               LIMIT 5
           """
           history = bq_client.query(query).to_dataframe()
           if not history.empty:
               history["timestamp"] = pd.to_datetime(history["timestamp"])
               st.dataframe(history.style.format({
                   "weight": "{:.1f} kg",
                   "height": "{:.0f} cm"
               }))
           else:
               st.info("No previous plans found")
       except Exception as e:
           st.error(f"History load error: {str(e)}")

if __name__ == "__main__":
   main()

Salve o código com o nome app.py.

5. Implantar apps usando o Cloud Build no Cloud Run

Agora, é claro que queremos mostrar esse app incrível para outras pessoas. Para isso, podemos empacotar e implantar o aplicativo no Cloud Run como um serviço público acessível a outras pessoas. Para isso, vamos analisar a arquitetura novamente.

Primeiro, precisamos do Dockerfile. Clique em Arquivo->Novo arquivo de texto,copie e cole o código a seguir e salve como Dockerfile.

# Use official Python image
FROM python:3.12-slim

# Set environment variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1
ENV PORT 8080

# Install system dependencies
RUN apt-get update && \
   apt-get install -y --no-install-recommends \
   build-essential \
   libpq-dev \
   && rm -rf /var/lib/apt/lists/*

# Set working directory
WORKDIR /app

# Copy requirements
COPY requirements.txt .

# Install Python dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy application files
COPY . .

# Expose port
EXPOSE $PORT

# Run the application
CMD ["streamlit", "run", "app.py", "--server.port", "8080", "--server.address", "0.0.0.0"]

Em seguida, vamos criar o cloudbuild.yaml para criar apps que se tornem imagens do Docker, enviar para o Artifact Registry e implantar no Cloud Run.

Clique em Arquivo->Novo arquivo de texto,copie e cole o código a seguir e salve-o como cloudbuild.yaml.

steps:
 # Build Docker image
 - name: 'gcr.io/cloud-builders/docker'
   args: ['build', '-t', 'gcr.io/$PROJECT_ID/diet-planner:$BUILD_ID', '--no-cache',
        '--progress=plain',
        '.']
   id: 'Build'
   timeout: 1200s
   waitFor: ['-']
   dir: '.'
  # Push to Container Registry
 - name: 'gcr.io/cloud-builders/docker'
   args: ['push', 'gcr.io/$PROJECT_ID/diet-planner:$BUILD_ID']
   id: 'Push'
   waitFor: ['Build']
  # Deploy to Cloud Run
 - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
   entrypoint: gcloud
   args:
     - 'run'
     - 'deploy'
     - 'diet-planner-service'
     - '--image=gcr.io/$PROJECT_ID/diet-planner:$BUILD_ID'
     - '--port=8080'
     - '--region=us-central1'
     - '--platform=managed'
     - '--allow-unauthenticated'
     - '--set-env-vars=GCP_PROJECT_ID=$PROJECT_ID,GCP_LOCATION=us-central1'
     - '--cpu=1'
     - '--memory=1Gi'
     - '--timeout=300'
   waitFor: ['Push']

options:
 logging: CLOUD_LOGGING_ONLY
 machineType: 'E2_HIGHCPU_8'
 diskSizeGb: 100

images:
 - 'gcr.io/$PROJECT_ID/diet-planner:$BUILD_ID'

Neste ponto, já temos todos os arquivos necessários para criar apps que se tornam imagens do Docker, enviar para o Artifact Registry e implantar no Cloud Run. Vamos fazer isso. Navegue até o terminal do Cloud Shell e verifique se o projeto atual está configurado para seu projeto ativo. Caso contrário, use o comando gcloud configure para definir o ID do projeto:

gcloud config set project [PROJECT_ID]

Em seguida, execute o comando a seguir para criar apps que se tornam imagens do Docker, envie para o Artifact Registry e implante no Cloud Run.

gcloud builds submit --config cloudbuild.yaml

Ele vai criar o contêiner do Docker com base no Dockerfile fornecido anteriormente e enviá-lo por push ao Artifact Registry. Depois disso, vamos implantar a imagem criada no Cloud Run. Todo esse processo é definido nas etapas de cloudbuild.yaml.

Estamos permitindo o acesso não autenticado porque este é um aplicativo de demonstração. Recomendamos usar a autenticação adequada para seus aplicativos empresariais e de produção.

Depois que a implantação for concluída, podemos verificar na página do Cloud Run. Para isso, pesquise "Cloud Run" na barra de pesquisa da parte de cima do console do Cloud e clique no produto.

Depois disso, inspecione o serviço implantado listado na página "Serviço do Cloud Run". Clique no serviço para acessar o URL dele.

O URL do serviço vai estar na barra superior

Use o aplicativo na janela anônima ou no dispositivo móvel. Ele já deve estar ativo.

6. Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste codelab, siga estas etapas:

No console do Google Cloud, acesse a página Gerenciar recursos.
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.
Ou acesse Cloud Run no console, selecione o serviço que você acabou de implantar e exclua.