Descripción general

La computación sin servidores en Google Cloud te permite desarrollar e implementar aplicaciones muy escalables en una plataforma sin servidores completamente administrada. Los servicios se escalan vertical y horizontalmente de forma automática en función del tráfico.

Con la integración de servicios, puedes incorporar fácilmente tus servicios de forma asíncrona y con acoplamiento bajo, lo que permite una innovación rápida. Eventarc te permite crear arquitecturas basadas en eventos sin necesidad de administrar la infraestructura. Con Workflows, puedes crear aplicaciones confiables con facilidad a través de la organización de servicios y APIs. Cloud Scheduler es un servicio de trabajos cron completamente administrado para programar tus cargas de trabajo. Cloud Tasks es un servicio completamente administrado que se usa para crear listas de tareas en cola distribuidas. Eventarc, Workflows, Cloud Scheduler y Cloud Tasks te ayudan a integrar tus servicios mientras mantienes la observabilidad, la confiabilidad y la seguridad.

En este lab, usarás Workflows para crear un flujo de trabajo que administre el proceso de creación de miniaturas y extracción de metadatos de imágenes entrantes. Eventarc detecta cuando se sube una imagen a un bucket de Cloud Storage y comienza a ejecutar el flujo de trabajo.

El flujo de trabajo llama a la API de Cloud Vision para analizar la foto subida. Cloud Vision determina si la imagen es segura, detecta el texto en ella y ofrece etiquetas para su contenido. Los datos de vision se extraen con una función personalizada creada en Cloud Run Functions. Los datos extraídos se guardan en Firestore, la base de datos de documentos sin servidores y completamente administrada de Google Cloud. El flujo de trabajo también usa Cloud Tasks para poner en cola una tarea con la que se creará una miniatura.

Cloud Build se usa para compilar tres servicios que se implementan en Cloud Run, una plataforma sin servidores con la que se ejecutan servicios alojados en contenedores. Uno de estos servicios crea una miniatura en respuesta a la tarea creada por el flujo de trabajo.

El segundo servicio crea un collage de fotos de las imágenes más recientes. El servicio de collage se ejecuta en un programa creado en Cloud Scheduler.

El tercer servicio se activa con Eventarc cuando se borra una imagen del bucket de Cloud Storage. Este servicio quitará los metadatos y la miniatura de la imagen borrada.

Aprendizajes esperados

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

• Activar servicios y flujos de trabajo de forma asíncrona con Eventarc
• Organizar servicios y APIs con Workflows
• Administrar una lista de tareas en cola distribuida con Cloud Tasks
• Ejecutar servicios según un programa con Cloud Scheduler

Configuración y requisitos

En cada lab, recibirás un proyecto de Google Cloud y un conjunto de recursos nuevos por tiempo limitado y sin costo adicional.

1. Haz clic en el botón Comenzar lab. Si debes pagar por el lab, se abrirá una ventana emergente para que selecciones tu 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 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. 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 o escribe el nombre del servicio o producto en el campo Búsqueda.

Activa Google Cloud Shell

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

Google Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

1. En la consola de Cloud, en la barra de herramientas superior derecha, haz clic en el botón Abrir Cloud Shell.

   

2. Haz clic en Continuar.

El aprovisionamiento y la conexión al entorno demorarán unos minutos. Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu PROJECT_ID. Por ejemplo:

gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con el completado de línea de comando.

• Puedes solicitar el nombre de la cuenta activa con este comando:

gcloud auth list

Resultado:

Credentialed accounts: - @.com (active)

Resultado de ejemplo:

Credentialed accounts: - google1623327_student@qwiklabs.net

• Puedes solicitar el ID del proyecto con este comando:

gcloud config list project

Resultado:

[core] project =

Resultado de ejemplo:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: La documentación completa de gcloud está disponible en la guía de descripción general de gcloud CLI .

Tarea 1: Habilita las APIs y crea buckets de Cloud Storage

En esta tarea, habilitarás las APIs requeridas. También crearás dos buckets en Cloud Storage: uno para subir imágenes y otro para almacenar las imágenes que genere tu aplicación.

Habilita las APIs

1. Para habilitar las APIs requeridas, ejecuta el siguiente comando:

   gcloud services enable \ workflows.googleapis.com \ workflowexecutions.googleapis.com \ eventarc.googleapis.com \ tasks.googleapis.com \ cloudscheduler.googleapis.com \ storage.googleapis.com \ vision.googleapis.com \ run.googleapis.com \ cloudfunctions.googleapis.com \ firestore.googleapis.com \ appengine.googleapis.com \ cloudbuild.googleapis.com \ artifactregistry.googleapis.com

   Esta aplicación usa varios servicios de Google Cloud y debes habilitar cada una de las APIs de estos servicios.

   Estas son las APIs que se habilitarán y su función:

   • La API de Workflows administra las definiciones de los flujos de trabajo. Un flujo de trabajo ejecutará el proceso principal cuando se suba una imagen nueva.
   • La API de Workflows Executions administra las ejecuciones de los flujos de trabajo.
   • La API de Eventarc administra la configuración de Eventarc. Se usará Eventarc para detectar las imágenes que se agreguen y borren de un bucket de Cloud Storage.
   • La API de Cloud Tasks crea y administra tareas distribuidas. El flujo de trabajo creará una tarea para que se genere una miniatura.
   • La API de Cloud Scheduler crea y administra trabajos cron programados. Se usará un trabajo programado para crear un collage de las imágenes más recientes.
   • La API de Cloud Storage crea y administra objetos y buckets de Cloud Storage.
   • La API de Cloud Vision permite acceder a las funciones de vision de aprendizaje automático de Google.
   • La API de Cloud Run crea y administra servicios de Cloud Run. Los servicios de Cloud Run se proporcionan para crear una miniatura, borrar una imagen y crear un collage.
   • La API de Cloud Functions crea y administra funciones. Se usa una función para extraer detalles de la respuesta de Cloud Vision.
   • La API de Firestore crea y administra bases de datos de Firestore.
   • La API de App Engine crea y administra aplicaciones de App Engine. Esta API es obligatoria para habilitar Firestore.
   • La API de Cloud Build administra la compilación de aplicaciones.
   • La API de Artifact Registry administra registros y artefactos de compilación.

