Transférer des données en streaming de Cloud Storage vers BigQuery à l'aide de Cloud Functions

Ce tutoriel explique comment transférer de nouveaux objets en streaming d'un bucket Cloud Storage vers BigQuery à l'aide de Cloud Functions. Cloud Functions est une plate-forme de calcul Google Cloud sans serveur basée sur des événements, qui assure un scaling automatique, une haute disponibilité et une tolérance aux pannes sans serveur à provisionner, gérer, mettre à jour ou corriger. Transférez des données en streaming via Cloud Functions pour vous permettre de connecter et d'étendre d'autres services Google Cloud en ne payant que lorsque votre application est en cours d'exécution.

Cet article est destiné aux analystes de données, aux développeurs ou aux opérateurs, qui doivent exécuter une analyse quasiment en temps réel sur les fichiers ajoutés à Cloud Storage. Dans cet article, nous partons du principe que vous connaissez bien Linux, Cloud Storage et BigQuery.

Architecture

Tous les composants et l'intégralité du flux du pipeline de streaming de ce tutoriel sont représentés dans l'architecture illustrée ci-dessous. Bien que ce pipeline demande que vous importiez des fichiers JSON dans Cloud Storage, des modifications mineures du code sont nécessaires pour assurer la compatibilité avec d'autres formats de fichiers. L'ingestion d'autres formats de fichiers n'est pas traitée dans cet article.

Schéma de l'architecture du pipeline

Dans le schéma précédent, le pipeline comprend les étapes suivantes :

  1. Les fichiers JSON sont importés dans le bucket Cloud Storage FILES_SOURCE.
  2. Cet événement déclenche la fonction Cloud streaming.
  3. Les données sont analysées et insérées dans BigQuery.
  4. L'état d'ingestion est consigné dans Firestore et Cloud Logging.
  5. Un message est publié dans l'un des sujets Pub/Sub suivants :
    • streaming_success_topic
    • streaming_error_topic
  6. En fonction des résultats, Cloud Functions déplace le fichier JSON du bucket FILES_SOURCE vers l'un des buckets suivants :
    • FILES_ERROR
    • FILES_SUCCESS

Objectifs

  • Créer un bucket Cloud Storage pour stocker vos fichiers JSON
  • Créer un ensemble de données et une table BigQuery dans lesquels vous pouvez transférer vos données en streaming
  • Configurer une fonction Cloud pour qu'elle se déclenche chaque fois que des fichiers sont ajoutés à votre bucket
  • Configurer des sujets Cloud Pub/Sub
  • Configurer des fonctions supplémentaires pour gérer le résultat des fonctions
  • Tester votre pipeline de streaming
  • Configurer Cloud Monitoring pour qu'il vous alerte sur tout comportement inattendu

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

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

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API Cloud Functions and Cloud Build.

    Activer les API

  5. Dans Cloud Console, accédez à Monitoring :

    Accéder à Cloud Monitoring

Une fois que vous avez terminé ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Consultez la page Effectuer un nettoyage pour en savoir plus.

Configurer votre environnement

Dans ce tutoriel, vous utilisez Cloud Shell pour saisir des commandes. Cloud Shell vous permet d'accéder à la ligne de commande dans Cloud Console et comprend le SDK Cloud ainsi que d'autres outils dont vous avez besoin pour développer dans Google Cloud. Cloud Shell apparaît sous la forme d'une fenêtre en bas de Cloud Console. L'initialisation peut prendre quelques minutes, mais la fenêtre apparaît immédiatement.

Pour configurer votre environnement et cloner le dépôt git utilisé dans ce tutoriel à l'aide de Cloud Shell, procédez comme suit :

  1. Dans Cloud Console, ouvrez Cloud Shell.

    Ouvrir Cloud Shell

  2. Assurez-vous que vous travaillez dans le projet que vous venez de créer. Remplacez [YOUR_PROJECT_ID] par votre projet Google Cloud nouvellement créé.

    gcloud config set project [YOUR_PROJECT_ID]
    
  3. Définissez la zone de calcul par défaut. Pour les besoins de ce tutoriel, il s'agit de us-east1. Si vous effectuez un déploiement dans un environnement de production, déployez dans une région de votre choix.

    REGION=us-east1
    
  4. Clonez le dépôt contenant les fonctions utilisées dans ce tutoriel.

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

Créer une source de streaming et un récepteur de destination

Pour insérer du contenu en streaming dans BigQuery, vous devez disposer d'un bucket Cloud Storage FILES_SOURCE et d'une table de destination dans BigQuery.

Créer le bucket Cloud Storage

