Questa pagina è stata tradotta dall'API Cloud Translation.

Crea un generatore di quiz con l'IA generativa e Cloud Run

1. Introduzione

In questo lab creerai un servizio web per generare quiz di cultura generale e integrarlo in un'app divertente e funzionante. Utilizzerai un linguaggio di programmazione diverso da quello utilizzato in precedenza: italiano.

Cosa farai...

Creerai un prompt che genererà un quiz in base a una serie di criteri.
Dovrai creare una semplice app web e verificare che venga eseguita come previsto nel tuo ambiente di sviluppo.
Dovrai aggiungere in modo incrementale la logica alla tua app web per trasformarla in un server API che genera quiz in base a un insieme di parametri di input.
Vedrai quanto è facile eseguire il deployment del tuo servizio di generazione di quiz nel cloud utilizzando Google Cloud Run.
Infine, configurerai un'app reale ( quizaic.com) per utilizzare il servizio di generazione di quiz di cui è stato eseguito il deployment e sarai in grado di svolgere quiz in tempo reale in base all'output.

Cosa imparerai...

Come creare un prompt basato su modelli per un modello linguistico di grandi dimensioni (LLM).
Come creare una semplice app server web in Python.
Come aggiungere il supporto per gli LLM di Google nella tua app web.
Come eseguire il deployment della tua app nel cloud in modo che chiunque possa provare la tua nuova creazione.
Come integrare il generatore di quiz in un'app più grande.

Che cosa ti serve...

Browser web Chrome
Un Account Google
Un progetto Cloud con fatturazione abilitata

Questo lab è rivolto a sviluppatori di tutti i livelli, inclusi i principianti. Anche se utilizzerai Python, non è necessario avere familiarità con la programmazione Python per capire cosa sta succedendo, perché ti spiegheremo tutto il codice che vedrai.

2. Configurazione

Questa sezione illustra tutto ciò che devi fare per iniziare a utilizzare questo lab.

Configurazione dell'ambiente da seguire in modo autonomo

Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

Il Nome progetto è il nome visualizzato dei partecipanti del progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarla.
L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca; di solito non ti importa cosa sia. Nella maggior parte dei codelab, dovrai fare riferimento al tuo ID progetto (in genere identificato come PROJECT_ID). Se l'ID generato non ti soddisfa, potresti generarne un altro casuale. In alternativa, puoi provarne una personalizzata per verificare se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto.
Per informazione, c'è un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare risorse/API Cloud. L'esecuzione di questo codelab non ha alcun costo. Per arrestare le risorse ed evitare di incorrere in fatturazione dopo questo tutorial, puoi eliminare le risorse che hai creato o eliminare il progetto. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.

Avvia Cloud Shell

In questo lab lavorerai in una sessione di Cloud Shell, un interprete di comandi ospitato da una macchina virtuale in esecuzione nel cloud di Google. Potresti eseguire facilmente questa sezione in locale sul tuo computer, ma l'utilizzo di Cloud Shell offre a chiunque l'accesso a un'esperienza riproducibile in un ambiente coerente. Dopo il lab, puoi riprovare questa sezione sul tuo computer.

Attiva Cloud Shell

Dalla console Cloud, fai clic su Attiva Cloud Shell .

Se è la prima volta che avvii Cloud Shell, ti verrà mostrata una schermata intermedia che descrive di cosa si tratta. Se ti è stata presentata una schermata intermedia, fai clic su Continua.

Il provisioning e la connessione a Cloud Shell dovrebbero richiedere solo qualche istante.

Questa macchina virtuale viene caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Gran parte, se non tutto, del lavoro in questo codelab può essere svolto con un browser.

Una volta stabilita la connessione a Cloud Shell, dovresti vedere che hai eseguito l'autenticazione e che il progetto è impostato sul tuo ID progetto.

Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:

gcloud auth list

Output comando

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Esegui questo comando in Cloud Shell per confermare che il comando gcloud è a conoscenza del tuo progetto:

gcloud config list project

Output comando

[core]
project = <PROJECT_ID>

In caso contrario, puoi impostarlo con questo comando:

gcloud config set project <PROJECT_ID>

Output comando

Updated property [core/project].

Abilita alcune API