Crea buckets de Cloud Storage

1. En Cloud Shell, crea un bucket de Cloud Storage para subir imágenes:

   export UPLOAD_BUCKET=uploaded-images-${GOOGLE_CLOUD_PROJECT} gcloud storage buckets create \ --location={{{project_0.default_region|set at lab start}}} gs://${UPLOAD_BUCKET} gcloud storage buckets update \ gs://${UPLOAD_BUCKET} --uniform-bucket-level-access gcloud storage buckets add-iam-policy-binding \ gs://${UPLOAD_BUCKET} \ --member=allUsers --role=roles/storage.objectViewer

   Estos comandos crean un bucket regional público con acceso uniforme. Cada vez que se copie una imagen en el bucket, se iniciará un flujo de trabajo para analizar la foto y almacenar los metadatos y una imagen en miniatura.

2. Crea un segundo bucket de Cloud Storage para las imágenes que generen las aplicaciones de imágenes:

   export GENERATED_BUCKET=generated-images-${GOOGLE_CLOUD_PROJECT} gcloud storage buckets create \ --location={{{project_0.default_region|set at lab start}}} gs://${GENERATED_BUCKET} gcloud storage buckets update \ gs://${GENERATED_BUCKET} --uniform-bucket-level-access gcloud storage buckets add-iam-policy-binding \ gs://${GENERATED_BUCKET} \ --member=allUsers --role=roles/storage.objectViewer

3. En el menú de navegación () de la consola de Google Cloud, navega a Cloud Storage > Buckets.

   Se mostrarán los dos buckets que creaste.

   Haz clic en Revisar mi progreso para verificar el objetivo. Crear buckets de Cloud Storage

Tarea 2: Crea la base de datos de Firestore

En esta tarea, crearás la base de datos de Firestore que almacenará los metadatos de las imágenes.

Crea la base de datos

1. Para crear la base de datos de Firestore, ejecuta el siguiente comando en Cloud Shell:

   export FIRESTORE_LOCATION={{{project_0.default_region|set at lab start}}} gcloud firestore databases create \ --location=${FIRESTORE_LOCATION} \ --type=firestore-native

   Se usará una colección de Firestore llamada images para almacenar los metadatos de las imágenes. El servicio de collage buscará en la base de datos las imágenes más recientes con miniaturas para crear el collage.

   Después de crear la base de datos, debes crear un índice para admitir esta búsqueda.

Crea el índice compuesto de Firestore

Un índice compuesto de Firestore se usa cuando necesitas que una sola consulta haga referencia a varios campos.

1. Para crear el índice compuesto, ejecuta el siguiente comando:

   gcloud firestore indexes composite create \ --collection-group=images \ --field-config field-path=thumbnail,order=descending \ --field-config field-path=created,order=descending \ --async

   Este índice permitirá que el servicio de collage encuentre las imágenes más recientes que tienen miniaturas.

   El parámetro --async indica que no quieres esperar a que se complete la operación.

2. En el campo Buscar de la barra de título de la consola de Google Cloud, escribe Firestore, haz clic en Buscar y, luego, en Firestore.

3. Haz clic en el ID de tu base de datos (predeterminado) y, en el panel izquierdo, haz clic en Índices.

   Deberías ver que se está creando el índice de la colección images.

   Nota: El índice de búsqueda puede tardar varios minutos en crearse. Puedes continuar trabajando en el lab antes de que se complete la creación del índice.

   Haz clic en Revisar mi progreso para verificar el objetivo. Crear la base de datos de Firestore y el índice compuesto

Tarea 3: Crea la lista de tareas en cola de miniaturas

En esta tarea, crearás una cola de Cloud Tasks para solicitar la creación de miniaturas por parte del servicio create-thumbnail.

1. Para crear la lista de tareas en cola, ingresa el siguiente comando en Cloud Shell:

   export QUEUE_REGION={{{project_0.default_region|set at lab start}}} gcloud tasks queues create thumbnail-task-queue \ --location=${QUEUE_REGION}

2. En el campo Buscar de la barra de título de la consola de Google Cloud, escribe Cloud Tasks, haz clic en Buscar y, luego, en Cloud Tasks.

   Se acaba de crear la cola llamada thumbnail-task-queue.

   Haz clic en Revisar mi progreso para verificar el objetivo. Crear la cola de Cloud Tasks

Tarea 4: Implementa los servicios de Cloud Run

En esta tarea, compilarás y, luego, implementarás los servicios de Cloud Run que usará la aplicación de imágenes.

Clona el repositorio de código fuente

1. En Cloud Shell, clona el repositorio de Git:

   git clone --depth=1 https://github.com/GoogleCloudPlatform/training-data-analyst

