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 lo integrerai in un'app divertente e funzionante. Utilizzerai un linguaggio di programmazione diverso da quelli che potresti aver utilizzato in precedenza: l'inglese.

Attività previste

Creerai un prompt che generi un quiz di cultura generale in base a una serie di criteri.
Creerai una semplice app web e verificherai che funzioni come previsto nel tuo ambiente di sviluppo.
Aggiungerai gradualmente 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 servizio di generazione di quiz sul cloud utilizzando Google Cloud Run.
Infine, configurerai un'app reale ( quizaic.com) per utilizzare il servizio di generazione di quiz di cui hai eseguito il deployment e potrai giocare a quiz dal vivo in base all'output.

Cosa imparerai…

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

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 devi avere familiarità con la programmazione in Python per capire cosa sta succedendo, perché spiegheremo tutto il codice che vedrai.

2. Configurazione

Questa sezione descrive tutto ciò che devi fare per iniziare questo lab.

Configurazione dell'ambiente 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 del progetto è il nome visualizzato per i partecipanti a questo 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 l'ID generato non ti piace, 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 in 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$.

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

Nella console Cloud, fai clic su Attiva Cloud Shell .

Se è la prima volta che avvii Cloud Shell, viene visualizzata una schermata intermedia che ne descrive le funzionalità. Se è stata visualizzata una schermata intermedia, fai clic su Continua.

Bastano pochi istanti per eseguire il provisioning e connettersi a Cloud Shell.

Questa macchina virtuale è 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 e l'autenticazione della rete. Gran parte del lavoro per questo codelab, se non tutto, può essere svolto con un browser.

Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è autenticato e 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 verificare che il comando gcloud conosca il 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 a Google Cloud Console > Vertex AI > Vertex AI Studio (Language). Dovresti visualizzare una pagina simile a questa:

Nella sezione Generate Text, fai clic sul pulsante Text Prompt. Nella finestra di dialogo successiva, inserisci un prompt che ritieni efficace per generare un quiz di curiosità 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 a destra consente di selezionare il modello da utilizzare e perfezionare alcune impostazioni:

Sono disponibili le impostazioni seguenti:

La regione in cui deve essere eseguita la richiesta di generazione.
Modello seleziona il modello linguistico di grandi dimensioni che vuoi utilizzare. Per questo codelab, scegli "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). Un top-k pari a 3 indica invece che il token successivo viene selezionato tra i tre 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.
Risposte massime è il numero massimo di risposte del modello generate per prompt.
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 le risposte devono essere stampate man mano che vengono generate o salvate e visualizzate al termine.
La soglia del filtro di sicurezza regola la probabilità di ricevere risposte potenzialmente dannose.

Una volta che hai un prompt che sembra generare un quiz ragionevole in base ai requisiti indicati sopra, potremmo analizzare questo quiz utilizzando codice personalizzato, ma non sarebbe meglio se l'LLM generasse il quiz in un formato strutturato che possiamo caricare direttamente nel nostro programma? Il programma che utilizzeremo più avanti in questo lab per chiamare il generatore prevede che i quiz siano espressi in JSON, un formato cross-language popolare per rappresentare i dati strutturati.

I quiz in questo lab sono espressi come un array di oggetti, in cui ogni oggetto contiene una domanda, un array di possibili risposte a quella domanda e una risposta corretta. Ecco la codifica JSON per i quiz in 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"
    },

    ...
]

Prova a modificare il prompt in modo che l'output del quiz sia nel formato JSON richiesto.

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

Una volta che il prompt genera 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 il prompt in modo programmatico a un LLM Vertex AI. Se ti interessa utilizzare un linguaggio di programmazione diverso da Python, consulta la pagina https://cloud.google.com/vertex-ai/docs/samples?text=generative.

4. Crea un semplice server web

Ora che hai un prompt funzionante, vogliamo integrarlo in un'app più grande. Naturalmente, potremmo incorporare il prompt nel codice sorgente dell'app più grande, ma vogliamo che il generatore funzioni come un microservizio che fornisce un servizio di generazione di quiz per altre app. Per farlo, dobbiamo creare un semplice server web e renderlo disponibile pubblicamente. Lo faremo nei passaggi successivi.

Inizia facendo 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 divisoria tra la console e la finestra di modifica/terminale trascinando la barra orizzontale tra le due regioni, evidenziata qui:

Puoi passare dall'editor al terminale e viceversa facendo clic sui pulsanti Open Editor e Open Terminal, rispettivamente. Ora prova a passare da un ambiente all'altro.

