GSP702

Descripción general

Go es un lenguaje de programación de código abierto de Google que facilita la creación de software rápido, confiable y eficiente a gran escala. En este lab, explorarás los conceptos básicos de Go por medio de la implementación de una app simple de Go en Cloud Run Functions y App Engine. Luego, usarás la app de Go para acceder a datos en BigQuery y Firestore.

Actividades

En este lab, realizarás las siguientes tareas:

• Configurar tu base de datos de Firestore e importar datos
• Acceder a una introducción sobre la potencia de Cloud Build
• Explorar datos en BigQuery y Firestore
• Implementar una app de Go en App Engine y Cloud Run Functions
• Examinar el código de la app de Go
• Probar la app en cada una de las plataformas

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs cuentan con un temporizador que no se puede pausar. El temporizador, 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 del navegador privada o de incógnito (opción recomendada) para ejecutar el lab. Así evitarás conflictos 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: Usa solo la cuenta de estudiante para este lab. Si usas otra cuenta de Google Cloud, es posible que se apliquen cargos a esa cuenta.

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

1. Haz clic en el botón Comenzar lab. Si debes pagar por el lab, se abrirá un diálogo para que selecciones la forma de pago. A la izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón para abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debes 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: Ordena 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 Cloud para este lab podría generar cargos adicionales.

7. Haz 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 acceder a los productos y servicios de Google Cloud, haz clic en el menú de navegación o escribe el nombre del servicio o producto en el campo Buscar.

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.

2. Haz clic para avanzar por las siguientes ventanas:

   • Continúa en la ventana de información de Cloud Shell.
   • Autoriza a Cloud Shell para que use tus credenciales para realizar llamadas a la API 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 {{{project_0.project_id | "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.

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

gcloud auth list

4. Haz clic en Autorizar.

Resultado:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} 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_0.project_id | "PROJECT_ID"}}} Nota: Para obtener toda la documentación de gcloud, en Google Cloud, consulta la guía con la descripción general de gcloud CLI.

¿Qué es Go?

Go (golang) es un lenguaje de uso general diseñado para la programación de sistemas, en el que se aplican tipos estrictos de datos y recolección de elementos no utilizados. Además, cuenta con asistencia de primera clase para la programación simultánea. Los programas se crean a partir de paquetes, que incluyen propiedades que permiten una administración eficiente de las dependencias.

A diferencia de Python y JavaScript, Go es un lenguaje compilado, no interpretado. El código fuente de Go se compila en código máquina antes de la ejecución. Como resultado, Go suele ser más rápido y eficiente que los lenguajes interpretados, y no requiere ningún entorno de ejecución instalado, como Node, Python o JDK, para ejecutarse.

Plataformas sin servidores

La computación sin servidores permite que los desarrolladores se enfoquen en escribir código sin tener que preocuparse por la infraestructura. Además, ofrece una serie de beneficios sobre la computación tradicional; por ejemplo, no se requiere la administración de servidores ni el aprovisionamiento por adelantado, la escala se ajusta automáticamente y pagas solo por los recursos que usas. Estas ventajas logran que la computación sin servidores sea ideal para casos de usos como aplicaciones HTTP sin estado, backends web, móviles y de IoT, procesamiento de datos por lotes y transmisión, chatbots y mucho más.

Go es perfecto para aplicaciones en la nube por su eficiencia, portabilidad y facilidad de aprendizaje. En este lab, se muestra cómo usar Cloud Build para implementar una app de Go en Cloud Run Functions y App Engine, todas las plataformas sin servidores de Google:

• Cloud Run Functions
• App Engine

Nota: Consulta Opciones sin servidores para obtener información acerca de qué plataforma sin servidores se adapta mejor a tus necesidades.

Cloud Build

Cloud Build es un servicio que ejecuta tus compilaciones en la infraestructura de Google Cloud. Cloud Build puede importar código fuente de Cloud Storage, GitHub o Bitbucket, ejecutar una compilación según tus especificaciones y producir artefactos como contenedores de Docker.

