GSP642

Descripción general

Para los labs de la Quest Google Cloud Serverless Workshop: Pet Theory, leerás el caso de una empresa ficticia y ayudarás a los personajes a llevar a cabo su plan de migración sin servidores.

Hace doce años, Lily fundó la cadena de clínicas veterinarias Pet Theory. la cual se expandió rápidamente durante el último tiempo. Sin embargo, su viejo sistema de programación de citas no puede manejar el aumento de la carga. Por eso, Lily te pide que diseñes un sistema basado en la nube que se escale mejor que la solución heredada.

En el equipo de operaciones de Pet Theory trabaja una sola persona, Patrick, por lo que se necesita una solución que no requiera mucho mantenimiento continuo. El equipo decidió optar por la tecnología sin servidores.

Se contrató a Ruby como asesora para que ayude a Pet Theory a hacer la transición hacia un modelo sin servidores. Después de comparar opciones de bases de datos sin servidores, el equipo elige Cloud Firestore. Puesto que Firestore es una tecnología sin servidores, no es necesario aprovisionar capacidad por adelantado. Esto significa que no existe el riesgo de alcanzar límites de operaciones o almacenamiento. Firestore mantiene tus datos sincronizados en todas las aplicaciones de cliente a través de objetos de escucha en tiempo real. Además, ofrece soporte sin conexión destinado a aplicaciones web y para dispositivos móviles, de modo que se puede compilar una aplicación dinámica que funcione independientemente de la latencia de la red o de la conectividad a Internet.

En este lab, ayudarás a Patrick a subir los datos existentes de Pet Theory a una base de datos de Cloud Firestore. Patrick trabajará estrechamente con Ruby para completar esta tarea.

Arquitectura

En este diagrama, se muestra una descripción general de los servicios que usarás y la manera en que se conectan entre sí:

Qué aprenderás

En este lab, aprenderás a hacer lo siguiente:

• Configurar Firestore en Google Cloud
• Escribir código para importar bases de datos
• Generar una colección de datos de clientes para hacer pruebas
• Importar los datos de clientes de prueba a Firestore

Requisitos previos

Este es un lab de nivel básico, Lo que supone que el usuario tiene conocimientos previos sobre los entornos de shell y la consola de Cloud. Será útil tener experiencia en Firebase, pero no es obligatorio.

Además, debes sentirte cómodo editando archivos. Puedes usar tu editor de texto favorito (como nano, vi, etc.) o puedes iniciar el editor de código de Cloud Shell, que se encuentra en la cinta superior:

Cuando esté todo listo, desplázate hacia abajo y sigue los pasos que se muestran a continuación para configurar el entorno de tu lab.

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs son cronometrados y no se pueden pausar. El cronómetro, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador de Internet estándar (se recomienda el navegador Chrome)

Nota: Usa una ventana de navegador privada o de Incógnito para ejecutar este lab. Así evitarás cualquier conflicto entre tu cuenta personal y la cuenta de estudiante, lo que podría generar cargos adicionales en tu cuenta personal.

• Tiempo para completar el lab: Recuerda que, una vez que comienzas un lab, no puedes pausarlo.

Nota: Si ya tienes un proyecto o una cuenta personal de Google Cloud, no los uses en este lab para evitar cargos adicionales en tu cuenta.

Cómo iniciar su lab y acceder a la consola de Google Cloud

1. Haga clic en el botón Comenzar lab. Si debe pagar por el lab, se abrirá una ventana emergente para que seleccione su forma de pago. A la izquierda, se encuentra el panel Detalles del lab que tiene estos elementos:

   • El botón Abrir la consola de Google
   • Tiempo restante
   • Las credenciales temporales que debe usar para el lab
   • Otra información para completar el lab, si es necesaria

2. Haga clic en Abrir la consola de Google. El lab inicia recursos y abre otra pestaña en la que se muestra la página de acceso.

   Sugerencia: Ordene las pestañas en ventanas separadas, una junto a la otra.

   Nota: Si ve el diálogo Elegir una cuenta, haga clic en Usar otra cuenta.

3. Si es necesario, copie el nombre de usuario del panel Detalles del lab y péguelo en el cuadro de diálogo Acceder. Haga clic en Siguiente.

4. Copie la contraseña del panel Detalles del lab y péguela en el cuadro de diálogo de bienvenida. Haga clic en Siguiente.

   Importante: Debe usar las credenciales del panel de la izquierda. No use sus credenciales de Google Cloud Skills Boost. Nota: Usar su propia Cuenta de Google podría generar cargos adicionales.