Nei passaggi successivi vedrai dove (e perché) sono necessari questi servizi, ma per il momento esegui questo comando per concedere al tuo progetto l'accesso a Cloud Build, Artifact Registry, Vertex AI e Cloud Run:

gcloud services enable cloudbuild.googleapis.com        \
                       artifactregistry.googleapis.com  \
                       aiplatform.googleapis.com        \
                       run.googleapis.com

Dovrebbe essere visualizzato un messaggio di operazione riuscita simile al seguente:

Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.

3. Prompt - Programmazione in linguaggio naturale

Inizieremo imparando a sviluppare un prompt per un modello linguistico di grandi dimensioni. Vai alla console Google Cloud > Vertex AI > Vertex AI Studio (lingua). Dovresti visualizzare una pagina simile alla seguente:

In Generate Text, fai clic sul pulsante Text Prompt. Nella finestra di dialogo successiva, inserisci un prompt che ritieni possa essere efficace per generare un quiz in base ai seguenti requisiti:

Argomento: Storia mondiale
Numero di domande: 5
Livello di difficoltà: intermedio
Lingua: inglese

Fai clic sul pulsante Invia per visualizzare l'output.

Come mostrato nello screenshot seguente, il riquadro di destra ti offre la possibilità di selezionare il modello che desideri utilizzare e di ottimizzare alcune impostazioni:

Sono disponibili le impostazioni seguenti:

La regione è quella in cui deve essere eseguita la richiesta di generazione.
Il modello seleziona il modello linguistico di grandi dimensioni (LLM) che vuoi utilizzare. Per questo codelab, utilizza "gemini-1.0-pro-001".
La temperatura controlla il grado di casualità nella selezione dei token. Le temperature più basse sono ideali per prompt che si aspettano una risposta vera o corretta, mentre le temperature più alte possono portare a risultati più diversificati o imprevisti.
Il limite di token determina la quantità massima di output di testo da un prompt. Un token equivale a circa quattro caratteri. Il valore predefinito è 1024.
Top-k cambia il modo in cui il modello seleziona i token per l'output. Un top-k pari a 1 indica che il token selezionato è il più probabile tra tutti i token nel vocabolario del modello (chiamato anche decodifica greedy), mentre un top-k pari a 3 indica che il token successivo viene selezionato tra i 3 token più probabili (utilizzando la temperatura). Il valore predefinito di top-k è 40.
Top-p cambia il modo in cui il modello seleziona i token per l'output. I token vengono selezionati dal più probabile al meno probabile, finché la somma delle probabilità non corrisponde al valore di top-p.
Numero massimo di risposte indica il numero massimo di risposte del modello generate per richiesta.
Una sequenza di interruzioni è una serie di caratteri (spazi inclusi) che interrompe la generazione di risposte se il modello la rileva.
Le risposte dinamiche selezionano se stampare le risposte man mano che vengono generate o salvate e vengono visualizzate una volta completate.
La soglia del filtro di sicurezza regola la probabilità di visualizzare risposte potenzialmente dannose.

Una volta che hai un prompt che sembra generare un quiz ragionevole in base ai requisiti indicati sopra, potremmo analizzare il quiz utilizzando un codice personalizzato, ma non sarebbe meglio che l'LLM generasse il quiz in un formato strutturato che possa essere caricato direttamente nel nostro programma? Il programma che utilizzeremo più avanti in questo lab per chiamare il generatore si aspetta che i quiz vengano espressi in JSON, che è un formato per più lingue molto usato per la rappresentazione di dati strutturati.

I quiz di questo lab sono espressi come array di oggetti, in cui ogni oggetto contiene una domanda, un array di possibili risposte alla domanda e una risposta corretta. Ecco la codifica JSON per i quiz di questo lab:

[
    {
        "question": "Who was the first person to walk on the moon?",
          "responses": [
              "Neil Armstrong",
              "Buzz Aldrin",
              "Michael Collins",
              "Yuri Gagarin"
           ],
           "correct": "Neil Armstrong"
    },
    {
        "question": "What was the name of the war that took place between the British and the French in North America from 1754 to 1763??",
          "responses": [
              "The French and Indian War",
              "The Seven Years' War",
              "The War of the Austrian Succession",
              "The Great War"
           ],
           "correct": "The French and Indian War"
    },

    ...
]