2. Crea un acceso directo de vínculo simbólico al directorio raíz para este lab:

   ln -s ~/training-data-analyst/courses/orchestration-and-choreography/lab1 ~/code

Crea un repositorio en Artifact Registry

Artifact Registry es la nueva generación de Container Registry. Puedes almacenar artefactos de compilación en un repositorio de Artifact Registry.

1. Para crear un repositorio de Artifact Registry para imágenes de Docker, ejecuta el siguiente comando en Cloud Shell:

   export REPO_NAME=image-app-repo export REPO_REGION={{{project_0.default_region|set at lab start}}} gcloud artifacts repositories create ${REPO_NAME} \ --location=${REPO_REGION} --repository-format=docker

Compila y, luego, implementa el servicio create-thumbnail

El servicio de miniaturas crea una miniatura para una imagen subida y la almacena en el bucket de imágenes generadas.

1. En Cloud Shell, haz clic en Abrir editor.

2. En el editor de Cloud Shell, navega a ~/code/cloud-run/create-thumbnail y examina los archivos del servicio create-thumbnail.

   El directorio contiene estos tres archivos:

   • package.json incluye metadatos pertinentes para compilar tu aplicación de Node.js. Define el comando que inicia la aplicación (node index.js) y especifica las versiones de los paquetes que usa el código.
   • Dockerfile especifica la imagen inicial (node:16-slim) y contiene la lista de comandos que se ejecutan para compilar la imagen del contenedor que alojará nuestro servicio. La instalación incluye Imagemagick, que se usará para crear imágenes en miniatura a partir de las imágenes subidas.
   • index.js contiene el código del servicio.

3. Haz clic en Abrir terminal.

4. Para compilar la imagen de Docker del servicio create-thumbnail con Cloud Build, ejecuta los siguientes comandos en Cloud Shell:

   export REPO_NAME=image-app-repo export REPO_REGION={{{project_0.default_region|set at lab start}}} export THUMBNAIL_SERVICE_NAME=create-thumbnail cd ~/code/cloud-run/create-thumbnail gcloud builds submit \ . \ --tag ${REPO_REGION}-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/${REPO_NAME}/${THUMBNAIL_SERVICE_NAME}

   El servicio se compila y se almacena en el repositorio de Artifact Registry.

5. Para implementar el servicio con Cloud Run, ejecuta los siguientes comandos en Cloud Shell:

   export REPO_NAME=image-app-repo export REPO_REGION={{{project_0.default_region|set at lab start}}} export THUMBNAIL_SERVICE_REGION={{{project_0.default_region|set at lab start}}} export THUMBNAIL_SERVICE_NAME=create-thumbnail export GENERATED_IMAGES_BUCKET=generated-images-${GOOGLE_CLOUD_PROJECT} cd ~/code/cloud-run/create-thumbnail gcloud config set run/region ${THUMBNAIL_SERVICE_REGION} gcloud config set run/platform managed gcloud run deploy ${THUMBNAIL_SERVICE_NAME} \ --image ${REPO_REGION}-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/${REPO_NAME}/${THUMBNAIL_SERVICE_NAME} \ --no-allow-unauthenticated \ --memory=1Gi \ --max-instances=1 \ --update-env-vars GENERATED_IMAGES_BUCKET=${GENERATED_IMAGES_BUCKET}

   El nombre del bucket generated-images se pasa a la aplicación a través de una variable de entorno.

Compila y, luego, implementa el servicio de collage

El servicio de collage combina las imágenes subidas más recientemente en un collage y lo almacena en el bucket de imágenes generadas.

1. En Cloud Shell, haz clic en Abrir editor.

2. En el editor de Cloud Shell, navega a ~/code/cloud-run/create-collage y examina los archivos del servicio create-collage.

   Este directorio contiene tres archivos: package.json, index.js y Dockerfile.

3. Haz clic en Abrir terminal.

4. Para compilar y, luego, implementar la imagen de Docker del servicio create-collage, ejecuta los siguientes comandos en Cloud Shell:

   export REPO_NAME=image-app-repo export REPO_REGION={{{project_0.default_region|set at lab start}}} export COLLAGE_SERVICE_REGION={{{project_0.default_region|set at lab start}}} export COLLAGE_SERVICE_NAME=create-collage export GENERATED_IMAGES_BUCKET=generated-images-${GOOGLE_CLOUD_PROJECT} cd ~/code/cloud-run/create-collage gcloud builds submit \ . \ --tag ${REPO_REGION}-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/${REPO_NAME}/${COLLAGE_SERVICE_NAME} gcloud config set run/region ${COLLAGE_SERVICE_REGION} gcloud config set run/platform managed gcloud run deploy ${COLLAGE_SERVICE_NAME} \ --image ${REPO_REGION}-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/${REPO_NAME}/${COLLAGE_SERVICE_NAME} \ --no-allow-unauthenticated \ --memory=1Gi \ --max-instances=1 \ --update-env-vars GENERATED_IMAGES_BUCKET=${GENERATED_IMAGES_BUCKET}

Compila y, luego, implementa el servicio de eliminación de imágenes

El servicio de eliminación de imágenes quita la imagen en miniatura del bucket de imágenes generadas y borra los metadatos de la imagen de la base de datos.

1. En Cloud Shell, haz clic en Abrir editor.

2. En el editor de Cloud Shell, navega a ~/code/cloud-run/delete-image y examina los archivos del servicio delete-image.

   Este directorio solo contiene dos archivos: index.js y package.json, no hay archivo Dockerfile.

   En lugar de compilar y publicar el contenedor de forma manual, este lab se basa en los paquetes de compilación de Google Cloud para compilarlo automáticamente.

   También ten en cuenta que el servicio analiza la solicitud como un CloudEvent. Eventarc envía eventos con el formato estándar de CloudEvent.

