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

Last reviewed 2019-02-15 UTC

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 :

Les fichiers JSON sont importés dans le bucket Cloud Storage FILES_SOURCE.
Cet événement déclenche la fonction Cloud streaming.
Les données sont analysées et insérées dans BigQuery.
L'état d'ingestion est consigné dans Firestore et Cloud Logging.
Un message est publié dans l'un des sujets Pub/Sub suivants :
- streaming_success_topic
- streaming_error_topic
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

Dans ce document, vous utilisez 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

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud Functions and Cloud Build APIs.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud Functions and Cloud Build APIs.

Enable the APIs

Dans la console Google Cloud, accédez à Monitoring.
Accéder à Cloud Monitoring

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Configurer votre environnement

Dans ce tutoriel, vous utilisez Cloud Shell pour saisir des commandes. Cloud Shell vous donne accès à l'interface de ligne de commande dans la console Google Cloud. En outre, il intègre Google Cloud CLI ainsi que d'autres outils dont vous pourrez avoir besoin pour le développement dans Google Cloud. Cloud Shell apparaît sous la forme d'une fenêtre en bas de la console Google Cloud. 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 :

Dans Google Cloud Console, ouvrez Cloud Shell.

Ouvrir Cloud Shell
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]
```
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
```

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.

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
```

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 :

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}
```
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.

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 │
└────────────────┴────────┴────────────────────────────────┘

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}

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 :

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

Accéder à Firestore
Dans la fenêtre Choisir un mode Cloud Firestore, cliquez sur Sélectionner le mode natif.
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.

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}
```
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.

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.

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}
```

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}

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.

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.

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 |
+------------+-----------+------------+

Dans Google Cloud Console, accédez à la page Firestore.

Accéder à Firestore
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.
Revenez à Cloud Shell.

Accéder à Cloud Shell
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.
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.

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

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'

Voici le résultat :

+------------+-----------+------------+
| first_name | last_name |    dob     |
+------------+-----------+------------+
| John       | Doe       | 1968-01-22 |
+------------+-----------+------------+

Dans la console Google Cloud, accédez à la page "Firestore".

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

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.
Revenez à Cloud Shell.

Accéder à Cloud Shell
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.

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.

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'

Voici le résultat :

+------------+-----------+------------+
| first_name | last_name |    dob     |
+------------+-----------+------------+
| John       | Doe       | 1968-01-22 |
+------------+-----------+------------+

Dans Google Cloud Console, accédez à la page Firestore.

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

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.
Revenez à Cloud Shell.

Accéder à Cloud Shell
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.
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.

firestore/show_streaming_errors.py

Afficher sur GitHub

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 :

Créez un environnement virtuel dans le dossier firestore.

pip install virtualenv
virtualenv firestore
source firestore/bin/activate

Installez le module Python pour Firestore dans votre environnement virtuel.
```
pip install google-cloud-firestore
```

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

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.

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

Accéder à la page Métriques basées sur les journaux
Cliquez sur Créer une métrique.
Dans la liste Filter (Filtre), sélectionnez Convert to advanced filter (Convertir en filtre avancé).

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é

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).
Dans Cloud Console, accédez à Monitoring ou cliquez sur le bouton suivant :

Accéder à Monitoring
Dans le volet de navigation Monitoring, sélectionnez Alertes, puis Créer une règle.
Dans le champ Nommer cette règle, saisissez streaming-error-alert.
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.
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.
(Facultatif) Cliquez sur Documentation, puis ajoutez les informations à inclure dans le message de notification.
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 supprimez les ressources individuelles.

Supprimer le projet

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

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