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 de Google Cloud Platform (GCP), sin servidores y basada en eventos, que proporciona ajuste de escala automático, alta disponibilidad y tolerancia a errores sin la necesidad de aprovisionar servidores, administrarlos, actualizarlos ni aplicarles parches. Puedes transmitir datos directamente a través de Cloud Functions para conectar y extender otros servicios de GCP, con la ventaja de que solo pagas mientras se ejecuta tu app.

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 transferencia se registra en Cloud Firestore y Stackdriver Logging.
  5. Se publica un mensaje en uno de los siguientes temas de Cloud Pub/Sub:
    • streaming_success_topic
    • streaming_error_topic
  6. Según los resultados, Cloud Functions mueve el archivo JSON del depósito FILES_SOURCE a uno de los siguientes depósitos:
    • FILES_ERROR
    • FILES_SUCCESS

Objetivos

  • Crear un depósito 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 depósito
  • Configurar temas de Cloud Pub/Sub
  • Configurar funciones adicionales que manejen el resultado de la función
  • Probar tu canalización de transmisión
  • Configurar Stackdriver Monitoring para que genere alertas ante cualquier conducta imprevista

Costos

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

  • Cloud Storage
  • Cloud Functions
  • Cloud Firestore
  • BigQuery
  • Logging
  • Monitoring

Usa la calculadora de precios a fin de generar una estimación de los costos según el uso previsto. Los usuarios nuevos de GCP pueden optar a una prueba gratuita.

Antes de comenzar

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. Selecciona o crea un proyecto de GCP.

    Ir a la página Administrar recursos

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

    Descubre cómo puedes habilitar la facturación

  4. Habilita las Cloud Functions API necesarias.

    Habilita las API

  5. Crea un lugar de trabajo de Stackdriver. Para obtener más información sobre los lugares de trabajo, consulta Administra lugares de trabajo.

    IR A Stackdriver

Cuando finalices este instructivo, puedes borrar los recursos creados para evitar la continuidad de la facturación. Para obtener más detalles, consulta Limpieza.

Configura tu entorno

En este instructivo, usarás Cloud Shell para ingresar comandos. Cloud Shell te da acceso a la línea de comandos de GCP Console y también incluye el SDK de Cloud y otras herramientas que necesitas para desarrollar en GCP. Cloud Shell aparece como una ventana en la parte inferior de GCP Console. Es posible que la inicialización tarde 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. Abre Cloud Shell en GCP Console.

    ABRIR Cloud Shell

  2. Asegúrate de que estás trabajando en el proyecto que acabas de crear. Reemplaza [YOUR_PROJECT_ID] con tu proyecto de GCP 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 realizarás 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 depósito de Cloud Storage

Debes crear un depósito 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 depósito es almacenar temporalmente 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 que se define en el archivo schema.json debe coincidir con el de los archivos 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
    

    El resultado es el siguiente:

    +---------+-------+--------+-------------------+
    | 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 transferencia en Cloud Firestore y Logging.
  • Publica un mensaje en un tema de error o éxito en Cloud Pub/Sub.

Sigue estos pasos para implementar la función:

  1. Crea un depósito de Cloud Storage para habilitar a etapa tus funciones durante la implementación. 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 de 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 Cloud Functions escrita en Python que se denomina streaming. Se activa cada vez que se agrega un archivo a tu 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 es el siguiente:

    ┌────────────────┬────────┬────────────────────────────────┐
    │  ENTRY_POINT   │ STATUS │           EVENT_TYPE           │
    ├────────────────┼────────┼────────────────────────────────┤
    │ streaming      │ ACTIVE │ google.storage.object.finalize │
    └────────────────┴────────┴────────────────────────────────┘
    
  4. Aprovisiona un tema de Cloud Pub/Sub llamado streaming_error_topic para que maneje la ruta de error.

    STREAMING_ERROR_TOPIC=streaming_error_topic
    gcloud pubsub topics create ${STREAMING_ERROR_TOPIC}
    
  5. Aprovisiona un tema de Cloud Pub/Sub llamado streaming_success_topic para que maneje la ruta del éxito.

    STREAMING_SUCCESS_TOPIC=streaming_success_topic
    gcloud pubsub topics create ${STREAMING_SUCCESS_TOPIC}
    

Configura tu base de datos de Cloud 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 implementamos en la sección anterior, almacena el estado de transferencia de los archivos en documentos de Cloud Firestore para que puedas consultar los errores recientes y buscar soluciones cuando sea necesario.

Para crear tu instancia de Cloud Firestore, sigue estos pasos:

  1. Ve a Cloud Firestore en GCP Console.

    IR A LA PÁGINA DE Cloud Firestore

  2. En la ventana Selecciona dónde almacenar tus datos, haz clic en Seleccionar modo nativo junto a Modo nativo.

  3. En la lista Selecciona una ubicación, elige nam5 (Estados Unidos) y haz clic en Crear base de datos. Espera a que termine de inicializarse Cloud Firestore. Por lo general, esto toma unos minutos.

Maneja errores de transmisión

A fin de aprovisionar una ruta para manejar los archivos con errores, implementa otra función de Cloud Functions que detecte 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 depósito de Cloud Storage para facilitar el procedimiento de solución de problemas.

  1. Crea tu depósito 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 que maneje 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 que usaste para implementar la función streaming. La principal diferencia es que, en 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 a 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)"
    

    El resultado es el siguiente:

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

Maneja las transmisiones realizadas correctamente

