arrow_back

Déployer des applications Spanner avec Cloud Run Functions et Cloud Run

Se connecter Rejoindre
Accédez à plus de 700 ateliers et cours

Déployer des applications Spanner avec Cloud Run Functions et Cloud Run

Atelier 1 heure 30 minutes universal_currency_alt 1 crédit show_chart Débutant
info Cet atelier peut intégrer des outils d'IA pour vous accompagner dans votre apprentissage.
Accédez à plus de 700 ateliers et cours

SCBL007

Présentation

Dans cet atelier, vous allez écrire des applications qui utilisent des bases de données Spanner et les déployer sur Cloud Run Functions et Cloud Run. Vous allez également installer, configurer et activer l'émulateur Spanner pour l'utiliser dans des environnements de développement.

Objectifs

Dans cet atelier, vous allez apprendre à :

  • déployer des fonctions Cloud Run qui lisent et écrivent dans des bases de données Spanner ;
  • configurer et utiliser l'émulateur Spanner pour le développement ;
  • créer une API REST pour lire et écrire des données Spanner ;
  • déployer une API REST sur Google Cloud Run.

Préparation

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

  • vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;
Remarque : Ouvrez une fenêtre de navigateur en mode incognito/navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le compte temporaire de participant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.
  • vous disposez d'un temps limité ; n'oubliez pas qu'une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.
Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier afin d'éviter que des frais supplémentaires ne vous soient facturés.

Activer Google Cloud Shell

Google Cloud Shell est une machine virtuelle qui contient des outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud. Google Cloud Shell offre un accès en ligne de commande à vos ressources GCP.

  1. Dans la console GCP, dans la barre d'outils située en haut à droite, cliquez sur le bouton Ouvrir Cloud Shell.

    Icône Cloud Shell

  2. Cliquez sur Continue (Continuez):

    cloudshell_continue

Il faut quelques instants pour mettre en service et se connecter à l'environnement. Lorsque vous êtes connecté, vous êtes déjà authentifié et le projet est défini sur votre PROJECT_ID. Par exemple:

Terminal Cloud Shell

gcloud est l'outil de ligne de commande associé à Google Cloud Platform. Pré-installé sur Cloud Shell, il est également compatible avec la saisie semi-automatique via la touche de tabulation.

Vous pouvez répertorier les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

Résultat :

ACTIVE: *
ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net
To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Pour répertorier les ID de projet, exécutez la commande suivante :

gcloud config list project

Résultat :

[core]
project = <ID_Projet>

Exemple de résultat :

[core]
project = qwiklabs-gcp-44776a13dea667a6

Tâche 1 : Créer une base de données avec des données de test

  1. Dans la barre de titre de la console Google Cloud, cliquez sur Activer Cloud Shell (Icône Cloud Shell). Si vous y êtes invité, cliquez sur Continuer. Vous pouvez également effectuer la même opération en sélectionnant la fenêtre de la console Cloud, puis en appuyant sur les touches G, puis S de votre clavier.

  2. Exécutez la commande suivante pour activer les API Cloud Build, Cloud Run et Event Arc. Si vous y êtes invité, autorisez la commande.

gcloud services enable cloudbuild.googleapis.com gcloud services enable run.googleapis.com gcloud services enable eventarc.googleapis.com
  1. Exécutez la commande Bash suivante afin de créer un fichier de schéma pour la base de données "Pets".
mkdir ~/lab-files cd ~/lab-files cat > ./pets-db-schema.sql << ENDOFFILE CREATE TABLE Owners ( OwnerID STRING(36) NOT NULL, OwnerName STRING(MAX) NOT NULL ) PRIMARY KEY (OwnerID); CREATE TABLE Pets ( OwnerID STRING(36) NOT NULL, PetID STRING(MAX) NOT NULL, PetType STRING(MAX) NOT NULL, PetName STRING(MAX) NOT NULL, Breed STRING(MAX) NOT NULL, ) PRIMARY KEY (OwnerID,PetID), INTERLEAVE IN PARENT Owners ON DELETE CASCADE ENDOFFILE
  1. Exécutez les commandes suivantes pour créer une instance et une base de données Spanner.
gcloud spanner instances create test-spanner-instance --config=regional-{{{project_0.default_region|place_holder_text}}} --description="test-spanner-instance" --processing-units=100 gcloud spanner databases create pets-db --instance=test-spanner-instance --database-dialect=GOOGLE_STANDARD_SQL --ddl-file=./pets-db-schema.sql
  1. Ajoutez quelques enregistrements de test à la base de données à l'aide des commandes suivantes.
