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 de données, par exemple compter les éléments d'une collection, partitionner une collection en quantiles, identifier les N éléments grands (ou les plus petits) 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 pré-construits 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 CombineFn pré-définie qui calcule la somme de tous les éléments en entrée. Plutôt que d’écrire votre propre version de Combine.Globally à partir d'une somme CombineFn, vous pouvez utiliser la version pré-définie 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 des transformations de base ParDo, Combine et autres. 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 comment utiliser (ou réutiliser) les transformations de base telles que ParDo 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. La transformation Keys, lorsqu'on lui transmet une PCollection de paires clé/valeur, renvoie une PCollection contenant uniquement les clés ; la transformation Values renvoie quant à elle une PCollection contenant uniquement 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 de simples transformations composées d'une seule fonction ParDo. Dans chaque cas, la fonction ParDo invoque une fonction 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> contenant uniquement 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 fonction ParDo appelle une simple DoFn pour produire la partie clé de la paire clé/valeur. La fonction 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 des PCollections de valeurs individuelles (utilisant Combine.globally) et des PCollections de paires clé/valeur (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 similaire à 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 GroupByKey et combine le flux de valeurs résultant pour chaque clé en une seule valeur. La fonction 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 correspondant à 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 cet 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 ainsi une PCollection d'éléments uniques associés à un nombre combiné d'occurrences.

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Besoin d'aide ? Consultez notre page d'assistance.