Utiliser l'interface de surveillance Dataflow

Lorsque vous exécutez votre pipeline à l'aide du service géré Dataflow, vous pouvez afficher la tâche correspondante et toute autre tâche au moyen de l'interface utilisateur Web de surveillance Dataflow. Elle vous permet de voir vos tâches Dataflow et d'interagir avec.

Vous pouvez accéder à l'interface de surveillance Dataflow à l'aide de Google Cloud Console. L'interface de surveillance peut vous montrer :

  • la liste de toutes les tâches Dataflow en cours d'exécution et des tâches précédemment exécutées au cours des 30 derniers jours ;
  • une représentation graphique de chaque pipeline ;
  • les détails de l'état, de l'exécution et de la version du SDK de votre tâche ;
  • des liens vers des informations sur les services Google Cloud exécutant votre pipeline (tels que Compute Engine et Cloud Storage) ;
  • toute erreur ou avertissement survenus au cours d'une tâche.

Vous pouvez afficher les graphiques de surveillance des tâches dans l'interface de surveillance Dataflow. Ces graphiques affichent des métriques sur la durée d'une tâche de pipeline et incluent les informations suivantes :

  • Visibilité au niveau des étapes pour identifier celles susceptibles de causer un retard de pipeline
  • Informations statistiques pouvant révéler un comportement anormal
  • Métriques d'E/S pouvant vous aider à identifier les goulots d'étranglement dans vos sources et vos récepteurs

Accéder à l'interface de surveillance Dataflow

Pour accéder à l'interface de surveillance Dataflow, procédez comme suit :

  1. Connectez-vous à Cloud Console.
  2. Sélectionnez votre projet Google Cloud.
  3. Cliquez sur le menu en haut à gauche.
  4. Accédez à la section Big Data et cliquez sur Dataflow.

Une liste des tâches Dataflow ainsi que leur état respectif apparaissent. Si vous ne voyez aucune tâche, vous devez en exécuter une nouvelle. Pour savoir comment exécuter une tâche, consultez les guides de démarrage rapide de Dataflow.

Liste des tâches Cloud Dataflow en cours, ayant échoué et ayant réussi.
Figure 1 : Liste des tâches Dataflow dans Cloud Console ayant l'état Running (En cours d'exécution), Failed (Échec) et Succeeded (Réussie).