owner_uuid=$(cat /proc/sys/kernel/random/uuid) gcloud spanner rows insert --table=Owners --database=pets-db --instance=test-spanner-instance --data=OwnerID=$owner_uuid,OwnerName=Doug gcloud spanner rows insert --table=Pets --database=pets-db --instance=test-spanner-instance --data=PetID=$(cat /proc/sys/kernel/random/uuid),OwnerID=$owner_uuid,PetName='Noir',PetType='Dog',Breed='Schnoodle' gcloud spanner rows insert --table=Pets --database=pets-db --instance=test-spanner-instance --data=PetID=$(cat /proc/sys/kernel/random/uuid),OwnerID=$owner_uuid,PetName='Bree',PetType='Dog',Breed='Mutt' gcloud spanner rows insert --table=Pets --database=pets-db --instance=test-spanner-instance --data=PetID=$(cat /proc/sys/kernel/random/uuid),OwnerID=$owner_uuid,PetName='Gigi',PetType='Dog',Breed='Retriever'

Tâche 2 : Créer une fonction Cloud Run pour lire dans Spanner

  1. Créez un dossier pour votre première fonction Cloud Run à l'aide de la commande suivante.
mkdir ~/lab-files/spanner_get_pets cd ~/lab-files/spanner_get_pets
  1. Créez deux fichiers pour votre application : main.py et requirements.txt.
touch main.py requirements.txt
  1. Cliquez sur le bouton Ouvrir l'éditeur. Dans le fichier lab-files/spanner_get_pets/requirements.txt que vous venez de créer, ajoutez le code suivant.
google-cloud-spanner==3.27.0
  1. Dans le fichier lab-files/spanner_get_pets/main.py, ajoutez le code suivant, qui lit les données de la base de données et renvoie les animaux de compagnie.
from google.cloud import spanner instance_id = 'test-spanner-instance' database_id = 'pets-db' client = spanner.Client() instance = client.instance(instance_id) database = instance.database(database_id) def spanner_get_pets(request): query = """SELECT OwnerName, PetName, PetType, Breed FROM Owners JOIN Pets ON Owners.OwnerID = Pets.OwnerID;""" outputs = [] with database.snapshot() as snapshot: results = snapshot.execute_sql(query) output = '<div>OwnerName,PetName,PetType,Breed</div>' outputs.append(output) for row in results: output = '<div>{},{},{},{}</div>'.format(*row) outputs.append(output) return '\n'.join(outputs)
  1. Cliquez sur le bouton Ouvrir le terminal. Déployez ensuite la fonction Cloud Run à l'aide de la commande suivante. Notez que le déclencheur sera de type HTTP, ce qui signifie qu'une URL sera générée pour appeler la fonction. (L'exécution de la commande prend quelques minutes.)
gcloud functions deploy spanner_get_pets --runtime python310 --trigger-http --region={{{project_0.default_region|place_holder_text}}} --quiet
  1. Une fois le déploiement de la fonction Cloud Run terminé, testez-la à l'aide de la commande suivante. Elle doit renvoyer les données de test.
curl -m 70 -X GET https://{{{project_0.default_region|place_holder_text}}}-${GOOGLE_CLOUD_PROJECT}.cloudfunctions.net/spanner_get_pets -H "Authorization: bearer $(gcloud auth print-identity-token)" -H "Content-Type: application/json"

Tâche 3 : Créer une fonction Cloud Run pour écrire dans Spanner

  1. Créez un dossier pour votre deuxième fonction Cloud Run à l'aide de la commande suivante.
mkdir ~/lab-files/spanner_save_pets cd ~/lab-files/spanner_save_pets
  1. Créez deux fichiers pour votre application : main.py et requirements.txt.
touch main.py requirements.txt
  1. Cliquez sur le bouton Ouvrir l'éditeur. Dans le fichier lab-files/spanner_save_pets/requirements.txt que vous venez de créer, ajoutez le code suivant.
google-cloud-spanner==3.27.0
  1. Dans le fichier lab-files/spanner_save_pets/main.py, ajoutez le code suivant, qui lit les données de la base de données et renvoie les animaux de compagnie.
from google.cloud import spanner import base64 import uuid import json instance_id = 'test-spanner-instance' database_id = 'pets-db' client = spanner.Client() instance = client.instance(instance_id) database = instance.database(database_id) def spanner_save_pets(event, context): pubsub_message = base64.b64decode(event['data']).decode('utf-8') data = json.loads(pubsub_message) # Check to see if the Owner already exists with database.snapshot() as snapshot: results = snapshot.execute_sql(""" SELECT OwnerID FROM OWNERS WHERE OwnerName = @owner_name""", params={"owner_name": data["OwnerName"]}, param_types={"owner_name": spanner.param_types.STRING}) row = results.one_or_none() if row != None: owner_exists = True owner_id = row[0] else: owner_exists = False owner_id = str(uuid.uuid4()) # Need a UUID for the new pet pet_id = str(uuid.uuid4()) def insert_owner_pet(transaction, data, owner_exists): try: row_ct = 0 params = { "owner_id": owner_id, "owner_name": data["OwnerName"], "pet_id": pet_id, "pet_name": data["PetName"], "pet_type": data["PetType"], "breed": data["Breed"], } param_types = { "owner_id": spanner.param_types.STRING, "owner_name": spanner.param_types.STRING, "pet_id": spanner.param_types.STRING, "pet_name": spanner.param_types.STRING, "pet_type": spanner.param_types.STRING, "breed": spanner.param_types.STRING, } # Only add the Owner if they don't exist already if not owner_exists: row_ct = transaction.execute_update( """INSERT Owners (OwnerID, OwnerName) VALUES (@owner_id, @owner_name)""", params=params, param_types=param_types,) # Add the pet row_ct += transaction.execute_update( """INSERT Pets (PetID, OwnerID, PetName, PetType, Breed) VALUES (@pet_id, @owner_id, @pet_name, @pet_type, @breed) """, params=params, param_types=param_types,) except: row_ct = 0 return row_ct row_ct = database.run_in_transaction(insert_owner_pet, data, owner_exists) print("{} record(s) inserted.".format(row_ct))
  1. Cliquez sur le bouton Ouvrir le terminal. Cette fonction Cloud Run se déclenche à la publication d'un message Pub/Sub. Pour qu'elle fonctionne, vous devez d'abord créer le sujet Pub/Sub à l'aide de la commande suivante.
gcloud pubsub topics create new-pet-topic
  1. Déployez la fonction Cloud Run à l'aide de la commande suivante. (L'exécution de la commande prend quelques minutes.)
