1. Introducción
En este codelab, aprenderás a compilar e implementar un planificador de dietas potenciado por IA. Para la IU con Streamlit, el modelo de LLM con Gemini Pro 2.5, el orquestador del motor de IA agentiva con Vertex AI para el desarrollo de IA agentiva, BigQuery para almacenar datos y Cloud Run para la implementación.
En el codelab, seguirás un enfoque paso a paso de la siguiente manera:
- Prepara tu proyecto de Google Cloud y habilita todas las APIs necesarias en él
- Crea un planificador de dietas basado en IA con Streamlit, Vertex AI y BigQuery
- Implementa la aplicación en Cloud Run
Descripción general de la arquitectura
Requisitos previos
- Un proyecto de Google Cloud Platform (GCP) con facturación habilitada
- Conocimientos básicos de Python
Qué aprenderás
- Cómo crear un planificador de dietas con IA agentiva usando Streamlit, Vertex AI y almacenar datos en BigQuery
- Cómo implementar la aplicación en Cloud Run
Requisitos
- Navegador web Chrome
- Una cuenta de Gmail
- Un proyecto de Cloud con la facturación habilitada
2. Configuración básica y requisitos
Configuración del entorno de autoaprendizaje
- Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.
- El nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
- El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como
PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto. - Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.
- A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.
3. Antes de comenzar
Configura el proyecto de Cloud en el editor de Cloud Shell
En este codelab, se supone que ya tienes un proyecto de Google Cloud con la facturación habilitada. Si aún no lo tienes, puedes seguir las instrucciones que se indican a continuación para comenzar.
- En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.
- Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información para verificar si la facturación está habilitada en un proyecto .
- Usarás Cloud Shell, un entorno de línea de comandos que se ejecuta en Google Cloud y que viene precargado con bq. Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.
- Una vez que te conectes a Cloud Shell, verifica que ya te autenticaste y que el proyecto se configuró con el ID de tu proyecto con el siguiente comando:
gcloud auth list
- En Cloud Shell, ejecuta el siguiente comando para confirmar que el comando gcloud conoce tu proyecto.
gcloud config list project
- Si tu proyecto no está configurado, usa el siguiente comando para hacerlo:
gcloud config set project <YOUR_PROJECT_ID>
Como alternativa, también puedes ver el ID de PROJECT_ID en la consola.
Haz clic en él y verás todos tus proyectos y el ID del proyecto en el lado derecho.
- Habilita las APIs requeridas con el siguiente comando. Este proceso puede tardar unos minutos, así que ten paciencia.
gcloud services enable aiplatform.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
cloudresourcemanager.googleapis.com \
bigquery.googleapis.com
Si el comando se ejecuta correctamente, deberías ver un mensaje similar al que se muestra a continuación:
Operation "operations/..." finished successfully.
La alternativa al comando de gcloud es a través de la consola, buscando cada producto o usando este vínculo.
Si olvidas alguna API, puedes habilitarla durante el curso de la implementación.
Consulta la documentación para ver los comandos y el uso de gcloud.
Configura el directorio de trabajo de la aplicación
- Haz clic en el botón Abrir editor para abrir un editor de Cloud Shell en el que puedes escribir tu código
- Asegúrate de que el proyecto de Cloud Code esté configurado en la esquina inferior izquierda (barra de estado) del editor de Cloud Shell, como se destaca en la siguiente imagen, y que esté configurado en el proyecto activo de Google Cloud en el que tienes habilitada la facturación. Haz clic en Autorizar si se te solicita. Es posible que el botón Cloud Code - Sign In tarde en aparecer después de inicializar el editor de Cloud Shell. Ten paciencia.
A continuación, prepararemos nuestro entorno de Python.
Configuración del entorno
Prepara el entorno virtual de Python
El siguiente paso es preparar el entorno de desarrollo. En este codelab, usaremos Python 3.12 y virtualenv de Python para simplificar la necesidad de crear y administrar la versión de Python y el entorno virtual.
- Si aún no abriste la terminal, haz clic en Terminal -> New Terminal o usa Ctrl + Mayúsculas + C.
- Crea una carpeta nueva y cambia la ubicación a esta carpeta con el siguiente comando:
mkdir agent_diet_planner
cd agent_diet_planner
- Crea un nuevo virtualenv con el siguiente comando
python -m venv .env
- Activa virtualenv con el siguiente comando
source .env/bin/activate
- Crea
requirements.txt. Haz clic en Archivo → Archivo de texto nuevo y completa el contenido que se muestra a continuación. Luego, guárdalo comorequirements.txt.
streamlit==1.33.0
google-cloud-aiplatform
google-cloud-bigquery
pandas==2.2.2
db-dtypes==1.2.0
pyarrow==16.1.0
- Luego, instala todas las dependencias de requirements.txt con el siguiente comando:
pip install -r requirements.txt
- Escribe el siguiente comando para verificar que estén instaladas todas las dependencias de las bibliotecas de Python.
pip list
Configura archivos de configuración
Ahora, deberemos configurar los archivos de configuración para este proyecto. Los archivos de configuración se usan para almacenar variables y credenciales de cuentas de servicio.
- El primer paso es crear una cuenta de servicio. Escribe cuenta de servicio en la búsqueda y, luego, haz clic en Cuenta de servicio.
- Haz clic en + Crear cuenta de servicio. Ingresa el nombre de la cuenta de servicio y, luego, haz clic en Crear y continuar.
- En el permiso, elige el rol Usuario de cuenta de servicio. Haz clic en + Agregar otro rol y elige los roles de IAM : Administrador de BigQuery, Administrador de Cloud Run, Invocador de Cloud Run, Agente de servicio de Vertex AI y Usuario de Vertex AI. Luego, haz clic en Listo.
- Haz clic en Correo electrónico de la cuenta de servicio, haz clic en la tecla de tabulación, haz clic en Agregar clave → Crear clave nueva.
- Elige json y, luego, haz clic en Crear. Guarda este archivo de cuenta de servicio de forma local para el siguiente paso
- Crea una carpeta llamada .streamlit con la siguiente configuración. Haz clic con el botón derecho del mouse, selecciona Nueva carpeta y escribe el nombre de la carpeta
.streamlit. - Haz clic con el botón derecho en la carpeta
.streamlit, luego, en Archivo nuevo y completa el valor que se indica a continuación. Luego, guárdalo comosecrets.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"
- Actualiza los valores de
project_id,private_key_id,private_key,client_emailyclient_id , and auth_provider_x509_cert_urlsegún la cuenta de servicio que creaste en el paso anterior.
Prepara el conjunto de datos de BigQuery
El siguiente paso es crear un conjunto de datos de BigQuery para guardar los resultados de la generación en BigQuery.
- Escribe BigQuery en la búsqueda y, luego, haz clic en BigQuery.
- Haz clic en
y, luego, en Crear conjunto de datos. - Ingresa el ID del conjunto de datos
diet_planner_datay, luego, haz clic en Crear conjunto de datos
.
4. Crea apps de Planificador de dieta con agentes
Compilaremos una interfaz web simple con 4 entradas que se verá de la siguiente manera:
Cambia el peso, la altura, la edad y el género según tu perfil y, luego, haz clic en Generar. Llamará al modelo de LLM Gemini Pro 2.5 en la biblioteca de Vertex AI y almacenará los resultados generados en BigQuery.
El código se separará en 6 partes para que no sea demasiado largo.
Crea la función para calcular el estado del IMC
- Haz clic con el botón derecho en la carpeta
agent_diet_planner→ Archivo nuevo… → ingresa el nombre de archivobmi_calc.pyy, luego, presiona Intro. - Completa el código con lo siguiente:
# 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
}
Crear apps principales del planificador de dieta del agente
- Haz clic con el botón derecho en la carpeta
agent_diet_planner→ Archivo nuevo… → ingresa el nombre de archivoapp.pyy, luego, presiona Intro. - Completa el código con lo siguiente:
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()
Cambia el valor your_gcp_project_id por el ID de tu proyecto.
Create agent diet planner main apps - setup_bq_tables
En esta sección, crearemos una función llamada setup_bq_table con 1 parámetro de entrada bq_client. Esta función definirá el esquema en la tabla de BigQuery y creará una tabla si no existe.
Completa el código con lo siguiente debajo del código anterior en 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")
Crea las apps principales del planificador de dietas del agente: generate_diet_plan
En esta sección, crearemos una función llamada generate_diet_plan con 1 parámetro de entrada. Esta función llamará al modelo de LLM Gemini Pro 2.5 con la instrucción de definición y generará resultados.
Completa el código con lo siguiente debajo del código anterior en 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
Create agent diet planner main apps - save_to_bq
En esta sección, crearemos una función llamada save_to_bq con 3 parámetros de entrada : bq_client, user_id y plan. Esta función guardará el resultado de la generación en la tabla de BigQuery.
Completa el código con lo siguiente debajo del código anterior en 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
Create agent diet planner main apps - main
En esta sección, crearemos una función llamada main sin parámetros de entrada. Esta función se encarga principalmente de controlar la secuencia de comandos de la IU de Streamlit, mostrar el resultado generado, mostrar el resultado histórico generado de la tabla de BigQuery y descargar datos en un archivo de Markdown.
Completa el código con lo siguiente debajo del código anterior en 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()
Guarda el código con el nombre app.py.
5. Implementa apps con Cloud Build en Cloud Run
Por supuesto, queremos mostrar esta increíble app a los demás. Para ello, podemos empaquetar esta aplicación y, luego, implementarla en Cloud Run como un servicio público al que puedan acceder otras personas. Para ello, volvamos a ver la arquitectura
Primero, necesitamos un Dockerfile. Haz clic en File->New Text File, copia y pega el siguiente código y, luego, guárdalo 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"]
A continuación, crearemos cloudbuild.yaml para compilar apps y convertirlas en imágenes de Docker, enviarlas a Artifact Registry y, luego, implementarlas en Cloud Run.
Haz clic en File->New Text File, copia y pega el siguiente código y, luego, guárdalo 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'
En este punto, ya tenemos todos los archivos necesarios para compilar apps y convertirlas en imágenes de Docker, enviarlas a Artifact Registry y, luego, implementarlas en Cloud Run. Ahora, implementémoslas. Navega a la terminal de Cloud Shell y asegúrate de que el proyecto actual esté configurado en tu proyecto activo. Si no es así, usa el comando gcloud config para establecer el ID del proyecto:
gcloud config set project [PROJECT_ID]
Luego, ejecuta el siguiente comando para compilar las apps y convertirlas en imágenes de Docker, enviarlas a Artifact Registry y, luego, implementarlas en Cloud Run.
gcloud builds submit --config cloudbuild.yaml
Compilará el contenedor de Docker según el Dockerfile que proporcionamos anteriormente y lo enviará a Artifact Registry. Luego, implementaremos la imagen construida en Cloud Run. Todo este proceso se define en los pasos de cloudbuild.yaml.
Ten en cuenta que permitimos el acceso no autenticado aquí porque se trata de una aplicación de demostración. Se recomienda usar la autenticación adecuada para tus aplicaciones empresariales y de producción.
Una vez que se complete la implementación, podemos verificarla en la página de Cloud Run. Para ello, busca Cloud Run en la barra de búsqueda superior de la consola de Cloud y haz clic en el producto de Cloud Run.
Después de eso, puedes inspeccionar el servicio implementado que aparece en la página Servicio de Cloud Run. Haz clic en el servicio para que podamos obtener la URL del servicio.
La URL del servicio aparecerá en la barra superior.
Usa tu aplicación desde la ventana de incógnito o tu dispositivo móvil. Ya debería estar disponible.
6. Limpia
Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en este codelab:
- En la consola de Google Cloud, ve a la página Administrar recursos.
- En la lista de proyectos, elige el proyecto que deseas borrar y haz clic en Borrar.
- En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrarlo.
- Como alternativa, puedes ir a Cloud Run en la consola, seleccionar el servicio que acabas de implementar y borrarlo.