Transformaciones predefinidas en el SDK de Cloud Dataflow

Los SDK de Dataflow proporcionan una biblioteca de transformaciones predefinidas que representan operaciones de procesamiento de datos comunes y útiles. Estas son transformaciones básicas con funciones de procesamiento genérico ya escritas o transformaciones compuestas que combinan las transformaciones predefinidas simples a fin de ejecutar funciones de procesamiento útiles.

Java

En el SDK de Dataflow para Java, puedes encontrar estas transformaciones en el paquete com.google.cloud.dataflow.sdk.transforms.

Puedes usar cualquiera de las transformaciones predefinidas en los SDK de Dataflow como se encuentran en tu propia canalización. Estas transformaciones son operaciones genéricas y sencillas que pueden realizar pasos comunes de procesamiento de datos, como contar elementos de una colección, dividir una colección en cuantiles, buscar los N elementos principales (o inferiores) en una colección y realizar combinaciones matemáticas básicas a partir de datos numéricos.

Muchas de las transformaciones predefinidas en el SDK de Dataflow son transformaciones compuestas genéricas que pueden tomar diferentes tipos de datos. Estas constan de transformaciones básicas anidadas como ParDo, GroupByKey y Combine.

Java

El SDK de Dataflow para Java puede representar las operaciones de procesamiento de datos más comunes mediante transformaciones básicas. Las transformaciones predefinidas que se proporcionan en los SDK son, en su mayoría, wrappers compilados con anterioridad para las transformaciones genéricas ParDo y Combine, entre otras. Su organización les permite contar elementos o realizar combinaciones matemáticas básicas. Sum.integersGlobally, por ejemplo, une la transformación básica Combine.Globally para los tipos Integer y proporciona una transformación CombineFn predefinida que calcula la suma de todos los elementos de entrada. En lugar de escribir tu propia versión de Combine.Globally con una suma de CombineFn, puedes usar la versión ya compilada que se proporciona en el SDK.

Si las transformaciones incluidas en los SDK de Dataflow no se adecuan con exactitud al caso práctico de tu canalización, puedes crear tus propias transformaciones compuestas genéricas y reutilizables. El código fuente de las transformaciones incluidas puede servir como modelo para crear tus propias transformaciones compuestas mediante ParDo, Combine y otras transformaciones básicas. Consulta Crea transformaciones compuestas para obtener más información.

Patrones de procesamiento comunes

Las transformaciones incluidas en los SDK de Dataflow proporcionan mecanismos sencillos para realizar operaciones de procesamiento de datos comunes en tus canalizaciones. El código fuente de estas transformaciones ilustra cómo se pueden usar (o reutilizar) las transformaciones básicas como ParDo para varias operaciones.

Wrappers de ParDo simples

Algunas de las transformaciones más simples que se proporcionan en los SDK de Dataflow son transformaciones de utilidad para administrar los pares clave-valor. A partir de una PCollection de pares clave-valor, la transformación Keys muestra una PCollection que solo contiene las claves, y la transformación Values muestra una PCollection que solo contiene los valores. La transformación KvSwap cambia el elemento de clave y el elemento de valor de cada par clave-valor y muestra una PCollection de los pares revertidos.

Java

Keys, Values, KvSwap, MapElements, FlatMapElements, Filter y Partition son transformaciones simples compuestas por una sola transformación ParDo. En cada caso, la transformación ParDo invoca un DoFn relativamente simple para producir los elementos de la PCollection de salida.

Este es el método apply para la transformación Keys, que acepta una PCollection genérica de elementos KV<K, V> y muestra una PCollection<K> en la que se incluyen solo las claves de los pares clave-valor:

  @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());
                     }
                    }));
  }

En el ejemplo, el método apply aplica una transformación ParDo a la colección de entrada (in). Esa transformación ParDo invoca un DoFn simple para generar la parte de la clave del par clave-valor. El DoFn es trivial y se puede definir como una instancia de clase interna anónima.

Patrones que combinan elementos

Los SDK de Dataflow contienen una cantidad de transformaciones sencillas que realizan combinaciones estadísticas y matemáticas comunes de los elementos. Por ejemplo, existen transformaciones que aceptan una PCollection de datos numéricos (como números enteros) y realizan una combinación matemática: buscan dentro de la colección la suma de todos los elementos, el promedio de todos los elementos o el elemento más grande o pequeño. Sum y Mean son ejemplos de transformaciones de este tipo.

Otras transformaciones realizan análisis estadísticos básicos en una colección: buscan los N elementos principales, por ejemplo, o dan como resultado una muestra aleatoria cada N elementos en una PCollection determinada. Top y Sample son ejemplos de transformaciones de este tipo.

Java

Estas transformaciones se basan en la transformación básica Combine. Incluyen variantes que funcionan en las PCollection de valores individuales (mediante Combine.globally) y en las PCollection de pares clave-valor (mediante Combine.perKey).

Consulta la fuente y la documentación de referencia de la API de Java para la transformación Top a fin de obtener un ejemplo de transformación combinada con variantes globales y por clave.

Procesamiento de estilo Map/Shuffle/Reduce

Algunas de las transformaciones incluidas en los SDK de Dataflow realizan procesamientos similares a un algoritmo del estilo Map/Shuffle/Reduce. Estas transformaciones incluyen Count, que acepta una colección de elementos no únicos y muestra una colección reducida en la que se incluyen solo los elementos únicos vinculados con un recuento de todos los casos de cada uno. La transformación RemoveDuplicates también reduce una colección de elementos no únicos a una solo con elementos únicos, pero no proporciona un recuento de casos.

Java

Estas transformaciones usan las transformaciones básicas ParDo y Combine.perKey. Combine.perKey es en sí misma una operación compuesta que realiza una operación GroupByKey y combina el flujo de valores resultantes para cada clave en un valor único. ParDo representa la fase Map de Map/Shuffle/Reduce, mientras que Combine.perKey representa las fases Shuffle y Reduce.

A continuación, se incluye el método apply para la transformación Count. Se muestra la lógica de procesamiento en las transformaciones anidadas ParDo y 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;
                   }
                 }));
  }

En el ejemplo, el método apply usa una transformación ParDo a fin de adjuntar un recuento de casos a cada elemento en la PCollection de entrada, lo que crea un par clave-valor para cada elemento. Esta es la fase Map de Map/Shuffle/Reduce. Luego, Count aplica una transformación Combine.perKey para llevar a cabo la lógica Shuffle y Reduce, y producir una PCollection de elementos únicos con un recuento combinado de los casos.