5. Haga clic para avanzar por las páginas siguientes:

   • Acepte los términos y condiciones.
   • No agregue opciones de recuperación o autenticación de dos factores (esta es una cuenta temporal).
   • No se registre para obtener pruebas gratuitas.

Después de un momento, se abrirá la consola de Cloud en esta pestaña.

Nota: Para ver el menú con una lista de los productos y servicios de Google Cloud, haga clic en el Menú de navegación que se encuentra en la parte superior izquierda de la pantalla.

Activa Cloud Shell

Cloud Shell es una máquina virtual que cuenta con herramientas para desarrolladores. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud. Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

1. Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.

Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu PROJECT_ID. El resultado contiene una línea que declara el PROJECT_ID para esta sesión:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con la función de autocompletado con tabulador.

2. Puedes solicitar el nombre de la cuenta activa con este comando (opcional):

gcloud auth list

3. Haz clic en Autorizar.

4. Ahora, el resultado debería verse de la siguiente manera:

Resultado:

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

5. Puedes solicitar el ID del proyecto con este comando (opcional):

gcloud config list project

Resultado:

[core] project = <project_ID>

Resultado de ejemplo:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: Para obtener toda la documentación de gcloud, consulta la guía con la descripción general de gcloud CLI en Google Cloud.

Tarea 1: Configura Firestore en Google Cloud

La tarea de Patrick es subir los datos existentes de Pet Theory a una base de datos de Cloud Firestore. Patrick trabajará estrechamente con Ruby para lograr este objetivo. Ruby recibe un mensaje de Patrick, de TI…

Patrick, administrador de TI	Hola Ruby: El primer paso que debemos dar para adoptar la tecnología sin servidores es crear una base de datos de Firestore con Google Cloud. ¿Puedes ayudarme con esta tarea? No sé muy bien cómo hacerlo. Patrick
Ruby, asesora de software	Hola, Patrick Por supuesto. Será un placer ayudarte. Te enviaré algunos recursos para comenzar. Avísame cuando termines de crear la base de datos. Ruby

Ayuda a Patrick a configurar una base de datos de Firestore a través de la consola de Cloud.

1. En la consola de Cloud, dirígete a Menú de navegación y selecciona Firestore.

2. Haz clic en el botón Seleccionar modo nativo.

Nota: Ambos modos son de alto rendimiento y ofrecen coherencia sólida, pero lucen diferentes y están optimizados para casos de uso distintos.

• El modo nativo permite que muchos usuarios accedan a los mismos datos al mismo tiempo (además, tiene funciones como actualizaciones en tiempo real y conexión directa entre tu base de datos y un cliente web o móvil).
• El modo Datastore pone énfasis en la alta capacidad de procesamiento (muchas lecturas y escrituras).

3. En el menú desplegable Seleccionar una ubicación, selecciona la región y, luego, haz clic en Crear base de datos.

Cuando termina la tarea, Ruby le envía un correo electrónico a Patrick…

Ruby, asesora de software	Hola, Patrick Configuraste muy bien la base de datos de Firestore. Para administrar el acceso a esta, usaremos una cuenta de servicio que se creó automáticamente con los privilegios necesarios. Ya estamos listos para hacer la migración de la base de datos vieja a Firestore. Ruby
Patrick, administrador de TI	Hola, Ruby Gracias por ayudarme. Configurar la base de datos de Firestore fue sencillo. Espero que el proceso de importar la base de datos sea más fácil que el de la base de datos heredada, que es bastante complejo y requiere muchos pasos. Patrick

Tarea 2: Escribe código para importar la base de datos

La nueva base de datos de Cloud Firestore está lista pero vacía. Los datos de clientes de Pet Theory todavía existen solo en la base de datos vieja.

Patrick le envía un mensaje a Ruby…

Patrick, administrador de TI	Hola, Ruby Mi gerente desea comenzar a migrar datos de clientes a la nueva base de datos de Firestore. Exporté un archivo CSV de nuestra base de datos heredada, pero no sé bien cómo importar estos datos a Firestore. ¿Hay alguna posibilidad de que me ayudes? Patrick
Ruby, asesora de software	Hola, Patrick Por supuesto. Programemos una reunión para analizar los pasos que debemos dar. Ruby

Tal como mencionó Patrick, los datos de clientes estarán disponibles en un archivo CSV. Ayuda a Patrick a crear una aplicación que lea los registros de clientes de un archivo CSV y los escriba en Firestore. Puesto que Patrick está familiarizado con JavaScript, compila esta aplicación con Node.js, el entorno de ejecución de JavaScript.

