1. Introduction
Dans cet atelier, vous allez créer un service Web pour générer des quiz et l'intégrer à une application amusante et fonctionnelle. Vous allez utiliser un langage de programmation différent de celui que vous avez peut-être utilisé auparavant : l'anglais.
Ce que vous allez effectuer...
- Vous allez créer un prompt qui génère un quiz de culture générale en fonction d'un ensemble de critères.
- Vous allez créer une application Web simple et vérifier qu'elle s'exécute comme prévu dans votre environnement de développement.
- Vous ajouterez progressivement de la logique à votre application Web pour la transformer en serveur d'API qui génère des quiz en fonction d'un ensemble de paramètres d'entrée.
- Vous verrez à quel point il est facile de déployer votre service de génération de quiz dans le cloud à l'aide de Google Cloud Run.
- Enfin, vous configurerez une application réelle ( quizaic.com) pour utiliser votre service de génération de quiz déployé et vous pourrez jouer à des quiz en direct en fonction du résultat.
Ce que vous allez apprendre...
- Découvrez comment créer un prompt basé sur un modèle pour un grand modèle de langage (LLM).
- Découvrez comment créer une application de serveur Web simple en Python.
- Découvrez comment ajouter la prise en charge du LLM de Google à votre application Web.
- Déployez votre application dans le cloud pour que tout le monde puisse essayer votre nouvelle création.
- Intégrer votre générateur de quiz dans une application plus grande
Ce dont vous avez besoin...
- Navigateur Web Chrome
- Un compte Google
- Un projet Cloud pour lequel la facturation est activée
Cet atelier s'adresse aux développeurs de tous niveaux, y compris aux débutants. Bien que vous utilisiez Python, vous n'avez pas besoin de maîtriser la programmation Python pour comprendre le processus, car nous vous expliquerons tout le code que vous verrez.
2. Configuration
Cette section décrit tout ce que vous devez faire pour commencer cet atelier.
Configuration de l'environnement au rythme de chacun
- Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. Si vous n'avez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.
- Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pourrez toujours le modifier.
- L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID de votre projet (généralement identifié par
PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet. - Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.
- Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300 $.
Démarrez Cloud Shell.
Dans cet atelier, vous allez travailler dans une session Cloud Shell. Cet environnement est un interpréteur de commandes hébergé sur une machine virtuelle qui s'exécute dans le cloud de Google. Vous pourriez tout aussi facilement effectuer les tâches de cette section en local sur votre propre ordinateur, mais le fait d'utiliser Cloud Shell permet à chacun de bénéficier d'une expérience reproductible dans un environnement cohérent. Après l'atelier, libre à vous de reproduire cette section sur votre ordinateur.
Activer Cloud Shell
- Dans Cloud Console, cliquez sur Activer Cloud Shell
.
Si vous démarrez Cloud Shell pour la première fois, un écran intermédiaire s'affiche pour vous expliquer de quoi il s'agit. Si cet écran s'est affiché, cliquez sur Continuer.
Le provisionnement et la connexion à Cloud Shell ne devraient pas prendre plus de quelques minutes.
Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez réaliser une grande partie, voire la totalité, des activités de cet atelier de programmation dans un navigateur.
Une fois connecté à Cloud Shell, vous êtes en principe authentifié, et le projet est défini avec votre ID de projet.
- Exécutez la commande suivante dans Cloud Shell pour vérifier que vous êtes authentifié :
gcloud auth list
Résultat de la commande
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Exécutez la commande suivante dans Cloud Shell pour vérifier que la commande gcloud connaît votre projet :
gcloud config list project
Résultat de la commande
[core] project = <PROJECT_ID>
Si vous obtenez un résultat différent, exécutez cette commande :
gcloud config set project <PROJECT_ID>
Résultat de la commande
Updated property [core/project].
Activer certaines API
Dans les étapes suivantes, vous verrez où ces services sont requis (et pourquoi). Mais pour l'instant, exécutez la commande ci-dessous pour autoriser votre projet à accéder à Cloud Build, Artifact Registry, Vertex AI et Cloud Run :
gcloud services enable cloudbuild.googleapis.com \
artifactregistry.googleapis.com \
aiplatform.googleapis.com \
run.googleapis.com
Un message semblable à celui qui suit s'affiche pour vous indiquer que l'opération s'est correctement déroulée :
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
3. Prompting : programmation en langage naturel
Nous allons commencer par apprendre à développer une requête pour un grand modèle de langage. Accédez à la console Google Cloud > Vertex AI > Vertex AI Studio (Langage). Une page semblable à celle-ci s'affiche :
Sous Generate Text, cliquez sur le bouton Text Prompt. Dans la boîte de dialogue suivante, saisissez un prompt qui, selon vous, pourrait être efficace pour générer un quiz de culture générale en fonction des exigences suivantes :
- Thème : Histoire du monde
- Nombre de questions : 5
- Niveau de difficulté : intermédiaire
- Langue : anglais
Cliquez sur le bouton "Envoyer" pour afficher le résultat.
Comme le montre la capture d'écran ci-dessous, le panneau de droite vous permet de sélectionner le modèle que vous souhaitez utiliser et d'affiner certains paramètres :
Voici les paramètres disponibles :
- La région dans laquelle votre demande de génération doit s'exécuter.
- "Modèle" vous permet de sélectionner le grand modèle de langage que vous souhaitez utiliser. Pour cet atelier de programmation, conservez "gemini-1.0-pro-001".
- La température permet de contrôler le degré de hasard dans la sélection des jetons. Des températures basses sont idéales pour les requêtes visant une réponse vraie ou correcte, tandis que des températures plus élevées peuvent entraîner des résultats plus diversifiés ou inattendus.
- La limite de jetons détermine la quantité maximale de texte pouvant être générée à partir d'une requête. Un jeton correspond environ à quatre caractères. La valeur par défaut est 1 024.
- Top K modifie la façon dont le modèle sélectionne les jetons pour la sortie. Une valeur top-K de 1 signifie que le jeton sélectionné est le plus probable parmi tous les jetons du vocabulaire du modèle (aussi appelé décodage glouton), tandis qu'un top-K de 3 signifie que le jeton suivant est sélectionné parmi les trois jetons les plus probables (à l'aide de la température). La valeur de Top K est fixée par défaut à 40.
- Top P modifie la façon dont le modèle sélectionne les jetons pour la sortie. Les jetons sont sélectionnés du plus probable au moins probable, jusqu'à ce que la somme de leurs probabilités soit égale à la valeur Top P.
- "Nombre max de réponses" correspond au nombre maximal de réponses du modèle générées par requête.
- Une séquence d'arrêt est une série de caractères (espaces compris) qui arrête la génération de réponse si le modèle la rencontre.
- L'option "Affichage progressif des réponses" permet de choisir si les réponses doivent être imprimées à mesure qu'elles sont générées ou enregistrées et affichées une fois terminées.
- Le seuil de filtre de sécurité ajuste la probabilité de voir des réponses potentiellement dangereuses.
Une fois que vous avez une invite qui semble générer un quiz raisonnable selon les exigences mentionnées ci-dessus, nous pourrions analyser ce quiz à l'aide d'un code personnalisé. Mais ne serait-il pas préférable que le LLM génère le quiz dans un format structuré que nous pourrions charger directement dans notre programme ? Le programme que nous utiliserons plus tard dans cet atelier pour appeler votre générateur s'attend à ce que les quiz soient exprimés en JSON, qui est un format multilingue populaire pour représenter des données structurées.
Dans cet atelier, les quiz sont exprimés sous la forme d'un tableau d'objets, où chaque objet contient une question, un tableau de réponses possibles à cette question et une réponse correcte. Voici l'encodage JSON pour les quiz de cet atelier :
[
{
"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"
},
...
]
Essayez de modifier votre requête pour que le quiz soit désormais généré au format JSON requis.
- Décrivez précisément le format que vous recherchez (par exemple, la phrase en italique ci-dessus).
- Incluez dans votre requête un exemple du format JSON souhaité.
Une fois que vous avez créé votre requête pour générer des quiz selon les spécifications souhaitées, cliquez sur le bouton GET CODE en haut à droite de la page pour afficher le code Python qui peut être utilisé pour envoyer votre requête de manière programmatique à un LLM Vertex AI. Si vous souhaitez utiliser un langage de programmation autre que Python, consultez https://cloud.google.com/vertex-ai/docs/samples?text=generative.
4. Créer un serveur Web simple
Maintenant que vous disposez d'un prompt fonctionnel, nous souhaitons l'intégrer à une application plus grande. Bien sûr, nous pourrions intégrer votre prompt au code source de l'application plus grande, mais nous souhaitons que votre générateur fonctionne comme un microservice qui fournit un service de génération de quiz pour d'autres applications. Pour ce faire, nous devons créer un serveur Web simple et le rendre accessible au public. Nous le ferons dans les étapes suivantes.
Commencez par cliquer sur le bouton Open Editor en haut de votre panneau Cloud Shell. Elle se présente comme suit :
Vous vous retrouverez alors dans un environnement IDE semblable à Visual Studio Code, dans lequel vous pourrez créer des projets, modifier le code source, exécuter vos programmes, etc.
Si votre écran est trop petit, vous pouvez agrandir ou réduire la ligne de séparation entre la console et votre fenêtre d'édition/de terminal en faisant glisser la barre horizontale entre ces deux régions, comme indiqué ici :
Vous pouvez passer de l'éditeur au terminal et inversement en cliquant respectivement sur les boutons Open Editor et Open Terminal. Essayez maintenant de passer d'un environnement à l'autre.
Ensuite, créez un dossier dans lequel stocker votre travail pour cet atelier. Pour ce faire, cliquez sur le bouton Ajouter un dossier 
, saisissez quiz-generator, puis appuyez sur Entrée. Tous les fichiers que vous allez créer dans cet atelier et tout le travail que vous allez effectuer dans Cloud Shell se feront dans ce dossier.
Créez maintenant un fichier requirements.txt. Cela indique à Python les bibliothèques dont votre application dépend. Pour cette application Web simple, vous allez utiliser un module Python populaire pour créer des serveurs Web appelé Flask,, la bibliothèque cliente google-cloud-aiplatform et un framework de serveur Web appelé gunicorn. Dans le volet de navigation des fichiers, effectuez un clic droit sur le dossier quiz-generator, puis sélectionnez l'élément de menu New file, comme suit :
Lorsque vous êtes invité à saisir le nom du nouveau fichier, saisissez requirements.txt, puis appuyez sur la touche Entrée. Assurez-vous que le nouveau fichier se trouve dans le dossier du projet quiz-generator.
Collez les lignes suivantes dans le nouveau fichier pour spécifier que votre application dépend du package Python flask, du serveur Web gunicorn et de la bibliothèque cliente google-cloud-aiplatform, ainsi que des versions associées de chacun.
flask==3.0.0 gunicorn==21.2.0 google-cloud-aiplatform==1.47.0
Vous n'avez pas besoin d'enregistrer explicitement ce fichier, car l'éditeur Cloud enregistre automatiquement les modifications.
En utilisant la même technique, créez un autre fichier nommé main.py. Il s'agira du fichier source Python principal (et unique) de votre application. Assurez-vous que le nouveau fichier se trouve dans le dossier quiz-generator.
Insérez le code suivant dans ce fichier :
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)
Revenez dans le terminal et accédez au dossier du projet à l'aide de la commande suivante :
cd quiz-generator
Exécutez la commande suivante pour installer les dépendances de votre projet :
pip3 install -r requirements.txt
Une fois les dépendances installées, le résultat doit ressembler à ceci :
Successfully installed flask-3.0.0
Lancez maintenant votre application en exécutant cette commande dans le terminal :
flask --app main.py --debug run --port 8080
À ce stade, votre application s'exécute sur la machine virtuelle dédiée à votre session Cloud Shell. Cloud Shell inclut un mécanisme de proxy qui vous permet d'accéder aux serveurs Web (comme celui que vous venez de démarrer) exécutés sur votre machine virtuelle depuis n'importe où sur Internet.
Cliquez sur le bouton web preview, puis sur l'élément de menu Preview on Port 8080, comme suit :
Un onglet de navigateur Web s'ouvre sur votre application en cours d'exécution, qui devrait ressembler à ceci :
5. Ajouter une méthode de génération avec analyse des paramètres
Nous souhaitons maintenant ajouter la prise en charge de l'envoi d'une nouvelle méthode appelée generate. Pour ce faire, ajoutez une instruction d'importation afin de manipuler la requête HTTP et modifiez la route principale pour analyser cette requête et imprimer les paramètres, comme suit :
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)
Actualisez l'onglet de votre navigateur Web pour voir les résultats. Cette fois, vous devriez voir le "Générateur de quiz", ainsi qu'un paramètre de requête automatiquement ajouté à votre URL (authuser). Essayez d'ajouter deux paramètres en ajoutant la chaîne "`¶m1=val1¶m2=val2`" à la fin de l'URL dans la barre d'adresse de votre navigateur. Rechargez la page. Vous devriez voir quelque chose comme ceci :
Maintenant que nous avons vu comment envoyer et analyser les paramètres de requête d'une URL, nous allons ajouter la prise en charge des paramètres spécifiques que nous souhaitons envoyer à notre générateur de quiz, à savoir :
topic: thème du quiz souhaiténum_q: nombre de questions souhaitédiff: niveau de difficulté souhaité (facile, moyen, difficile)lang: langue souhaitée pour le 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)
Actualisez l'onglet de votre navigateur Web pour voir les résultats. Une page Web semblable à celle-ci devrait s'afficher :
Essayez de modifier l'URL pour définir des valeurs pour différents paramètres. Par exemple, essayez d'ajouter le suffixe "?authuser=0&topic=Literature&num_q=10&diff=easy&lang=French" à la fin de l'URL dans la barre d'adresse :
6. Ajouter et mettre en forme votre requête
Nous allons ensuite ajouter la prise en charge des paramètres spécifiques que nous souhaitons envoyer à notre générateur de quiz, à savoir :
topic: thème du quiz souhaiténum_q: nombre de questions souhaitédiff: niveau de difficulté souhaité (facile, moyen, difficile)lang: langue souhaitée pour le quiz
Copiez la requête que vous avez développée avec Vertex Generative AI Studio lors d'une étape précédente, mais remplacez les valeurs codées en dur pour le thème, le nombre de questions et le niveau de difficulté par les chaînes suivantes :
- {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)
Actualisez l'onglet de votre navigateur Web pour voir les résultats. Une page Web semblable à celle-ci devrait s'afficher :
Essayez de modifier l'URL pour modifier ces quatre paramètres.
7. Ajouter la bibliothèque cliente Vertex AI
Nous sommes maintenant prêts à utiliser la bibliothèque cliente Python Vertex AI pour générer votre quiz. Cela automatisera l'invite interactive que vous avez effectuée à l'étape 3 et donnera à votre service de génération un accès programmatique aux capacités LLM de Google. Mettez à jour votre fichier main.py comme suit :
Veillez à remplacer "YOUR_PROJECT" par l'ID de votre projet.
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)
Actualisez l'onglet de votre navigateur Web pour voir les résultats. Notez que cela peut prendre plusieurs secondes, car vous effectuez maintenant une demande LLM. Une page Web semblable à celle-ci devrait s'afficher :
Essayez de modifier l'URL pour demander un autre thème de quiz, un autre nombre de questions et un autre niveau de difficulté.
Et voilà, votre microservice est terminé. Félicitations ! À l'étape suivante, vous apprendrez à déployer votre service dans le cloud afin que tout le monde puisse y accéder, où qu'il se trouve.
8. Vers le cloud !
Maintenant que vous avez créé votre propre générateur de quiz, vous allez vouloir partager cette merveille avec le reste du monde. Il est donc temps de le déployer dans le cloud. Mais vous aimeriez faire plus que simplement le partager. Vous souhaitez vous assurer que :
- fonctionne de manière fiable : vous bénéficiez d'une tolérance aux pannes automatique en cas de plantage d'un ordinateur exécutant votre application.
- Il s'adapte automatiquement : votre application peut gérer de gros volumes de trafic et réduit automatiquement son empreinte lorsqu'elle n'est pas utilisée.
- minimise vos coûts en ne vous facturant pas les ressources que vous n'utilisez pas. Vous n'êtes facturé que pour les ressources consommées lors de la réponse au trafic.
- est accessible via un nom de domaine personnalisé : vous disposez d'une solution en un clic pour attribuer un nom de domaine personnalisé à votre service.
- offre un excellent temps de réponse. Les démarrages à froid sont raisonnablement réactifs, mais vous pouvez les affiner en spécifiant une configuration d'instance minimale.
- accepte le chiffrement de bout en bout à l'aide de la sécurité Web SSL/TLS standard : lorsque vous déployez un service, vous bénéficiez sans frais et automatiquement du chiffrement Web standard et des certificats requis correspondants.
En déployant votre application sur Google Cloud Run, vous bénéficiez de tous les avantages ci-dessus et plus encore. Le composant de base pour partager votre application avec Cloud Run est un conteneur.
Les conteneurs nous permettent de créer une boîte modulaire dans laquelle exécuter une application avec toutes ses dépendances regroupées. Comme les conteneurs peuvent être utilisés sur presque tous les serveurs virtuels ou réels, cela nous permet de déployer votre application où vous le souhaitez, du serveur sur site au cloud, et même de déplacer votre application d'un fournisseur de services à un autre.
Pour en savoir plus sur les conteneurs et leur fonctionnement dans Google Cloud Run, consultez l'atelier de programmation Passer du développement à la production en trois étapes faciles avec Cloud Run.
Déployer votre application sur Cloud Run
Cloud Run est un service régional. Cela signifie que l'infrastructure qui exécute vos services Cloud Run est située dans une région spécifique et gérée par Google pour être disponible de manière redondante dans toutes les zones de cette région. Pour plus de simplicité, nous utiliserons la région codée en dur us-central1 dans cet atelier.
Nous allons utiliser un buildpack pour générer automatiquement votre conteneur. Créez un fichier nommé Procfile dans l'éditeur Cloud et insérez cette ligne de texte :
web: gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app
Cela indique au système de buildpacks comment exécuter votre application dans le conteneur généré automatiquement. Ensuite, exécutez la commande suivante dans le terminal Cloud Shell (à partir du même répertoire quiz-generator) :
gcloud run deploy quiz-generator \
--source . \
--region us-central1 \
--allow-unauthenticated
Cela indique à la commande gcloud que vous souhaitez qu'elle utilise des buildpacks pour créer votre image de conteneur, en fonction des fichiers sources qu'elle trouve dans le répertoire actuel (le dot dans --source . est une abréviation pour le répertoire actuel). Étant donné que le service s'occupe implicitement de l'image de conteneur, vous n'avez pas besoin de spécifier d'image dans cette commande gcloud.
Patientez quelques instants jusqu'à la fin du déploiement. En cas de réussite, la commande gcloud affiche l'URL du nouveau service :
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
Vous pouvez également récupérer l'URL de votre service à l'aide de cette commande :
gcloud run services describe quiz-generator \ --region us-central1 \ --format "value(status.url)"
Vous devriez obtenir un résultat semblable à celui-ci :
https://quiz-generator-co24gukjmq-uc.a.run.app
Ce lien est une URL dédiée, avec sécurité TLS, pour votre service Cloud Run. Ce lien est permanent (tant que vous n'avez pas désactivé votre service) et peut être utilisé n'importe où sur Internet. Il n'utilise pas le mécanisme de proxy de Cloud Shell mentionné précédemment, qui dépendait d'une machine virtuelle temporaire.
Cliquez sur le Service URL en surbrillance pour ouvrir un onglet de navigateur Web sur votre application en cours d'exécution. Vérifiez que le résultat est le même que celui que vous avez vu dans votre environnement de développement. Vérifiez également que vous pouvez ajuster le quiz généré en fournissant des paramètres à la fin de l'URL.
Félicitations ! Votre application s'exécute désormais dans le cloud de Google. Votre application est disponible publiquement, avec un chiffrement TLS (HTTPS) et une mise à l'échelle automatique pour gérer des niveaux de trafic incroyables.
9. Rassembler tous les éléments
Dans cette dernière étape, nous allons exécuter votre générateur de quiz dans l'application Quizaic. Accédez à l'URL Quizaic, connectez-vous à votre compte Google, puis accédez à l'onglet Create Quiz. Sélectionnez le type de générateur Custom, collez votre URL Cloud Run dans le champ URL, remplissez les autres champs obligatoires, puis envoyez le formulaire.
Au bout de quelques instants, vous devriez voir un nouveau quiz (voir "Mon nouveau quiz" dans l'image ci-dessous), avec une vignette générée par l'IA. Vous pouvez le modifier, y jouer, le cloner ou le supprimer à l'aide des boutons correspondants. Ce nouveau quiz a été créé à l'aide du service Web que vous venez de déployer en fonction de votre requête basée sur un modèle.
10. Nettoyage
Bien que le service Cloud Run ne soit pas facturé lorsqu'il n'est pas utilisé, il se peut que des frais vous incombent pour le stockage de l'image de conteneur générée.
Afin d'éviter que des frais ne vous soient facturés, vous pouvez soit supprimer votre projet GCP, ce qui interrompra la facturation de toutes les ressources qui y ont été utilisées, soit supprimer votre image de conteneur en exécutant la commande suivante :
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>
Pour supprimer votre service Cloud Run, utilisez cette commande :
gcloud run services delete quiz-generator --region us-central1 --quiet
11. Bravo !
Félicitations ! Vous avez créé un prompt LLM et déployé un microservice Cloud Run à l'aide de ce prompt. Vous pouvez désormais programmer en langage naturel et partager vos créations avec le monde entier.
Je voudrais vous laisser avec une question importante :
Une fois votre application opérationnelle dans votre environnement de développement, combien de lignes de code avez-vous dû modifier pour la déployer dans le cloud, avec tous les attributs de qualité de production offerts par Cloud Run ?
La réponse est bien sûr zéro. :)
Autres ateliers de programmation à consulter :
- Passer du développement à la production en trois étapes faciles avec Cloud Run
- Application de résumé de texte avec Vertex AI et SvelteKit
- Application de chat avec l'API PaLM sur Cloud Run
- Fonction Cloud qui encapsule les modèles PaLM Text Bison
- Des données à l'IA générative avec l'API Spanner et Vertex AI Imagen
Documents de référence...
12. Incitation à l'action
Si vous avez apprécié cet atelier de programmation et que vous souhaitez passer plus de temps à utiliser Google Cloud, rejoignez Google Cloud Innovators dès aujourd'hui !
Google Cloud Innovators est sans frais et inclut :
- Discussions en direct, sessions AMA et interventions dédiées à la feuille de route pour découvrir les dernières actualités directement auprès des Googleurs
- les dernières actualités Google Cloud directement dans votre boîte de réception ;
- Badge numérique et arrière-plan de visioconférence
- 500 crédits d'ateliers et de formations sur Skills Boost
Cliquez ici pour vous inscrire.