gcloud functions deploy spanner_save_pets --runtime python310 --trigger-topic=new-pet-topic --region={{{project_0.default_region|place_holder_text}}} --quiet
  1. Lorsque l'exécution de la commande est terminée, accédez au service Pub/Sub dans la console. Cliquez sur le sujet new-pet-topic pour afficher ses détails.
    Sur la page des détails, cliquez sur l'onglet Messages, puis sur le bouton Publier un message.
    Saisissez le message ci-dessous, puis cliquez sur le bouton Publier. Remarque : le message est au format JSON et doit suivre exactement le schéma indiqué pour que la fonction réussisse.
{"OwnerName": "Jean", "PetName": "Sally", "PetType": "Frog", "Breed": "Green"}
  1. Déclenchez la fonction Cloud Run spanner_gets_pets à l'aide de la commande curl que vous avez exécutée précédemment. Vérifiez que le nouveau propriétaire "Jean" et sa grenouille "Sally" ont bien été ajoutés.
curl -m 70 -X GET https://{{{project_0.default_region|place_holder_text}}}-${GOOGLE_CLOUD_PROJECT}.cloudfunctions.net/spanner_get_pets -H "Authorization: bearer $(gcloud auth print-identity-token)" -H "Content-Type: application/json"

Tâche 4 : Démarrer l'émulateur Spanner

  1. Dans le terminal Cloud Shell, exécutez la commande suivante pour installer et démarrer l'émulateur Spanner.
sudo apt-get install google-cloud-sdk-spanner-emulator gcloud emulators spanner start
  1. L'émulateur prend le contrôle du terminal. Dans la barre d'outils Cloud Shell, cliquez sur l'icône + pour ouvrir un nouvel onglet de terminal. Exécutez les commandes suivantes afin de configurer Cloud SDK pour qu'il utilise l'émulateur.