Vous allez créer un bucket Cloud Storage qui représente la source du pipeline de streaming présenté dans ce tutoriel. L'objectif principal de ce bucket est le stockage temporaire des fichiers JSON qui sont insérés en streaming dans BigQuery.

  • Créez votre bucket Cloud Storage FILES_SOURCE, dans lequel FILES_SOURCE est configuré en tant que variable d'environnement avec un nom unique.

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

Créer la table BigQuery

Cette section explique comment créer une table BigQuery utilisée comme destination de contenu pour vos fichiers. BigQuery vous permet de spécifier le schéma de la table lorsque vous chargez des données dans celle-ci ou lorsque vous créez une table. Dans cette section, vous allez créer la table et spécifier son schéma en même temps.

  1. Créez une table et un ensemble de données BigQuery. Le schéma défini dans le fichier schema.json doit correspondre au schéma des fichiers provenant du bucket FILES_SOURCE.

    bq mk mydataset
    bq mk mydataset.mytable schema.json
    
  2. Vérifiez que la table a été créée.

    bq ls --format=pretty mydataset
    

    Le résultat est le suivant :

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

Insérer des données en streaming dans BigQuery

Maintenant que vous avez créé la source et le récepteur de destination, vous allez créer la Fonction Cloud permettant de transférer des données en streaming de Cloud Storage vers BigQuery.

Configurer la fonction Cloud "streaming"

La fonction "streaming" repère les nouveaux fichiers ajoutés au bucket FILES_SOURCE, puis déclenche un processus qui effectue les opérations suivantes :

  • Analyse et validation du fichier
  • Vérification de l'absence de doublons
  • Insertion du contenu du fichier dans BigQuery
  • Journalisation de l'état d'ingestion dans Firestore et Logging
  • Publication d'un message dans un sujet d'erreur ou de réussite dans Pub/Sub

Pour déployer la fonction, procédez comme suit :

  1. Créez un bucket Cloud Storage pour organiser vos fonctions lors du déploiement, dans lequel FUNCTIONS_BUCKET est configuré en tant que variable d'environnement avec un nom unique.

    FUNCTIONS_BUCKET=${DEVSHELL_PROJECT_ID}-functions-$(date +%s)
    gsutil mb -c regional -l ${REGION} gs://${FUNCTIONS_BUCKET}
    
  2. Déployez la fonction streaming Le code de mise en œuvre se trouve dans le dossier ./functions/streaming. Cette opération peut prendre quelques minutes.

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

    Ce code déploie une fonction Cloud rédigée en Python, nommée streaming. Elle se déclenche chaque fois qu'un fichier est ajouté à votre bucket FILES_SOURCE.

  3. Vérifiez que la fonction a été déployée.

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

    Le résultat est le suivant :

    ┌────────────────┬────────┬────────────────────────────────┐
    │  ENTRY_POINT   │ STATUS │           EVENT_TYPE           │
    ├────────────────┼────────┼────────────────────────────────┤
    │ streaming      │ ACTIVE │ google.storage.object.finalize │
    └────────────────┴────────┴────────────────────────────────┘
    
  4. Provisionnez un sujet Pub/Sub, nommé streaming_error_topic, pour gérer le chemin d'erreur.

    STREAMING_ERROR_TOPIC=streaming_error_topic
    gcloud pubsub topics create ${STREAMING_ERROR_TOPIC}
    
  5. Provisionnez un sujet Pub/Sub, nommé streaming_success_topic, pour gérer le chemin de réussite.

    STREAMING_SUCCESS_TOPIC=streaming_success_topic
    gcloud pubsub topics create ${STREAMING_SUCCESS_TOPIC}
    

Configurer votre base de données Cloud Firestore

Pendant que les données sont insérées en streaming dans BigQuery, il est important de comprendre ce qui se passe lors de chaque ingestion de fichier. Par exemple, supposons que vous ayez des fichiers qui ont été importés de manière incorrecte. Dans ce cas, vous devez identifier la cause première du problème et le résoudre pour éviter de générer des données corrompues et des rapports inexacts à la fin du pipeline. La fonction streaming, déployée dans la section précédente, stocke l'état d'ingestion des fichiers dans des documents Firestore afin que vous puissiez interroger les erreurs récentes et résoudre les éventuels problèmes.

Pour créer votre instance Cloud Firestore, procédez comme suit :

  1. Dans Google Cloud Console, accédez à Cloud Firestore.

    Accéder à Firestore

  2. Dans la fenêtre Choisir un mode Cloud Firestore, cliquez sur Sélectionner le mode natif.

  3. Dans la liste Sélectionnez un emplacement, sélectionnez nam5 (États-Unis), puis cliquez sur Créer une base de données. Attendez la fin de l'initialisation de Firestore. Cette opération prend généralement quelques minutes.