A fin de aprovisionar una ruta para manejar los archivos transmitidos correctamente, implementa una tercera función de Cloud Functions que detecte los mensajes publicados en streaming_success_topic. Para fines de este instructivo, los archivos transferidos correctamente se archivan en un depósito de Cloud Storage de la clase Coldline.

  1. Crea tu 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 transferidos correctamente.

    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 que maneje los archivos transferidos correctamente. 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)"
    

    El resultado es el siguiente:

    ┌─────────────┬────────┬─────────────────────────────┐
    │ 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 correctamente a través de toda la canalización. A fin de asegurarte de que todo se comporte correctamente, debes verificar todas las ubicaciones de almacenamiento: BigQuery, Cloud Firestore y los depósitos de 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 tus datos en BigQuery.

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

    Este comando hace que se muestre el contenido del archivo data.json:

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

    IR A LA PÁGINA DE Cloud 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 utiliza el nombre del archivo como 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 transferido del depósito FILES_SOURCE.

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

    El resultado es un mensaje de tipo CommandException porque el archivo ya no existe en el depósito FILES_SOURCE.

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

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

    El resultado es el siguiente:

    TOTAL: 1 objects, 312 bytes.
    

Transfiere archivos que ya se hayan procesado

El nombre del archivo se utiliza como ID de documento en Cloud Firestore. Esto facilita que la función streaming pueda consultar si un archivo determinado se procesó o no. 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}
    

    El resultado es el siguiente:

    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 es el siguiente:

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

    IR A LA PÁGINA DE Cloud Firestore

  4. En el documento /streaming_filesdata.json, verifica que se haya agregado el nuevo campo **duplication_attempts**.

    Verifica que la función "streaming" almacene la cantidad de "duplication_attempts"

    Cada vez que se agrega al depósito FILES_SOURCE un archivo que tiene el mismo nombre que otro procesado con éxito previamente, el contenido del archivo se ignora y se agrega un nuevo intento de duplicación al campo **duplication_attempts** en Cloud 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 es el siguiente:

    TOTAL: 1 objects, 312 bytes.
    

    En el caso de la duplicación, la función streaming registra el comportamiento imprevisto 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 el archivo data_error.json al depósito FILES_SOURCE.

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

    El resultado es el siguiente:

    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 es el siguiente:

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

    IR A LA PÁGINA DE Cloud Firestore

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

    Verifica que la función "streaming" almacene el estado de error del archivo

    Para los archivos con errores, la función streaming también almacena un campo error_message, que te brinda información detallada sobre el motivo por el cual 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 un mensaje de tipo 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, según lo previsto.

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

    El resultado es el siguiente:

    TOTAL: 1 objects, 311 bytes.
    

Encuentra y soluciona problemas de transferencia de datos

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

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

Para ver los resultados de la consulta en tu entorno, haz lo siguiente:

  1. Crea un entorno virtual en tu carpeta firestore.

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

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

    python firestore/show_streaming_errors.py
    

    El archivo show_streaming_errors.py contiene la consulta de Cloud Firestore y código estándar adicional para repetir el resultado y darle formato a la información de salida. Cuando ejecutes el comando que se muestra antes, 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 tu 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, la siguiente configuración usa los mensajes logging.error(..) predeterminados de Python.

  1. En GCP 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 Crear Métrica (Create Metric).

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

    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 el Editor de métricas (Metric editor), completa los siguientes campos y haz clic en Crear métrica (Create Metric).

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

      Campos del editor de métricas

  6. En Monitoring, ve a Crear una política (Create a Policy) para crear una política de alertas.

    IR A STACKDRIVER MONITORING

  7. En la ventana Crear una política (Create a Policy), completa los siguientes pasos.

    1. Haz clic en Agregar condición (Add condition).
    2. Completa los siguientes campos y haz clic en Guardar (Save).

      • En el campo Título (Title), ingresa streaming-error-condition.
      • En el campo Métrica (Metric), ingresa logging/user/streaming-error.

        IU para agregar una condición en Monitoring

      • En la lista La condición se activa si (Condition triggers if), selecciona Alguna serie temporal infringe (Any time series violates).

      • En la lista Condición (Condition), selecciona supera (is above).

      • En el campo Umbral (Threshold), ingresa 0.

      • En la lista Durante (For), selecciona 1 minuto (1 minute).

        Activadores de la condición

    3. En la lista Tipo de canal de notificación (Notification Channel Type), selecciona Correo electrónico (Email), ingresa tu dirección de correo electrónico y haz clic en Agregar canal de notificación (Add Notification Channel).

    4. En el campo Ponle nombre a esta política (Name this policy), ingresa streaming-error-alert y haz clic en Guardar (Save).

Una vez que hayas guardado la política de alertas, Stackdriver supervisará los registros de errores de la función streaming y enviará una alerta por correo electrónico cada vez que haya errores de transmisión durante un intervalo de un minuto.

Limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

Cómo borrar el proyecto

  1. En la GCP Console, dirígete a la página Proyectos.

    Ir a la página Proyectos

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

Pasos siguientes

  • Revisa Eventos y activadores para aprender otras formas de activar una función sin servidores en GCP.
  • 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 Cloud Firestore para obtener más información sobre esta base de datos NoSQL de escala global.
  • Visita la página de 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 de Cuotas y límites de Cloud Functions para conocer el tamaño máximo que puede manejar una función implementada.
  • Prueba otras funciones de Google Cloud Platform. Revisa nuestros instructivos.
¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...