Verifica se puoi modificare il prompt per generare il quiz nel formato JSON richiesto.

Specifica a parole il formato esatto che vuoi cercare (ad es. la frase in corsivo sopra).
Includi nel prompt un esempio del formato JSON desiderato.

Dopo aver generato i quiz in base alle specifiche desiderate, fai clic sul pulsante GET CODE nell'angolo in alto a destra della pagina per visualizzare il codice Python che può essere utilizzato per inviare in modo programmatico il prompt a un LLM Vertex AI. Se ti interessa utilizzare un linguaggio di programmazione diverso da Python, consulta https://cloud.google.com/vertex-ai/docs/samples?text=generative.

4. Crea un server web semplice

Ora che hai un prompt funzionante, vogliamo integrarlo in un'app più grande. Ovviamente, potremmo incorporare il tuo prompt nel codice sorgente dell'app più grande, ma vogliamo che il generatore funzioni come microservizio che fornisca un servizio di generazione di quiz per altre app. A questo scopo, dovremo creare un semplice server web e renderlo disponibile pubblicamente. Lo faremo nei seguenti passaggi.

Per iniziare, fai clic sul pulsante Open Editor nella parte superiore del riquadro di Cloud Shell. Ha questo aspetto:

Ti troverai quindi in un ambiente IDE simile a Visual Studio Code, in cui potrai creare progetti, modificare il codice sorgente, eseguire i tuoi programmi e così via.

Se lo schermo è troppo stretto, puoi espandere o ridurre la linea di divisione tra la console e la finestra di modifica/terminale trascinando la barra orizzontale tra queste due aree, evidenziate qui:

Puoi spostarti tra l'editor e il terminale facendo clic rispettivamente sui pulsanti Open Editor e Open Terminal. Prova a passare da un ambiente all'altro ora.

Quindi, crea una cartella in cui archiviare il lavoro per questo lab, facendo clic sul pulsante Aggiungi cartella , inserisci quiz-generator e premendo Invio. Tutti i file creati in questo lab, così come tutto il lavoro che svolgi in Cloud Shell, si svolgeranno in questa cartella.

Ora crea un file requirements.txt. Questo indica a Python le librerie da cui dipende la tua app. Per questa semplice app web, utilizzerai un modulo Python molto usato per creare server web, Flask,, la libreria client google-cloud-aiplatform, e un framework del server web chiamato gunicorn. Nel riquadro di navigazione dei file, fai clic con il tasto destro del mouse sulla cartella quiz-generator e seleziona la voce di menu New file, in questo modo:

Quando ti viene richiesto il nome del nuovo file, inserisci requirements.txt e premi il tasto Invio. Assicurati che il nuovo file finisca nella cartella del progetto quiz-generator.

Incolla le righe seguenti nel nuovo file per specificare che la tua app dipende dal pacchetto Python flask, dal server web gunicorn e dalla libreria client google-cloud-aiplatform, insieme alle versioni associate di ognuno.

flask==3.0.0
gunicorn==21.2.0
google-cloud-aiplatform==1.47.0

Non è necessario salvare esplicitamente questo file perché Cloud Editor salverà automaticamente le modifiche.

Utilizzando la stessa tecnica, crea un altro nuovo file denominato main.py. Questo sarà il file di origine Python principale (e unico) della tua app. Anche in questo caso, assicurati che il nuovo file finisca nella cartella quiz-generator.

Inserisci il seguente codice in questo file:

from flask import Flask
import os

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
@app.route("/", methods=["GET"])
def say_hello():
    html = "<h1>Hello world!</h1>"
    return html

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Torna al terminale e passa alla cartella del progetto con questo comando:

cd quiz-generator

Esegui questo comando per installare le dipendenze del progetto:

pip3 install -r requirements.txt

Dopo l'installazione delle dipendenze, dovresti vedere un output che termina in questo modo:

Successfully installed flask-3.0.0

Ora avvia l'app eseguendo questo comando nel terminale:

flask --app main.py --debug run --port 8080

A questo punto, l'app è in esecuzione sulla macchina virtuale dedicata alla sessione di Cloud Shell. Cloud Shell include un meccanismo di proxy che ti permette di accedere ai server web (come quello appena avviato) in esecuzione sulla tua macchina virtuale da qualsiasi luogo sulla rete internet globale.