gcloud config configurations create emulator gcloud config set auth/disable_credentials true gcloud config set project $GOOGLE_CLOUD_PROJECT gcloud config set api_endpoint_overrides/spanner http://localhost:9020/
  1. Créez l'instance et la base de données à l'aide de gcloud. Notez bien que ces commandes utilisent l'émulateur, et non Spanner dans le cloud. Veillez à exécuter chaque commande séparément, et non d'un seul bloc.
cd ~/lab-files gcloud spanner instances create emulator-instance --config=emulator-config --description="EmulatorInstance" --nodes=1 gcloud spanner databases create pets-db --instance=emulator-instance --database-dialect=GOOGLE_STANDARD_SQL --ddl-file=./pets-db-schema.sql
  1. Pour que le code de la bibliothèque cliente Python utilise l'émulateur, la variable d'environnement SPANNER_EMULATOR_HOST doit être définie. Pour cela, exécutez le code suivant.
export SPANNER_EMULATOR_HOST=localhost:9010

Tâche 5 : Écrire une API REST pour la base de données Spanner "Pets"

  1. Créez un dossier pour les fichiers de programme Cloud Run et ajoutez les fichiers requis.
mkdir ~/lab-files/cloud-run cd ~/lab-files/cloud-run touch Dockerfile main.py requirements.txt
  1. Cliquez sur le bouton Ouvrir l'éditeur. Dans le fichier lab-files/cloud-run/requirements.txt que vous venez de créer, ajoutez le code suivant.
Flask==3.0.3 Flask-RESTful==0.3.10 google-cloud-spanner==3.27.0 gunicorn==22.0.0
  1. Dans le fichier main.py, ajoutez le code suivant. Ce code utilise Python Flask et la bibliothèque Flask-RESTful afin de créer une API REST pour la base de données "Pets".
    Remarque : Examinez les variables d'environnement utilisées en haut du fichier (lignes 11 à 20). Lors d'un déploiement sur Cloud Run, vous définissez ces variables pour qu'elles pointent vers la vraie base de données Spanner. Si elles ne sont pas définies, l'émulateur est utilisé par défaut.