3. Haz clic en Abrir terminal.

4. Para compilar y, luego, implementar el servicio delete-image en Cloud Run con los paquetes de compilación de Google Cloud, ejecuta los siguientes comandos en Cloud Shell:

   export DELETE_SERVICE_REGION={{{project_0.default_region|set at lab start}}} export DELETE_SERVICE_NAME=delete-image export GENERATED_IMAGES_BUCKET=generated-images-${GOOGLE_CLOUD_PROJECT} cd ~/code/cloud-run/delete-image npm install gcloud config set run/region ${DELETE_SERVICE_REGION} gcloud config set run/platform managed gcloud run deploy ${DELETE_SERVICE_NAME} \ --source . \ --no-allow-unauthenticated \ --max-instances=1 \ --update-env-vars GENERATED_IMAGES_BUCKET=${GENERATED_IMAGES_BUCKET}

   gcloud run deploy advierte que se debe crear un repositorio de Docker de Artifact Registry para las imágenes creadas por los paquetes de compilación de Google Cloud.

5. Cuando se te pregunte si quieres continuar, ingresa Y.

Examina los repositorios de artefactos y los servicios de Cloud Run

1. En el campo Buscar de la barra de título de la consola de Google Cloud, escribe Artifact Registry, haz clic en Buscar y, luego, en Artifact Registry.

   El repositorio que creaste (image-app-repo) y el repositorio creado por los paquetes de compilación de Google Cloud (cloud-run-source-deploy) están en Artifact Registry.

2. Haz clic en image-app-repo.

   En image-app-repo, están almacenadas las imágenes de Docker que compilaste para los servicios create-collage y create-thumbnail.

3. Regresa a Artifact Registry > Repositorios y, luego, haz clic en cloud-run-source-deploy.

   El repositorio contiene la imagen de Docker delete-image que se creó automáticamente con los paquetes de compilación de Google Cloud.

4. En el menú de navegación () de la consola de Google Cloud, navega a Cloud Run > Servicios.

   Se implementaron los tres servicios.

   Haz clic en Revisar mi progreso para verificar el objetivo. Crear el repositorio y, luego, implementar los servicios de Cloud Run

Tarea 5: Crea una función para analizar la respuesta de Cloud Vision

En esta tarea, crearás una Cloud Run Function para analizar los datos de la imagen que devolvió la API de Cloud Vision.

1. En Cloud Shell, haz clic en Abrir editor.

2. En el editor de Cloud, navega a ~/code/cloud-functions/extract-image-metadata y examina los archivos de la función extract-image-metadata.

   El servicio de Node.js contiene los archivos index.js y package.json. Cloud Run Functions usa automáticamente paquetes de compilación para crear el contenedor, por lo que no se requiere un archivo Dockerfile.

3. Haz clic en Abrir terminal.

4. Para implementar la función, ejecuta el siguiente comando en Cloud Shell:

   export EXTRACT_FUNCTION_REGION={{{project_0.default_region|set at lab start}}} export EXTRACT_FUNCTION_NAME=extract-image-metadata cd ~/code/cloud-functions/${EXTRACT_FUNCTION_NAME} gcloud config set functions/region ${EXTRACT_FUNCTION_REGION} gcloud functions deploy ${EXTRACT_FUNCTION_NAME} \ --gen2 \ --source . \ --runtime=nodejs20 \ --entry-point=extract_image_metadata \ --trigger-http \ --no-allow-unauthenticated Nota: Si la implementación indica que no se pudieron recuperar los metadatos del repositorio, intenta varias veces más hasta que la implementación de la función se ejecute con éxito.

5. En el campo Buscar de la barra de título de la consola de Google Cloud, escribe Cloud Run Functions, haz clic en Buscar y, luego, en Cloud Run Functions.

   Se implementó la función extract-image-metadata.

   Haz clic en Revisar mi progreso para verificar el objetivo. Crear la función para analizar la respuesta de Cloud Vision

Tarea 6: Crea el flujo de trabajo

En esta tarea, crearás un flujo de trabajo para organizar tus llamadas a la API y al servicio.

1. En Cloud Shell, haz clic en Abrir editor.

2. En el editor de Cloud Shell, navega a ~/code/workflows y examina el archivo YAML image-add-workflow.yaml.

   El flujo de trabajo especifica una serie de pasos que se deben realizar cuando se inicia el flujo de trabajo. Estos son los pasos que no requieren registro:

   • init asigna variables que se usarán en el flujo de trabajo. bucket y filename se completan con los valores que pasa Eventarc cuando se llama al flujo de trabajo. projectId obtiene el valor de ID del proyecto de una variable de entorno que se completa automáticamente para un flujo de trabajo.
   • imageAnalysisCall llama a la API de Cloud Vision para analizar la imagen subida.
   • extractImageMetadata llama a una Cloud Run Function Run para extraer la información importante de la respuesta a la llamada a la API de Cloud Vision.
   • checkSafety sale del flujo de trabajo cuando la API de Cloud Vision determina que la imagen no es segura.
   • storeMetadata llama a la API de Firestore para almacenar los metadatos de la imagen.
   • getThumbnailService llama a un conector de Cloud Run para encontrar la URL del servicio de Cloud Run create-thumbnail.
   • queueThumbnail usa un conector de Cloud Tasks para crear una tarea que llame de forma asíncrona al servicio de miniaturas.
   • completed finaliza el flujo de trabajo y devuelve el identificador de la ejecución del flujo de trabajo.