Fai clic sul pulsante web preview e poi sulla voce di menu Preview on Port 8080 in questo modo:

Nell'app in esecuzione viene aperta una scheda del browser web, che dovrebbe avere un aspetto simile a questo:

5. Aggiungi un metodo di generazione con analisi dei parametri

Ora vogliamo aggiungere il supporto per il campo di un nuovo metodo chiamato generate. Per farlo, aggiungi un'istruzione di importazione per manipolare la richiesta HTTP e modificare la route principale per analizzare la richiesta e i parametri di stampa, come indicato di seguito:

from flask import Flask
from flask import request                       #<-CHANGED
import os

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])                #<-CHANGED
def generate():                                 #<-CHANGED
    params = request.args.to_dict()             #<-CHANGED
    html = f"<h1>Quiz Generator</h1>"           #<-CHANGED
    for param in params:                        #<-CHANGED
        html += f"<br>{param}={params[param]}"  #<-CHANGED
    return html                                 #<-CHANGED

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Ora ricarica la scheda del browser web esistente per visualizzare i risultati. Questa volta dovresti vedere il "Generatore di quiz", insieme a un parametro di query aggiunto automaticamente al tuo URL (authuser). Prova ad aggiungere altri due parametri aggiungendo la stringa "`&param1=val1&param2=val2`" alla fine dell'URL nella barra degli indirizzi del browser, ricarica la pagina. Dovresti vedere qualcosa di simile a questo:

Ora che abbiamo visto come inviare e analizzare i parametri di query su un URL, aggiungeremo il supporto per i parametri specifici da inviare al nostro generatore di quiz, che sono i seguenti:

topic: l'oggetto del quiz desiderato
num_q: il numero di domande desiderate
diff: il livello di difficoltà desiderato (facile, intermedio, difficile)
lang: la lingua desiderata per il quiz

from flask import Flask
from flask import request
import os

# Default quiz settings  #<-CHANGED
TOPIC = "History"        #<-CHANGED
NUM_Q = "5"              #<-CHANGED
DIFF = "intermediate"    #<-CHANGED
LANG = "English"         #<-CHANGED

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# This function takes a dictionary, a name, and a default value.
# If the name exists as a key in the dictionary, the corresponding
# value is returned. Otherwise, the default value is returned.
def check(args, name, default):  #<-CHANGED
    if name in args:             #<-CHANGED
        return args[name]        #<-CHANGED
    return default               #<-CHANGED

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])
# This function generates a quiz using Vertex AI.
def generate():
    args = request.args.to_dict()        #<-CHANGED
    topic = check(args, "topic", TOPIC)  #<-CHANGED
    num_q = check(args, "num_q", NUM_Q)  #<-CHANGED
    diff = check(args, "diff", DIFF)     #<-CHANGED
    lang = check(args, "lang", LANG)     #<-CHANGED
    html = f"""
        <h1>Quiz Generator</h1><br>
        {topic=}<br>
        {num_q=}<br>
        {diff=}<br>
        {lang=}"""                       #<-CHANGED
    return html

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Ora ricarica la scheda del browser web esistente per visualizzare i risultati. Il risultato dovrebbe essere simile alla seguente pagina web:

Prova a modificare l'URL per impostare i valori di vari parametri. Ad esempio, prova a utilizzare il suffisso "?authuser=0&topic=Literature&num_q=10&diff=easy&lang=French" alla fine dell'URL nella barra degli indirizzi:

6. Aggiungi e formatta il prompt

In seguito, aggiungeremo il supporto per i parametri specifici da inviare al nostro generatore di quiz, che sono i seguenti:

topic: l'oggetto del quiz desiderato
num_q: il numero di domande desiderate
diff: il livello di difficoltà desiderato (facile, intermedio, difficile)
lang: la lingua desiderata per il quiz

Copia il prompt che hai sviluppato con Vertex Generative AI Studio in un passaggio precedente, ma modifica i valori hardcoded per l'argomento, il numero di domande e il livello di difficoltà con queste stringhe:

{topic}
{num_q}
{diff}
{lang}

from flask import Flask
from flask import request
import os