import os import uuid from flask import Flask, jsonify, request from flask_restful import Api, Resource from google.api_core import exceptions from google.cloud import spanner from werkzeug.exceptions import BadRequest, NotFound # --- Configuration --- # Use emulator settings by default, but override with environment variables if they exist. INSTANCE_ID = os.environ.get("INSTANCE_ID", "emulator-instance") DATABASE_ID = os.environ.get("DATABASE_ID", "pets-db") # --- Database Repository --- class SpannerRepository: """ A repository class to handle all database interactions with Google Cloud Spanner. This separates database logic from the API/view layer. """ def __init__(self, instance_id, database_id): spanner_client = spanner.Client() self.instance = spanner_client.instance(instance_id) self.database = self.instance.database(database_id) def list_all_pets(self): """Retrieves all pets with their owner information.""" query = """ SELECT o.OwnerID, o.OwnerName, p.PetID, p.PetName, p.PetType, p.Breed FROM Owners o JOIN Pets p ON o.OwnerID = p.OwnerID """ with self.database.snapshot() as snapshot: results = snapshot.execute_sql(query) # 1. Materialize the iterator into a list of rows. # Each 'row' in this list is a regular Python list of values. rows = list(results) # 2. If there are no rows, the metadata might be incomplete. # This check prevents the original 'NoneType' error. if not rows: return [] # 3. If we have rows, the metadata is guaranteed to be available. # Get the column names from the result set's metadata. # Note: results.metadata is the correct attribute. keys = [field.name for field in results.metadata.row_type.fields] # 4. Zip the keys with each row's list of values to create dicts. return [dict(zip(keys, row)) for row in rows] def get_pet_by_id(self, pet_id): """Retrieves a single pet by its ID.""" query = """ SELECT o.OwnerID, o.OwnerName, p.PetID, p.PetName, p.PetType, p.Breed FROM Owners o JOIN Pets p ON o.OwnerID = p.OwnerID WHERE p.PetID = @pet_id """ params = {"pet_id": pet_id} param_types = {"pet_id": spanner.param_types.STRING} with self.database.snapshot() as snapshot: results = snapshot.execute_sql( query, params=params, param_types=param_types ) # results.one_or_none() returns a special Row object (not a list) # that has a .keys() method, so this is correct and simpler. row = results.one_or_none() if not row: return None return dict(zip(row.keys(), row)) def create_pet_and_owner(self, data): """ Creates a new pet. If the owner doesn't exist, creates the owner as well. This entire operation is performed in a single transaction. """ def _tx_create_pet(transaction): pet_id = str(uuid.uuid4()) owner_name = data["OwnerName"] owner_result = transaction.execute_sql( "SELECT OwnerID FROM Owners WHERE OwnerName = @name", params={"name": owner_name}, param_types={"name": spanner.param_types.STRING}, ).one_or_none() if owner_result: owner_id = owner_result[0] else: owner_id = str(uuid.uuid4()) transaction.insert( "Owners", columns=("OwnerID", "OwnerName"), values=[(owner_id, owner_name)], ) pet_columns = ["PetID", "OwnerID", "PetName", "PetType", "Breed"] pet_values = [ pet_id, owner_id, data["PetName"], data["PetType"], data["Breed"], ] transaction.insert("Pets", columns=pet_columns, values=[pet_values]) new_pet_data = { "PetID": pet_id, "OwnerID": owner_id, "OwnerName": owner_name, "PetName": data["PetName"], "PetType": data["PetType"], "Breed": data["Breed"], } return new_pet_data return self.database.run_in_transaction(_tx_create_pet) def delete_pet_by_id(self, pet_id): """Deletes a single pet by its ID in a transaction.""" def _tx_delete_pet(transaction): return transaction.execute_update( "DELETE FROM Pets WHERE PetID = @pet_id", params={"pet_id": pet_id}, param_types={"pet_id": spanner.param_types.STRING}, ) return self.database.run_in_transaction(_tx_delete_pet) def delete_all_pets_and_owners(self): """Deletes all owners, which cascades to delete all pets.""" def _tx_delete_all(transaction): return transaction.execute_update("DELETE FROM Owners WHERE true") return self.database.run_in_transaction(_tx_delete_all) # --- API Resources --- db_repo = SpannerRepository(INSTANCE_ID, DATABASE_ID) class PetsList(Resource): def get(self): """Returns a list of all pets.""" pets = db_repo.list_all_pets() return jsonify(pets) def post(self): """Creates a new pet and possibly a new owner.""" try: data = request.get_json(force=True) required_fields = ["OwnerName", "PetName", "PetType", "Breed"] if not all(field in data for field in required_fields): raise BadRequest("Missing required fields in JSON payload.") except BadRequest as e: return {"message": str(e)}, 400 try: new_pet = db_repo.create_pet_and_owner(data) return new_pet, 201 except exceptions.GoogleAPICallError as e: return {"message": "Database transaction failed", "error": str(e)}, 500 def delete(self): """Deletes all owners and pets.""" deleted_count = db_repo.delete_all_pets_and_owners() return {"message": f"{deleted_count} owner record(s) deleted (pets cascaded)."}, 200 class Pet(Resource): def get(self, pet_id): """Returns a single pet by ID.""" pet = db_repo.get_pet_by_id(pet_id) if pet: return jsonify(pet) raise NotFound("Pet with the specified ID was not found.") def delete(self, pet_id): """Deletes a single pet by ID.""" try: deleted_count = db_repo.delete_pet_by_id(pet_id) if deleted_count > 0: return {"message": f"Pet with ID {pet_id} was deleted."}, 200 raise NotFound("Pet with the specified ID was not found.") except exceptions.NotFound: raise NotFound("Pet with the specified ID was not found.") def patch(self, pet_id): """This endpoint is not implemented.""" return {"message": "Update operation is not implemented."}, 501 # --- Flask App Initialization --- def create_app(): """Application factory to create and configure the Flask app.""" app = Flask(__name__) api = Api(app) # API Resource routing api.add_resource(PetsList, "/pets") api.add_resource(Pet, "/pets/<string:pet_id>") # Centralized error handling @app.errorhandler(NotFound) def handle_not_found(e): return jsonify({"message": str(e)}), 404 @app.errorhandler(BadRequest) def handle_bad_request(e): return jsonify({"message": str(e)}), 400 @app.errorhandler(Exception) def handle_generic_error(e): app.logger.error(f"An unhandled exception occurred: {e}", exc_info=True) return jsonify({"message": "An internal server error occurred."}), 500 return app app = create_app() if __name__ == "__main__": # Use debug=False in a production environment app.run(host="0.0.0.0", port=8080, debug=True)
  1. Cliquez sur le bouton Ouvrir le terminal, puis exécutez le code suivant pour installer les packages nécessaires.
