Présentation

Conçue pour le scaling automatique et les hautes performances, Google Cloud Datastore est une base de données de documents NoSQL qui simplifie le développement d'applications. Dans cet atelier, vous allez stocker des données d'une application Quiz en ligne à l'aide de Datastore. Vous allez également configurer l'application pour récupérer des données à partir de Datastore et les afficher dans le quiz.

Le squelette de l'application Quiz a déjà été codé. Vous allez cloner le dépôt contenant le squelette à l'aide de Google Cloud Shell, examiner le code dans l'éditeur Cloud Shell, puis l'afficher à l'aide de la fonction d'aperçu sur le Web de Cloud Shell. Vous modifierez ensuite le code de façon à stocker les données dans Cloud Datastore.

Objectifs

Dans cet atelier, vous allez réaliser les tâches suivantes :

• Exploiter Cloud Shell en tant qu'environnement de développement

• Prévisualiser l'application

• Modifier le code de l'application pour intégrer Cloud Datastore

Prérequis

Prérequis de l'atelier

Pour chaque atelier, nous vous attribuons un nouveau projet Google Cloud et un nouvel ensemble de ressources pour une durée déterminée, sans frais.

1. Connectez-vous à Qwiklabs dans une fenêtre de navigation privée.

2. Vérifiez le temps imparti pour l'atelier (par exemple : 01:15:00) : vous devez pouvoir le terminer dans ce délai.
   Une fois l'atelier lancé, vous ne pouvez pas le mettre en pause. Si nécessaire, vous pourrez le redémarrer, mais vous devrez tout reprendre depuis le début.

3. Lorsque vous êtes prêt, cliquez sur Démarrer l'atelier.

4. Notez vos identifiants pour l'atelier (Nom d'utilisateur et Mot de passe). Ils vous serviront à vous connecter à Google Cloud Console.

5. Cliquez sur Ouvrir la console Google.

6. Cliquez sur Utiliser un autre compte, puis copiez-collez les identifiants de cet atelier lorsque vous y êtes invité.
   Si vous utilisez d'autres identifiants, des messages d'erreur s'afficheront ou des frais seront appliqués.

7. Acceptez les conditions d'utilisation et ignorez la page concernant les ressources de récupération des données.

Activer Google Cloud Shell

Google Cloud Shell est une machine virtuelle qui contient de nombreux 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 vous permet d'accéder à vos ressources Google Cloud grâce à une ligne de commande.

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

   

2. Cliquez sur Continuer.

Le provisionnement et la connexion à l'environnement prennent quelques instants. Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Par exemple :

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

• Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

Résultat :

Exemple de résultat :

• Vous pouvez lister les ID de projet à l'aide de cette commande :

Résultat :

Exemple de résultat :

Préparer l'application Quiz

Dans cette section, vous allez accéder à Cloud Shell, cloner le dépôt Git qui contient l'application Quiz, puis exécuter l'application.

Cloner le code source dans Cloud Shell

1. Dans Cloud Shell, exécutez la commande suivante pour cloner le dépôt pour la classe :

2. Créez un lien symbolique vers votre répertoire de travail :

Configurer et exécuter l'application Quiz

1. Accédez au répertoire qui contient les exemples de fichiers de l'atelier :

   cd ~/datastore/start

2. Créez la variable d'environnement GCLOUD_PROJECT qui référence l'ID du projet GCP :

   export GCLOUD_PROJECT=$DEVSHELL_PROJECT_ID