# Default quiz settings
TOPIC = "History"
NUM_Q = 5
DIFF = "intermediate"
LANG = "English"

PROMPT = """
Generate a quiz according to the following specifications:

- topic: {topic}
- num_q: {num_q}
- diff:  {diff}
- lang:  {lang}

Output should be (only) an unquoted json array of objects with keys:
"Question", "responses", and "correct".

"""  #<-CHANGED

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# This function takes a dictionary, a name, and a default value.
# If the name exists as a key in the dictionary, the corresponding
# value is returned. Otherwise, the default value is returned.
def check(args, name, default):
    if name in args:
        return args[name]
    return default

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])
# This function generates a quiz using Vertex AI.
def generate():
    args = request.args.to_dict()
    topic = check(args, "topic", TOPIC)
    num_q = check(args, "num_q", NUM_Q)
    diff = check(args, "diff", DIFF)
    lang = check(args, "lang", LANG)
    prompt = PROMPT.format(topic=topic, num_q=num_q, diff=diff, lang=lang)  #<-CHANGED 
    html = f"<h1>Prompt:</h1><br><pre>{prompt}</pre>"                       #<-CHANGED
    return html

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Ora ricarica la scheda del browser web esistente per visualizzare i risultati. Il risultato dovrebbe essere simile alla seguente pagina web:

Prova a modificare l'URL per cambiare questi quattro parametri.

7. Aggiungi la libreria client di Vertex AI

Ora siamo pronti a utilizzare la libreria client Python di Vertex AI per generare il quiz. In questo modo, i prompt interattivi che hai eseguito nel passaggio 3 verranno automatici e al tuo servizio di generatore l'accesso programmatico alle funzionalità LLM di Google. Aggiorna il file main.py come segue:

Assicurati di sostituire "YOUR_PROJECT" con l'ID progetto effettivo.

from flask import Flask
from flask import request
from flask import Response                                          #<-CHANGED
import os

import vertexai    
from vertexai.generative_models import GenerativeModel  #<-CHANGED

# Default quiz settings
TOPIC = "History"
NUM_Q = 5
DIFF = "intermediate"
LANG = "English"
MODEL = "gemini-1.0-pro"  #<-CHANGED

PROMPT = """
Generate a quiz according to the following specifications:

- topic: {topic}
- num_q: {num_q}
- diff:  {diff}
- lang:  {lang}

Output should be (only) an unquoted json array of objects with keys "question", "responses", and "correct".

"""

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.
if not PORT:
    PORT = 8080

# Initialize Vertex AI access.
vertexai.init(project="YOUR_PROJECT", location="us-central1")  #<-CHANGED
parameters = {                                                 #<-CHANGED
    "candidate_count": 1,                                      #<-CHANGED
    "max_output_tokens": 1024,                                 #<-CHANGED
    "temperature": 0.5,                                        #<-CHANGED
    "top_p": 0.8,                                              #<-CHANGED
    "top_k": 40,                                               #<-CHANGED
}                                                              #<-CHANGED
model = GenerativeModel(MODEL)             #<-CHANGED

# This function takes a dictionary, a name, and a default value.
# If the name exists as a key in the dictionary, the corresponding
# value is returned. Otherwise, the default value is returned.
def check(args, name, default):
    if name in args:
        return args[name]
    return default

# The app.route decorator routes any GET requests sent to the /generate
# path to this function, which responds with "Generating:" followed by
# the body of the request.
@app.route("/", methods=["GET"])
# This function generates a quiz using Vertex AI.
def generate():
    args = request.args.to_dict()
    topic = check(args, "topic", TOPIC)
    num_q = check(args, "num_q", NUM_Q)
    diff = check(args, "diff", DIFF)
    lang = check(args, "lang", LANG)
    prompt = PROMPT.format(topic=topic, num_q=num_q, diff=diff, lang=lang)
    response = model.generate_content(prompt, generation_config=parameters)  #<-CHANGED
    print(f"Response from Model: {response.text}")           #<-CHANGED
    html = f"{response.text}"                                #<-CHANGED
    return Response(html, mimetype="application/json")       #<-CHANGED

# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Ora ricarica la scheda del browser web esistente per visualizzare i risultati. Tieni presente che questa operazione potrebbe richiedere diversi secondi perché ora stai effettivamente effettuando una richiesta LLM. Il risultato dovrebbe essere simile alla seguente pagina web:

