GSP642

Présentation

Il y a 12 ans, Lily a créé une chaîne de cliniques vétérinaires appelée Pet Theory. Pet Theory a connu une expansion rapide ces dernières années. Toutefois, son ancien système de prise de rendez-vous n'étant plus en mesure de gérer l'augmentation de la charge de travail, Lily vous demande de concevoir un système plus évolutif basé sur le cloud.

L'équipe opérationnelle de Pet Theory est composée d'une seule personne, Patrick. La solution ne doit donc pas nécessiter beaucoup de maintenance. L'équipe a opté pour une technologie sans serveur.

Ruby a été engagée comme consultante pour aider Pet Theory à faire la transition vers la solution sans serveur. Après avoir comparé les différentes options de base de données sans serveur, l'équipe a choisi Cloud Firestore. Étant donné que Firestore est sans serveur, il n'est pas nécessaire de provisionner à l'avance la capacité, ce qui signifie qu'il n'y a pas de risque d'avoir des limites de stockage ou d'opérations. Firestore permet de synchroniser les données entre les applications clientes grâce à des écouteurs en temps réel, et peut fonctionner hors connexion pour le mobile et le Web. Il est ainsi possible de créer une application réactive qui fonctionne indépendamment de la latence du réseau ou de la connectivité Internet.

Dans cet atelier, vous allez aider Patrick à télécharger les données existantes de Pet Theory dans une base de données Cloud Firestore. À cet effet, il travaillera en étroite collaboration avec Ruby.

Architecture

Ce schéma présente les services que vous allez utiliser et la manière dont ils se connectent les uns aux autres :

Objectifs

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

• Configurer Firestore dans Google Cloud
• Rédiger le code d'importation de la base de données
• Générer une collection de données client pour les tests
• Importer des données client de test dans Firestore

Prérequis

Cet atelier s'adresse aux débutants qui maîtrisent déjà la console Cloud et les environnements de shell. Connaître Firebase peut être utile, mais ce n'est pas requis.

Vous devez également savoir modifier des fichiers. Vous pouvez utiliser votre éditeur de texte préféré (comme nano, vi, etc.) ou lancer l'éditeur de code de Cloud Shell, qui se trouve dans le ruban supérieur :

Lorsque vous êtes prêt, faites défiler la page vers le bas et suivez les indications pour passer à la configuration de l'environnement de votre atelier.

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 temporaire étudiant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• vous disposez d'un temps limité ; 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.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, un pop-up s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau Détails concernant l'atelier, qui contient les éléments suivants :

   • Le bouton Ouvrir la console Google Cloud
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans la fenêtre de navigation privée si vous utilisez le navigateur Chrome).

   L'atelier lance les ressources, puis ouvre la page Se connecter dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur ci-dessous et collez-le dans la boîte de dialogue Se connecter.

   {{{user_0.username | "Username"}}}

   Vous trouverez également le nom d'utilisateur dans le panneau Détails concernant l'atelier.

4. Cliquez sur Suivant.

5. Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.

   {{{user_0.password | "Password"}}}

   Vous trouverez également le mot de passe dans le panneau Détails concernant l'atelier.

6. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis pour l'atelier. Ne saisissez pas ceux de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

7. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas à des essais gratuits.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Pour afficher un menu contenant la liste des produits et services Google Cloud, cliquez sur le menu de navigation en haut à gauche.

Activer Cloud Shell

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. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.

1. Cliquez sur Activer Cloud Shell  en haut de la console Google Cloud.

Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Le résultat contient une ligne qui déclare YOUR_PROJECT_ID (VOTRE_ID_PROJET) pour cette session :

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

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.