3. Installez les dépendances de l'application :

   mvn clean install

   L'installation peut prendre quelques minutes. Lorsqu'elle est terminée, un résultat semblable aux lignes suivantes doit s'afficher :

   Exemple de résultat :

   [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 38.805 s [INFO] Finished at: 2018-05-27T22:40:49-04:00 [INFO] Final Memory: 35M/84M [INFO] ------------------------------------------------------------------------

4. Exécutez l'application :

   mvn spring-boot:run

   L'application s'exécute lorsque le dernier résultat qui s'affiche est semblable à ce qui suit.

   01:39:26.404 [restartedMain] INFO c.g.training.appdev.QuizApplication - Started QuizApplication in 12.628 seconds (JVM running for 14.1 57)

Examiner l'application Quiz

1. Dans Cloud Shell, cliquez sur Web preview > Preview on port 8080 (Aperçu sur le Web > Prévisualiser sur le port 8080) pour prévisualiser l'application Quiz.

2. Cliquez sur Create Question (Créer une question).

   Un formulaire simple contenant des zones de texte pour la question et les réponses doit s'afficher. Des cases d'option permettent de sélectionner la bonne réponse. Les auteurs du quiz peuvent ajouter des questions dans cette partie de l'application.

3. Cliquez sur Take Test (Faire le test).

   Une application cliente s'ouvre. L'application Quite Interesting Quiz est vide, car vous n'avez pas encore créé de question.

4. Dans la barre de navigation supérieure, cliquez sur GCP.

Vous devez voir un titre et des réponses factices. Le titre est un exemple de question.

C'est ici que les participants au quiz répondront aux questions.

Pour revenir à l'application côté serveur, cliquez sur Quite Interesting Quiz (Quiz très intéressant) dans la barre de navigation.

Examiner le code de l'application Quiz

Dans cette section et tout au long de l'atelier, vous allez examiner le code de l'application Quiz dans un éditeur de code. Vous pouvez utiliser les éditeurs de script shell installés sur Cloud Shell, tels que nano ou vim, ou encore l'éditeur de code intégré de Cloud Shell. Cet atelier utilise ce dernier.

Lancer l'éditeur de texte Cloud Shell

Dans Cloud Shell, cliquez sur l'icône Open Editor (Ouvrir l'éditeur).

Examiner le code

1. Accédez au dossier /training-data-analyst/courses/developingapps/v1.3/java/datastore/start à l'aide du panneau de l'explorateur de fichiers situé dans la partie gauche de l'éditeur.

Il s'agit du dossier racine de l'application.

2. À partir du dossier start, accédez au dossier src/main/java/com/google/training/appdev à l'aide du panneau de l'explorateur de fichiers situé dans la partie gauche de l'éditeur.

   Les chemins d'accès des fichiers de code source Java sont relatifs au dossier appdev.

Examiner l'application Web Spring Boot

1. Sélectionnez le fichier .../QuizApplication.java.

   Dans ce fichier, la classe contient le point d'entrée de l'application Spring Boot.

2. Sélectionnez le fichier .../services/gcp/domain/Question.java.

   Dans ce fichier, la classe de domaine représente les données des questions transmises au formulaire et les questions affichées lorsque le quiz est lancé.

3. Sélectionnez le fichier .../web/QuestionsController.java.

   Ce fichier contient les gestionnaires qui affichent le formulaire et collectent les données publiées dans ce dernier par les auteurs du quiz via l'application Web.

   Dans le fichier QuestionsController.java, localisez le gestionnaire qui répond aux requêtes HTTP POST pour la route /questions/add.

4. Accédez au dossier /training-data-analyst/courses/developingapps/v1.3/java/datastore/start/src/main/resources à l'aide du panneau de l'explorateur de fichiers situé dans la partie gauche de l'éditeur.

5. Sélectionnez le dossier templates.

Ce dossier contient le modèle de l'interface utilisateur de l'application Web, créé à l'aide du moteur de création de modèles Thyme.

6. Sélectionnez le fichier .../templates/new_question.html.

   Ce fichier contient le modèle du formulaire "Create Question" (Créer une question). Notez qu'il existe une liste permettant de choisir un quiz, les zones de texte dans lesquelles l'auteur peut saisir des questions et des réponses, ainsi que les cases d'option permettant de sélectionner la réponse correcte.

   Revenez au dossier contenant le code source Java à l'aide du panneau de l'explorateur de fichiers situé dans la partie gauche de l'éditeur. (Pour rappel, il s'agit de start/src/main/java/com/google/training/appdev.)

7. Sélectionnez le fichier .../api/QuizEndpoint.java.

   Ce fichier contient le gestionnaire qui envoie des données JSON aux élèves qui font un test. Notez que les gestionnaires peuvent également utiliser l'objet questionService.

8. Sélectionnez le fichier .../services/gcp/datastore/QuestionService.java.

   Il s'agit du fichier dans lequel vous rédigerez le code Datastore permettant d'enregistrer et de charger les questions du quiz vers et depuis Cloud Datastore. L'application Web et l'API utilisent cette classe.

Ajouter des entités à Cloud Datastore

Dans cette section, vous allez écrire le code permettant d'enregistrer les données du formulaire dans Cloud Datastore.