3. Haz clic en Abrir terminal.

4. Para crear una cuenta de servicio para la identidad del flujo de trabajo y agregar algunos permisos básicos, ejecuta los siguientes comandos:

   export WORKFLOWS_SA=workflows-sa gcloud iam service-accounts create ${WORKFLOWS_SA} gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \ --member="serviceAccount:${WORKFLOWS_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/datastore.user" gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \ --member="serviceAccount:${WORKFLOWS_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/cloudtasks.enqueuer" gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \ --member="serviceAccount:${WORKFLOWS_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/logging.logWriter" gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \ --member="serviceAccount:${WORKFLOWS_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/iam.serviceAccountUser"

   Los roles permiten las siguientes funcionalidades:

   • roles/datastore.user permite que el flujo de trabajo escriba documentos en Firestore.
   • roles/cloudtasks.enqueuer permite que el flujo de trabajo cree una tarea de Cloud Tasks.
   • roles/logging.logWriter permite que el flujo de trabajo registre variables en Cloud Logging.
   • roles/iam.serviceAccountUser permite que la cuenta de servicio suplante a otra cuenta de servicio, de modo que Cloud Tasks pueda enviar la solicitud con la identidad de la cuenta de servicio del flujo de trabajo.

5. Para agregar permisos para llamar a la función y al servicio de Cloud Run, ejecuta los siguientes comandos:

   export WORKFLOWS_SA=workflows-sa export THUMBNAIL_SERVICE_NAME=create-thumbnail export THUMBNAIL_SERVICE_REGION={{{project_0.default_region|set at lab start}}} export EXTRACT_FUNCTION_NAME=extract-image-metadata gcloud functions add-iam-policy-binding ${EXTRACT_FUNCTION_NAME} \ --member="serviceAccount:${WORKFLOWS_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/cloudfunctions.invoker" gcloud run services add-iam-policy-binding ${THUMBNAIL_SERVICE_NAME} \ --region=${THUMBNAIL_SERVICE_REGION} \ --member="serviceAccount:${WORKFLOWS_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/run.viewer" gcloud run services add-iam-policy-binding ${THUMBNAIL_SERVICE_NAME} \ --region=${THUMBNAIL_SERVICE_REGION} \ --member="serviceAccount:${WORKFLOWS_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/run.invoker"

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

   Estos roles adicionales permiten las siguientes funcionalidades:

   • roles/cloudfunctions.invoker permite que el flujo de trabajo llame a la función que extrae los metadatos de la respuesta de Cloud Vision.
   • roles/run.viewer permite que el flujo de trabajo consulte los detalles del servicio de miniaturas.
   • roles/run.invoker permite que la cuenta de servicio del flujo de trabajo llame al servicio de miniaturas. Cloud Tasks usará la cuenta de servicio cuando llame al servicio.

6. Para implementar el flujo de trabajo, ejecuta el siguiente comando:

   export WORKFLOW_NAME=image-add-workflow export WORKFLOW_REGION={{{project_0.default_region|set at lab start}}} export WORKFLOWS_SA=workflows-sa cd ~/code/workflows gcloud workflows deploy ${WORKFLOW_NAME} \ --source=${WORKFLOW_NAME}.yaml \ --location=${WORKFLOW_REGION} \ --service-account="${WORKFLOWS_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" Nota: Si el comando falla con el agente de servicio de Workflows, no existe. Vuelve a implementar el flujo de trabajo.

7. En el campo Buscar de la barra de título de la consola de Google Cloud, escribe Workflows, haz clic en Buscar y, luego, en Workflows.

8. Haz clic en el ícono de Fijar junto a Workflows.

9. Haz clic en image-add-workflow y, luego, en la pestaña Fuente.

   En el panel izquierdo, se muestra el código del flujo de trabajo y, en el panel derecho, se muestra una visualización del flujo de tráfico para los pasos del flujo de trabajo.

   Haz clic en Revisar mi progreso para verificar el objetivo. Crear el flujo de trabajo

Tarea 7: Crea un activador de Eventarc para iniciar el flujo de trabajo

En esta tarea, crearás un activador de Eventarc que ejecute el flujo de trabajo cuando se agregue un archivo al bucket uploaded-images.

1. Para crear una cuenta de servicio para el activador del flujo de trabajo y otorgarle los permisos necesarios, ejecuta el siguiente comando en Cloud Shell:

   export WORKFLOW_TRIGGER_SA=workflow-trigger-sa gcloud iam service-accounts create ${WORKFLOW_TRIGGER_SA} gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \ --member="serviceAccount:${WORKFLOW_TRIGGER_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/workflows.invoker" gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \ --member "serviceAccount:${WORKFLOW_TRIGGER_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/eventarc.eventReceiver"

   Estos comandos crean una cuenta de servicio llamada workflow-trigger-sa y agregan roles para recibir eventos e invocar flujos de trabajo.

2. Para otorgarle a la cuenta de servicio de Cloud Storage el permiso para crear eventos, ejecuta el siguiente comando:

   export CLOUD_STORAGE_SA="$(gcloud storage service-agent)" gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \ --member="serviceAccount:${CLOUD_STORAGE_SA}" \ --role="roles/pubsub.publisher"

   Estos comandos recuperan la cuenta de servicio de Cloud Storage y agregan el permiso para publicar eventos de Pub/Sub.

