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

Attività previste

Creerai un prompt che genererà un quiz 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.
Scoprirai quanto è facile eseguire il deployment del servizio di creazione 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 è 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.

Occorrente

Browser web Chrome
Un Account Google
Un progetto Cloud con la 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 a tuo ritmo

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 al progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
L'ID progetto è univoco per 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 interessa quale 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 piace, puoi generarne un altro casuale. In alternativa, puoi provare il tuo e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane invariato per tutta la durata del progetto.
Per tua informazione, esiste un terzo valore, un Numero 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 le API/risorse Cloud. La partecipazione a questo codelab non ha costi, o quasi. 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

Nella console Cloud, fai clic su Attiva Cloud Shell .

Se è la prima volta che avvii Cloud Shell, viene visualizzata una schermata intermedia che descrive di cosa si tratta. Se viene visualizzata una schermata intermedia, fai clic su Continua.

Dovrebbero bastare 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 di rete e l'autenticazione. Gran parte, se non tutto, del lavoro in questo codelab può essere svolto con un browser.

Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è già autenticato e il progetto è già 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 il seguente 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 alla console Google Cloud > Vertex AI > Vertex AI Studio (Language). Dovresti visualizzare una pagina simile a questa:

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 a destra ti consente di selezionare il modello da utilizzare e perfezionare 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, mantieni "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 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.
La funzionalità Risposte dinamiche consente di scegliere se stampare le risposte man mano che vengono generate o se salvarle e visualizzarle al termine.
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 analizzarlo utilizzando codice personalizzato, ma non sarebbe più pratico lasciare che sia l'LLM a generare 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 si aspetta che i quiz siano espressi in JSON, un formato multilingue molto utilizzato per la rappresentazione dei 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 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 il quiz venga visualizzato nel formato JSON richiesto.

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

Una volta che il prompt genera quiz in base alle tue specifiche, 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 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 prompt nel codice sorgente dell'app più grande, ma vogliamo che il generatore funzioni come un microservizio che fornisca 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 che seguono.

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

Ti troverai in un ambiente IDE simile a Visual Studio Code, in cui puoi creare progetti, modificare il codice sorgente, eseguire i 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.

A questo punto, crea una cartella in cui archiviare il 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. In questo modo, Python sa quali librerie sono necessarie per la tua app. Per questa semplice app web, utilizzerai un modulo Python molto utilizzato 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, in questo modo:

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 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 venga inserito 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 come segue:

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 Cloud Shell. Cloud Shell include un meccanismo di proxy che ti consente di accedere ai server web (come quello che hai appena avviato) in esecuzione sulla tua macchina virtuale da qualsiasi parte della 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 l'inserimento di un nuovo metodo denominato generate. Aggiungi un'istruzione di importazione per manipolare la richiesta HTTP e modifica il 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 "Generatore di quiz", 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 quanto segue:

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, che sono i seguenti:

topic: l'argomento del quiz desiderato
num_q: il numero di domande desiderate
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. Il risultato dovrebbe essere simile alla seguente pagina web:

Prova a modificare l'URL per impostare i valori per 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 del quiz che preferisci

Copia il prompt sviluppato con Vertex 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. Il risultato dovrebbe essere simile alla seguente pagina web:

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

7. Aggiungi la libreria client Vertex AI

Ora è tutto pronto per utilizzare la libreria client Python di Vertex AI per generare il quiz. In questo modo, verrà automatizzato il prompt interattivo che hai eseguito nel passaggio 3 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.

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. Verso il cloud!

Ora che hai creato il tuo generatore di quiz, vorrai condividerlo con il resto del mondo, quindi è il momento di eseguirlo in cloud. Ma vorresti fare di più che condividerlo. Assicurati 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, non ti addebitano alcun costo per 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 solo clic per assegnare un nome di dominio personalizzato al tuo servizio
offre tempi di risposta eccellenti: gli avviamenti a freddo sono ragionevolmente reattivi, ma puoi ottimizzarli specificando una configurazione di istanze minime
supporta la crittografia end-to-end utilizzando la sicurezza web SSL/TLS standard: quando esegui il deployment di un servizio, ricevi 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 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 fisici, abbiamo un modo per eseguire il deployment dell'applicazione ovunque tu voglia, dall'on-premise al cloud e persino per spostarla da un fornitore di servizi all'altro.

Per scoprire di più sui container e sul loro funzionamento in Google Cloud Run, consulta il codelab Dalla fase di sviluppo alla produzione in tre 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 in modo da 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 il cosiddetto buildpack per generare automaticamente il container. Crea un nuovo file denominato Procfile in Cloud Editor e inserisci questa singola 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. Poi esegui il seguente 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 utilizzare i buildpack per creare l'immagine container in base ai file di origine trovati nella directory corrente (il dot in --source . è l'abbreviazione della directory corrente). Poiché il servizio si occupa implicitamente dell'immagine del contenitore, 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 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 tu non disattivi il servizio) e può essere utilizzato ovunque su internet. Non utilizza il meccanismo di proxy di Cloud Shell menzionato in precedenza, che dipendeva da una macchina virtuale transitoria.

Fai clic sulla Service URL evidenziata per aprire una scheda del browser web nell'app in esecuzione. Verifica che il risultato corrisponda a quello visualizzato nell'ambiente di sviluppo. Verifica inoltre di poter modificare il quiz generato specificando i parametri alla fine dell'URL.

Complimenti! La tua app è ora in esecuzione nella piattaforma Google Cloud. Senza doverti preoccupare di nulla, la tua app è disponibile pubblicamente, con crittografia TLS (HTTPS) e scalabilità automatica per livelli di traffico sbalorditivi.

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.

Dopo pochi istanti, dovresti avere un nuovo quiz (vedi "Il mio nuovo quiz" nell'immagine di seguito), con un'immagine in miniatura generata dall'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 decidere di 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 del contenitore 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 correttamente un prompt LLM e hai eseguito il deployment di un microservizio Cloud Run utilizzandolo. 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 provare…

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, AMA e sessioni con roadmap dal vivo per scoprire le ultime novità direttamente dai Googler
le ultime notizie su 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.