1. En Cloud Shell, ejecuta el siguiente comando para clonar el repositorio de Pet Theory:

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

2. Usa el editor de código de Cloud Shell (o tu editor preferido) para editar tus archivos. En la cinta superior de la sesión de Cloud Shell, haz clic en Abrir editor, el cual se abrirá en una pestaña nueva. Si se te solicita, haz clic en Abrir en una ventana nueva para iniciar el editor de código.

3. Luego, cambia tu directorio de trabajo actual a lab01:

cd pet-theory/lab01

En el directorio, puedes ver el archivo package.json de Patrick. Este archivo muestra los paquetes de los que depende tu proyecto de Node.js y hace que tu compilación se pueda reproducir, por lo que será más fácil compartirla con otros.

A continuación, se muestra un archivo package.json de ejemplo:

{ "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": "^4.4.5" } }

Ahora que Patrick ya importó su código fuente, se contacta con Ruby para saber qué paquetes necesita para que la migración funcione.

Patrick, administrador de TI	Hola, Ruby El código que usaste para la base de datos heredada es bastante básico: solo crea un archivo CSV listo para el proceso de importación. ¿Necesito descargar algo antes de comenzar? Patrick
Ruby, asesora de software	Hola, Patrick Te sugiero que uses uno de los muchos paquetes de Node de @google-cloud para interactuar con Firestore. En ese caso, solo tendríamos que modificar un poco el código existente, puesto que ya se hizo el trabajo pesado. Ruby

Para permitir que el código de Patrick escriba en la base de datos de Firestore, debes instalar algunas dependencias de par adicionales.

4. Para ello, ejecuta el comando siguiente:

npm install @google-cloud/firestore

5. Para permitir que la aplicación escriba registros en Cloud Logging, instala un módulo adicional:

npm install @google-cloud/logging

Cuando el comando se complete correctamente, el archivo package.json se actualizará automáticamente para incluir las nuevas dependencias de par y se verá de esta forma.

... "dependencies": { "@google-cloud/firestore": "^6.4.1", "@google-cloud/logging": "^10.3.1", "csv-parse": "^4.4.5" }

Ahora, es el momento de observar la secuencia de comandos que lee el archivo CSV de los clientes y escribe un registro en Firestore por cada línea del archivo. A continuación, se muestra la aplicación original de Patrick:

const { promisify } = require("util"); const parse = promisify(require("csv-parse")); const { readFile } = require("fs").promises; if (process.argv.length < 3) { console.error("Please include a path to a csv file"); process.exit(1); } 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 fileContents = await readFile(csvFileName, "utf8"); const records = await parse(fileContents, { columns: true }); try { await writeToDatabase(records); } catch (e) { console.error(e); process.exit(1); } console.log(`Wrote ${records.length} records`); } importCsv(process.argv[2]).catch((e) => console.error(e));

La aplicación toma la salida del archivo CSV de entrada y la importa a la base de datos heredada. A continuación, actualiza este código para escribir en Firestore.

6. Abre el archivo pet-theory/lab01/importTestData.js.

Para hacer referencia a la API de Firestore mediante la aplicación, debes agregar la dependencia de par a la base de código existente.

7. Agrega la siguiente dependencia de Firestore en la línea 4 del archivo:

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

Asegúrate de que la parte superior del archivo sea así:

const { promisify } = require("util"); const parse = promisify(require("csv-parse")); const { readFile } = require("fs").promises; const { Firestore } = require("@google-cloud/firestore"); // add this

La integración con la base de datos de Firestore se puede realizar con algunas líneas de código. Ruby compartió contigo y con Patrick algunos códigos de plantilla justamente con ese fin.

8. Agrega el siguiente código debajo de la línea 9 o el condicional if (process.argv.length < 3):

const db = new Firestore(); function writeToFirestore(records) { const batchCommits = []; let batch = db.batch(); records.forEach((record, i) => { var docRef = db.collection("customers").doc(record.email); batch.set(docRef, record); if ((i + 1) % 500 === 0) { console.log(`Writing record ${i + 1}`); batchCommits.push(batch.commit()); batch = db.batch(); } }); batchCommits.push(batch.commit()); return Promise.all(batchCommits); }

El fragmento de código anterior declara un nuevo objeto de base de datos, que hace referencia a la base de datos que creaste antes en este lab. La función usa un procesamiento por lotes en el que cada registro se procesa de a uno y configura una referencia al documento según el identificador agregado. Al final de la función, el contenido del lote se escribe en la base de datos.

