Transmite datos de Cloud Storage a BigQuery con Cloud Functions

En este instructivo, se demuestra cómo transmitir objetos nuevos desde un depósito de Cloud Storage a BigQuery mediante Cloud Functions. Cloud Functions es una plataforma de procesamiento sin servidores controlada por eventos de Google Cloud que proporciona ajuste de escala automático, alta disponibilidad y tolerancia a errores sin servidores para aprovisionar, administrar, actualizar o aplicar parches. Puedes transmitir datos a través de Cloud Functions para conectarte y extender otros servicios de Google Cloud y solo pagar cuando tu app está en ejecución.

Este artículo está dirigido a analistas de datos, operadores o desarrolladores que necesitan ejecutar análisis casi en tiempo real de archivos que se agregan a Cloud Storage. En el artículo, se supone que el lector está familiarizado con Linux, Cloud Storage y BigQuery.

Arquitectura

En el siguiente diagrama de arquitectura, se ilustran todos los componentes y todo el flujo de la canalización de transmisión de este instructivo. Si bien esta canalización está diseñada para subir archivos JSON a Cloud Storage, puede adaptarse a otros formatos de archivos con algunos cambios menores en el código. La transferencia de otros formatos de archivo no se trata en este artículo.

Diagrama de arquitectura de la canalización

En el diagrama anterior, la canalización consta de los siguientes pasos:

  1. Los archivos JSON se suben al depósito FILES_SOURCE de Cloud Storage.
  2. Este evento activa la función streaming de Cloud Functions.
  3. Los datos se analizan y se insertan en BigQuery.
  4. El estado de la transferencia se registra en Firestore y Cloud Logging.
  5. Se publica un mensaje en uno de los siguientes temas de Pub/Sub:
    • streaming_success_topic
    • streaming_error_topic
  6. Según los resultados, Cloud Functions traslada el archivo JSON del depósito FILES_SOURCE a uno de los siguientes depósitos:
    • FILES_ERROR
    • FILES_SUCCESS

Objetivos

  • Crear un bucket de Cloud Storage para almacenar tus archivos JSON
  • Crear un conjunto de datos y una tabla de BigQuery para transmitir tus datos allí
  • Configurar una función Cloud Functions para que se active cada vez que se agreguen archivos a tu bucket
  • Configurar temas de Pub/Sub
  • Configurar funciones adicionales que manejen el resultado de las funciones
  • Probar la canalización de transmisión
  • Configurar Cloud Monitoring para alertar sobre comportamientos inesperados

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

  • Cloud Storage
  • Cloud Functions
  • Firestore
  • BigQuery
  • Logging
  • Monitoring
  • Container Registry
  • Cloud Build

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud sean aptos para obtener una prueba gratuita.

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyecto

  3. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

  4. Habilita las API de Cloud Functions and Cloud Build.

    Habilita las API

  5. En Cloud Console, ve a Monitoring.

    Ir a Cloud Monitoring

Cuando finalices este instructivo, podrás borrar los recursos creados para evitar que se te siga facturando. Para obtener más información, consulta cómo hacer una limpieza.

Configura tu entorno

En este instructivo usarás Cloud Shell para ingresar comandos. Cloud Shell te brinda acceso a la línea de comandos en Cloud Console y, además, incluye el SDK de Cloud y otras herramientas que necesitas para el desarrollo en Google Cloud. Cloud Shell se abre en una ventana en la parte inferior de Cloud Console. Es posible que la inicialización tome unos minutos, pero la ventana aparecerá de inmediato.

Para configurar tu entorno y clonar el repositorio de Git que se usa en este instructivo mediante Cloud Shell, sigue estos pasos:

  1. En Cloud Console, abre Cloud Shell.

    Abra Cloud Shell

  2. Asegúrate de que estés trabajando en el proyecto que acabas de crear. Reemplaza [YOUR_PROJECT_ID] por tu proyecto de Google Cloud recién creado.

    gcloud config set project [YOUR_PROJECT_ID]
    
  3. Configura la zona de procesamiento predeterminada. Para los fines de este instructivo, es us-east1. Si realizas la implementación en un entorno de producción, elige la región en la que deseas hacerlo.

    REGION=us-east1
    
  4. Clona el repositorio que contiene las funciones utilizadas en este instructivo.

    git clone https://github.com/GoogleCloudPlatform/solutions-gcs-bq-streaming-functions-python
    cd solutions-gcs-bq-streaming-functions-python
    