Poi, crea una cartella in cui archiviare il tuo lavoro per questo lab facendo clic sul pulsante Aggiungi cartella , inserisci quiz-generator e premi Invio. Tutti i file che crei in questo lab e tutto il lavoro che svolgi in Cloud Shell verranno eseguiti in questa cartella.

Ora crea un file requirements.txt. Indica a Python le librerie da cui dipende la tua app. Per questa semplice app web, utilizzerai un modulo Python molto diffuso per la creazione di server web chiamato Flask,, la libreria client google-cloud-aiplatform e un framework per 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, come mostrato di seguito:

Quando ti viene chiesto 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 seguenti righe 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 ciascuno.

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

Non devi salvare esplicitamente questo file perché Cloud Editor salva 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 aver installato le 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, la tua app è in esecuzione sulla macchina virtuale dedicata alla sessione di Cloud Shell. Cloud Shell include un meccanismo proxy che ti consente di accedere ai server web (come quello appena avviato) in esecuzione sulla tua macchina virtuale da qualsiasi punto di internet.

Fai clic sul pulsante web preview e poi sulla voce di menu Preview on Port 8080 come segue:

Si aprirà una scheda del browser web con l'app in esecuzione, che dovrebbe avere un aspetto simile a questo:

5. Aggiungi un metodo generate con l'analisi dei parametri

Ora vogliamo aggiungere il supporto per un nuovo metodo chiamato generate. Aggiungi un'istruzione di importazione per manipolare la richiesta HTTP e modifica la route principale per analizzare questa richiesta e stampare i parametri, come segue:

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 "Quiz Generator", insieme a un parametro di query aggiunto automaticamente all'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 e dovresti vedere qualcosa di simile a questo:

Ora che abbiamo visto come inviare e analizzare i parametri di query in un URL, aggiungeremo il supporto per i parametri specifici che vogliamo inviare al nostro generatore di quiz, ovvero:

topic: l'argomento del quiz che vuoi creare
num_q: il numero di domande che vuoi
diff: il livello di difficoltà desiderato (facile, intermedio, difficile)
lang: la lingua del quiz che preferisci

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. Dovresti visualizzare una pagina web simile alla seguente:

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. Aggiungere e formattare il prompt

Successivamente, aggiungeremo il supporto per i parametri specifici che vogliamo inviare al nostro generatore di quiz, ovvero:

topic: l'argomento del quiz che vuoi creare
num_q: il numero di domande che vuoi
diff: il livello di difficoltà desiderato (facile, intermedio, difficile)
lang: la lingua del quiz che preferisci

Copia il prompt che hai sviluppato con Vertex Generative AI Studio in un passaggio precedente, ma modifica i valori hardcoded per argomento, numero di domande e 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. Dovresti visualizzare una pagina web simile alla seguente:

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

7. Aggiungi la libreria client Vertex AI

Ora siamo pronti a utilizzare la libreria client Python di Vertex AI per generare il quiz. In questo modo, l'invito interattivo eseguito nel passaggio 3 verrà automatizzato e il servizio di generazione avrà 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. Dovresti visualizzare una pagina web simile alla seguente:

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

Il microservizio è pronto. Complimenti. Nel passaggio successivo, imparerai a eseguire il deployment del servizio nel cloud in modo che chiunque possa accedervi da qualsiasi luogo.

8. Al cloud!

Ora che hai creato il tuo generatore di quiz, vorrai condividere questa meraviglia con il resto del mondo, quindi è il momento di eseguirne il deployment sul cloud. Ma vorresti fare molto di più che condividerlo. Vuoi assicurarti che:

funziona in modo affidabile: ottieni la tolleranza automatica agli errori in caso di arresto anomalo di un computer che esegue la tua app
scala automaticamente: la tua app sarà in grado di gestire livelli di traffico elevati e ridurrà automaticamente il suo footprint quando non viene utilizzata
riduce al minimo i costi, in quanto non ti addebita le risorse che non utilizzi. Ti vengono addebitate solo le risorse consumate durante la risposta al traffico.
è accessibile tramite un nome di dominio personalizzato: hai accesso a una soluzione con un 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 perfezionarli specificando una configurazione di istanza minima.
supporta la crittografia end-to-end utilizzando la sicurezza web SSL/TLS standard. Quando implementi un servizio, ottieni la crittografia web standard e i certificati richiesti corrispondenti, senza costi e automaticamente.