Une tâche peut présenter les états suivants :

  •  : l'interface de surveillance n'a pas encore reçu d'information d'état de la part du service Dataflow.
  • Running (En cours d'exécution) : la tâche est en cours d'exécution.
  • Not started (Non démarrée) : la tâche est créée, mais le système a besoin d'un certain temps pour se préparer avant de la lancer.
  • Queued (En file d'attente) : une tâche FlexRS est en file d'attente.
  • Cancelling… (Annulation…) : la tâche est en cours d'annulation.
  • Cancelled (Annulée) : la tâche a été annulée par l'utilisateur.
  • Draining… (Drainage…) : la tâche est en cours de drainage.
  • Drained (Drainée) : l'utilisateur a drainé la tâche.
  • Updating… (Mise à jour…) : la tâche est en cours de mise à jour.
  • Updated (Mise à jour) : l'utilisateur a mis à jour la tâche.
  • Succeeded (Réussie) : la tâche s'est correctement terminée.
  • Failed (Échec) : la tâche n'a pas abouti.

Pour plus d'informations sur un pipeline, cliquez sur le nom de cette tâche.

Accéder aux graphiques de surveillance des tâches

Pour accéder à un graphique de surveillance d'une tâche, cliquez sur son nom dans l'interface de surveillance Dataflow. Vous accédez ainsi à la page Job details (Informations sur la tâche), qui contient les éléments suivants :

  • Job graph (Graphique de la tâche) : représentation visuelle de votre pipeline
  • Job metrics (Métriques de tâche) : métriques sur l'exécution de votre tâche
  • Volet Job info (Informations sur la tâche) : informations descriptives sur votre pipeline
  • Job logs (Journaux de la tâche) : journaux générés par le service Dataflow au niveau de la tâche
  • Worker logs (Journaux de nœud de calcul) : journaux générés par le service Dataflow au niveau du nœud de calcul
  • Job error reporting (Rapports d'erreurs liés aux tâches) : graphiques indiquant où les erreurs se sont produites tout au long de la chronologie choisie et le nombre de toutes les erreurs consignées
  • Time selector (Sélecteur de temps) : outil permettant d'ajuster la période de vos métriques

Sur la page Job details (Informations sur la tâche), vous pouvez changer de vue à l'aide des onglets Job graph (Graphique de la tâche) et Job metrics (Métriques de tâche).

Vue de l'interface utilisateur de surveillance Dataflow, dans laquelle l'onglet

Vue de l'interface utilisateur de surveillance Dataflow, dans laquelle l'onglet

Pour revenir à l'ancienne page Job details (Informations sur la tâche), cliquez sur Back to old job page (Revenir à l'ancienne page des tâches) en haut de la page.

Mode plein écran

Pour afficher un graphique de métriques en plein écran, cliquez sur .

Utiliser le sélecteur de temps

Vous pouvez ajuster la période des métriques à l'aide du sélecteur de temps. Vous pouvez sélectionner une durée prédéfinie ou un intervalle de temps personnalisé pour analyser votre tâche.

Le sélecteur de temps vous permet de sélectionner une période en utilisant des incréments d'heures et de jours ou une plage personnalisée.

Pour les tâches par flux ou par lot en cours d'exécution, l'affichage par défaut des graphiques comporte les six dernières heures de métriques pour cette tâche. Pour les tâches par flux arrêtées ou terminées, l'affichage par défaut des graphiques comporte la durée totale d'exécution de la tâche.

Métriques des étapes et des nœuds de calcul

Vous pouvez afficher des graphiques pour les métriques suivantes :

  • Fraîcheur des données (pipelines de traitement par flux uniquement)
  • Latence du système (pipelines de traitement par flux uniquement)
  • Autoscaling
  • Débit
  • Utilisation du processeur
  • Décompte de journal d'erreur de nœud de calcul

Pour accéder à ces graphiques, cliquez sur le bouton d'activation de la légende "Expand chart legend" (Développer la légende du graphique).

Le bouton d'activation de la légende se trouve à côté du bouton

Débit

Le débit correspond au volume de données traitées à tout moment. Cette métrique par étape est affichée en tant que nombre d'éléments par seconde. Pour afficher cette métrique en octets par seconde, cliquez sur Throughput (elements/sec) (Débit (éléments/s))  > Throughput (bytes/sec) (Débit (octets/s)).

Visualisation des données montrant le débit de quatre étapes d'un pipeline.

Utilisation du processeur

L'utilisation du processeur correspond à la quantité de processeur utilisée, divisée par la quantité de processeur disponible pour le traitement. Cette métrique par nœud de calcul est affichée sous forme de pourcentage.

Visualisation des données montrant l'utilisation du processeur dans un nœud de calcul Dataflow.

Créer des alertes Cloud Monitoring

Dataflow est entièrement intégré à Cloud Monitoring, qui vous permet de créer des alertes lorsque votre tâche dépasse un seuil défini par l'utilisateur.

Pour obtenir des instructions concernant la création de ces alertes, consultez la page Utiliser Cloud Monitoring pour les pipelines Dataflow.

Afficher un pipeline

Lorsque vous sélectionnez une tâche Dataflow spécifique, l'interface de surveillance affiche des informations détaillées sur le pipeline dans cette tâche. Ces informations incluent une représentation graphique de votre pipeline tel qu'il est exécuté sur le service Dataflow, ainsi qu'un résumé de la tâche, le journal de celle-ci et des informations détaillées sur chaque étape du pipeline.

L'interface de surveillance Dataflow offre une représentation graphique de votre pipeline : le graphique d'exécution. Sur le graphique d'exécution d'un pipeline, chaque transformation est représentée sous la forme d'une case. Chaque case contient le nom de la transformation et certaines informations sur son état, par exemple :

  • Running (En cours d'exécution) : l'étape est en cours d'exécution.
  • Queued (En file d'attente) : l'étape d'une tâche FlexRS est en file d'attente.
  • Succeeded (Réussie) : l'étape s'est terminée avec succès.
  • Stopped (Arrêtée) : l'étape a été arrêtée, car la tâche s'est arrêtée.
  • Unknown (Inconnu) : l'étape n'a pas pu indiquer l'état.
  • Failed (Échec) : l'étape n'a pas abouti.

Graphique d'exécution de base

Code du pipeline :

Java : SDK 2.x


  // Read the lines of the input text.
  p.apply("ReadLines", TextIO.read().from(options.getInputFile()))
     // Count the words.
     .apply(new CountWords())
     // Write the formatted word counts to output.
     .apply("WriteCounts", TextIO.write().to(options.getOutput()))
         .to(options.getOutput()));

Python


(
    p
    # Read the lines of the input text.
    | 'ReadLines' >> beam.io.ReadFromText(options.input)
    # Count the words.
    | CountWords()
    # Write the formatted word counts to output.
    | 'WriteCounts' >> beam.io.WriteToText(options.output))

Java : SDK 1.x

Graphique d'exécution :

Graphique d'exécution d'un pipeline WordCount tel qu'il s'affiche dans l'interface de surveillance de Cloud Dataflow.

Figure 2 : Code du pipeline WordCount affiché côte à côte avec le graphique d'exécution obtenu dans l'interface de surveillance Dataflow.

Transformations composites

Dans le graphique d'exécution, vous pouvez développer les transformations composites (qui contiennent plusieurs sous-transformations imbriquées). Les transformations composites que vous pouvez développer sont identifiées par une flèche. Cliquez sur cette flèche pour développer la transformation et afficher les sous-transformations qu'elle contient.

Code du pipeline :

Java : SDK 2.x


  // The CountWords Composite Transform
  // inside the WordCount pipeline.

  public static class CountWords
    extends PTransform<PCollection<String>, PCollection<String>> {

    @Override
    public PCollection<String> apply(PCollection<String> lines) {

      // Convert lines of text into individual words.
      PCollection<String> words = lines.apply(
        ParDo.of(new ExtractWordsFn()));

      // Count the number of times each word occurs.
      PCollection<KV<String, Long>> wordCounts =
        words.apply(Count.<String>perElement());

      return wordCounts;
    }
  }

Remarque : Dans l'image de droite, l'étape FormatCounts n'est pas pertinente pour ce SDK.

Python


# The CountWords Composite Transform inside the WordCount pipeline.
class CountWords(beam.PTransform):
  def expand(self, pcoll):
    return (
        pcoll
        # Convert lines of text into individual words.
        | 'ExtractWords' >> beam.ParDo(ExtractWordsFn())
        # Count the number of times each word occurs.
        | beam.combiners.Count.PerElement()
        # Format each word and count into a printable string.
        | 'FormatCounts' >> beam.ParDo(FormatCountsFn()))

Java : SDK 1.x

Graphique d'exécution :

Graphique d'exécution d'un pipeline WordCount, avec la transformation CountWords développée de façon à afficher les sous-transformations qui la constituent.

Figure 3 : Code du pipeline correspondant aux sous-étapes de la transformation CountWords, affiché côte à côte avec le graphique d'exécution développé pour l'ensemble du pipeline.

Noms de transformation

Dataflow propose plusieurs solutions pour obtenir le nom de la transformation apparaissant dans le graphique d'exécution de l'interface de surveillance :

Java : SDK 2.x

  • Dataflow peut utiliser un nom que vous attribuez lorsque vous appliquez votre transformation. Le premier argument que vous fournissez à la méthode apply sert de nom à la transformation.
  • Dataflow peut déduire le nom de la transformation soit du nom de la classe (si vous avez créé une transformation personnalisée), soit du nom de votre objet fonction DoFn (si vous utilisez une transformation de base telle que ParDo).

Python

  • Dataflow peut utiliser un nom que vous attribuez lorsque vous appliquez votre transformation. Vous pouvez définir le nom d'une transformation en spécifiant l'argument label de celle-ci.
  • Dataflow peut déduire le nom de la transformation soit du nom de la classe (si vous avez créé une transformation personnalisée), soit du nom de votre objet fonction DoFn (si vous utilisez une transformation de base telle que ParDo).

Java : SDK 1.x

Comprendre les métriques

Durée d'exécution

Lorsque vous cliquez sur une étape, la métrique Wall time (Durée d'exécution) s'affiche. Cette durée d'exécution fournit une approximation du temps total passé sur l'ensemble des threads et la totalité des nœuds de calcul pour les actions suivantes :

  • Initialisation de l'étape
  • Traitement des données
  • Mélange des données
  • Clôture de l'étape

Pour les étapes composites, il s'agit de la durée cumulée des étapes des composants. Cette estimation peut vous aider à identifier les étapes particulièrement lentes et à déterminer quelles parties de votre pipeline prennent plus de temps qu'elles ne le devraient.

Vous pouvez afficher le temps nécessaire à l'exécution d'une étape de votre pipeline.
Figure 4 : La métrique Wall time (Durée d'exécution) peut vous aider à vérifier que votre pipeline fonctionne efficacement.

Pour déterminer ce qui ralentit l'exécution d'un pipeline, consultez l'article Understanding timing in Dataflow pipelines (Comprendre la gestion du temps dans les pipelines Cloud Dataflow). Il comporte un exemple utilisant la métrique Wall Time (Durée d'exécution), précédemment appelée Total Execution Time (Temps total d'exécution).

Métriques des entrées secondaires

Les métriques des entrées secondaires vous montrent comment les modèles et algorithmes d'accès aux entrées secondaires affectent les performances de votre pipeline. Lorsque votre pipeline utilise une entrée secondaire, Dataflow écrit la collection sur une couche persistante (telle qu'un disque), et vos transformations lisent les données à partir de cette collection persistante. Ces lectures et écritures affectent le temps d'exécution de votre tâche.

L'interface de surveillance Dataflow affiche les métriques des entrées secondaires lorsque vous sélectionnez une transformation qui crée ou absorbe une collection d'entrée secondaire. Vous pouvez consulter les métriques dans la section Side Input Metrics (Métriques des entrées secondaires) de l'onglet Step (Étape).

Transformations créant une entrée secondaire

Si la transformation sélectionnée crée une collection de l'entrée secondaire, la section Side Input Metrics (Métriques des entrées secondaires) affiche le nom de la collection, ainsi que les métriques suivantes :

  • Time spent writing (Durée de l'écriture) : temps d'exécution passé à écrire la collection de l'entrée secondaire.
  • Bytes written (Octets écrits) : nombre total d'octets écrits dans la collection de l'entrée secondaire.
  • Time & bytes read from side input (Durée de la lecture et octets lus à partir des entrées secondaires) : tableau contenant des métriques supplémentaires pour toutes les transformations absorbant la collection de l'entrée secondaire. Ces transformations sont appelées side input consumers (consommateurs de l'entrée secondaire).

Le tableau Time & bytes read from side input (Durée de la lecture et octets lus à partir des entrées secondaires) contient les informations suivantes pour chaque consommateur de l'entrée secondaire :

  • Side input consumer (Consommateur de l'entrée secondaire) : nom de la transformation consommant l'entrée secondaire.
  • Time spent reading (Durée de la lecture) : temps passé par ce consommateur à lire la collection de l'entrée secondaire.
  • Bytes read (Octets lus) : nombre d'octets lus par ce consommateur à partir de la collection de l'entrée secondaire.

Si votre pipeline comporte une transformation composite qui crée une entrée secondaire, développez la transformation composite jusqu'à ce que la sous-transformation spécifique qui crée l'entrée secondaire s'affiche. Ensuite, sélectionnez cette sous-transformation pour afficher la section Side Input Metrics (Métriques des entrées secondaires).

La figure 5 illustre les métriques des entrées secondaires pour une transformation créant une collection d'entrée secondaire.

Vous pouvez sélectionner la sous-transformation. Ses métriques d'entrées secondaires sont alors visibles dans l'onglet
Figure 5 : Le graphique d'exécution comporte une transformation composite développée (MakeMapView). La sous-transformation créant l'entrée secondaire (CreateDataflowView) est sélectionnée, et les métriques des entrées secondaires sont visibles dans l'onglet Step (Étape).

Transformations consommant une ou plusieurs entrées secondaires

Si la transformation sélectionnée consomme une ou plusieurs entrées secondaires, la section Side Input Metrics (Métriques des entrées secondaires) affiche le tableau Time & bytes read from side input (Durée de la lecture et octets lus à partir des entrées secondaires). Ce tableau contient les informations suivantes pour chaque collection de l'entrée secondaire :

  • Side input collection (Collection de l'entrée secondaire) : nom de la collection de l'entrée secondaire.
  • Time spent reading (Durée de la lecture) : temps passé par la transformation à lire cette collection de l'entrée secondaire.
  • Bytes read (Octets lus) : nombre d'octets lus par la transformation dans la collection de l'entrée secondaire.

Si votre pipeline comporte une transformation composite qui lit une entrée secondaire, développez la transformation composite jusqu'à voir la sous-transformation spécifique qui lit l'entrée secondaire. Ensuite, sélectionnez cette sous-transformation pour afficher la section Side Input Metrics (Métriques des entrées secondaires).

La figure 6 illustre les métriques des entrées secondaires pour une transformation lisant une collection d'entrée secondaire.

Vous pouvez sélectionner la transformation. Ses métriques d'entrées secondaires sont alors visibles dans l'onglet
Figure 6 : La transformation JoinBothCollections lit une collection de l'entrée secondaire JoinBothCollections est sélectionnée dans le graphique d'exécution, et les métriques des entrées secondaires sont visibles dans l'onglet Step (Étape).

Identifier les problèmes de performances des entrées secondaires

La réitération est un problème de performances courant lié aux entrées secondaires. Si votre PCollection d'entrée secondaire est trop volumineuse, les nœuds de calcul ne peuvent pas mettre en cache l'intégralité de la collection. Par conséquent, les nœuds de calcul doivent régulièrement lire les données depuis le stockage persistant de la collection de l'entrée secondaire.

Dans la figure 7, les métriques des entrées secondaires montrent que le nombre total d'octets lus dans la collection de l'entrée secondaire est bien supérieur à la taille de la collection (nombre total d'octets écrits).

Vous pouvez sélectionner la transformation. Ses métriques d'entrées secondaires sont alors visibles dans l'onglet
Figure 7 : Exemple de réitération. La collection de l'entrée secondaire a une taille de 563 Mo, et la somme des octets lus par les transformations consommatrices atteint pratiquement 12 Go.

Pour améliorer les performances de ce pipeline, modifiez votre algorithme pour éviter les itérations ou la récupération répétée des données de l'entrée secondaires. Dans cet exemple, le pipeline calcule le produit cartésien de deux collections. Pour chaque élément de la collection principale, l'algorithme parcourt l'ensemble de la collection de l'entrée secondaire. Vous pouvez améliorer le modèle d'accès du pipeline en regroupant plusieurs éléments de la collection principale. Cette modification réduit le nombre de lectures de la collection de l'entrée secondaire requises par les nœuds de calcul.

Un autre problème de performances courant peut survenir si votre pipeline effectue une jointure en appliquant une fonction ParDo sur une ou plusieurs entrées secondaires volumineuses. Dans ce cas, les nœuds de calcul consacrent une large proportion du temps d'exécution de la jointure à lire les données des collections d'entrées secondaires.

La figure 8 illustre des exemples de métriques des entrées secondaires dans ce type de contexte :

Vous pouvez sélectionner la transformation. Ses métriques d'entrées secondaires sont alors visibles dans l'onglet
Figure 8 : Le temps total d'exécution de la transformation JoinBothCollections est de 18 min 31 s. Les nœuds de calcul passent la majeure partie du temps d'exécution (10 min 3 s) à lire la collection de l'entrée secondaire, qui a une taille de 10 Go.

Pour améliorer les performances de ce pipeline, utilisez CoGroupByKey au lieu des entrées secondaires.

Latence du système et fraîcheur des données

Le volet Job summary (Résumé de la tâche) vous permet de consulter des graphes illustrant les métriques de latence du système et de fraîcheur des données pour les six dernières heures. Les données sont échantillonnées toutes les 60 secondes. Après échantillonnage, les données ne sont pas visibles pendant un délai pouvant atteindre 180 secondes.

Latence du système

La latence du système correspond à la durée maximale actuelle d'un élément de données en cours de traitement ou en attente de traitement. Cette métrique indique le délai d'attente, en secondes, d'un élément dans une source du pipeline. La durée maximale est ajustée après le traitement. Les cas suivants sont également à prendre en considération :

  • S'il existe plusieurs sources et récepteurs, la latence du système correspond au délai d'attente le plus long d'un élément dans une source avant qu'il ne soit écrit dans tous les récepteurs.
  • Si aucune valeur n'est fournie par une source pour le délai d'attente d'un élément dans celle-ci et si l'élément ne dispose pas de métadonnées définissant son heure d'événement, la latence du système est calculée en fonction du moment où le pipeline reçoit l'élément.

Fraîcheur des données

La fraîcheur des données correspond au temps écoulé entre le temps réel et la marque de sortie. Une marque de données de sortie est associée à chaque étape de votre pipeline. La marque de données de sortie T indique que les ressources de calcul ont traité tous les éléments avec une heure d'événement antérieure à T. La marque de données de sortie a pour limite supérieure la marque de données d'entrée la plus ancienne de tous les calculs effectués en amont. Si certaines données d'entrée n'ont pas encore été traitées, la marque de sortie peut être bloquée, ce qui affecte la fraîcheur des données.

Un clic sur le lien Create alerting (Créer des alertes), qui est situé sous les graphiques, permet d'ouvrir la page Créer une règle d'alerte du tableau de bord Stackdriver Monitoring.

Afficher les graphes des métriques de latence du système et de fraîcheur des données.
Figure 9 : Affichage des graphiques représentant les métriques de latence du système et de fraîcheur des données.

Autoscaling

Le volet Job summary (Résumé de la tâche) vous permet de consulter des informations concernant votre tâche d'autoscaling. Le service Dataflow choisit automatiquement le nombre d'instances de nœud de calcul nécessaires à l'exécution de votre tâche d'autoscaling. Le nombre d'instances de calcul peut changer au fil du temps en fonction des besoins de votre tâche.

Vous pouvez afficher le nombre d'instances de nœuds de calcul utilisées par votre pipeline d'autoscaling ainsi que d'autres informations dans l'onglet

Pour voir l'historique des modifications de l'autoscaling, cliquez sur le lien See More History (Afficher plus d'entrées d'historique). Cela ouvre une fenêtre contenant des informations sur l'historique du nombre de nœuds de calcul assignés à votre pipeline.

Pour afficher l'historique des modifications de l'autoscaling, cliquez sur le lien

Remarque : Vous pouvez afficher les détails de l'autoscaling pour les pipelines de flux continu exécutés ou modifiés depuis le 12 décembre 2016. Si votre pipeline a été lancé avant cette date et n'a pas été modifié depuis, vous ne pourrez consulter les détails de l'autoscaling qu'après avoir mis à jour votre pipeline.

Création de rapports d'erreur

L'interface Error Reporting rassemble et présente les erreurs générées dans vos pipelines.

Le rapport d'erreurs comprend :

  • Une liste des erreurs avec les messages correspondants
  • Le nombre d'occurrences de chaque erreur
  • Un histogramme indiquant quand est survenue chaque erreur
  • L'heure à laquelle l'erreur s'est produite pour la dernière fois

Pour afficher le rapport d'erreurs de votre pipeline, cliquez sur le menu Logs (Journaux) situé au-dessus du graphique du pipeline, puis sur l'onglet Stack Traces (Traces de piles) visible en-dessous du graphique. Dans l'interface de surveillance Dataflow, vous verrez un résumé de chaque erreur consignée et le nombre de fois où elle s'est produite.

Les volets Worker error log count (Décompte de journal d'erreur de nœud de calcul) indiquent le taux d'erreurs observées sur tous les nœuds de calcul à tout moment.

Récapitulatif de chaque erreur consignée et de son nombre d'occurrences.

Pour afficher plus d'informations sur les erreurs, cliquez sur le résumé d'une erreur. Vous êtes alors redirigé vers l'interface Error Reporting.

Plus d'informations sur les erreurs dans l'interface Stackdriver Error Reporting

L'interface Error Reporting offre des fonctionnalités supplémentaires. Pour plus d'informations sur les erreurs générées par vos pipelines, consultez la page Afficher les erreurs.