Prova a modificare l'URL per richiedere un argomento del quiz, un numero di domande e un livello di difficoltà diversi.

E per questo abbiamo terminato il microservizio: congratulazioni! Nel passaggio successivo, scoprirai come eseguire il deployment del tuo servizio nel cloud in modo che chiunque possa accedervi ovunque.

8. al cloud

Ora che hai creato il tuo generatore di quiz, vorrai condividere questo pizzico di meraviglie con il resto del mondo, quindi è il momento di eseguirne il deployment nel Cloud. ma vorresti fare di più che condividerli. Devi assicurarti che:

funziona in modo affidabile: ottieni la tolleranza di errore automatica nel caso in cui un computer su cui la tua app si arresti in modo anomalo
scalabilità automatica: la tua app rimarrà al passo con ampi livelli di traffico e ridurrà automaticamente la sua impronta se inutilizzata
riduce al minimo i costi, evitando di addebitarti risorse che non utilizzi: ti verranno addebitate solo le risorse utilizzate durante la risposta al traffico
è accessibile tramite un nome di dominio personalizzato. Puoi utilizzare una soluzione che richiede un solo clic per assegnare un nome di dominio personalizzato al tuo servizio
Offre un tempo di risposta eccellente: gli avvii a freddo sono ragionevolmente reattivi, ma puoi ottimizzarlo specificando una configurazione di istanza minima
supporta la crittografia end-to-end mediante la sicurezza web SSL/TLS standard. Quando distribuisci un servizio, ottieni la crittografia web standard e i certificati richiesti corrispondenti, senza costi e automaticamente

Eseguendo il deployment della tua app in Google Cloud Run, ottieni tutto quanto indicato sopra e altro ancora. Il componente di base di base per la condivisione di un'app con Cloud Run è un container.

I container ci danno la possibilità di creare una casella modulare in cui eseguire un'applicazione con tutte le sue dipendenze in un unico bundle. Poiché i container possono essere utilizzati su quasi tutti i server virtuali o reali, questo ci permette di eseguire il deployment della tua applicazione ovunque tu voglia, da on-premise al cloud, e persino di spostare la tua applicazione da un fornitore di servizi a un altro.

Per saperne di più sui container e sul loro funzionamento in Google Cloud Run, consulta il codelab Dev to Prod in 3 semplici passaggi con Cloud Run.

Esegui il deployment dell'app in Cloud Run

Cloud Run è un servizio regionale, il che significa che l'infrastruttura che esegue i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google per essere disponibile in modo ridondante in tutte le zone all'interno di quella regione. Per semplicità, in questo lab utilizzeremo la regione impostata come hardcoded us-central1.

Utilizzeremo il cosiddetto buildpack per generare automaticamente il container. Crea un nuovo file denominato Procfile in Cloud Editor e inserisci questa riga di testo:

web: gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app

Questo indica al sistema buildpack come eseguire l'app nel contenitore generato automaticamente. A questo punto, esegui questo comando nel terminale Cloud Shell (dalla stessa directory quiz-generator) :

gcloud run deploy quiz-generator  \
    --source .                    \
    --region us-central1          \
    --allow-unauthenticated