Créer une application App Engine pour provisionner Cloud Datastore

Dans Cloud Shell, cliquez sur l'icône Open Terminal (Ouvrir le terminal), puis arrêtez l'application en appuyant sur les touches Ctrl+C.

Pour créer une application App Engine dans votre projet, exécutez la commande suivante dans Cloud Shell :

Importer et utiliser le package Java Datastore

1. Ouvrez le fichier .../services/gcp/datastore/QuestionService.java dans l'éditeur Cloud Shell.

2. Codez une importation générique pour le package com.google.cloud.datastore.*.

   // TODO: Import the com.google.cloud.datastore.* package import com.google.cloud.datastore.*; // END TODO

3. Déclarez un objet client Datastore nommé datastore et initialisez-le.

   // TODO: Create a Datastore client object, datastore // The DatastoreOptions class has a getDefaultInstance() // static method. // Use the getService() method of the DatastoreOptions // object to get the Datastore client private Datastore datastore = DatastoreOptions.getDefaultInstance().getService(); // END TODO

Après ces modifications, la première partie de QuestionService.java se compose des lignes suivantes :

Écrire le code permettant de créer une entité Cloud Datastore

1. Déclarez une chaîne finale statique nommée ENTITY_KIND, initialisée par la valeur "Question".

   // TODO: Declare a static final String named kind //The Datastore key is the equivalent of a primary key in a // relational database. // There are two main ways of writing a key: // 1. Specify the kind, and let Datastore generate a unique // numeric id // 2. Specify the kind and a unique string id private static final String ENTITY_KIND = "Question"; // END TODO

2. Créez une classe KeyFactory pour les entités Question.

   Pour plus d'informations sur les entités, consultez l'article Entities, propriétés et clés.

   // TODO: Create a KeyFactory for Question entities private final KeyFactory keyFactory = datastore.newKeyFactory().setKind(ENTITY_KIND); // END TODO

3. Dans la méthode createQuestion(Question question), indiquez Key comme type de retour de la méthode.

   // TODO: Modify return type to Key public Key createQuestion(Question question) { // END TODO

4. Déclarez une clé avec un identifiant alloué pour l'entité Question à l'aide du client datastore et de la classe KeyFactory.

   // TODO: Declare the entity key, // with a Datastore allocated id Key key = datastore.allocateId(keyFactory.newKey()); // END TODO

   Pour plus d'informations, consultez l'article Classe KeyFactory.

5. Déclarez une entité nommée questionEntity, puis initialisez-la à l'aide d'un générateur d'entités.

   // TODO: Declare the entity object, with the key and data // The entity's members are set using the Entity.Builder. // This has a set method for property names and values // Values are retrieved from the Domain object Entity questionEntity = Entity.newBuilder(key) .set(Question.QUIZ, question.getQuiz()) .set(Question.AUTHOR, question.getAuthor()) .set(Question.TITLE, question.getTitle()) .set(Question.ANSWER_ONE,question.getAnswerOne()) .set(Question.ANSWER_TWO, question.getAnswerTwo()) .set(Question.ANSWER_THREE,question.getAnswerThree()) .set(Question.ANSWER_FOUR, question.getAnswerFour()) .set(Question.CORRECT_ANSWER, question.getCorrectAnswer()) .build(); // END TODO

6. Utilisez l'objet client Datastore (datastore) pour enregistrer l'entité en appelant sa méthode put(questionEntity).

   // TODO: Save the entity datastore.put(questionEntity); // END TODO

7. Modifiez l'instruction return pour qu'elle renvoie la clé associée à l'entité.

   // TODO: Return the key return key; // END TODO

8. Enregistrez le fichier.

Les lignes suivantes représentent le contenu QuestionService.java avec toutes les modifications apportées à ce stade.

Exécuter l'application et créer une entité Cloud Datastore

1. Dans Cloud Shell, cliquez sur l'icône Open Terminal (Ouvrir le terminal), puis exécutez l'application :

   mvn spring-boot:run

   L'application s'exécute lorsque le dernier résultat qui s'affiche est semblable à ce qui suit :

   08:11:19.014 [restartedMain] INFO c.g.training.appdev.QuizApplication - Started QuizApplication in 10.401 seconds (JVM running for 11.28)

2. Dans Cloud Shell, cliquez sur Web preview > Preview on port 8080 (Aperçu sur le Web > Prévisualiser sur le port 8080) pour prévisualiser l'application Quiz.

