1. Introduzione
In questo codelab imparerai a creare e implementare un piano alimentare basato sull'AI. Per la UI che utilizza Streamlit, il modello LLM che utilizza Gemini Pro 2.5, l'orchestratore del motore di AI agentica che utilizza Vertex AI per lo sviluppo dell'AI agentica, BigQuery per l'archiviazione dei dati e Cloud Run per il deployment.
Nel codelab, seguirai un approccio passo passo come segue:
- Prepara il progetto Google Cloud e abilita tutte le API richieste
- Crea un pianificatore di diete basato sull'AI utilizzando Streamlit, Vertex AI e BigQuery
- Esegui il deployment dell'applicazione in Cloud Run
Panoramica dell'architettura
Prerequisito
- Un progetto Google Cloud con fatturazione abilitata.
- Conoscenza di base di Python
Cosa imparerai a fare
- Come creare un pianificatore di diete basato sull'AI utilizzando Streamlit, Vertex AI e archiviare i dati in BigQuery
- Come eseguire il deployment dell'applicazione in Cloud Run
Che cosa ti serve
- Browser web Chrome
- Un account Gmail
- Un progetto cloud con fatturazione abilitata
2. Configurazione di base e requisiti
Configurazione dell'ambiente autonomo
- Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai già un account Gmail o Google Workspace, devi crearne uno.
- Il nome del progetto è il nome visualizzato per i partecipanti al progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
- L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere identificato come
PROJECT_ID). Se non ti piace l'ID generato, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto. - Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. Completare questo codelab non costa molto, se non nulla. Per arrestare le risorse ed evitare addebiti oltre a quelli previsti da questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.
3. Prima di iniziare
Configura il progetto cloud nell'editor di Cloud Shell
Questo codelab presuppone che tu abbia già un progetto Google Cloud con la fatturazione abilitata. Se non l'hai ancora fatto, puoi seguire le istruzioni riportate di seguito per iniziare.
- Nella console Google Cloud, nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud.
- Verifica che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata per un progetto .
- Utilizzerai Cloud Shell, un ambiente a riga di comando in esecuzione in Google Cloud precaricato con bq. Fai clic su Attiva Cloud Shell nella parte superiore della console Google Cloud.
- Una volta eseguita la connessione a Cloud Shell, verifica di essere già autenticato e che il progetto sia impostato sul tuo ID progetto utilizzando il seguente comando:
gcloud auth list
- Esegui questo comando in Cloud Shell per verificare che il comando gcloud conosca il tuo progetto.
gcloud config list project
- Se il progetto non è impostato, utilizza il seguente comando per impostarlo:
gcloud config set project <YOUR_PROJECT_ID>
In alternativa, puoi anche visualizzare l'ID PROJECT_ID nella console.
Fai clic e vedrai tutti i tuoi progetti e l'ID progetto sul lato destro.
- Abilita le API richieste tramite il comando mostrato di seguito. L'operazione potrebbe richiedere alcuni minuti.
gcloud services enable aiplatform.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
cloudresourcemanager.googleapis.com \
bigquery.googleapis.com
Se il comando viene eseguito correttamente, dovresti visualizzare un messaggio simile a quello mostrato di seguito:
Operation "operations/..." finished successfully.
L'alternativa al comando gcloud è tramite la console, cercando ogni prodotto o utilizzando questo link.
Se manca un'API, puoi sempre abilitarla durante l'implementazione.
Consulta la documentazione per i comandi e l'utilizzo di gcloud.
Configurare la directory di lavoro dell'applicazione
- Fai clic sul pulsante Apri editor per aprire un editor di Cloud Shell in cui puoi scrivere il codice
- Assicurati che il progetto Cloud Code sia impostato nell'angolo in basso a sinistra (barra di stato) dell'editor di Cloud Shell, come evidenziato nell'immagine seguente, e che sia impostato sul progetto Google Cloud attivo in cui hai attivato la fatturazione. Autorizza, se richiesto. Potrebbe volerci un po' di tempo dopo l'inizializzazione di Cloud Shell Editor prima che venga visualizzato il pulsante Cloud Code - Sign In, quindi abbi pazienza.
Successivamente, prepareremo il nostro ambiente Python.
Configurazione dell'ambiente
Prepara l'ambiente virtuale Python
Il passaggio successivo consiste nel preparare l'ambiente di sviluppo. In questo codelab utilizzeremo Python 3.12 e python virtualenv per semplificare la necessità di creare e gestire la versione di Python e l'ambiente virtuale.
- Se non hai ancora aperto il terminale, aprilo facendo clic su Terminale -> Nuovo terminale o utilizza Ctrl + Maiusc + C.
- Crea una nuova cartella e cambia la posizione in questa cartella eseguendo il seguente comando
mkdir agent_diet_planner
cd agent_diet_planner
- Crea un nuovo virtualenv eseguendo il seguente comando
python -m venv .env
- Attiva virtualenv con questo comando
source .env/bin/activate
- Crea
requirements.txt. Fai clic su File → Nuovo file di testo e inserisci i contenuti riportati di seguito. Poi salvalo comerequirements.txt
streamlit==1.33.0
google-cloud-aiplatform
google-cloud-bigquery
pandas==2.2.2
db-dtypes==1.2.0
pyarrow==16.1.0
- Quindi installa tutte le dipendenze da requirements.txt eseguendo il seguente comando
pip install -r requirements.txt
- Digita il seguente comando per verificare che siano installate tutte le dipendenze delle librerie Python
pip list
File di configurazione dell'installazione
Ora dobbiamo configurare i file di configurazione per questo progetto. I file di configurazione vengono utilizzati per archiviare le credenziali delle variabili e del service account.
- Il primo passo consiste nel creare un service account. Digita service account nella ricerca, quindi fai clic su service account.
- Fai clic su + Crea service account. Inserisci il nome del service account, quindi fai clic su Crea e continua.
- In Autorizzazione, scegli il ruolo Utente account di servizio. Fai clic su + Aggiungi un altro ruolo e scegli il ruolo IAM : Amministratore BigQuery, Amministratore Cloud Run, Invocatore Cloud Run, Agente di servizio Vertex AI e Utente Vertex AI, quindi fai clic su Fine
- Fai clic su Email account di servizio, fai clic sul tasto Tab, fai clic su Aggiungi chiave → Crea nuova chiave.
- Scegli JSON, quindi fai clic su Crea. Salva questo file del service account in locale per il passaggio successivo
- Crea una cartella denominata .streamlit con la seguente configurazione. Fai clic con il tasto destro del mouse, fai clic su Nuova cartella e digita il nome della cartella
.streamlit. - Fai clic con il tasto destro del mouse nella cartella
.streamlit, poi fai clic su Nuovo file e inserisci il valore riportato di seguito. Poi salvalo comesecrets.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"
- Aggiorna il valore per
project_id,private_key_id,private_key,client_email,client_id , and auth_provider_x509_cert_urlin base al service account creato nel passaggio precedente
Prepara il set di dati BigQuery
Il passaggio successivo consiste nel creare un set di dati BigQuery per salvare i risultati della generazione in BigQuery.
- Digita BigQuery nella ricerca, quindi fai clic su BigQuery.
- Fai clic su
, quindi su Crea set di dati. - Inserisci l'ID del set di dati
diet_planner_datae poi fai clic su Crea set di dati
.
4. Crea app per la pianificazione della dieta dell'agente
Creeremo una semplice interfaccia web con 4 input simile a questa
Modifica peso, altezza, età e genere in base al tuo profilo, poi fai clic su Genera. Chiamerà il modello LLM Gemini Pro 2.5 nella libreria Vertex AI e memorizzerà i risultati generati in BigQuery.
Il codice verrà suddiviso in 6 parti per non essere troppo lungo.
Crea la funzione calculate bmi status
- Fai clic con il tasto destro del mouse sulla cartella
agent_diet_planner→ Nuovo file… → inserisci il nome del filebmi_calc.py, quindi premi Invio. - Riempi il codice con quanto segue
# 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
}
Crea app principali per la pianificazione della dieta dell'agente
- Fai clic con il tasto destro del mouse sulla cartella
agent_diet_planner→ Nuovo file… → inserisci il nome del fileapp.py, quindi premi Invio. - Riempi il codice con quanto segue
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()
Modifica il valore your_gcp_project_id con l'ID progetto.
Create agent diet planner main apps - setup_bq_tables
In questa sezione creeremo una funzione denominata setup_bq_table con un parametro di input bq_client. Questa funzione definirà lo schema nella tabella BigQuery e creerà una tabella se non esiste.
Riempi il codice con il seguente codice sotto il codice precedente in 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")
Create agent diet planner main apps - generate_diet_plan
In questa sezione creeremo una funzione denominata generate_diet_plan con un parametro di input. Questa funzione chiamerà il modello LLM Gemini Pro 2.5 con il prompt di definizione e genererà i risultati.
Riempi il codice con il seguente codice sotto il codice precedente in 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
In questa sezione creeremo una funzione denominata save_to_bq con tre parametri di input : bq_client, user_id e plan. Questa funzione salverà il risultato generato nella tabella BigQuery
Riempi il codice con il seguente codice sotto il codice precedente in 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
In questa sezione creeremo una funzione denominata main senza parametri di input. Questa funzione gestisce principalmente lo script dell'interfaccia utente di Streamlit, la visualizzazione del risultato generato, la visualizzazione del risultato storico generato dalla tabella BigQuery e il download dei dati nel file Markdown.
Riempi il codice con il seguente codice sotto il codice precedente in 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()
Salva il codice con il nome app.py.
5. Esegui il deployment delle app utilizzando Cloud Build in Cloud Run
Ora, ovviamente, vogliamo mostrare questa fantastica app agli altri. Per farlo, possiamo creare un pacchetto di questa applicazione ed eseguirne il deployment in Cloud Run come servizio pubblico a cui possono accedere altri utenti. Per farlo, rivediamo l'architettura
Per prima cosa, abbiamo bisogno di Dockerfile. Fai clic su File->Nuovo file di testo,copia e incolla il seguente codice e salvalo come 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"]
Successivamente, creeremo cloudbuild.yaml per creare app che diventino immagini Docker, eseguirne il push su Artifact Registry ed eseguirne il deployment su Cloud Run.
Fai clic su File->Nuovo file di testo, copia e incolla il seguente codice, quindi salvalo come 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'
A questo punto, abbiamo già tutti i file necessari per creare app che diventino immagini Docker, eseguirne il push su Artifact Registry ed eseguirne il deployment su Cloud Run. Eseguiamo il deployment. Vai al terminale Cloud Shell e assicurati che il progetto attuale sia configurato sul tuo progetto attivo. In caso contrario, devi utilizzare il comando gcloud configure per impostare l'ID progetto:
gcloud config set project [PROJECT_ID]
Quindi, esegui questo comando per creare app che diventino immagini Docker, eseguirne il push in Artifact Registry e il deployment in Cloud Run
gcloud builds submit --config cloudbuild.yaml
Verrà creato il container Docker in base al Dockerfile fornito in precedenza e verrà eseguito il push in Artifact Registry. Dopodiché, eseguiremo il deployment dell'immagine creata in Cloud Run. L'intera procedura è definita nei passaggi cloudbuild.yaml.
Tieni presente che qui consentiamo l'accesso non autenticato perché si tratta di un'applicazione demo. Ti consigliamo di utilizzare l'autenticazione appropriata per le applicazioni aziendali e di produzione.
Una volta completato il deployment, possiamo controllarlo nella pagina Cloud Run. Cerca Cloud Run nella barra di ricerca della console Google Cloud in alto e fai clic sul prodotto Cloud Run.
Dopodiché, puoi esaminare il servizio di cui è stato eseguito il deployment elencato nella pagina del servizio Cloud Run. Fai clic sul servizio per ottenere il relativo URL.
L'URL del servizio si trova nella barra superiore
Continua a utilizzare l'applicazione dalla finestra di navigazione in incognito o dal tuo dispositivo mobile. Dovrebbe essere già disponibile.
6. Esegui la pulizia
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo codelab, segui questi passaggi:
- Nella console Google Cloud, vai alla pagina Gestisci risorse.
- Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
- Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.
- In alternativa, puoi andare a Cloud Run nella console, selezionare il servizio di cui hai appena eseguito il deployment ed eliminarlo.