3. Para crear el activador, ejecuta el siguiente comando:

   export WORKFLOW_TRIGGER_REGION={{{project_0.default_region|set at lab start}}} export WORKFLOW_NAME=image-add-workflow export WORKFLOW_REGION={{{project_0.default_region|set at lab start}}} export UPLOAD_BUCKET=uploaded-images-${GOOGLE_CLOUD_PROJECT} export WORKFLOW_TRIGGER_SA=workflow-trigger-sa gcloud eventarc triggers create image-add-trigger \ --location=${WORKFLOW_TRIGGER_REGION} \ --destination-workflow=${WORKFLOW_NAME} \ --destination-workflow-location=${WORKFLOW_REGION} \ --event-filters="type=google.cloud.storage.object.v1.finalized" \ --event-filters="bucket=${UPLOAD_BUCKET}" \ --service-account="${WORKFLOW_TRIGGER_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com"

   Este activador llamará al flujo de trabajo cada vez que se escriba un archivo en el bucket uploaded-images.

   Nota: Si recibes un error de propagación de permisos cuando crees el activador, es posible que se deba a que un permiso aún no se propagó a Eventarc. Si vuelves a intentar crear el activador una o dos veces, debería funcionar.

   Haz clic en Revisar mi progreso para verificar el objetivo. Crear el activador de Eventarc para iniciar el flujo de trabajo

Tarea 8: Prueba el flujo de trabajo para agregar imagen

En esta tarea, probarás los pasos que se realizan cuando se agrega una imagen al bucket uploaded-images.

1. Para subir una imagen al bucket uploaded-images, ejecuta los siguientes comandos:

   export UPLOAD_BUCKET=uploaded-images-${GOOGLE_CLOUD_PROJECT} export IMAGE_NAME=neon.jpg gcloud storage cp ~/code/images/${IMAGE_NAME} gs://${UPLOAD_BUCKET}

   Cuando finaliza la carga, Eventarc la detecta y, luego, inicia el flujo de trabajo.

2. En el menú de navegación () de la consola de Google Cloud, navega a Flujos de trabajo > Flujos de trabajo.

3. Haz clic en image-add-workflow y, luego, en la pestaña Ejecuciones.

   Pronto deberías ver una ejecución del flujo de trabajo.

   Nota: Es posible que la ejecución tarde uno o dos minutos en comenzar.

4. Haz clic en el ID de ejecución para abrir la página Detalles de la ejecución.

   En esta página, se muestran los detalles de la ejecución del flujo de trabajo.

   En el panel de entrada, se muestra el contenido del evento de Cloud Storage que envió el activador de Eventarc.

   En el panel de salida, se muestran los valores que se devolvieron al final del flujo de trabajo.

   En el panel de registros, se muestran las entradas de registro creadas por el flujo de trabajo.

5. En el campo Buscar de la barra de título de la consola de Google Cloud, escribe Cloud Run Functions, haz clic en Buscar y, luego, en Cloud Run Functions.

6. Haz clic en extract-image-metadata.

   En este panel, se muestran detalles sobre la función que se usa para extraer la información de la respuesta de Cloud Vision.

7. Haz clic en la pestaña Registros.

   Aquí se encuentran los datos registrados de la ejecución de la función. Se registraron las etiquetas y el texto de la imagen.

8. En el campo Buscar de la barra de título de la consola de Google Cloud, escribe Firestore, haz clic en Buscar y, luego, en Firestore.

9. Haz clic en (predeterminado).

   La colección de imágenes debería mostrar un documento llamado neon.jpg que escribió el flujo de trabajo. Se muestran las etiquetas adjuntas a la imagen y el texto que se encuentra en ella.

10. En el menú de navegación () de la consola de Google Cloud, navega a Cloud Run > Servicios y, luego, haz clic en create-thumbnail.

    En este panel, se muestra información sobre el servicio create-thumbnail.

11. Haz clic en la pestaña Registros.

    Aquí se encuentran los datos registrados de la ejecución del servicio.

12. En Cloud Shell, ejecuta los siguientes comandos:

    export UPLOAD_BUCKET=uploaded-images-${GOOGLE_CLOUD_PROJECT} export GENERATED_BUCKET=generated-images-${GOOGLE_CLOUD_PROJECT} export IMAGE_NAME=neon.jpg echo "uploaded image: https://storage.googleapis.com/${UPLOAD_BUCKET}/${IMAGE_NAME}" echo "generated image: https://storage.googleapis.com/${GENERATED_BUCKET}/${IMAGE_NAME}" echo "Listing of generated-images bucket:" gcloud storage ls gs://${GENERATED_BUCKET}

    El bucket generated-images debería tener una miniatura creada por el servicio create-thumbnail. Puedes hacer clic en los vínculos de Cloud Shell para abrir una pestaña nueva y ver las imágenes subidas y generadas.

    Nota: Puede tardar un poco en que la imagen generada aparezca en el bucket y en el listado.

    Haz clic en Revisar mi progreso para verificar el objetivo. Probar el flujo de trabajo para agregar imágenes

Tarea 9: Agrega un trabajo programado para crear un collage

En esta tarea, crearás un trabajo de Cloud Scheduler para crear de forma periódica un collage de las fotos que se subieron más recientemente.

Sube imágenes