Además, ejecuta la compilación como una serie de pasos que se ejecutan en un contenedor de Docker. Un paso de compilación puede hacer lo mismo que un contenedor, independientemente del entorno. Para obtener más información, consulta la documentación de Cloud Build.

Cloud Run Functions

Cloud Run Functions es la plataforma de computación sin servidores controlada por eventos de Google Cloud. Debido a que Go se compila en código máquina binario, no tiene frameworks dependientes para iniciar y no requiere un intérprete. El tiempo de inicio en frío de Go es de entre 80 ms y 1,400 ms. Eso significa que las aplicaciones y los servicios pueden permanecer inactivos sin costo alguno y, luego, iniciarse y comenzar a entregar tráfico en frío en 1,400 ms o menos. Después de ese primer inicio, la función entrega tráfico al instante. Este factor por sí solo hace que Go sea un lenguaje ideal para una implementación de Cloud Run Functions.

Arquitectura

Cuando implementas Google Cloud Data Drive, tu app de muestra de Go, en Cloud Run Functions, la arquitectura de flujo de datos se ve de la siguiente manera:

App Engine

El entorno estándar de App Engine se basa en instancias de contenedores que se ejecutan en la infraestructura de Google. Los contenedores se configuran previamente con uno de los tantos entornos de ejecución disponibles.

Arquitectura

Cuando implementas Google Cloud Data Drive, tu app de ejemplo de Go, en App Engine, la arquitectura de flujo de datos se ve de la siguiente manera:

Código fuente de Google Cloud Data Drive

En este lab, implementarás una app sencilla llamada Google Cloud Data Drive. Google desarrolló esta app de código abierto para extraer datos de Google Cloud con rapidez. La app de Google Cloud Data Drive forma parte de una serie de herramientas que demuestran patrones de uso eficaces para usar las APIs y los servicios de Cloud.

La app de Google Cloud Data Drive de Go expone una ruta de URL simple y componible para recuperar datos en formato JSON de plataformas de datos de Google Cloud compatibles. Actualmente, la aplicación admite BigQuery y Firestore, pero tiene un diseño modular que puede admitir cualquier cantidad de fuentes de datos.

Estos patrones de URL HTTP se usan para obtener datos de Google Cloud ejecutando Google Cloud Data Drive.

• Firestore : [SERVICE_URL]/fs/[PROJECT_ID]/[COLLECTION]/[DOCUMENT]

• BigQuery: [SERVICE_URL]/bq/[PROJECT_ID]/[DATASET]/[TABLE]

En el ejemplo anterior, se ilustra lo siguiente:

Parámetro	Descripción
[SERVICE URL]	La URL base de la aplicación de App Engine o Cloud Run Functions. En App Engine, se verá como https://[PROJECT ID].appspot.com/.
[PROJECT ID]	El ID del proyecto de la colección de Firestore o el conjunto de datos de BigQuery al que quieres acceder. Encontrarás el ID del proyecto en el panel izquierdo del lab.
[COLLECTION]	El ID de la colección de Firestore (symbols/product)
[DOCUMENT]	El documento de Firestore que te gustaría devolver (symbol)
[DATASET]	El nombre del conjunto de datos de BigQuery (publicviews)
[TABLE]	El nombre de la tabla de BigQuery (ca_zip_codes)

Nota: Aunque en este lab se usa curl para probar la app, puedes crear las URLs por tu cuenta para realizar más pruebas funcionales en un navegador.

Tarea 1: configura el entorno

1. En Cloud Shell, ingresa el siguiente comando para crear una variable de entorno que almacene el ID del proyecto que usarás más adelante en este lab:

gcloud config set compute/region {{{ project_0.default_region | "filled in at lab startup." }}} export REGION=$(gcloud config get compute/region) export PROJECT_ID=$(gcloud info --format="value(config.project)")

2. Para obtener el código de muestra de este lab, cópialo de Google Cloud Storage (GCS):