Gérer les erreurs de streaming

Pour provisionner un chemin afin de gérer les fichiers d'erreur, vous devez déployer une autre fonction Cloud qui repère les messages publiés dans streaming_error_topic. Les besoins de votre entreprise déterminent la manière dont vous gérez ces erreurs dans un environnement de production. Pour les besoins de ce tutoriel, les fichiers problématiques sont déplacés vers un autre bucket Cloud Storage afin de faciliter le dépannage.

  1. Créez le bucket Cloud Storage permettant de stocker les fichiers problématiques. FILES_ERROR est configuré en tant que variable d'environnement avec un nom unique pour le bucket qui stocke les fichiers d'erreur.

    FILES_ERROR=${DEVSHELL_PROJECT_ID}-files-error-$(date +%s)
    gsutil mb -c regional -l ${REGION} gs://${FILES_ERROR}
    
  2. Déployez la fonction streaming_error permettant de gérer les erreurs. Cette opération peut prendre quelques minutes.

    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}
    

    Cette commande est semblable à la celle permettant de déployer la fonction streaming, à une différence près. Dans cette commande, la fonction est déclenchée par un message publié dans un sujet et reçoit deux variables d'environnement : la variable SOURCE_BUCKET, depuis laquelle les fichiers sont copiés, et la variable DESTINATION_BUCKET, dans laquelle ils sont copiés.

  3. Vérifiez que la fonction streaming_error a été créée.

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

    Le résultat est le suivant :

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

Gérer un streaming réussi

Pour provisionner un chemin afin de gérer les fichiers de réussite, vous devez déployer une troisième fonction Cloud qui repère les messages publiés dans streaming_success_topic. Pour les besoins de ce tutoriel, les fichiers ingérés avec succès sont archivés dans un bucket Cloud Storage Coldline.

  1. Créez votre bucket Cloud Storage Coldline. FILES_SUCCESS est configuré en tant que variable d'environnement avec un nom unique pour le bucket qui stocke les fichiers de réussite.

    FILES_SUCCESS=${DEVSHELL_PROJECT_ID}-files-success-$(date +%s)
    gsutil mb -c coldline -l ${REGION} gs://${FILES_SUCCESS}
    
  2. Déployez la fonction streaming_success pour gérer les réussites. Cette opération peut prendre quelques minutes.

    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. Vérifiez que la fonction a été créée.

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

    Le résultat est le suivant :

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

Tester le pipeline de streaming

Vous avez désormais terminé la création de votre pipeline de streaming. Vous devez maintenant tester différents chemins. Tout d'abord, vous allez tester l'ingestion de nouveaux fichiers, puis l'ingestion de fichiers en double et enfin l'ingestion de fichiers problématiques.

Ingérer de nouveaux fichiers

Pour tester l'ingestion de nouveaux fichiers, vous allez importer un fichier qui doit parcourir l'intégralité du pipeline avec succès. Pour vous assurer que tout fonctionne correctement, vous devez vérifier tous les éléments de stockage : BigQuery, Firestore et les buckets Cloud Storage.

  1. Importez le fichier data.json dans le bucket FILES_SOURCE.

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

    Le résultat se présente comme suit :

    Operation completed over 1 objects/312.0 B.
    
  2. Interrogez les données dans BigQuery.

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

    Cette commande génère le contenu du fichier data.json :

    +------------+-----------+------------+
    | first_name | last_name |    dob     |
    +------------+-----------+------------+
    | John       | Doe       | 1968-01-22 |
    +------------+-----------+------------+
    
  3. Dans Cloud Console, accédez à la page Firestore.

    Accéder à Firestore

  4. Accédez au document / > streaming_files > data.json pour vérifier que le champ success: true est présent. La fonction streaming stocke l'état du fichier dans une collection appelée streaming_files et utilise le nom du fichier comme ID de document.

    Vérification que la fonction "streaming" stocke l'état de réussite du fichier

  5. Revenez à Cloud Shell.

    Accéder à Cloud Shell

  6. Vérifiez que le fichier ingéré a été supprimé du bucket FILES_SOURCE par la fonction streaming_success.

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

    Le résultat est une CommandException, car le fichier n'existe plus dans le bucket FILES_SOURCE.

  7. Vérifiez que le fichier ingéré se trouve maintenant dans le bucket FILES_SUCCESS.

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

    Le résultat est le suivant :

    TOTAL: 1 objects, 312 bytes.
    

Ingérer des fichiers déjà traités