Se esegui il deployment dell'app in Google Cloud Run, ottieni tutto quanto sopra e altro ancora. Il blocco di base per la condivisione dell'app con Cloud Run è un container.

I container ci consentono di creare una scatola modulare in cui eseguire un'applicazione con tutte le sue dipendenze raggruppate. Poiché i container possono essere utilizzati su quasi tutti i server virtuali o reali, questo ci offre un modo per eseguire il deployment dell'applicazione ovunque tu voglia, da on-premise al cloud e persino per spostare l'applicazione da un fornitore di servizi a un altro.

Per scoprire di più sui container e su come funzionano in Google Cloud Run, consulta il codelab Dev to Prod in Three Easy Steps with 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 hardcoded us-central1.

Utilizzeremo un elemento chiamato 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 container 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

In questo modo, il comando gcloud sa che vuoi utilizzare i buildpack per creare l'immagine container in base ai file sorgente trovati nella directory corrente (dot in --source . è l'abbreviazione della directory corrente). Poiché il servizio gestisce implicitamente l'immagine container, non devi 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 servizio con questo comando:

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

Dovresti visualizzare un risultato simile a questo:

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 tu non disattivi il servizio) e utilizzabile ovunque su internet. Non utilizza il meccanismo proxy di Cloud Shell menzionato in precedenza, che dipendeva da una macchina virtuale temporanea.

Fai clic su Service URL evidenziato per aprire una scheda del browser web con l'app in esecuzione. Verifica che il risultato sia lo stesso di quello visualizzato nell'ambiente di sviluppo. Verifica anche di poter modificare il quiz generato fornendo parametri alla fine dell'URL.

Complimenti! La tua app è ora in esecuzione nella cloud di Google. Senza doverci pensare, la tua app è disponibile pubblicamente, con crittografia TLS (HTTPS) e scalabilità automatica a livelli di traffico sbalorditivi.

9. Mettere insieme tutti i pezzi

In questo ultimo passaggio, siamo pronti a eseguire il generatore di quiz nell'ambito dell'app Quizaic. Visita l'URL di Quizaic, 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.

Dopo qualche istante, dovresti visualizzare un nuovo quiz (vedi "Il mio nuovo quiz" nell'immagine sotto), con una miniatura generata dall'AI, che puoi modificare, riprodurre, clonare o eliminare tramite i pulsanti corrispondenti. Questo nuovo quiz è stato creato utilizzando il servizio web che hai appena implementato in base al prompt basato su modello.

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 GCP per evitare addebiti, interrompendo così la fatturazione per tutte le risorse utilizzate all'interno di quel progetto, o semplicemente eliminare l'immagine del 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!

Congratulazioni. Hai creato correttamente un prompt LLM e hai 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 l'app funziona nel tuo ambiente di sviluppo, quante righe di codice hai dovuto modificare per eseguirne il deployment nel cloud, con tutti gli attributi di livello di produzione offerti da Cloud Run?

La risposta, ovviamente, è zero. :)

Altri codelab da provare...

Documenti di riferimento…

12. Invito all'azione

Se questo codelab ti è piaciuto e probabilmente trascorrerai più tempo a lavorare con Google Cloud, ti consigliamo di aderire a Google Cloud Innovators oggi stesso.

Google Cloud Innovators è senza costi e include:

Discussioni dal vivo, sessioni di domande e risposte e roadmap per conoscere le ultime novità direttamente dai Googler
le ultime notizie di Google Cloud direttamente nella tua posta in arrivo
Badge digitale e sfondo per videoconferenze
500 crediti per lab e corsi su Skills Boost

Fai clic qui per registrarti.

Crea un generatore di quiz con l'IA generativa e Cloud Run Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

1. Introduzione

Attività previste

Cosa imparerai…

Cosa ti serve…

2. Configurazione

Configurazione dell'ambiente autonomo

Avvia Cloud Shell

Attiva Cloud Shell

Abilita alcune API

3. Prompt: programmazione in linguaggio naturale

4. Crea un semplice server web

5. Aggiungi un metodo generate con l'analisi dei parametri

6. Aggiungere e formattare il prompt

7. Aggiungi la libreria client Vertex AI

8. Al cloud!

Esegui il deployment dell'app in Cloud Run

9. Mettere insieme tutti i pezzi

10. Pulizia

11. Ce l'hai fatta!

Altri codelab da provare...

Documenti di riferimento…

12. Invito all'azione

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