Crea receptores de origen y destino para la transmisión

Para transmitir contenido a BigQuery, debes tener un depósito de Cloud Storage FILES_SOURCE y una tabla de destino en BigQuery.

Crea el bucket de Cloud Storage

Debes crear un bucket de Cloud Storage que represente la fuente de la canalización de transmisión que se presenta en este instructivo. El propósito principal de este bucket es almacenar de forma temporal los archivos JSON que se transmiten a BigQuery.

  • Crea tu depósito FILES_SOURCE en Cloud Storage. FILES_SOURCE debe configurarse como una variable de entorno con un nombre único.

    FILES_SOURCE=${DEVSHELL_PROJECT_ID}-files-source-$(date +%s)
    gsutil mb -c regional -l ${REGION} gs://${FILES_SOURCE}
    

Crea la tabla de BigQuery

En esta sección, crearemos una tabla de BigQuery que se utilizará como destino de contenido para tus archivos. BigQuery te permite especificar el esquema de la tabla cuando cargas datos en la tabla o cuando creas una tabla nueva. En esta sección, crearás la tabla y especificarás su esquema al mismo tiempo.

  1. Crea un conjunto de datos y una tabla de BigQuery. El esquema definido en el archivo schema.json debe coincidir con el esquema de los archivos que provienen del depósito FILES_SOURCE.

    bq mk mydataset
    bq mk mydataset.mytable schema.json
    
  2. Verifica que se haya creado la tabla.

    bq ls --format=pretty mydataset
    

    Este es el resultado:

    +---------+-------+--------+-------------------+
    | tableId | Type  | Labels | Time Partitioning |
    +---------+-------+--------+-------------------+
    | mytable | TABLE |        |                   |
    +---------+-------+--------+-------------------+
    

Transmite datos a BigQuery

Ahora que creaste los receptores de origen y destino, crea la función de Cloud Functions que transmitirá los datos de Cloud Storage a BigQuery.

Configura la función de transmisión de Cloud Functions

La función de transmisión detecta los archivos nuevos que se agregan al depósito FILES_SOURCE y, luego, activa un proceso que hace lo siguiente:

  • Analiza y valida el archivo.
  • Verifica que no haya duplicados.
  • Inserta el contenido del archivo en BigQuery.
  • Registra el estado de la transferencia en Firestore y Logging.
  • Publica un mensaje en un tema de transmisión con errores o correcta en Pub/Sub.

Sigue estos pasos para implementar la función:

  1. Crea un depósito de Cloud Storage para almacenar en etapa intermedia tus funciones durante la implementación, en la que FUNCTIONS_BUCKET debe configurarse como una variable de entorno con un nombre único.

    FUNCTIONS_BUCKET=${DEVSHELL_PROJECT_ID}-functions-$(date +%s)
    gsutil mb -c regional -l ${REGION} gs://${FUNCTIONS_BUCKET}
    
  2. Implementa la función streaming. El código de implementación se encuentra en la carpeta ./functions/streaming. Puede tardar algunos minutos en terminar.

    gcloud functions deploy streaming --region=${REGION} \
        --source=./functions/streaming --runtime=python37 \
        --stage-bucket=${FUNCTIONS_BUCKET} \
        --trigger-bucket=${FILES_SOURCE}
    

    Este código implementa una función de Cloud Functions escrita en Python con el nombre streaming. Esta se activa cada vez que se agrega un archivo al depósito FILES_SOURCE.

  3. Verifica que se haya implementado la función.

    gcloud functions describe streaming  --region=${REGION} \
        --format="table[box](entryPoint, status, eventTrigger.eventType)"
    

    El resultado se muestra a continuación:

    ┌────────────────┬────────┬────────────────────────────────┐
    │  ENTRY_POINT   │ STATUS │           EVENT_TYPE           │
    ├────────────────┼────────┼────────────────────────────────┤
    │ streaming      │ ACTIVE │ google.storage.object.finalize │
    └────────────────┴────────┴────────────────────────────────┘
    
  4. Aprovisiona un tema de Pub/Sub con el nombre streaming_error_topic a fin de administrar la ruta de acceso con errores.

    STREAMING_ERROR_TOPIC=streaming_error_topic
    gcloud pubsub topics create ${STREAMING_ERROR_TOPIC}
    
  5. Aprovisiona un tema de Pub/Sub con el nombre streaming_success_topic para administrar la ruta de acceso correcta.

    STREAMING_SUCCESS_TOPIC=streaming_success_topic
    gcloud pubsub topics create ${STREAMING_SUCCESS_TOPIC}
    