pip install -r requirements.txt
  1. Exécutez maintenant le code suivant dans le terminal pour lancer le programme.
python main.py

  1. Dans la barre d'outils Cloud Shell, cliquez à nouveau sur l'icône + pour ouvrir un troisième onglet de terminal.

  2. Vous pouvez utiliser des commandes curl pour tester l'API. Pour commencer, ajoutez des enregistrements à l'aide de commandes HTTP POST.

curl -X POST --data '{"OwnerName": "Sue", "PetName": "Sparky", "PetType": "Cat", "Breed": "Alley"}' http://localhost:8080/pets curl -X POST --data '{"OwnerName": "Sue", "PetName": "Pickles", "PetType": "Dog", "Breed": "Shepherd"}' http://localhost:8080/pets curl -X POST --data '{"OwnerName": "Doug", "PetName": "Noir", "PetType": "Dog", "Breed": "Schnoodle"}' http://localhost:8080/pets curl -X POST --data '{"OwnerName": "Doug", "PetName": "Bree", "PetType": "Dog", "Breed": "Mutt"}' http://localhost:8080/pets curl -X POST --data '{"OwnerName": "Joey", "PetName": "Felix", "PetType": "Cat", "Breed": "Tabby"}' http://localhost:8080/pets
  1. Vérifiez si les enregistrements ont été ajoutés à l'aide d'une commande HTTP GET. Elle doit renvoyer les enregistrements au format JSON.
curl http://localhost:8080/pets Remarque : Si vous avez omis une étape ou si vous n'obtenez pas le résultat souhaité, suivez à nouveau les étapes de la tâche 4 à l'aide de Cloud Shell.
  1. Saisissez exit pour fermer le troisième onglet du terminal, puis appuyez sur Ctrl+C pour arrêter le programme Python dans le deuxième onglet du terminal. Fermez le deuxième onglet en saisissant exit.
    Revenez au premier onglet du terminal et arrêtez l'émulateur en appuyant sur Ctrl+C.
Remarque : Ces enregistrements ont bien été ajoutés à l'émulateur. Vous allez ensuite déployer l'application sur Cloud Run et utiliser la vraie instance Spanner.

Tâche 6 : Déployer une application sur Cloud Run

  1. Pour déployer l'application sur Cloud Run, vous avez besoin d'une image Docker. Commencez par accéder au dossier cloud-run.
cd ~/lab-files/cloud-run
  1. Pour créer l'image Docker, vous devez ajouter des instructions au fichier Dockerfile. Cliquez sur le bouton Ouvrir l'éditeur, puis ouvrez le fichier Dockerfile. Collez-y le code suivant.
FROM python:3.9 WORKDIR /app COPY . . RUN pip install gunicorn RUN pip install -r requirements.txt ENV PORT=8080 CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 main:app
  1. Revenez au terminal et exécutez le code suivant pour créer l'image Docker. (Vérifiez que vous vous trouvez bien dans le dossier ~/lab-files/cloud-run.)
gcloud builds submit --tag=gcr.io/$GOOGLE_CLOUD_PROJECT/spanner-pets-api:v1.0 .

  1. Vérifiez que Cloud Run est activé pour votre projet dans Explorer et activer les API.

  2. Déployez maintenant l'application Cloud Run à l'aide de la commande suivante. Notez que les variables d'environnement sont définies dans la commande afin que le code utilise l'instance Cloud Spanner, et non l'émulateur. L'exécution de la commande prend quelques minutes.

gcloud run deploy spanner-pets-api --image gcr.io/$GOOGLE_CLOUD_PROJECT/spanner-pets-api:v1.0 --update-env-vars INSTANCE_ID=test-spanner-instance,DATABASE_ID=pets-db --region={{{project_0.default_region|place_holder_text}}}
  1. Une fois la commande exécutée, notez l'URL du service et copiez-la dans le presse-papiers. Comme vous l'avez fait avec l'émulateur, vous pouvez utiliser des commandes curl pour tester l'API. D'abord, créez une variable pour stocker l'URL, comme indiqué ci-dessous. Veillez à bien coller l'intégralité de votre URL, y compris le préfixe https://..., à la place de l'ensemble de l'espace réservé <YOUR_SERVICE_URL_HERE>.
pets_url=<YOUR_SERVICE_URL_HERE>
  1. Ajoutez des enregistrements à l'aide de commandes curl.
curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X POST --data '{"OwnerName": "Sue", "PetName": "Sparky", "PetType": "Cat", "Breed": "Alley"}' $pets_url/pets curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X POST --data '{"OwnerName": "Sue", "PetName": "Pickles", "PetType": "Dog", "Breed": "Shepherd"}' $pets_url/pets curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X POST --data '{"OwnerName": "Doug", "PetName": "Noir", "PetType": "Dog", "Breed": "Schnoodle"}' $pets_url/pets curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X POST --data '{"OwnerName": "Doug", "PetName": "Bree", "PetType": "Dog", "Breed": "Mutt"}' $pets_url/pets curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X POST --data '{"OwnerName": "Joey", "PetName": "Felix", "PetType": "Cat", "Breed": "Tabby"}' $pets_url/pets

  1. Les enregistrements ont donc bien été ajoutés. Dans la console, accédez au service Cloud Run, puis cliquez sur votre service pour afficher ses détails et consulter ses journaux. Vous verrez que chaque requête que vous avez exécutée y est enregistrée.

  2. Vous pouvez également vérifier que les enregistrements ont bien été ajoutés.

curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" $pets_url/pets

  1. Accédez à Spanner, et explorez l'instance ainsi que la base de données.

  2. L'API implémente également une fonction de suppression DELETE. Revenez au terminal et saisissez la commande suivante pour supprimer toutes les données.

curl -H "Authorization: Bearer $(gcloud auth print-identity-token)" -X DELETE $pets_url/pets
  1. Dans la console, supprimez l'instance Spanner pour qu'elle ne vous soit pas facturée.

Félicitations ! Vous avez écrit des applications qui utilisent des bases de données Spanner et vous les avez déployées dans Cloud Run Functions et Cloud Run. Vous avez également installé, configuré et activé l'émulateur Spanner pour l'utiliser dans des environnements de développement.

Terminer l'atelier

Une fois l'atelier terminé, cliquez sur End Lab (Terminer l'atelier). Qwiklabs supprime les ressources que vous avez utilisées, puis efface le compte.

Vous avez alors la possibilité de noter votre expérience au cours de l'atelier. Sélectionnez le nombre d'étoiles correspondant à votre note, saisissez un commentaire, puis cliquez sur Submit (Envoyer).

Voici à quoi correspond le nombre d'étoiles que vous pouvez attribuer à un atelier :

  • 1 étoile = très insatisfait(e)
  • 2 étoiles = insatisfait(e)
  • 3 étoiles = ni insatisfait(e), ni satisfait(e)
  • 4 étoiles = satisfait(e)
  • 5 étoiles = très satisfait(e)

Si vous ne souhaitez pas donner votre avis, vous pouvez fermer la boîte de dialogue.

Pour soumettre des commentaires, suggestions ou corrections, veuillez utiliser l'onglet Support.

Copyright 2024 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms de société et de produit peuvent être des marques des sociétés auxquelles ils sont associés.

Avant de commencer

  1. Les ateliers créent un projet Google Cloud et des ressources pour une durée déterminée.
  2. Les ateliers doivent être effectués dans le délai imparti et ne peuvent pas être mis en pause. Si vous quittez l'atelier, vous devrez le recommencer depuis le début.
  3. En haut à gauche de l'écran, cliquez sur Démarrer l'atelier pour commencer.

Utilisez la navigation privée

  1. Copiez le nom d'utilisateur et le mot de passe fournis pour l'atelier
  2. Cliquez sur Ouvrir la console en navigation privée

Connectez-vous à la console

  1. Connectez-vous à l'aide des identifiants qui vous ont été attribués pour l'atelier. L'utilisation d'autres identifiants peut entraîner des erreurs ou des frais.
  2. Acceptez les conditions d'utilisation et ignorez la page concernant les ressources de récupération des données.
  3. Ne cliquez pas sur Terminer l'atelier, à moins que vous n'ayez terminé l'atelier ou que vous ne vouliez le recommencer, car cela effacera votre travail et supprimera le projet.

Ce contenu n'est pas disponible pour le moment

Nous vous préviendrons par e-mail lorsqu'il sera disponible

Parfait !

Nous vous contacterons par e-mail s'il devient disponible

Un atelier à la fois

Confirmez pour mettre fin à tous les ateliers existants et démarrer celui-ci

Utilisez la navigation privée pour effectuer l'atelier

Ouvrez une fenêtre de navigateur en mode navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le compte temporaire de participant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.