mkdir DIY-Tools gsutil cp -R gs://spls/gsp702/DIY-Tools/* DIY-Tools/

Prepara tus bases de datos

En este lab, se usan datos de muestra en BigQuery y Firestore para probar tu app de Go.

Base de datos de BigQuery

BigQuery es un almacén de datos sin servidores y preparado para el futuro, que incluye numerosas funciones relacionadas con el aprendizaje automático, la partición de datos y la segmentación. Esto te permite analizar gigabytes y petabytes de datos a gran velocidad y sin sobrecarga operativa con ANSI SQL.

El conjunto de datos de BigQuery es una vista de los códigos postales de California y se creó para ti cuando comenzó el lab.

Base de datos de Firestore

Firestore es una base de datos de documentos sin servidores con funciones de búsqueda muy rápida de documentos y de eventos en tiempo real. También puede brindar un ANS del 99.999%. Para usar datos en Firestore y probar tu app, debes inicializar Firestore en modo nativo y, luego, importar los datos de muestra.

Se creó una instancia de base de datos en modo nativo de Firestore.

1. En la consola de Cloud, haz clic en Menú de navegación > Firestore para abrir Firestore en la consola.

Espera a que se inicialice la instancia de la base de datos de Firestore. Este proceso también inicializa App Engine en la misma región, lo que te permite implementar la aplicación en App Engine sin tener que crear primero una instancia de App Engine.

2. En Cloud Shell, inicia un trabajo de importación de Firestore que proporcione datos de muestra de Firestore para el lab:

gcloud firestore import gs://$PROJECT_ID-firestore/prd-back

Este trabajo de importación carga una copia de seguridad de Cloud Firestore de una colección llamada symbols en el bucket de almacenamiento $PROJECT_ID-firestore.

Este trabajo de importación tarda hasta 5 minutos en completarse. Puedes empezar la siguiente sección mientras esperas.

Verificar la implementación de la base de datos de Firestore

Configura los permisos para Cloud Build

Cloud Build es un servicio que ejecuta tus compilaciones en la infraestructura de Google Cloud. De forma predeterminada, Cloud Build no tiene los permisos suficientes para implementar aplicaciones en

• App Engine
• Cloud Run Functions

Debes habilitar esos servicios antes de usar Cloud Build para implementar la app de Google Cloud Data Drive.

1. En la consola, haz clic en Menú de navegación > Cloud Build > Configuración.
2. Establece el Estado de Cloud Functions en Habilitar.

3. Cuando se te solicite, haz clic en Grant access to All Service Accounts.
4. Establece el Estado de Cloud Run en Habilitar.
5. Configura el Estado de App Engine como Habilitar.

Tarea 2: realiza la implementación en Cloud Run Functions

Cloud Run Functions es la plataforma de computación sin servidores controlada por eventos de Google Cloud. Cuando combinas Go y Cloud Run Functions, obtienes lo mejor que tiene para ofrecer la tecnología sin servidores en cuanto a tiempos de inicio rápidos y escala infinita, por lo que tu aplicación puede tener los mejores tiempos de respuesta basados en eventos.

Revisa el código fuente y descubre cómo reutilizar el código fuente de Google Cloud Data Drive en una función de Cloud Run.

Revisa la función main

1. Al inicio de la función main en DIY-Tools/gcp-data-drive/cmd/webserver/main.go, le indicas al servidor web que envíe todas las solicitudes HTTP a la función gcpdatadrive.GetJSONData de Go.