Questo indica al comando gcloud che vuoi che utilizzi buildpack per creare la tua immagine container, in base ai file di origine che trova nella directory corrente (dot in --source . è un'abbreviazione della directory corrente). Poiché il servizio si occupa dell'immagine container in modo implicito, non è necessario specificare un'immagine in questo comando gcloud.

Attendi qualche istante fino al completamento del deployment. Se l'operazione riesce, il comando gcloud visualizza l'URL del nuovo servizio:

Building using Buildpacks and deploying container to Cloud Run service [quiz-generator] in project [YOUR_PROJECT] region [YOUR_REGION]
OK Building and deploying new service... Done.                                                                          
  OK Creating Container Repository...                                                                                   
  OK Uploading sources...                                                                                               
  OK Building Container... Logs are available at [https://console.cloud.google.com/cloud-build/builds/0cf1383f-35db-412d
  -a973-557d5e2cd4a4?project=780573810218].                                                                             
  OK Creating Revision...                                                                                               
  OK Routing traffic...                                                                                                 
  OK Setting IAM Policy...                                                                                              
Done.                                                                                                                   
Service [quiz-generator] revision [quiz-generator-00001-xnr] has been deployed and is serving 100 percent of traffic.
Service URL: https://quiz-generator-co24gukjmq-uc.a.run.app

Puoi anche recuperare l'URL del tuo servizio con questo comando:

gcloud run services describe quiz-generator  \
  --region us-central1                       \
  --format "value(status.url)"

Il risultato dovrebbe essere simile al seguente:

https://quiz-generator-co24gukjmq-uc.a.run.app

Questo link è un URL dedicato, con sicurezza TLS, per il tuo servizio Cloud Run. Questo link è permanente (a condizione che non disattivi il servizio) e utilizzabile ovunque su internet. Non utilizza il meccanismo di proxy di Cloud Shell citato in precedenza, che dipendeva da una macchina virtuale temporanea.

Fai clic sulla Service URL evidenziata per aprire una scheda del browser web con l'app in esecuzione. Verifica che il risultato sia lo stesso che hai visto nell'ambiente di sviluppo. Verifica inoltre di poter modificare il quiz generato fornendo i parametri alla fine dell'URL.

Complimenti! La tua app è ora in esecuzione nel cloud di Google. Senza pensarci bene, la tua app è disponibile pubblicamente, con la crittografia TLS (HTTPS) e la scalabilità automatica a livelli di traffico incredibili.

9. Stiamo mettendo insieme tutti i pezzi

In questo passaggio finale, siamo pronti a eseguire il generatore di quiz come parte dell'app quizaic. Vai all'URL del quiz, accedi al tuo Account Google e vai alla scheda Create Quiz. Seleziona il tipo di generatore Custom, incolla l'URL di Cloud Run nel campo URL, compila gli altri campi obbligatori e invia il modulo.

Tra pochi istanti dovresti avere un nuovo quiz (vedi "Il mio nuovo quiz" nell'immagine di seguito) con un'immagine in miniatura creata con l'IA, che puoi modificare, riprodurre, clonare o eliminare tramite i pulsanti corrispondenti. Questo nuovo quiz è stato creato utilizzando il servizio web di cui hai appena eseguito il deployment in base al prompt basato su modelli.

10. Pulizia

Sebbene non siano previsti addebiti per Cloud Run quando il servizio non è in uso, ti potrebbero comunque essere addebitati i costi di archiviazione dell'immagine container creata.

Puoi eliminare il tuo progetto Google Cloud per evitare addebiti, interrompendo così la fatturazione per tutte le risorse utilizzate all'interno di quel progetto, o semplicemente eliminare l'immagine container utilizzando questo comando:

gcloud config set artifacts/repository cloud-run-source-deploy
gcloud config set artifacts/location us-central1
gcloud artifacts docker images list

# Note image tag for resulting list

gcloud artifacts docker images delete <IMAGE-TAG>

Per eliminare il servizio Cloud Run, utilizza questo comando:

gcloud run services delete quiz-generator --region us-central1 --quiet

11. Ce l'hai fatta!

Complimenti: hai creato un prompt LLM ed eseguito il deployment di un microservizio Cloud Run utilizzando questo prompt. Ora puoi programmare in linguaggio naturale e condividere le tue creazioni con il mondo!

Voglio lasciarti con una domanda importante:

Una volta che la tua app funzionava nell'ambiente di sviluppo, quante righe di codice hai dovuto modificare per eseguirne il deployment nel cloud, con tutti gli attributi di livello enterprise offerti da Cloud Run?

La risposta, ovviamente, è zero.

Altri codelab da scoprire...

Documenti di riferimento...

12. Invito all'azione

Se hai apprezzato questo codelab e probabilmente passerai più tempo a fare pratica con Google Cloud, ti consigliamo di partecipare a Google Cloud Innovators oggi stesso.

Google Cloud Innovators è senza costi e include:

Discussioni dal vivo, AMA e sessioni di roadmap per conoscere le ultime novità direttamente dai Googler
le ultime novità su Google Cloud direttamente nella tua posta in arrivo
Sfondo con badge digitale e videoconferenze
500 crediti di lab e apprendimento su Skills Boost

Fai clic qui per registrarti.