Configura la base de datos de Firestore

Mientras los datos se transmiten a BigQuery, es importante comprender qué sucede con cada transferencia de archivos. Por ejemplo, supongamos que tienes archivos que se importaron de forma incorrecta. En este caso, tienes que determinar cuál fue la causa raíz del problema y arreglarla para evitar que se generen informes incorrectos y datos dañados al final de tu canalización. La función streaming, que se implementó en la sección anterior, almacena el estado de la transferencia de archivos en documentos de Firestore para que puedas consultar los errores recientes y solucionar cualquier problema.

Para crear la instancia de Firestore, sigue estos pasos:

  1. En Google Cloud Console, ve a Firestore.

    Ir a Firestore

  2. En la ventana Elegir un modo de Cloud Firestore, haz clic en Seleccionar modo nativo.

  3. En la lista Seleccionar una ubicación, elige nam5 (Estados Unidos) y haz clic en Crear base de datos. Espera a que finalice la inicialización de Firestore. Por lo general, esto tarda unos minutos.

Maneja errores de transmisión

A fin de aprovisionar una ruta de acceso para controlar los archivos con errores, implementa otra función de Cloud Functions que escuche los mensajes publicados en streaming_error_topic. La forma en la que deben manejarse estos errores en un entorno de producción depende de cuáles sean las necesidades de tu empresa. A los fines de este instructivo, los archivos problemáticos se pasan a otro bucket de Cloud Storage para facilitar el procedimiento de solución de problemas.

  1. Crea tu bucket de Cloud Storage para almacenar archivos problemáticos: FILES_ERROR se configura como una variable de entorno con un nombre único para el depósito que almacena los archivos con errores.

    FILES_ERROR=${DEVSHELL_PROJECT_ID}-files-error-$(date +%s)
    gsutil mb -c regional -l ${REGION} gs://${FILES_ERROR}
    
  2. Implementa la función streaming_error para controlar los errores. Esto puede tardar algunos minutos.

    gcloud functions deploy streaming_error --region=${REGION} \
        --source=./functions/move_file \
        --entry-point=move_file --runtime=python37 \
        --stage-bucket=${FUNCTIONS_BUCKET} \
        --trigger-topic=${STREAMING_ERROR_TOPIC} \
        --set-env-vars SOURCE_BUCKET=${FILES_SOURCE},DESTINATION_BUCKET=${FILES_ERROR}
    

    Este comando es similar al comando usado para implementar la función streaming. La diferencia principal es que, con este comando, la función se activa mediante un mensaje publicado en un tema y recibe dos variables de entorno: SOURCE_BUCKET (la ubicación desde donde se copian los archivos) y DESTINATION_BUCKET (la ubicación en la que se copian los archivos).

  3. Verifica que se haya creado la función streaming_error.

    gcloud functions describe streaming_error --region=${REGION} \
        --format="table[box](entryPoint, status, eventTrigger.eventType)"
    

    Este es el resultado:

    ┌─────────────┬────────┬─────────────────────────────┐
    │ ENTRY_POINT │ STATUS │          EVENT_TYPE         │
    ├─────────────┼────────┼─────────────────────────────┤
    │ move_file   │ ACTIVE │ google.pubsub.topic.publish │
    └─────────────┴────────┴─────────────────────────────┘
    

Controla las transmisiones correctas