func main() { // Register the initial HTTP handler. http.HandleFunc("/", gcpdatadrive.GetJSONData) port := os.Getenv("PORT") ...

2. Consulta la función main en main.go en GitHub.

En una función de Cloud Run, no se usa main.go. En cambio, el entorno de ejecución de la función de Cloud Run se configura para enviar solicitudes HTTP directamente a la función gcpdatadrive.GetJSONData de Go que se define en el archivo DIY-Tools/gcp-data-drive/gcpdatadrive.go.

3. Para ver cómo se hace, observa que, en la implementación de la aplicación de Google Cloud Data Drive en Cloud Run Functions, se usan Cloud Build y cloudbuild_gcf.yaml:

Nota: Se quitaron los comentarios para mayor claridad.

4. Consulta el archivo cloudbuild_gcf.yaml en GitHub.

Estos pasos de Cloud Build también son similares a los que se usan para implementar la aplicación en Cloud Run, pero en este caso, implementas la aplicación en Cloud Run Functions usando el comando gcloud functions deploy.

Ten en cuenta que el parámetro --entrypoint de Cloud Run Functions se usa para especificar la función GetJSONData y no la función main en el paquete principal de Go que se usa cuando se implementa en App Engine o Cloud Run.

Implementa la app de Google Cloud Data Drive

1. En Cloud Shell, cambia al directorio de la aplicación que clonaste desde GitHub:

cd ~/DIY-Tools/gcp-data-drive

2. Ingresa el comando incluido a continuación para recuperar los detalles del proyecto y otorgar el permiso pubsub.publisher a la cuenta de servicio.

PROJECT_ID=$(gcloud config get-value project) PROJECT_NUMBER=$(gcloud projects list --filter="project_id:$PROJECT_ID" --format='value(project_number)') SERVICE_ACCOUNT=$(gcloud storage service-agent --project=$PROJECT_ID) gcloud projects add-iam-policy-binding $PROJECT_ID \ --member serviceAccount:$SERVICE_ACCOUNT \ --role roles/pubsub.publisher

3. Implementa la app de Google Cloud Data Drive en Cloud Run Functions con Cloud Build:

gcloud builds submit --config cloudbuild_gcf.yaml --project $PROJECT_ID --no-source --substitutions=_GIT_SOURCE_BRANCH="master",_GIT_SOURCE_URL="https://github.com/GoogleCloudPlatform/DIY-Tools",_GCP_REGION="{{{project_0.default_region}}}" Nota: Si recibes un error de permiso 403, espera un minuto y vuelve a ejecutar el comando de compilación. Por lo general, los permisos de la cuenta de servicio tardan un par de minutos en propagarse.

4. Ingresa el siguiente comando para otorgar acceso no autorizado a la función de Cloud Run de Google Cloud Data Drive:

gcloud alpha functions add-iam-policy-binding gcp-data-drive --member=allUsers --role=roles/cloudfunctions.invoker

Si se te pregunta “Would you like to run this command and additionally grant [allUsers] permission to invoke function [gcp-data-drive] (Y/n)?”, ingresa Y.

5. Almacena la URL del activador HTTP de Cloud Run Functions en una variable de entorno:

export CF_TRIGGER_URL=$(gcloud functions describe gcp-data-drive --format="value(url)")

6. Usa curl para llamar a la aplicación y consultar datos de la colección symbols de Firestore en tu proyecto:

curl $CF_TRIGGER_URL/fs/$PROJECT_ID/symbols/product/symbol | jq .

Esto responde con el contenido de un archivo JSON que contiene los valores de la colección symbols en tu proyecto.

[ { "asin": "", "brand": "", "category": "", "docid": "914600502073", "fbafees": 0, "lastMatchLookup": "0001-01-01T00:00:00Z", "listPrice": 0, "manufacturer": "", "pkgquantity": 0, "salesrank": 0, "smallImage": "", "title": "", "upc": "914600502073" }, { "asin": "0744018307", "bbw": true, "brand": "", "category": "book_display_on_website", "cpip": 2000, "docid": "9780744018301", "fba": false, "fbafees": 722, "inStock": "NOW", "lastMatchLookup": "2020-03-13T14:00:10.209183Z", "lastOfferLookup": "2020-03-13T14:00:13.670858Z", "listPrice": 3999, "manufacturer": "Prima Games", "pkgquantity": 0, "salesrank": 337073, "sfbc": 0, "sfbr": 0, "smallImage": "http://ecx.images-amazon.com/images/I/51NFIAHRfTL._SL75_.jpg", "title": "Wolfenstein II: The New Colossus: Prima Collector's Edition Guide", "upc": "9780744018301" } ]

7. Usa curl para llamar a la aplicación y consultar datos de la tabla publicviews.ca_zip_codes de BigQuery en tu proyecto del lab:

curl $CF_TRIGGER_URL/bq/$PROJECT_ID/publicviews/ca_zip_codes

Esto responde con el contenido de un archivo JSON que contiene los resultados de la sentencia de SQL SELECT * FROM publicviews.ca_zip_codes; de BigQuery.

[ { "Zipcode": "96090", "area_land_miles": 1.027, "state_code": "CA" }, { "Zipcode": "94929", "area_land_miles": 1.062, "state_code": "CA" } ] Verifica la implementación de la aplicación de Cloud Run Functions

Tarea 3: activadores adicionales de Cloud Run Functions

Cloud Run Functions tiene una arquitectura basada en eventos. La app que implementaste usa una solicitud HTTP como un evento. Explora el código de otra app de Go que reciba un tipo de evento diferente. La función se activa con un evento de escritura de Firestore.

El código fuente de Go que se muestra a continuación se adaptó de la guía de muestra de código de Go:

package mygopackage import ( "context" "fmt" "log" "time" "cloud.google.com/go/functions/metadata" ) // FirestoreEvent is the payload of a Firestore event. type FirestoreEvent struct { OldValue FirestoreValue `json:"oldValue"` Value FirestoreValue `json:"value"` UpdateMask struct { FieldPaths []string `json:"fieldPaths"` } `json:"updateMask"` } // FirestoreValue holds Firestore fields. type FirestoreValue struct { CreateTime time.Time `json:"createTime"` Fields interface{} `json:"fields"` Name string `json:"name"` UpdateTime time.Time `json:"updateTime"` } // DoSomeThingOnWrite is triggered by // a change to a Firestore document. func DoSomeThingOnWrite(ctx context.Context, e FirestoreEvent) error { meta, err := metadata.FromContext(ctx) if err != nil { return fmt.Errorf("metadata.FromContext: %v", err) } // The variables e and meta contain // the information from the event // so now we can Go do some logic // work with the data. In this case // we are simply writing it to the log. log.Printf("Function triggered by change to: %v", meta.Resource) log.Printf("Old value: %+v", e.OldValue) log.Printf("New value: %+v", e.Value) return nil }

Consulta el código fuente de ejemplo en GitHub.

Este ejemplo contiene código que se puede usar para implementar Cloud Run Functions que controlan eventos de Firestore, en lugar del activador de solicitudes HTTP que se usa en la aplicación de ejemplo del lab. Registras esta función con un activador de eventos de Cloud Firestore usando DoSomeThingOnWrite como el punto de entrada de Cloud Run Functions.

Cloud Run Functions actualmente admite los activadores de eventos incluidos a continuación.

El ejemplo anterior es un caso sencillo, pero puedes imaginar el potencial que tiene. Las Cloud Run Functions sencillas de Go realizan tareas que antes implicaban la carga de administrar un sistema operativo. Por ejemplo, puedes usar una función como esta para ejecutar Prevención de pérdida de datos (DLP) y limpiar los datos cuando un cliente escribe algo en Cloud Firestore por medio de una app para dispositivos móviles.

La función de Cloud Run podría reescribir un informe de resumen en Firestore sobre el consumo web basado en un evento de Pub/Sub. Hay muchos procesos pequeños basados en eventos que son buenos candidatos para Cloud Run Functions de Go. Lo mejor de todo es que no hay servidores en los que aplicar parches.

Tarea 4: realiza la implementación en App Engine

App Engine es ideal para ejecutar aplicaciones de Go. App Engine es una plataforma de computación sin servidores completamente administrada que puede aumentar o reducir la escala de forma vertical a medida que fluctúan las cargas de trabajo. Las aplicaciones de Go se compilan en un único archivo ejecutable binario durante la implementación. Los tiempos de inicio en frío para las aplicaciones de Go suelen ser de entre 80 milisegundos y 1,400 milisegundos. Además, cuando se ejecutan, App Engine puede escalar horizontalmente para satisfacer las cargas de trabajo de escala global más exigentes en cuestión de segundos.

Revisa el archivo de configuración YAML de Cloud Build

El archivo YAML, DIY-Tools/gcp-data-drive/cloudbuild_appengine.yaml, de Cloud Build que se muestra a continuación contiene las definiciones de los pasos de Cloud Build con los que se implementa tu aplicación en App Engine. Este archivo se usa para implementar la aplicación en App Engine.

En el primer paso, se ejecuta el comando git para clonar el repositorio de código fuente que contiene la aplicación. Este paso está parametrizado para permitirte cambiar fácilmente entre las ramas de la aplicación.

En el segundo paso, se ejecuta el comando sed para reemplazar la línea runtime: go113 en el archivo app.yaml por runtime: go121. Esto es necesario porque el entorno de ejecución de Go 1.13 quedó obsoleto y se quitará en el futuro. Ten en cuenta que este es solo un parche para mantener la app en funcionamiento. Debes actualizar la app para usar el entorno de ejecución de Go más reciente en tus propios proyectos.

En el tercer paso, se ejecuta el comando gcloud app deploy para implementar la aplicación en App Engine.

Al igual que con los otros ejemplos, podrías implementar esta app de forma manual con gcloud app deploy, pero Cloud Build te permite delegar esa tarea a la infraestructura de Google, por ejemplo, si quieres crear una canalización de CI/CD sin servidores.

Nota: Se quitaron los comentarios del archivo para mayor claridad. steps: - name: 'gcr.io/cloud-builders/git' args: ['clone','--single-branch','--branch', '${_GIT_SOURCE_BRANCH}','${_GIT_SOURCE_URL}'] - name: 'ubuntu' # Or any base image containing 'sed' args: ['sed', '-i', 's/runtime: go113/runtime: go121/', 'app.yaml'] # Replace go113 with go121 dir: 'DIY-Tools/gcp-data-drive/cmd/webserver' - name: 'gcr.io/cloud-builders/gcloud' args: ['app','deploy','app.yaml','--project','$PROJECT_ID'] dir: 'DIY-Tools/gcp-data-drive/cmd/webserver'

Consulta cloudbuild_appengine.yaml en GitHub.

Implementa la app de Google Cloud Data Drive

1. En DIY-Tools/gcp-data-drive, implementa la app de servidor web de Go en App Engine con Cloud Build:

gcloud builds submit --config cloudbuild_appengine.yaml \ --project $PROJECT_ID --no-source \ --substitutions=_GIT_SOURCE_BRANCH="master",_GIT_SOURCE_URL="https://github.com/GoogleCloudPlatform/DIY-Tools"

La implementación tarda unos minutos en completarse.

2. Almacena la URL de App Engine en una variable de entorno para usarla en el comando para llamar a la app:

Nota: La URL de App Engine es la target url en el resultado. export TARGET_URL=https://$(gcloud app describe --format="value(defaultHostname)")

3. Usa curl para llamar a la aplicación que se ejecuta en App Engine y consultar datos de Firestore:

curl $TARGET_URL/fs/$PROJECT_ID/symbols/product/symbol | jq .

Esto responde con el contenido de un archivo JSON que contiene tres valores de la colección symbols en tu proyecto.

[ { "asin": "", "brand": "", "category": "", "docid": "914600502073", "fbafees": 0, "lastMatchLookup": "0001-01-01T00:00:00Z", "listPrice": 0, "manufacturer": "", "pkgquantity": 0, "salesrank": 0, "smallImage": "", "title": "", "upc": "914600502073" }, { "asin": "0744018307", "bbw": true, "brand": "", "category": "book_display_on_website", "cpip": 2000, "docid": "9780744018301", "fba": false, "fbafees": 722, "inStock": "NOW", "lastMatchLookup": "2020-03-13T14:00:10.209183Z", "lastOfferLookup": "2020-03-13T14:00:13.670858Z", "listPrice": 3999, "manufacturer": "Prima Games", "pkgquantity": 0, "salesrank": 337073, "sfbc": 0, "sfbr": 0, "smallImage": "http://ecx.images-amazon.com/images/I/51NFIAHRfTL._SL75_.jpg", "title": "Wolfenstein II: The New Colossus: Prima Collector's Edition Guide", "upc": "9780744018301" } ]

4. Usa curl para llamar a la app que se ejecuta en App Engine y consultar datos de BigQuery:

curl $TARGET_URL/bq/$PROJECT_ID/publicviews/ca_zip_codes | jq .

Esto responde con el contenido de un archivo JSON que contiene los resultados de la sentencia de SQL SELECT * FROM publicviews.ca_zip_codes; de BigQuery.

[ { "Zipcode": "96090", "area_land_miles": 1.027, "state_code": "CA" }, { "Zipcode": "94929", "area_land_miles": 1.062, "state_code": "CA" } ]

Aumenta la carga

Aumenta la carga para ver qué sucede.

1. Usa el editor nano para crear una secuencia de comandos de shell sencilla que coloque algo de carga en la aplicación:

nano loadgen.sh

2. Escribe o pega la siguiente secuencia de comandos en el editor:

#!/bin/bash for ((i=1; i<=1000; i++)); do curl "$TARGET_URL/bq/$PROJECT_ID/publicviews/ca_zip_codes" > /dev/null & done

3. Presiona Ctrl+X, Y y, luego, Intro para guardar el nuevo archivo.
4. Haz que la secuencia de comandos sea ejecutable:

chmod +x loadgen.sh

5. Ejecuta la prueba de carga:

./loadgen.sh

6. En la consola, haz clic en Menú de navegación > App Engine > Instancias.

Se abre la ventana Instancias y muestra un resumen de las solicitudes por segundo y una lista de las instancias creadas cuando ejecutaste la prueba de carga en Cloud Shell. Observa cómo App Engine creó automáticamente instancias adicionales de la app y distribuyó el tráfico HTTP entrante.

Nota: Es posible que el gráfico de resumen tarde entre 3 y 5 minutos en mostrar los datos. No olvides actualizar la ventana Instancias.

7. En Cloud Shell, presiona Ctrl+C para finalizar la prueba de carga si aún se está ejecutando.

Verificar la implementación de la aplicación de App Engine

¡Felicitaciones!

En este lab de autoaprendizaje, exploraste cómo usar el lenguaje de programación Go para implementar aplicaciones en todas las plataformas de computación sin servidores de Google Cloud. Estas son las conclusiones clave:

• El lenguaje de programación Go tiene increíbles características que mejoran la rentabilidad y eficiencia, por lo que es una excelente opción para las aplicaciones modernas locales y en la nube.
• La misma base de código de Go se puede implementar en todas las plataformas de computación sin servidores, basadas en contenedores y de Anthos de Google Cloud sin modificaciones.
• Cloud Build (también sin servidores) es una parte clave de una canalización de CI/CD basada en la nube para proporcionar coherencia en la entrega a los ciclos de vida de tu aplicación.
• Cloud Run Functions y App Engine son plataformas sin servidores sencillas que operan a la escala de Google y son fáciles de implementar.
• Google Cloud Data Drive es una biblioteca de extracción de datos de código abierto que puedo usar en mi entorno de Google Cloud existente.

Próximos pasos y más información

• Para obtener más información sobre Go, consulta El lenguaje de programación Go.
• Consulta Go en GitHub.

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.

Actualización más reciente del manual: 5 de noviembre de 2024

Prueba más reciente del lab: 5 de noviembre de 2024

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