1. Para subir más imágenes al bucket uploaded-images, ejecuta los siguientes comandos:

   export UPLOAD_BUCKET=uploaded-images-${GOOGLE_CLOUD_PROJECT} gcloud storage cp ~/code/images/alley.jpg \ gs://${UPLOAD_BUCKET} gcloud storage cp ~/code/images/desktop.jpg \ gs://${UPLOAD_BUCKET} gcloud storage cp ~/code/images/rainbow.jpg \ gs://${UPLOAD_BUCKET} gcloud storage cp ~/code/images/vegas.jpg \ gs://${UPLOAD_BUCKET}

   El flujo de trabajo se ejecutará para cada imagen, lo que dará como resultado una miniatura para cada imagen.

2. Para crear una cuenta de servicio para llamar al servicio create-collage, ejecuta los siguientes comandos:

   export COLLAGE_SCHED_SA=collage-schedule-sa export COLLAGE_SERVICE=create-collage export COLLAGE_SERVICE_REGION={{{project_0.default_region|set at lab start}}} gcloud iam service-accounts create ${COLLAGE_SCHED_SA} gcloud run services add-iam-policy-binding ${COLLAGE_SERVICE} \ --region=${COLLAGE_SERVICE_REGION} \ --member="serviceAccount:${COLLAGE_SCHED_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/run.invoker"

3. Para recuperar la URL de servicio del servicio create-collage, ejecuta el siguiente comando en Cloud Shell:

   export SERVICE_REGION={{{project_0.default_region|set at lab start}}} export SERVICE_NAME=create-collage gcloud run services describe ${SERVICE_NAME} \ --platform managed \ --region ${SERVICE_REGION} \ --format 'value(status.url)'

   Copia la URL en el portapapeles, la necesitarás cuando crees el trabajo programado.

4. En el campo Buscar de la barra de título de la consola de Google Cloud, escribe Cloud Scheduler, haz clic en Buscar y, luego, en Cloud Scheduler.

5. Haz clic en + Crear trabajo.

6. Especifica los siguientes parámetros de configuración de programación:

   Propiedad	Valor
   Nombre	collage-schedule
   Región	selecciona
   Frecuencia	* * * * *
   Zona horaria	busca UTC y, luego, selecciona Horario universal coordinado (UTC)

   La frecuencia especifica el programa en formato unix-cron. * * * * * especifica que el trabajo se ejecutará una vez por minuto.

   La frecuencia de una vez por minuto se elige para facilitar la prueba.

7. Haz clic en Continuar y, luego, selecciona el Tipo de objetivo de HTTP.

8. Especifica los siguientes parámetros de configuración de ejecución:

   Propiedad	Valor
   URL	pega la URL del servicio create-collage
   Método HTTP	selecciona POST
   Encabezado de la autenticación	selecciona Agregar token de OIDC
   Cuenta de servicio	selecciona collage-schedule-sa
   Público	pega la URL del servicio create-collage

9. Haz clic en Continuar y, luego, en Crear.

   El trabajo collage-schedule se muestra en la página Trabajos de Cloud Scheduler.

   El trabajo debería ejecutarse en un minuto.

10. Haz clic en Actualizar hasta que el trabajo collage-schedule muestre una marca de verificación, lo que indica que se completó correctamente.

Haz clic en Revisar mi progreso para verificar el objetivo. Agregar un trabajo programado para crear el collage

1. En Cloud Shell, ejecuta los siguientes comandos:

   export GENERATED_BUCKET=generated-images-${GOOGLE_CLOUD_PROJECT} export IMAGE_NAME=collage.png echo "generated collage: https://storage.googleapis.com/${GENERATED_BUCKET}/${IMAGE_NAME}" echo "Listing of generated-images bucket:" gcloud storage ls gs://${GENERATED_BUCKET}

   El bucket generated-images ahora debería incluir el archivo collage.png. Puedes hacer clic en el vínculo “generated collage” en Cloud Shell para abrir una pestaña nueva y ver el collage.

   Un archivo copiado en Cloud Storage está disponible inmediatamente después de que se completa el proceso de carga del archivo, por lo que el vínculo debería funcionar justo después de que se complete el trabajo programado. Cuando se enumera el contenido del bucket, es posible que el archivo no aparezca hasta poco tiempo después.

Tarea 10: Activa un servicio para borrar archivos de imagen y metadatos

En esta tarea, crearás un activador de Eventarc para quitar la imagen de miniatura asociada y el documento de Firestore cuando se borre una imagen del bucket uploaded-images.

Crea una cuenta de servicio y administrar roles

1. Para crear una cuenta de servicio para el activador delete-image y otorgarle los permisos necesarios, ejecuta el siguiente comando en Cloud Shell:

   export DELETE_TRIGGER_SA=delete-image-trigger-sa export DELETE_SERVICE_REGION={{{project_0.default_region|set at lab start}}} export DELETE_SERVICE=delete-image gcloud iam service-accounts create ${DELETE_TRIGGER_SA} gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \ --member "serviceAccount:${DELETE_TRIGGER_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/eventarc.eventReceiver" gcloud run services add-iam-policy-binding ${DELETE_SERVICE} \ --region=${DELETE_SERVICE_REGION} \ --member="serviceAccount:${DELETE_TRIGGER_SA}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \ --role="roles/run.invoker"

   Estos comandos crean una cuenta de servicio llamada delete-image-trigger-sa y agregan permisos para recibir eventos e invocar el servicio delete-image.

2. En el menú de navegación () de la consola de Google Cloud, navega a Cloud Run y, luego, haz clic en delete-image.

3. En la página Detalles del servicio, haz clic en la pestaña Activadores.

4. Haz clic en + Agregar activador y, luego, selecciona Activador de Cloud Storage.