A fin de aprovisionar una ruta de acceso para controlar archivos correctos, implementa una tercera función de Cloud Functions que escuche los mensajes publicados en streaming_success_topic. Para los fines de este instructivo, los archivos transferidos de forma correcta se archivan en un bucket de Cloud Storage de la clase Coldline.

  1. Crea el depósito de Cloud Storage de clase Coldline. FILES_SUCCESS se configura como una variable de entorno con un nombre único para el depósito que almacena los archivos correctos.

    FILES_SUCCESS=${DEVSHELL_PROJECT_ID}-files-success-$(date +%s)
    gsutil mb -c coldline -l ${REGION} gs://${FILES_SUCCESS}
    
  2. Implementa la función streaming_success para controlar la transmisión correcta. Esto puede tardar algunos minutos.

    gcloud functions deploy streaming_success --region=${REGION} \
        --source=./functions/move_file \
        --entry-point=move_file --runtime=python37 \
        --stage-bucket=${FUNCTIONS_BUCKET} \
        --trigger-topic=${STREAMING_SUCCESS_TOPIC} \
        --set-env-vars SOURCE_BUCKET=${FILES_SOURCE},DESTINATION_BUCKET=${FILES_SUCCESS}
    
  3. Verifica que se haya creado la función.

    gcloud functions describe streaming_success  --region=${REGION} \
        --format="table[box](entryPoint, status, eventTrigger.eventType)"
    

    Este es el resultado:

    ┌─────────────┬────────┬─────────────────────────────┐
    │ ENTRY_POINT │ STATUS │          EVENT_TYPE         │
    ├─────────────┼────────┼─────────────────────────────┤
    │ move_file   │ ACTIVE │ google.pubsub.topic.publish │
    └─────────────┴────────┴─────────────────────────────┘
    

Prueba tu canalización de transmisión

Si realizaste los pasos anteriores, ya terminaste de crear tu canalización de transmisión. Ahora, es el momento de probar las distintas rutas. Primero, probaremos transferir archivos nuevos, luego usaremos archivos duplicados y, por último, transferiremos archivos con problemas.

Transfiere archivos nuevos

Para probar la transferencia de archivos nuevos, debes subir un archivo que pase de forma correcta a través de toda la canalización. Para asegurarte de que todo funcione de forma correcta, debes verificar todos los depósitos de almacenamiento: BigQuery, Firestore y Cloud Storage.

  1. Sube el archivo data.json al depósito FILES_SOURCE.

    gsutil cp test_files/data.json gs://${FILES_SOURCE}
    

    El resultado es este:

    Operation completed over 1 objects/312.0 B.
    
  2. Consulta los datos en BigQuery.

    bq query 'select first_name, last_name, dob from mydataset.mytable'
    

    Este comando genera el contenido del archivo data.json:

    +------------+-----------+------------+
    | first_name | last_name |    dob     |
    +------------+-----------+------------+
    | John       | Doe       | 1968-01-22 |
    +------------+-----------+------------+
    
  3. En Cloud Console, ve a la página de Firestore.

    Ir a Firestore

  4. Ve al documento /streaming_filesdata.json para verificar que esté presente el campo success: true. La función streaming almacena el estado del archivo en una colección llamada streaming_files y usa el nombre del archivo como el ID del documento.

    Verifica que la función “streaming” almacene el estado de éxito del archivo

  5. Vuelve a Cloud Shell.

    Ir a Cloud Shell

  6. Verifica que la función streaming_success haya quitado el archivo que se borró del depósito FILES_SOURCE.

    gsutil ls -l gs://${FILES_SOURCE}/data.json
    

    El resultado es una CommandException porque el archivo ya no existe en el depósito FILES_SOURCE.

  7. Verifica que el archivo transferido esté en el depósito FILES_SUCCESS.

    gsutil ls -l gs://${FILES_SUCCESS}/data.json
    

    Este es el resultado:

    TOTAL: 1 objects, 312 bytes.
    

Transfiere archivos que ya se hayan procesado

El nombre del archivo se usa como ID del documento en Firestore. Esto facilita que la función streaming consulte si se procesó o no un archivo determinado. Si un archivo ya se transfirió correctamente antes, todo nuevo intento de agregarlo se ignorará, ya que no haría más que generar información duplicada en BigQuery y daría como resultado informes inexactos.