3. Cliquez sur Create Question (Créer une question), remplissez le formulaire à l'aide des valeurs suivantes, puis cliquez sur Save (Enregistrer).

Vous êtes redirigé vers la page d'accueil de l'application.

La question que vous venez de créer est maintenant dans DataReturn. Dans la console, cliquez sur le menu de navigation > Datastore > Entities (Entités) pour afficher la nouvelle question.

Interroger Cloud Datastore

Dans cette section, vous allez écrire du code permettant de récupérer des données d'entité de Cloud Datastore.

Écrire le code permettant de récupérer des entités Cloud Datastore

1. Dans Cloud Shell, cliquez sur l'icône Open Editor (Ouvrir l'éditeur). Dans le fichier .../services/gcp/datastore/QuestionService.java, accédez à la méthode getAllQuestions(String quiz), puis supprimez le code correspondant aux questions "Dummy".

   // TODO: Remove this code List<Question> questions = new ArrayList<>(); Question dummy = new Question.Builder() .withQuiz("gcp") .withAuthor("Dummy Author") .withTitle("Dummy Title") .withAnswerOne("Dummy Answer One") .withAnswerTwo("Dummy Answer Two") .withAnswerThree("Dummy Answer Three") .withAnswerFour("Dummy Answer Four") .withCorrectAnswer(1) .withId(-1) .build(); questions.add(dummy); return questions; // END TODO

2. Toujours dans la méthode getAllQuestions(String quiz), créez un objet de requête et initialisez-le à l'aide d'une requête qui récupère des entités Question pour un quiz spécifique à partir de Cloud Datastore.

   // TODO: Create the query // The Query class has a static newEntityQueryBuilder() // method that allows you to specify the kind(s) of // entities to be retrieved. // The query can be customized to filter the Question // entities for one quiz. Query<Entity> query = Query.newEntityQueryBuilder() .setKind(ENTITY_KIND) .setFilter(StructuredQuery.PropertyFilter.eq( Question.QUIZ, quiz)) .build(); // END TODO

   Pour en savoir plus, consultez la page Requêtes Datastore.

3. Appelez la méthode datastore.run(query) de l'objet client Datastore, puis attribuez le résultat à l'itérateur d'entité nommé entities.

   // TODO: Execute the query // The datastore.run(query) method returns an iterator // for entities Iterator<Entity> entities = datastore.run(query); // END TODO

4. Renvoyez les résultats transformés, en utilisant la méthode buildQuestions(entities) pour convertir les entités Datastore en objets de domaine.

   // TODO: Return the transformed results // Use the buildQuestions(entities) method to convert // from Datastore entities to domain objects return buildQuestions(entities); // END TODO

5. Annulez la mise en commentaire des méthodes d'assistance buildQuestions(...) et entityToQuestion(...) fournies dans la classe QuestionService et utilisez-les pour mettre en correspondance l'itérateur avec une liste d'objets domaine de question.

Les lignes suivantes constituent le fichier QuestionService.java actualisé :

Exécuter l'application et tester la requête Cloud Datastore

1. Enregistrez le fichier .../services/gcp/datastore/QuestionService.java, puis revenez à la commande Cloud Shell.

2. Dans Cloud Shell, cliquez sur Open Terminal (Ouvrir le terminal). Arrêtez l'application en appuyant sur les touches Ctrl+C.

3. Démarrez l'application.

4. Dans Cloud Shell, cliquez sur Web preview > Preview on port 8080 (Aperçu sur le Web > Prévisualiser sur le port 8080) pour prévisualiser l'application Quiz.

5. Remplacez la chaîne de requête à la fin de l'URL de l'application par /api/quizzes/gcp.

6. Revenez à la page d'accueil de l'application et cliquez sur Take Test (Faire le test), puis sur GCP.

Terminer l'atelier

Une fois l'atelier terminé, cliquez sur Terminer l'atelier. Google Cloud Skills Boost supprime les ressources que vous avez utilisées, puis efface le compte.

Si vous le souhaitez, vous pouvez noter l'atelier. Sélectionnez un nombre d'étoiles, saisissez un commentaire, puis cliquez sur Envoyer.

Le nombre d'étoiles correspond à votre degré de satisfaction :

• 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 accéder à l'onglet Assistance.

Copyright 2026 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.