GSP642

Descripción general

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í:

Objetivos

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 introductorio. 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 tu 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 Cloud
   • El tiempo restante
   • Las credenciales temporales que debe usar para el lab
   • Otra información para completar el lab, si es necesaria

2. Haz clic en Abrir la consola de Google Cloud (o haz clic con el botón derecho y selecciona Abrir el vínculo en una ventana de incógnito si ejecutas el navegador Chrome).

   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 ves el diálogo Elegir una cuenta, haz clic en Usar otra cuenta.

3. De ser necesario, copia el nombre de usuario a continuación y pégalo en el diálogo Acceder.

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

   También puedes encontrar el nombre de usuario en el panel Detalles del lab.

4. Haz clic en Siguiente.

5. Copia la contraseña que aparece a continuación y pégala en el diálogo Te damos la bienvenida.

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

   También puedes encontrar la contraseña en el panel Detalles del lab.

6. Haz clic en Siguiente.

   Importante: Debes usar las credenciales que te proporciona el lab. No uses las credenciales de tu cuenta de Google Cloud. Nota: Usar tu propia Cuenta de Google podría generar cargos adicionales.

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

   • Acepta los Términos y Condiciones.
   • No agregues opciones de recuperación o autenticación de dos factores (esta es una cuenta temporal).
   • No te registres para obtener pruebas gratuitas.

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

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

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 al menú de navegación y selecciona Firestore.

2. Haz clic en +Crear base de datos.

3. Selecciona la opción Modo nativo y haz clic en Continuar.

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).

4. En el menú desplegable Región, selecciona 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": "^5.5.3" } }

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": "^7.3.0", "@google-cloud/logging": "^11.0.0", "csv-parse": "^5.5.3" }

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 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));

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 a través de 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 3 del archivo:

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

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

const csv = require('csv-parse'); const fs = require('fs'); 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 34 o después del condicional 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 }

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 recibe una referencia de documento según el identificador agregado. Al final de la función, el contenido del lote se confirma (escribe) en la base de datos.

9. 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 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. Agrega el registro 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 siguiente 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 csv = require('csv-parse'); const fs = require('fs'); const { Firestore } = require("@google-cloud/firestore"); const { Logging } = require('@google-cloud/logging');

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 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); }

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

8. 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

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.

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: 28 de febrero de 2024

Prueba más reciente del lab: 28 de febrero de 2024

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.