5. Especifica los siguientes parámetros de configuración del activador:

   Propiedad	Valor
   Nombre del activador	image-delete-trigger
   Tipo de evento	selecciona google.cloud.storage.object.v1.deleted
   Bucket	haz clic en Explorar, luego selecciona el bucket uploaded-images y, por último, haz clic en Seleccionar
   Cuenta de servicio	selecciona la cuenta de servicio delete-image-trigger-sa
   Ruta de URL de servicio	/

6. Si se te indica que se debe otorgar un rol a Pub/Sub, haz clic en Otorgar.

7. Haz clic en Guardar activador.

   Este activador llamará al servicio delete-image cada vez que se borre un archivo del bucket uploaded-images.

   Nota: Si recibes un mensaje de error en el que se indica que una región incumple una restricción en el recurso de activación, es posible que hayas seleccionado el bucket de Cloud Storage incorrecto. Vuelve a intentar realizar el proceso de creación y confirma la selección del bucket de imágenes subidas.

Haz clic en Revisar mi progreso para verificar el objetivo. Activar un servicio para borrar archivos de imagen y metadatos

Prueba de eliminación de imágenes

1. Para enumerar una imagen en los buckets de Cloud Storage y el documento correspondiente en Firestore, ejecuta los siguientes comandos:

   export UPLOAD_BUCKET=uploaded-images-${GOOGLE_CLOUD_PROJECT} export GENERATED_BUCKET=generated-images-${GOOGLE_CLOUD_PROJECT} export IMAGE_NAME=vegas.jpg echo "Listing of image in uploaded-images bucket:" gcloud storage ls gs://${UPLOAD_BUCKET}/${IMAGE_NAME} echo "Listing of image in generated-images bucket:" gcloud storage ls gs://${GENERATED_BUCKET}/${IMAGE_NAME} echo "Image document in Firestore:" curl -q -s -H "Authorization: Bearer $(gcloud auth print-access-token)" \ -X GET "https://firestore.googleapis.com/v1/projects/${GOOGLE_CLOUD_PROJECT}/databases/(default)/documents/images/${IMAGE_NAME}"

   Estos comandos muestran los detalles de Cloud Storage y Firestore de una sola imagen. Luego, debemos quitar esa imagen.

2. Para borrar una imagen del bucket uploaded-images, ejecuta el siguiente comando:

   export UPLOAD_BUCKET=uploaded-images-${GOOGLE_CLOUD_PROJECT} export IMAGE_NAME=vegas.jpg gcloud storage rm gs://${UPLOAD_BUCKET}/${IMAGE_NAME}

   Eventarc detectará el archivo eliminado y llamará al servicio image-delete, que quitará la miniatura y el documento de Firestore.

3. Para verificar si se quitaron la miniatura y el documento de Firestore, ejecuta los mismos comandos que usaste antes:

   export UPLOAD_BUCKET=uploaded-images-${GOOGLE_CLOUD_PROJECT} export GENERATED_BUCKET=generated-images-${GOOGLE_CLOUD_PROJECT} export IMAGE_NAME=vegas.jpg echo "Listing of image in uploaded-images bucket:" gcloud storage ls gs://${UPLOAD_BUCKET}/${IMAGE_NAME} echo "Listing of image in generated-images bucket:" gcloud storage ls gs://${GENERATED_BUCKET}/${IMAGE_NAME} echo "Image document in Firestore:" curl -q -s -H "Authorization: Bearer $(gcloud auth print-access-token)" -X GET "https://firestore.googleapis.com/v1/projects/${GOOGLE_CLOUD_PROJECT}/databases/(default)/documents/images/${IMAGE_NAME}"

   Se quitaron los elementos.

4. En el menú de navegación () de la consola de Google Cloud, navega a Cloud Run > Servicios y, luego, haz clic en delete-image.

5. Haz clic en Registros.

   Los registros del servicio delete-image muestran que se borró la miniatura del bucket generated-images y el documento de Firestore de la base de datos.

¡Felicitaciones!

Usaste Eventarc para activar servicios y flujos de trabajo de forma correcta, organizaste servicios y APIs con flujos de trabajo, creaste y usaste una lista de tareas en cola distribuida con Cloud Tasks y, por último, creaste un trabajo para ejecutar un servicio con Cloud Scheduler.

Próximos pasos/Más información

• Descubre cómo puedes usar Cloud Run para compilar tus propias aplicaciones en nuestro curso Application Development with Cloud Run.
• Obtén más información sobre cómo Google Cloud permite arquitecturas sin servidores con videos del equipo de Serverless Expeditions.

Finalice su lab

Cuando haya completado el lab, haga clic en Finalizar lab. Google Cloud Skills Boost quitará los recursos que usó y limpiará la cuenta.

Tendrá la oportunidad de calificar su experiencia en el lab. Seleccione la cantidad de estrellas que corresponda, ingrese un comentario y haga clic en Enviar.

La cantidad de estrellas indica lo siguiente:

• 1 estrella = Muy insatisfecho
• 2 estrellas = Insatisfecho
• 3 estrellas = Neutral
• 4 estrellas = Satisfecho
• 5 estrellas = Muy satisfecho

Puede cerrar el cuadro de diálogo si no desea proporcionar comentarios.

Para enviar comentarios, sugerencias o correcciones, use la pestaña Asistencia.

Copyright 2024 Google LLC. Todos los derechos reservados. Google y el logotipo de Google son marcas de Google LLC. El resto de los nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que están asociados.