9. Finalmente, debes agregar una llamada a la nueva función. Actualiza la función importCsv para agregar la llamada a función a writeToFirestore y quitar la llamada a writeToDatabase. Se verá de la siguiente manera:

async function importCsv(csvFileName) { const fileContents = await readFile(csvFileName, "utf8"); const records = await parse(fileContents, { columns: true }); try { await writeToFirestore(records); // await writeToDatabase(records); } catch (e) { console.error(e); process.exit(1); } console.log(`Wrote ${records.length} records`); }

10. A continuación, agrega registros para la aplicación. Para hacer referencia a la API de Logging a través de la aplicación, agrega la dependencia de par a la base de código existente. Agrega la línea justo debajo de las otras sentencias en la parte superior del archivo:

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

Asegúrate de que la parte superior del archivo sea así:

const { promisify } = require("util"); const parse = promisify(require("csv-parse")); const { readFile } = require("fs").promises; const { Firestore } = require("@google-cloud/firestore"); const { Logging } = require("@google-cloud/logging"); //add this

11. Agrega algunas variables constantes y, luego, inicializa el cliente de Logging. Agrégalas justo debajo de las líneas anteriores en el archivo (línea 5 aprox.), de la siguiente manera:

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

12. Agrega código para escribir los registros en la función importCsv justo debajo de la línea "console.log(Wrote ${records.length} records);", que debería verse de la siguiente manera:

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

Después de estas actualizaciones, tu bloque de código de la función importCsv debería verse de la siguiente manera:

async function importCsv(csvFileName) { const fileContents = await readFile(csvFileName, "utf8"); const records = await parse(fileContents, { columns: true }); try { await writeToFirestore(records); //await writeToDatabase(records); } catch (e) { console.error(e); process.exit(1); } 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]); }

Ahora, cuando se ejecute el código de la aplicación, la base de datos de Firestore se actualizará con el contenido del archivo CSV. La función importCsv toma un nombre de archivo y analiza el contenido línea por línea. Cada línea procesada se envía ahora a la función de Firestore writeToFirestore, donde cada nuevo registro se escribe en la base de datos de "clientes".

Nota: En un entorno de producción, escribirás tu propia versión de la secuencia de comandos de importación.

Tarea 3: Crea datos de prueba

Es hora de importar algunos datos. Patrick contacta a Ruby porque tiene una duda sobre cómo ejecutar una prueba con datos de clientes reales…

Patrick, administrador de TI	Hola, Ruby Creo que lo mejor sería no usar datos de clientes para hacer las pruebas. Debemos proteger la privacidad de los clientes, pero también debemos tener certeza de que la secuencia de comandos de importación de datos funciona correctamente. ¿Se te ocurre otra forma de hacer las pruebas? Patrick
Ruby, asesora de software	Hola, Patrick Es un buen punto. Es una situación delicada, ya que los datos de clientes pueden incluir información de identificación personal, o PII. Compartiré algunos códigos de inicio contigo para crear datos de clientes ficticios. Luego, podemos usar esos datos para probar la secuencia de comandos de importación. Ruby

Ayuda a Patrick a poner en marcha este generador de datos pseudoaleatorio.

1. Primero, instala la biblioteca "faker". La secuencia de comandos que genera los datos de clientes falsos usará esa biblioteca. Ejecuta el siguiente comando para actualizar la dependencia en package.json:

npm install faker@5.5.3

2. Ahora, abre el archivo llamado createTestData.js con el editor de código y analiza el código. Asegúrate de que se vea de la siguiente manera:

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. Agrega Logging para la base de código. En la línea 3, agrega la siguiente referencia para el módulo de la API de Logging desde el código de la aplicación:

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

La parte superior del archivo debería verse de este modo:

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

4. Ahora, agrega algunas variables constantes y, luego, inicializa el cliente de Logging. Agrégalas justo debajo de las sentencias 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. Agrega código para escribir los registros en la función createTestData justo debajo de la línea "console.log(Created file ${fileName} containing ${recordCount} records.);", que se verá de la siguiente manera:

// 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. Después de actualizar, el bloque de código de la función createTestData debería verse así:

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. Ejecuta el siguiente comando para configurar tu ID de proyecto en Cloud Shell; reemplaza PROJECT_ID por el ID de tu proyecto de Qwiklabs:

gcloud config set project PROJECT_ID

8. Ahora, establece el ID del proyecto como una variable de entorno:

PROJECT_ID=$(gcloud config get-value project)

9. Ejecuta el siguiente comando en Cloud Shell para crear el archivo customers_1000.csv, que incluirá 1,000 registros de datos de prueba:

node createTestData 1000

Deberías obtener un resultado similar al siguiente:

Created file customers_1000.csv containing 1000 records.

10. Abre el archivo customers_1000.csv y verifica que se hayan creado los datos de prueba.

Prueba la tarea completada

Haz clic en Revisar mi progreso para verificar la tarea realizada. Si creaste correctamente datos de prueba de muestra para la base de datos de Firestore, verás una puntuación de evaluación.

Crear datos de prueba para la base de datos de Firestore

Tarea 4: Importa datos de clientes de prueba

1. Para probar la capacidad de importación, usa la secuencia de comandos de importación y los datos de prueba que creaste antes:

node importTestData customers_1000.csv

Deberías obtener un resultado similar al siguiente:

Writing record 500 Writing record 1000 Wrote 1000 records

2. Observa si obtienes un error similar al siguiente:

Error: Cannot find module 'csv-parse'

De ser así, ejecuta el siguiente comando para agregar el paquete csv-parse a tu entorno:

npm install csv-parse

3. Luego, vuelve a ejecutar el comando. Deberías recibir el resultado siguiente:

Writing record 500 Writing record 1000 Wrote 1000 records

4. En este momento, si tienes ganas de aventurarte, puedes crear un archivo de datos de prueba más grande y también importarlo a la base de datos de Firestore:

node createTestData 20000 node importTestData customers_20000.csv

Deberías obtener un resultado similar al siguiente:

Writing record 500 Writing record 1000 .. .. Writing record 15000 Writing record 15500 Writing record 16000 Writing record 16500 Writing record 17000 Writing record 17500 Writing record 18000 Writing record 18500 Writing record 19000 Writing record 19500 Writing record 20000 Wrote 20000 records

En las secciones anteriores, viste cómo Patrick y Ruby crearon datos de prueba y una secuencia de comandos para importar datos a Firestore. Ahora, Patrick se siente más confiado en cuanto a la carga de datos de cliente en la base de datos de Firestore.

Prueba la tarea completada

Haz clic en Revisar mi progreso para verificar la tarea realizada. Si importaste correctamente datos de prueba de muestra a la base de datos de Firestore, verás una puntuación de evaluación.

Importar datos de prueba a la base de datos de Firestore

Tarea 5: Inspecciona los datos en Firestore

Con un poco de ayuda de ti y de Ruby, Patrick migró correctamente los datos de prueba a la base de datos de Firestore. Abre Firestore y observa los resultados.

1. Vuelve a la pestaña de la consola de Cloud. En Menú de navegación, haz clic en Firestore. Una vez allí, haz clic en el ícono de lápiz.

2. Escribe /customers y presiona Intro.

3. Actualiza la pestaña de tu navegador. Deberías ver que la siguiente lista de clientes se migró correctamente:

¡Felicitaciones!

En este lab, adquiriste experiencia práctica en Firestore. Después de generar una colección de datos de clientes para hacer pruebas, ejecutaste una secuencia de comandos que importó los datos a Firestore. Luego, aprendiste a manipular datos en Firestore desde la consola de Cloud.

Finaliza la Quest

Este lab de autoaprendizaje forma parte de las Quests Google Cloud Run Serverless Workshop y Build Apps & Website with Firebase. Una Quest es una serie de labs relacionados que forman una ruta de aprendizaje. Si completas una Quest, obtendrás una insignia como reconocimiento por tu logro. Puedes hacer públicas tus insignias y agregar vínculos a ellas en tu currículum en línea o en tus cuentas de redes sociales. Inscríbete en cualquier Quest que contenga este lab y obtén un crédito inmediato de finalización. Consulta el catálogo de Google Cloud Skills Boost para ver todas las Quests disponibles.

Realiza tu próximo lab

Continúa tu Quest con el siguiente lab de la serie, Compila una aplicación web sin servidores con Firebase.

Capacitación y certificación de Google Cloud

Recibe la formación que necesitas para aprovechar al máximo las tecnologías de Google Cloud. Nuestras clases incluyen habilidades técnicas y recomendaciones para ayudarte a avanzar rápidamente y a seguir aprendiendo. Para que puedas realizar nuestros cursos cuando más te convenga, ofrecemos distintos tipos de capacitación de nivel básico a avanzado: a pedido, presenciales y virtuales. Las certificaciones te ayudan a validar y demostrar tus habilidades y tu conocimiento técnico respecto a las tecnologías de Google Cloud.

Última actualización del manual: 5 de diciembre de 2023

Prueba más reciente del lab: 5 de diciembre de 2023

Copyright 2024 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.