Transformations prédéfinies dans le SDK Cloud Dataflow

Les SDK Dataflow fournissent une bibliothèque de transformations pré-écrites qui représentent des opérations de traitement de données courantes et utiles. Ces transformations sont soit des transformations de base représentant des fonctions de traitement génériques prédéfinies, soit des transformations composites combinant des transformations simples prédéfinies pour réaliser des fonctions de traitement utiles.

Java

Dans le SDK Dataflow pour Java, ces transformations sont hébergées dans le package com.google.cloud.dataflow.sdk.transforms.

Vous pouvez utiliser n'importe laquelle des transformations prédéfinies dans le SDK Dataflow telle quelle dans vos propres pipelines. Ces transformations sont des opérations génériques et pratiques pouvant réaliser des étapes courantes de traitement des données, par exemple compter les éléments d'une collection, diviser une collection en quantiles, identifier les N premiers (ou derniers) éléments d'une collection et réaliser des combinaisons mathématiques de base sur des données numériques.

La plupart des transformations prédéfinies dans le SDK Dataflow sont des transformations composites génériques pouvant accepter différents types de données. Elles sont construites à partir de transformations de base imbriquées telles que ParDo, GroupByKey et Combine.

Java

Le SDK Dataflow pour Java peut représenter la plupart des opérations de traitement de données au moyen des transformations de base. Les transformations prédéfinies fournies dans les SDK sont essentiellement des wrappers intégrés pour les transformations génériques ParDo, Combine, etc. et organisés de manière à compter les éléments ou à effectuer des combinaisons mathématiques de base. Par exemple, Sum.integersGlobally encapsule la transformation de base Combine.Globally pour les types Integer et fournit une fonction CombineFn prédéfinie qui calcule la somme de tous les éléments d'entrée. Plutôt que d'écrire votre propre version de Combine.Globally avec une fonction de calcul de somme CombineFn, vous pouvez utiliser la version intégrée fournie dans le SDK.

Si les transformations incluses dans les SDK Dataflow ne correspondent pas exactement au cas d'utilisation de votre pipeline, vous pouvez créer vos propres transformations composites génériques et réutilisables. Le code source des transformations incluses peut vous servir de modèle pour créer vos propres transformations composites à l'aide de ParDo, de Combine et d'autres transformations de base. Pour plus d'informations, consultez la page Créer des transformations composites.

Modèles de traitements courants

Les transformations incluses dans les SDK Dataflow fournissent des mécanismes pratiques pour réaliser des opérations de traitement de données courantes dans vos pipelines. Le code source de ces transformations illustre la façon dont les transformations de base telles que ParDo peuvent être utilisées (ou réutilisées) pour diverses opérations.

Wrappers ParDo simples

Certaines des transformations les plus simples fournies dans les SDK Dataflow sont des transformations utilitaires permettant de traiter des paires clé/valeur. Pour une PCollection de paires clé/valeur donnée, la transformation Keys renvoie une PCollection ne contenant que les clés. La transformation Values renvoie quant à elle une PCollection ne contenant que les valeurs. La transformation KvSwap permute les éléments clé et valeur pour chaque paire clé/valeur, et renvoie une PCollection des paires inversées.

Java

Keys, Values, KvSwap, MapElements, FlatMapElements, Filter et Partition sont des transformations simples composées d'un seule transformation ParDo. Dans chaque cas, la transformation ParDo appelle une classe DoFn relativement simple pour produire les éléments de la PCollection de sortie.

Voici la méthode apply pour la transformation Keys, qui accepte une PCollection générique d'éléments KV<K, V>, et renvoie une PCollection<K> ne contenant que les clés des paires clé/valeur :

  @Override
  public PCollection<K> apply(PCollection<? extends KV<K, ?>> in) {
    return
        in.apply(ParDo.named("Keys")
                 .of(new DoFn<KV<K, ?>, K>() {
                     @Override
                     public void processElement(ProcessContext c) {
                       c.output(c.element().getKey());
                     }
                    }));
  }

Dans l'exemple, la méthode apply applique une transformation ParDo à la collection d'entrée (in). Cette transformation ParDo appelle une classe DoFn simple pour générer la partie clé de la paire clé/valeur. La classe DoFn est triviale et peut être définie comme une instance de classe interne anonyme.

Motifs combinant des éléments

Les SDK Dataflow contiennent un certain nombre de transformations pratiques qui effectuent des combinaisons statistiques et mathématiques courantes sur les éléments. Par exemple, certaines transformations acceptent une PCollection de données numériques (telles que des entiers) et réalisent une combinaison mathématique : calculer la somme de tous les éléments, calculer la moyenne de tous les éléments ou identifier le plus grand ou le plus petit élément de la collection. Sum et Mean sont des exemples de transformations de ce type.

D'autres transformations effectuent une analyse statistique de base sur une collection : trouver les N premiers éléments, par exemple, ou renvoyer un échantillon aléatoire de N éléments d'une PCollection donnée. Top et Sample sont des exemples de transformations de ce type.

Java

Ces transformations sont basées sur la transformation de base Combine. Elles incluent des variantes qui fonctionnent sur les PCollection de valeurs individuelles (en utilisant Combine.globally) et les PCollection de paires clé/valeur (en utilisant Combine.perKey).

Consultez les détails de la transformation Top dans la documentation de référence des sources et de l'API pour Java : vous y verrez un exemple de transformation combinée avec des variantes globales et par clé.

Traitement de type mappage/brassage/réduction (Map/Shuffle/Reduce)

Certaines des transformations incluses dans le SDK Dataflow effectuent un traitement semblable à un algorithme de type Map/Shuffle/Reduce (mappage/brassage/réduction). Ces transformations incluent Count, qui prend en entrée une collection d'éléments potentiellement non uniques et renvoie une collection réduite constituée seulement des éléments uniques, associés au nombre d'occurrences de chacun. De manière similaire, la transformation RemoveDuplicates réduit une collection d'éléments non uniques à ses éléments uniques, mais ne fournit pas de nombre d'occurrences.

Java

Ces transformations utilisent les transformations de base ParDo et Combine.perKey. Combine.perKey est elle-même une opération composite qui effectue une opération GroupByKey et combine le flux de valeurs obtenu pour chaque clé en une seule valeur. La transformation ParDo représente la phase de mappage de l'algorithme Map/Shuffle/Reduce ; Combine.perKey représente les phases de brassage et de réduction.

Voici la méthode apply pour la transformation Count, illustrant la logique de traitement dans les transformations imbriquées ParDo et Combine.perKey :

  @Override
  public PCollection<KV<T, Long>> apply(PCollection<T> in) {
    return
        in
        .apply(ParDo.named("Init")
               .of(new DoFn<T, KV<T, Long>>() {
                   @Override
                   public void processElement(ProcessContext c) {
                     c.output(KV.of(c.element(), 1L));
                   }
                 }))

        .apply(Combine.<T, Long>perKey(
                 new SerializableFunction<Iterable<Long>, Long>() {
                   @Override
                   public Long apply(Iterable<Long> values) {
                     long sum = 0;
                     for (Long value : values) {
                       sum += value;
                     }
                     return sum;
                   }
                 }));
  }

Dans l'exemple, la méthode apply utilise une transformation ParDo pour associer un nombre d'occurrences à chaque élément de la PCollection d'entrée, créant ainsi une paire clé/valeur pour chaque élément. Il s'agit de la phase de mappage de l'algorithme Map/Shuffle/Reduce. Count applique ensuite une transformation Combine.perKey pour exécuter la logique de brassage et de réduction, et produire une PCollection d'éléments uniques associés à un nombre combiné d'occurrences.