En esta sección, debes verificar que la canalización funcione según lo previsto cuando se suben archivos duplicados al depósito FILES_SOURCE.

  1. Vuelve a subir el mismo archivo data.json al depósito FILES_SOURCE.

    gsutil cp test_files/data.json gs://${FILES_SOURCE}
    

    Este es el resultado:

    Operation completed over 1 objects/312.0 B.
    
  2. Si envías una consulta a BigQuery, el resultado será el mismo que antes. Esto significa que la canalización procesó el archivo, pero no insertó su contenido en BigQuery porque ya se lo había transferido antes.

    bq query 'select first_name, last_name, dob from mydataset.mytable'
    

    El resultado se muestra a continuación:

    +------------+-----------+------------+
    | first_name | last_name |    dob     |
    +------------+-----------+------------+
    | John       | Doe       | 1968-01-22 |
    +------------+-----------+------------+
    
  3. En Cloud Console, ve a la página de Firestore.

    Ir a Firestore

  4. En el documento / > streaming_files > data.json, verifica si se agregó el nuevo campo **duplication_attempts**.

    Verifica que la función “streaming” almacene “duplication_attempts”

    Cada vez que se agrega un archivo al depósito FILES_SOURCE con el mismo nombre que uno ya procesado de forma correcta, el contenido del archivo se ignora y se agrega un nuevo intento de duplicación al campo **duplication_attempts** en Firestore.

  5. Vuelve a Cloud Shell.

    Ir a Cloud Shell

  6. Verifica que el archivo duplicado aún se encuentre en el depósito FILES_SOURCE.

    gsutil ls -l gs://${FILES_SOURCE}/data.json
    

    El resultado se muestra a continuación:

    TOTAL: 1 objects, 312 bytes.
    

    En la situación de duplicación, la función streaming registra el comportamiento inesperado en Logging, ignora la transferencia y deja el archivo en el depósito FILES_SOURCE para su análisis posterior.

Transfiere archivos con errores

Ya confirmaste que tu canalización de transmisión funciona y que las duplicaciones no se transfieren a BigQuery. Ahora, revisaremos la ruta de error.

  1. Sube data_error.json al depósito FILES_SOURCE.

    gsutil cp test_files/data_error.json gs://${FILES_SOURCE}
    

    Este es el resultado:

    Operation completed over 1 objects/311.0 B.
    
  2. Si envías una consulta a BigQuery, el resultado será el mismo que antes. Esto significa que la canalización procesó el archivo, pero no insertó su contenido en BigQuery porque ya no cumple con el esquema esperado.

    bq query 'select first_name, last_name, dob from mydataset.mytable'
    

    El resultado se muestra a continuación:

    +------------+-----------+------------+
    | first_name | last_name |    dob     |
    +------------+-----------+------------+
    | John       | Doe       | 1968-01-22 |
    +------------+-----------+------------+
    
  3. En Cloud Console, ve a la página de Firestore.

    Ir a Firestore

  4. En el documento /streaming_filesdata_error.json, verifica que se haya agregado el campo success: false.

    Verifica que la función “streaming” (transmisión) almacene el estado de error del archivo

    En el caso de los archivos con errores, la función streaming también almacena un campo error_message que proporciona información detallada sobre el motivo por el que no se transfirió el archivo.

  5. Vuelve a Cloud Shell.

    Ir a Cloud Shell

  6. Verifica que la función streaming_error haya quitado el archivo del depósito FILES_SOURCE.

    gsutil ls -l gs://${FILES_SOURCE}/data_error.json
    

    El resultado es una CommandException porque el archivo ya no existe en el depósito FILES_SOURCE.

  7. Verifica que el archivo esté ahora en el depósito FILES_ERROR, como es de esperar.

    gsutil ls -l gs://${FILES_ERROR}/data_error.json
    

    Este es el resultado:

    TOTAL: 1 objects, 311 bytes.
    

Detecta y soluciona problemas de transferencia de datos

La ejecución de consultas en la colección streaming_files de Firestore te permite diagnosticar y solucionar problemas con rapidez. En esta sección, debes filtrar todos los archivos con errores mediante la API estándar de Python para Firestore.

db = firestore.Client()
docs = db.collection(u'streaming_files')\
    .where(u'success', u'==', False)\
    .get()

