Migra desde MapReduce para App Engine hacia Apache Beam y Dataflow

Este instructivo está dirigido a los usuarios de MapReduce para App Engine. En él se muestra cómo migrar desde MapReduce para App Engine hacia Apache Beam y Dataflow.

¿Por qué migrar?

MapReduce para App Engine es un modelo de programación que permite procesar grandes cantidades de datos de forma paralela y distribuida. Es útil para tareas grandes y de larga duración que no se pueden manejar dentro del alcance de una sola solicitud, como las siguientes:

  • Analizar registros de aplicaciones
  • Agregar datos relacionados de fuentes externas
  • Transformar datos de un formato a otro
  • Exportar datos para el análisis externo

Sin embargo, MapReduce para App Engine es una biblioteca de código abierto que mantiene la comunidad. Se compiló a partir de los servicios de App Engine y ya no es compatible con Google.

Por otro lado, Dataflow es compatible por completo con Google y proporciona más funciones en comparación con MapReduce para App Engine.

Casos de migración

A continuación, se incluyen algunos ejemplos de casos en los que podrías beneficiarte de la migración desde MapReduce para App Engine hacia Apache Beam y Dataflow:

  • Almacena los datos de tu aplicación de base de datos de Datastore en un almacén de datos de BigQuery para el procesamiento analítico mediante SQL.
  • Usa Dataflow como alternativa a MapReduce para App Engine a fin de llevar a cabo el mantenimiento o las actualizaciones de tu conjunto de datos de Datastore.
  • Crea una copia de seguridad de partes de tu base de datos de Datastore en Cloud Storage.

¿Qué son Dataflow y Apache Beam?

Dataflow es un servicio administrado que ejecuta una amplia variedad de patrones de procesamiento de datos. Apache Beam es un modelo de programación unificado que proporciona SDK para definir flujos de trabajo de procesamiento de datos. Usa Apache Beam a fin de crear canalizaciones complejas por lotes y de transmisión, y ejecútalas en Dataflow.

Comienza a usar Dataflow y Apache Beam

Para comenzar, elige una de las siguientes guías de inicio rápido:

Crea y ejecuta una canalización

Cuando uses MapReduce para App Engine, crea clases de procesamiento de datos y agrega la biblioteca de MapReduce. Luego, una vez que se hayan definido las especificaciones y la configuración del trabajo, crea y, también, inicia el trabajo en un solo paso mediante el método estático start() en la clase de trabajo adecuada.

En el caso de los trabajos de Map, crea las clases Input y Output, y la clase Map, que realiza la asignación. En los trabajos de MapReduce para App Engine, crea las clases Input y Output, además de define las clases Mapper y Reducer a fin de llevar a cabo las transformaciones de datos.

Con Apache Beam, el proceso es un poco distinto, ya que debes crear una canalización. Debes usar conectores de entrada y salida para leer y escribir en tus receptores y fuentes de datos. Usa transformaciones de datos predefinidas (o escríbelas tú mismo) para implementar las transformaciones de datos. Luego, una vez que tu código esté listo, implementa la canalización en el servicio de Dataflow.

Convierte trabajos de MapReduce para App Engine en canalizaciones de Apache Beam

En la tabla siguiente, se muestran los equivalentes en Apache Beam de los pasos de asignación, distribución y reducción del modelo de MapReduce para App Engine.

Java: SDK 2.x

MapReduce para App Engine Equivalente en Apache Beam
Map MapElements<InputT,OutputT>
Shuffle GroupByKey<K,V>
Reduce Combine.GroupedValues<K,InputT,OutputT>

Una práctica común es usar Combine.PerKey<K,InputT,OutputT> en lugar de GroupByKey y CombineValues.

Python

MapReduce para App Engine Equivalente en Apache Beam
Map beam.Map
Shuffle beam.GroupByKey
Reduce beam.CombineValues

Una práctica común es usar beam.CombinePerKey en lugar de beam.GroupByKey y beam.CombineValues.


En el siguiente código de muestra, se muestra cómo implementar el modelo de MapReduce para App Engine en Apache Beam:

Java: SDK 2.x

Tomado de MinimalWordCount.java:
p.apply(TextIO.read().from("gs://apache-beam-samples/shakespeare/*"))

 // Apply a ParDo that returns a PCollection, where each element is an
 // individual word in Shakespeare's texts.
 .apply("ExtractWords", ParDo.of(new DoFn() {
                   @ProcessElement
                   public void processElement(ProcessContext c) {
                     for (String word : c.element().split(ExampleUtils.TOKENIZER_PATTERN)) {
                       if (!word.isEmpty()) {
                         c.output(word);
                       }
                     }
                   }
                 }))

 // Apply the Count transform that returns a new PCollection of key/value pairs,
 // where each key represents a unique word in the text.
 .apply(Count.perElement())

 // Apply a MapElements transform that formats our PCollection of word counts
 // into a printable string, suitable for writing to an output file.
 .apply("FormatResults", MapElements.via(new SimpleFunction, String>() {
                   @Override
                   public String apply(KV input) {
                     return input.getKey() + ": " + input.getValue();
                   }
                 }))

 // Apply a write transform that writes the contents of the PCollection to a
 // series of text files.
 .apply(TextIO.write().to("wordcounts"));

Python

Tomado de wordcount_minimal.py:
# Read the text file[pattern] into a PCollection.
lines = p | ReadFromText(known_args.input)

# Count the occurrences of each word.
counts = (
    lines
    | 'Split' >> (beam.FlatMap(lambda x: re.findall(r'[A-Za-z\']+', x))
                  .with_output_types(unicode))
    | 'PairWithOne' >> beam.Map(lambda x: (x, 1))
    | 'GroupAndSum' >> beam.CombinePerKey(sum))

# Format the counts into a PCollection of strings.
output = counts | 'Format' >> beam.Map(lambda (w, c): '%s: %s' % (w, c))

# Write the output using a "Write" transform that has side effects.
# pylint: disable=expression-not-assigned
output | WriteToText(known_args.output)

Beneficios adicionales de Apache Beam y Dataflow

Si decides migrar tus trabajos de MapReduce para App Engine a las canalizaciones de Apache Beam, te beneficiarás con varias funciones que ofrecen Apache Beam y Dataflow.

Programa trabajos de Cloud Dataflow

Si estás familiarizado con las listas de tareas en cola de App Engine, puedes programar tus trabajos recurrentes mediante Cron. En este ejemplo, se muestra cómo usar Cron de App Engine para programar las canalizaciones de Apache Beam.

Hay varias formas adicionales de programar la ejecución de tu canalización. Puedes hacer lo siguiente:

Supervisa los trabajos de Cloud Dataflow

A fin de supervisar tus trabajos de MapReduce para App Engine, dependes de una URL alojada en appspot.com.

Cuando ejecutas las canalizaciones mediante el servicio administrado de Dataflow, puedes supervisarlas por medio de la interfaz de usuario de la supervisión basada en la web de Dataflow. También puedes usar Stackdriver Monitoring para obtener información adicional acerca de tus canalizaciones.

Lectura y escritura

En Apache Beam, los lectores y escritores de MapReduce para App Engine se denominan fuentes y receptores de datos, o conectores de E/S.

Apache Beam tiene muchos conectores de E/S para varios servicios de Google Cloud, como Bigtable, BigQuery, Datastore, Cloud SQL y otros. También hay conectores de E/S que crean los colaboradores de Apache Beam para servicios que no son de Google, como Apache Cassandra y MongoDB.

Próximos pasos