Le nom de fichier est utilisé comme ID de document dans Cloud Firestore. La fonction streaming peut ainsi facilement demander si un fichier donné a été traité ou non. Si un fichier a déjà été ingéré avec succès, toute nouvelle tentative d'ajout de fichier est ignorée, car cela dupliquerait des informations dans BigQuery et donnerait lieu à des rapports inexacts.

Dans cette section, vous allez vérifier que le pipeline fonctionne comme prévu lorsque des fichiers en double sont importés dans le bucket FILES_SOURCE.

  1. Importez à nouveau le même fichier data.json dans le bucket FILES_SOURCE.

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

    Le résultat est le suivant :

    Operation completed over 1 objects/312.0 B.
    
  2. L'interrogation de BigQuery renvoie le même résultat qu'auparavant. Cela signifie que le pipeline a traité le fichier, mais qu'il n'a pas inséré son contenu dans BigQuery, car il avait déjà été ingéré.

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

    Le résultat est le suivant :

    +------------+-----------+------------+
    | first_name | last_name |    dob     |
    +------------+-----------+------------+
    | John       | Doe       | 1968-01-22 |
    +------------+-----------+------------+
    
  3. Dans Cloud Console, accédez à la page "Firestore".

    Accéder à Firestore

  4. Dans le document / > streaming_files > data.json, vérifiez que le champ **duplication_attempts** a été ajouté.

    Vérification que la fonction "streaming" stocke l'élément "duplication_attempts"

    Chaque fois qu'un fichier est ajouté au bucket FILES_SOURCE avec le même nom qu'un fichier traité précédemment, son contenu est ignoré et une nouvelle tentative de duplication est ajoutée au champ **duplication_attempts** dans Firestore.

  5. Revenez à Cloud Shell.

    Accéder à Cloud Shell

  6. Vérifiez que le fichier en double se trouve toujours dans le bucket FILES_SOURCE.

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

    Le résultat est le suivant :

    TOTAL: 1 objects, 312 bytes.
    

    Dans le scénario de duplication, la fonction streaming consigne le comportement inattendu dans Logging, ignore l'ingestion et laisse le fichier dans le bucket FILES_SOURCE pour une analyse ultérieure.

Ingérer des fichiers avec des erreurs

Maintenant que vous avez confirmé que votre pipeline de streaming fonctionne et que les doublons ne sont pas ingérés dans BigQuery, vous pouvez vérifier le chemin d'erreur.

  1. Importez data_error.json dans le bucket FILES_SOURCE.

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

    Le résultat est le suivant :

    Operation completed over 1 objects/311.0 B.
    
  2. L'interrogation de BigQuery renvoie le même résultat qu'auparavant. Cela signifie que le pipeline a traité le fichier, mais qu'il n'a pas inséré le contenu dans BigQuery, car celui-ci ne respecte pas le schéma attendu.

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

    Le résultat est le suivant :

    +------------+-----------+------------+
    | first_name | last_name |    dob     |
    +------------+-----------+------------+
    | John       | Doe       | 1968-01-22 |
    +------------+-----------+------------+
    
  3. Dans Cloud Console, accédez à la page Firestore.

    Accéder à Firestore

  4. Dans le document / > streaming_files > data_error.json, vérifiez que le champ success: false a été ajouté.

    Vérification que la fonction "streaming" stocke l'état d'erreur du fichier

    Pour les fichiers contenant des erreurs, la fonction streaming stocke également un champ error_message, qui fournit des informations détaillées sur la raison du défaut d'ingestion du fichier.

  5. Revenez à Cloud Shell.

    Accéder à Cloud Shell

  6. Vérifiez que le fichier a été supprimé du bucket FILES_SOURCE par la fonction streaming_error.

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

    Le résultat est une CommandException, car le fichier n'existe plus dans le bucket FILES_SOURCE.

  7. Vérifiez que le fichier se trouve maintenant dans le bucket FILES_ERROR, comme prévu.

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

    Le résultat est le suivant :

    TOTAL: 1 objects, 311 bytes.
    

Trouver et résoudre les problèmes d'ingestion de données

L'exécution de requêtes sur la collection streaming_files dans Firestore vous permet de diagnostiquer et de résoudre rapidement les problèmes. Dans cette section, vous allez filtrer tous les fichiers d'erreur à l'aide de l'API Python standard pour Firestore.

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