2. (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

3. Cliquez sur Autoriser.

4. Vous devez à présent obtenir le résultat suivant :

Résultat :

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

5. (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project = <ID_Projet>

Exemple de résultat :

[core] project = qwiklabs-gcp-44776a13dea667a6 Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

Tâche 1 : Configurer Firestore dans Google Cloud

La tâche de Patrick consiste à télécharger les données existantes de Pet Theory dans une base de données Cloud Firestore. Il travaillera en étroite collaboration avec Ruby dans ce but. Ruby reçoit un message de Patrick du service informatique...

Patrick, Administrateur informatique	Bonjour Ruby, La première étape pour passer au mode sans serveur consiste à créer une base de données Firestore avec Google Cloud. Pouvez-vous m'aider ? Je n'ai pas beaucoup d'expérience avec ce type de configuration. Patrick
Ruby, Consultante en logiciels	Bonjour Patrick, Bien sûr, je serais ravie de vous aider. Je vous enverrai quelques ressources pour commencer, puis nous prendrons contact une fois que vous aurez créé la base de données. Ruby

Aidez Patrick à configurer une base de données Firestore à l'aide de la console Cloud.

1. Dans la console Cloud, accédez au menu de navigation et sélectionnez Firestore.

2. Cliquez sur +Créer une base de données.

3. Sélectionnez l'option Mode natif et cliquez sur Continuer.

Remarque : Les deux modes sont très performants avec une cohérence forte, mais ne se ressemblent pas et sont optimisés pour des cas d'utilisation différents.

• Le mode natif permet à un grand nombre d'utilisateurs d'accéder aux mêmes données en même temps. De plus, il offre des fonctionnalités telles que les mises à jour en temps réel et une connexion directe entre votre base de données et un client Web/mobile.
• Le mode Datastore met l'accent sur la fourniture d'un haut débit (beaucoup de lectures et d'écritures).

4. Dans le menu déroulant Région, sélectionnez la région et cliquez sur Créer une base de données.

Une fois la tâche accomplie, Ruby envoie un e-mail à Patrick...

Ruby, Consultante en logiciels	Bonjour Patrick, Félicitations pour la configuration de la base de données Firestore ! Pour gérer l'accès à la base de données, nous allons utiliser un compte de service qui a été créé automatiquement avec les droits nécessaires. Nous sommes maintenant prêts à migrer de l'ancienne base de données à Firestore. Ruby
Patrick, Administrateur informatique	Bonjour Ruby, Merci pour votre aide, la configuration de la base de données Firestore a été simple. J'espère que l'importation dans cette nouvelle base sera moins complexe que l'ancien processus, qui nécessitait de nombreuses étapes. Patrick

Tâche 2 : Écrire le code d'importation de la base de données

La nouvelle base de données Cloud Firestore est en place, mais elle est vide. Les données relatives aux clients de Pet Theory n'existent toujours que dans l'ancienne base de données.

Patrick envoie un message à Ruby...

Patrick, Administrateur informatique	Bonjour Ruby, Mon responsable souhaiterait commencer à migrer les données des clients vers la nouvelle base de données Firestore. J'ai exporté un fichier CSV depuis l'ancienne base de données, mais je ne sais pas comment importer ces données dans Firestore. Pouvez-vous me donner un coup de main ? Patrick
Ruby, Consultante en logiciels	Bonjour Patrick, Bien sûr, organisons une réunion pour discuter de la procédure à suivre. Ruby

Comme l'explique Patrick, les données client seront disponibles dans un fichier CSV. Aidez-le à créer une application qui lit les enregistrements client à partir d'un fichier CSV et les écrit dans Firestore. Puisque Patrick connaît bien JavaScript, créez cette application à l'aide de l'environnement d'exécution JavaScript Node.js.

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

git clone https://github.com/rosera/pet-theory

2. Utilisez l'éditeur de code Cloud Shell (ou votre éditeur préféré) pour modifier les fichiers. Dans le ruban supérieur de votre session Cloud Shell, cliquez sur Ouvrir l'éditeur pour faire apparaître un nouvel onglet. Si vous y êtes invité, cliquez sur Ouvrir dans une nouvelle fenêtre pour lancer l'éditeur de code :

3. Passez de votre répertoire de travail actuel au répertoire lab01 :

cd pet-theory/lab01

Dans ce répertoire, vous verrez le fichier package.json de Patrick. Ce fichier répertorie les packages dont dépend votre projet Node.js et rend votre version reproductible, et donc plus facile à partager avec les autres.

Voici un exemple de fichier package.json :

{ "name": "lab01", "version": "1.0.0", "description": "This is lab01 of the Pet Theory labs", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": [], "author": "Patrick - IT", "license": "MIT", "dependencies": { "csv-parse": "^5.5.3" } }

Maintenant que Patrick a importé son code source, il contacte Ruby pour connaître les packages dont il a besoin pour que la migration fonctionne.

Patrick, Administrateur informatique	Bonjour Ruby, Le code que j'utilise pour l'ancienne base de données est assez basique, il crée simplement un fichier CSV à utiliser pour l'importation. Dois-je télécharger quelque chose avant de commencer ? Patrick
Ruby, Consultante en logiciels	Bonjour Patrick, Je vous conseille d'utiliser l'un des nombreux packages @google-cloud Node pour interagir avec Firestore. Il suffira alors d'apporter de petites modifications au code existant puisque le gros du travail a été fait. Ruby

Pour permettre au code de Patrick d'écrire dans la base de données Firestore, vous devez installer des dépendances supplémentaires entre pairs.

4. Pour ce faire, exécutez la commande suivante :

npm install @google-cloud/firestore

5. Pour permettre à l'application d'écrire des journaux dans Cloud Logging, installez un module supplémentaire :

npm install @google-cloud/logging

Une fois l'exécution de la commande terminée, le fichier package.json sera automatiquement mis à jour pour inclure les nouvelles dépendances de pairs, et se présentera comme suit :

... "dependencies": { "@google-cloud/firestore": "^7.3.0", "@google-cloud/logging": "^11.0.0", "csv-parse": "^5.5.3" }

Il est maintenant temps d'examiner le script qui lit le fichier CSV des clients et écrit un enregistrement dans Firestore pour chaque ligne du fichier CSV. L'application initiale de Patrick se présente comme suit :

const csv = require('csv-parse'); const fs = require('fs'); function writeToDatabase(records) { records.forEach((record, i) => { console.log(`ID: ${record.id} Email: ${record.email} Name: ${record.name} Phone: ${record.phone}`); }); return ; } async function importCsv(csvFilename) { const parser = csv.parse({ columns: true, delimiter: ',' }, async function (err, records) { if (e) { console.error('Error parsing CSV:', e); return; } try { console.log(`Call write to Firestore`); await writeToDatabase(records); console.log(`Wrote ${records.length} records`); } catch (e) { console.error(e); process.exit(1); } }); await fs.createReadStream(csvFilename).pipe(parser); } if (process.argv.length < 3) { console.error('Please include a path to a csv file'); process.exit(1); } importCsv(process.argv[2]).catch(e => console.error(e));

Elle prend la sortie du fichier CSV d'entrée et l'importe dans l'ancienne base de données. Mettez maintenant à jour ce code pour écrire dans Firestore.

6. Ouvrez le fichier pet-theory/lab01/importTestData.js.

Pour référencer l'API Firestore via l'application, vous devez ajouter la dépendance de pairs au codebase existant.

7. Ajoutez la dépendance Firestore suivante à la ligne 3 du fichier :

const { Firestore } = require("@google-cloud/firestore");

Assurez-vous que le haut du fichier se présente comme suit :

const csv = require('csv-parse'); const fs = require('fs'); const { Firestore } = require("@google-cloud/firestore"); // Add this

L'intégration avec la base de données Firestore peut se faire grâce à quelques lignes de code. Ruby vous a justement envoyé, à Patrick et à vous, des modèles de code dans ce but.

8. Ajoutez le code suivant sous la ligne 34, ou après la condition if (process.argv.length < 3) :

async function writeToFirestore(records) { const db = new Firestore({ // projectId: projectId }); const batch = db.batch() records.forEach((record)=>{ console.log(`Write: ${record}`) const docRef = db.collection("customers").doc(record.email); batch.set(docRef, record, { merge: true }) }) batch.commit() .then(() => { console.log('Batch executed') }) .catch(err => { console.log(`Batch error: ${err}`) }) return }

L'extrait de code ci-dessus déclare un nouvel objet de base de données, qui fait référence à la base de données créée plus tôt dans l'atelier. La fonction utilise un traitement par lot. Chaque enregistrement du lot est traité à tour de rôle et se voit attribuer une référence de document basée sur l'identifiant ajouté. À la fin de la fonction, le contenu du lot est validé (écrit) dans la base de données.

9. Mettez à jour la fonction importCsv pour ajouter l'appel de fonction writeToFirestore et retirer l'appel de fonction writeToDatabase. La fonction devrait ressembler à ceci :

async function importCsv(csvFilename) { const parser = csv.parse({ columns: true, delimiter: ',' }, async function (err, records) { if (err) { console.error('Error parsing CSV:', err); return; } try { console.log(`Call write to Firestore`); await writeToFirestore(records); // await writeToDatabase(records); console.log(`Wrote ${records.length} records`); } catch (e) { console.error(e); process.exit(1); } }); await fs.createReadStream(csvFilename).pipe(parser); }

10. Ajoutez une fonctionnalité de journalisation à l'application. Pour référencer l'API Logging via l'application, ajoutez la dépendance de pairs au codebase existant. Ajoutez la ligne suivante juste en dessous des autres instructions "require" en haut du fichier :

const { Logging } = require('@google-cloud/logging');

Assurez-vous que le haut du fichier se présente comme suit :

const csv = require('csv-parse'); const fs = require('fs'); const { Firestore } = require("@google-cloud/firestore"); const { Logging } = require('@google-cloud/logging');

11. Ajoutez quelques variables constantes et initialisez le client Logging. Insérez-les dans le fichier, juste en dessous des lignes présentées ci-dessus (~ligne 5), comme ceci :

const logName = "pet-theory-logs-importTestData"; // Creates a Logging client const logging = new Logging(); const log = logging.log(logName); const resource = { type: "global", };

12. Ajoutez du code pour écrire les journaux dans la fonction importCsv située juste en dessous de la ligne "console.log(Wrote ${records.length} records);" qui doit se présenter comme suit :

// A text log entry success_message = `Success: importTestData - Wrote ${records.length} records`; const entry = log.entry( { resource: resource }, { message: `${success_message}` } ); log.write([entry]);

Après ces mises à jour, le bloc de code de votre fonction importCsv devrait ressembler à ce qui suit :

async function importCsv(csvFilename) { const parser = csv.parse({ columns: true, delimiter: ',' }, async function (err, records) { if (err) { console.error('Error parsing CSV:', err); return; } try { console.log(`Call write to Firestore`); await writeToFirestore(records); // await writeToDatabase(records); console.log(`Wrote ${records.length} records`); // A text log entry success_message = `Success: importTestData - Wrote ${records.length} records`; const entry = log.entry( { resource: resource }, { message: `${success_message}` } ); log.write([entry]); } catch (e) { console.error(e); process.exit(1); } }); await fs.createReadStream(csvFilename).pipe(parser); }

Une fois le code d'application exécuté, la base de données Firestore sera mise à jour avec le contenu du fichier CSV. La fonction importCsv prend un nom de fichier et analyse le contenu ligne par ligne. Chaque ligne traitée est maintenant envoyée à la fonction writeToFirestore, où chaque nouvelle donnée est écrite dans la base de données "client".

Remarque : Dans un environnement de production, vous écrirez votre propre version du script d'importation.

Tâche 3 : Créer des données de test

Il est temps d'importer des données. Patrick contacte Ruby pour lui faire part de ses inquiétudes concernant l'utilisation de données réelles de clients pour son test...

Patrick, Administrateur informatique	Bonjour Ruby, Je pense qu'il serait préférable que nous n'utilisions pas les données client réelles pour les tests. Nous devons protéger la confidentialité de nos clients, mais nous devons également être sûrs du bon fonctionnement de notre script d'importation de données. Auriez-vous une autre solution à proposer ? Patrick
Ruby, Consultante en logiciels	Bonjour Patrick, Bien vu. C'est un sujet délicat, car les données client peuvent comporter des informations personnelles. Je vais vous envoyer un code de démarrage pour créer des pseudo-données client. Nous pourrons ensuite utiliser ces données pour tester le script d'importation. Ruby

Aidez Patrick à mettre en place ce générateur de données pseudo-aléatoires.

1. Tout d'abord, installez la bibliothèque "faker", qui sera utilisée par le script générant les fausses données client. Exécutez la commande suivante pour mettre à jour la dépendance dans le fichier package.json :

npm install faker@5.5.3

2. Ouvrez maintenant le fichier nommé createTestData.js à l'aide de l'éditeur de code et examinez le code. Assurez-vous qu'il ressemble à ce qui suit :

const fs = require('fs'); const faker = require('faker'); function getRandomCustomerEmail(firstName, lastName) { const provider = faker.internet.domainName(); const email = faker.internet.email(firstName, lastName, provider); return email.toLowerCase(); } async function createTestData(recordCount) { const fileName = `customers_${recordCount}.csv`; var f = fs.createWriteStream(fileName); f.write('id,name,email,phone\n') for (let i=0; i<recordCount; i++) { const id = faker.datatype.number(); const firstName = faker.name.firstName(); const lastName = faker.name.lastName(); const name = `${firstName} ${lastName}`; const email = getRandomCustomerEmail(firstName, lastName); const phone = faker.phone.phoneNumber(); f.write(`${id},${name},${email},${phone}\n`); } console.log(`Created file ${fileName} containing ${recordCount} records.`); } recordCount = parseInt(process.argv[2]); if (process.argv.length != 3 || recordCount < 1 || isNaN(recordCount)) { console.error('Include the number of test data records to create. Example:'); console.error(' node createTestData.js 100'); process.exit(1); } createTestData(recordCount);

3. Ajoutez Logging pour le codebase. Sur la troisième ligne, ajoutez la référence suivante pour le module de l'API Logging à partir du code d'application :

const { Logging } = require("@google-cloud/logging");

Le haut du fichier devrait maintenant se présenter comme suit :

const fs = require("fs"); const faker = require("faker"); const { Logging } = require("@google-cloud/logging"); //add this

4. Ajoutez maintenant quelques variables constantes et initialisez le client Logging. Ajoutez ces variables juste en dessous des instructions de const :

const logName = "pet-theory-logs-createTestData"; // Creates a Logging client const logging = new Logging(); const log = logging.log(logName); const resource = { // This example targets the "global" resource for simplicity type: "global", };

5. Ajoutez du code pour écrire les journaux dans la fonction createTestData située juste en dessous de la ligne "console.log(Created file ${fileName} containing ${recordCount} records.);" qui doit se présenter comme suit :

// A text log entry const success_message = `Success: createTestData - Created file ${fileName} containing ${recordCount} records.`; const entry = log.entry( { resource: resource }, { name: `${fileName}`, recordCount: `${recordCount}`, message: `${success_message}`, } ); log.write([entry]);

6. Après la mise à jour, le bloc de code de la fonction createTestData devrait ressembler à ce qui suit :

async function createTestData(recordCount) { const fileName = `customers_${recordCount}.csv`; var f = fs.createWriteStream(fileName); f.write('id,name,email,phone\n') for (let i=0; i<recordCount; i++) { const id = faker.datatype.number(); const firstName = faker.name.firstName(); const lastName = faker.name.lastName(); const name = `${firstName} ${lastName}`; const email = getRandomCustomerEmail(firstName, lastName); const phone = faker.phone.phoneNumber(); f.write(`${id},${name},${email},${phone}\n`); } console.log(`Created file ${fileName} containing ${recordCount} records.`); // A text log entry const success_message = `Success: createTestData - Created file ${fileName} containing ${recordCount} records.`; const entry = log.entry( { resource: resource }, { name: `${fileName}`, recordCount: `${recordCount}`, message: `${success_message}`, } ); log.write([entry]); }

7. Exécutez la commande suivante dans Cloud Shell pour créer le fichier customers_1000.csv, qui contiendra 1 000 enregistrements de données de test :

node createTestData 1000

Vous devez obtenir un résultat semblable à celui-ci :

Created file customers_1000.csv containing 1000 records.

8. Ouvrez le fichier customers_1000.csv et vérifiez que les données de test ont bien été créées.

Tester la tâche terminée

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à créer un échantillon de données de test pour la base de données Firestore, vous verrez une note d'évaluation s'afficher.

Créer des données de test pour la base de données Firestore

Tâche 4 : Importer des données client de test

1. Pour tester la capacité d'importation, utilisez le script d'importation et les données de test créées précédemment :

node importTestData customers_1000.csv

Vous devez obtenir un résultat semblable à celui-ci :

Writing record 500 Writing record 1000 Wrote 1000 records

2. Si vous obtenez une erreur du type :

Error: Cannot find module 'csv-parse'

Exécutez la commande suivante pour ajouter le package csv-parse à votre environnement :

npm install csv-parse

3. Puis, exécutez à nouveau la commande. Vous devez obtenir le résultat suivant :

Writing record 500 Writing record 1000 Wrote 1000 records

Dans les deux précédentes sections, vous avez vu comment Patrick et Ruby ont créé des données de test et un script pour importer des données dans Firestore. Patrick est maintenant plus à l'aise avec le chargement des données client dans la base de données Firestore.

Tester la tâche terminée

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à importer des échantillons de données de test dans la base de données Firestore, vous verrez un score d'évaluation s'afficher.

Importer des données de test dans la base de données Firestore

Tâche 5 : Examiner les données dans Firestore

Grâce à votre aide et à celle de Ruby, Patrick a maintenant réussi à migrer les données de test vers la base de données Firestore. Ouvrez Firestore et consultez les résultats.

1. Revenez à l'onglet de la console Cloud. Dans le menu de navigation, cliquez sur Firestore. Cliquez ensuite sur l'icône en forme de crayon.

2. Saisissez /customers et appuyez sur Entrée.

3. Actualisez l'onglet de votre navigateur et la liste suivante de clients ayant migré doit s'afficher :

Félicitations !

Dans cet atelier, vous avez reçu une formation pratique à l'utilisation de Firestore. Après avoir généré un ensemble de données client pour les tests, vous avez exécuté un script qui a importé les données dans Firestore. Vous avez ensuite appris à manipuler les données dans Firestore à l'aide de la console Cloud.

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 28 février 2024

Dernier test de l'atelier : 28 février 2024

Copyright 2024 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.