Para ver los resultados de la consulta en el entorno, sigue estos pasos:

  1. Crea un entorno virtual en la carpeta firestore.

    pip install virtualenv
    virtualenv firestore
    source firestore/bin/activate
    
  2. Instala el módulo de Python para Firestore en el entorno virtual.

    pip install google-cloud-firestore
    
  3. Visualiza los problemas de la canalización existente.

    python firestore/show_streaming_errors.py
    

    El archivo show_streaming_errors.py contiene la consulta de Firestore y otro código estándar para repetir el resultado y darle formato. Cuando ejecutes el comando anterior, el resultado debería ser similar al siguiente:

    +-----------------+-------------------------+----------------------------------------------------------------------------------+
    | File Name       | When                    | Error Message                                                                    |
    +-----------------+-------------------------+----------------------------------------------------------------------------------+
    | data_error.json | 2019-01-22 11:31:58 UTC | Error streaming file 'data_error.json'. Cause: Traceback (most recent call las.. |
    +-----------------+-------------------------+----------------------------------------------------------------------------------+
    
  4. Desactiva el entorno virtual cuando termines el análisis.

    deactivate
    

    Una vez que hayas encontrado y reparado los archivos problemáticos, súbelos nuevamente al depósito FILES_SOURCE con el mismo nombre de archivo. Este proceso hace que vuelvan a pasar por toda la canalización de transmisión para insertar su contenido en BigQuery.

Alerta sobre comportamientos inesperados

En entornos de producción, es importante supervisar y generar alertas cada vez que suceda algo inesperado. Una de las muchas funciones de Logging son las métricas personalizadas. Las métricas personalizadas te permiten crear políticas de alertas para que se les envíen notificaciones a ti y a tu equipo cuando la métrica cumpla con los criterios especificados.

En esta sección, debes configurar Monitoring para que envíe alertas por correo electrónico siempre que falle la transferencia de un archivo. Para identificar una transferencia con errores, en la siguiente configuración se usan los mensajes logging.error(..) de Python predeterminados.

  1. En Cloud Console, ve a la página Métricas basadas en registros.

    Ir a la página Métricas basadas en registros

  2. Haz clic en Create Metric (Crear métrica).

  3. En la lista Filter (Filtros), selecciona Convert to advanced filter (Convertir a filtro avanzado).

    Menú de filtro avanzado

  4. En el filtro avanzado, pega la siguiente configuración.

    resource.type="cloud_function"
    resource.labels.function_name="streaming"
    resource.labels.region="us-east1"
    "Error streaming file "
    

    Configuración que debe pegarse en el filtro avanzado

  5. En Metric editor (Editor de métricas), completa los siguientes campos y haz clic en Create Metric (Crear métrica).

    • En el campo Nombre, ingresa streaming-error.
    • En la sección Labels (Etiquetas), ingresa payload_error en el campo Name (Nombre).
    • En la lista Label type (Tipo de etiqueta), selecciona String.
    • En la lista Field name (Nombre del campo), selecciona textPayload (textPayload).
    • En el campo Extraction regular expression (Expresión regular de extracción), ingresa (Error streaming file '.*'.).
    • En la lista Type (Tipo), selecciona Counter (Contador).

      Campos del editor de métricas

  6. En Google Cloud Console, ve a Monitoring o usa el siguiente botón:

    Ir a Monitoring

  7. En el panel de navegación de Monitoring, selecciona Alerting (Alertas) y, luego, Create Policy (Crear política).

  8. En el campo Name this policy (Nombra esta política), ingresa streaming-error-alert.

  9. Haz clic en Agregar condición:

    • En el campo Título, ingresa streaming-error-condition.
    • En el campo Metric (Métrica), ingresa logging/user/streaming-error.
    • En la lista Condition triggers if (La condición se activa si), selecciona Any time series violates (Alguna serie temporal infringe).
    • En la lista Condition (Condición), selecciona is above (supera).
    • En el campo Umbral, ingresa 0.
    • En la lista For (Durante), selecciona 1 minute (1 minuto).
  10. En la lista Notification Channel Type (Tipo de canal de notificaciones), selecciona Email (Correo electrónico), ingresa tu dirección de correo electrónico y haz clic en Add Notification Channel (Agregar canal de notificaciones).

  11. Haz clic en Documentation (Documentación) y agrega cualquier dato que desees incluir en un mensaje de notificación (opcional).

  12. Haz clic en Save (Guardar).

Después de que se guarda la política de alertas, Monitoring supervisa los registros de errores de la función streaming y envía una alerta por correo electrónico cada vez que surgen errores de transmisión durante un intervalo de un minuto.

Realice una limpieza

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?

  • Consulta Eventos y activadores para conocer otras formas de activar una función sin servidores en Google Cloud.
  • Visita la página de alertas para aprender cómo mejorar la política de alertas que definiste en este instructivo.
  • Visita la documentación de Firestore para obtener más información sobre esta base de datos NoSQL de escala global.
  • Visita la página Cuotas y límites de BigQuery para comprender los límites de inserción de transmisión que se aplican cuando implementas esta solución en un entorno de producción.
  • Visita la página Cuotas y límites de Cloud Functions para conocer el tamaño máximo que puede manejar una función implementada.
  • Explora arquitecturas de referencia, diagramas, instructivos y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.