Pour afficher les résultats de la requête dans votre environnement, procédez comme suit :

  1. Créez un environnement virtuel dans le dossier firestore.

    pip install virtualenv
    virtualenv firestore
    source firestore/bin/activate
    
  2. Installez le module Python pour Firestore dans votre environnement virtuel.

    pip install google-cloud-firestore
    
  3. Visualisez les problèmes de pipeline existants.

    python firestore/show_streaming_errors.py
    

    Le fichier show_streaming_errors.py contient la requête Firestore et un autre code standard permettant la mise en boucle et le formatage du résultat. Après l'exécution de la commande précédente, le résultat ressemble à ceci :

    +-----------------+-------------------------+----------------------------------------------------------------------------------+
    | 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. Désactivez votre environnement virtuel lorsque vous avez terminé l'analyse.

    deactivate
    

    Une fois que vous avez trouvé et corrigé les fichiers problématiques, importez-les à nouveau dans le bucket FILES_SOURCE avec le même nom de fichier. Ce processus les oblige à parcourir l'intégralité du pipeline de streaming pour insérer leur contenu dans BigQuery.

Alerter sur les comportements inattendus

Dans les environnements de production, il est important de surveiller et d'alerter sur chaque événement imprévu. Les métriques personnalisées constituent l'une des nombreuses fonctionnalités de Logging. Elles vous permettent de créer des règles d'alerte afin de vous informer, vous et votre équipe, lorsqu'une métrique répond aux critères spécifiés.

Dans cette section, vous allez configurer Monitoring pour qu'il envoie des alertes par e-mail en cas d'échec d'ingestion de fichier. Pour identifier une ingestion en échec, la configuration suivante utilise les messages logging.error(..) Python par défaut.

  1. Dans Cloud Console, accédez à la page "Métriques basées sur les journaux".

    Accéder à la page Métriques basées sur les journaux

  2. Cliquez sur Créer une métrique.

  3. Dans la liste Filter (Filtre), sélectionnez Convert to advanced filter (Convertir en filtre avancé).

    Menu de filtre avancé

  4. Dans le filtre avancé, collez la configuration suivante.

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

    Configuration à coller dans le filtre avancé

  5. Dans le panneau Metric Editor (Éditeur de métriques), renseignez les champs suivants, puis cliquez sur Create Metric (Créer la métrique).

    • Dans le champ Name (Nom), saisissez streaming-error.
    • Dans le champ Name (Nom) de la section Label (Libellé), saisissez payload_error.
    • Dans la liste Label type (Type d'étiquette), sélectionnez String (Chaîne).
    • Dans la liste Field name (Nom du champ), sélectionnez textPayload.
    • Dans le champ Extraction regular expression (Expression régulière d'extraction), saisissez (Error streaming file '.*'.).
    • Dans la liste Type, sélectionnez Counter (Compteur).

      Champs de l'éditeur de métriques

  6. Dans Cloud Console, accédez à Monitoring ou cliquez sur le bouton suivant :

    Accéder à Monitoring

  7. Dans le volet de navigation Monitoring, sélectionnez  Alertes, puis Créer une règle.

  8. Dans le champ Nommer cette règle, saisissez streaming-error-alert.

  9. Cliquez sur Ajouter une condition :

    • Dans le champ Titre, saisissez streaming-error-condition.
    • Dans le champ Métrique, saisissez logging/user/streaming-error.
    • Dans la liste La condition se déclenche, sélectionnez À chaque infraction de série temporelle.
    • Dans la liste Condition, sélectionnez est supérieure à.
    • Dans le champ Seuil, saisissez 0.
    • Dans la liste Pendant, sélectionnez 1 minute.
  10. Dans la liste Type de canal de notification, sélectionnez E-mail, saisissez votre adresse e-mail, puis cliquez sur Ajouter un canal de notification.

  11. (Facultatif) Cliquez sur Documentation, puis ajoutez les informations à inclure dans le message de notification.

  12. Cliquez sur Enregistrer.

Une fois la règle d'alerte enregistrée, Monitoring surveille les journaux d'erreurs de la fonction streaming et envoie une alerte par e-mail chaque fois que des erreurs de streaming se produisent pendant une minute.

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et les ressources individuelles.

Supprimer le projet

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante

  • Consultez la page Événements et déclencheurs pour découvrir d'autres façons de déclencher une fonction sans serveur dans Google Cloud.
  • Consultez la page relative aux alertes pour découvrir comment améliorer la règle d'alerte définie dans ce tutoriel.
  • Consultez la documentation de Firestore pour en savoir plus sur cette base de données NoSQL à l'échelle mondiale.
  • Consultez la page Quotas et limites de BigQuery pour comprendre les limites d'insertion en streaming lors de la mise en œuvre de cette solution dans un environnement de production.
  • Consultez la page relative aux quotas et aux limites de Cloud Functions pour connaître la taille maximale qu'une fonction déployée peut gérer.
  • Explorez des architectures de référence, des schémas, des tutoriels et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.