Migra de App Engine MapReduce a Apache Beam y Cloud Dataflow

Este instructivo está dirigido a los usuarios de App Engine MapReduce. Aquí se muestra cómo migrar de App Engine MapReduce a Apache Beam y Cloud Dataflow.

¿Por qué migrar?

App Engine MapReduce es un modelo de programación para 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 análisis externo

Sin embargo, App Engine MapReduce es una biblioteca de código abierto que mantiene la comunidad basada en los servicios de App Engine y ya no es compatible con Google.

Por otro lado, Cloud Dataflow es compatible por completo con Google y proporciona una funcionalidad más amplia que la de App Engine MapReduce.

Casos de migración

Los siguientes son algunos casos de ejemplo en los que podrías beneficiarte de la migración de App Engine MapReduce a Apache Beam y Cloud Dataflow:

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

¿Qué son Cloud Dataflow y Apache Beam?

Cloud Dataflow es un servicio administrado para ejecutar 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 para crear canalizaciones complejas por lotes y de transmisión, y ejecútalas en Cloud Dataflow.

Comienza con Cloud Dataflow y Apache Beam

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

Crea y ejecuta una canalización

Cuando usas App Engine MapReduce, debes crear clases de procesamiento de datos, agregar la biblioteca MapReduce y, una vez que se definen las especificaciones y la configuración del trabajo, crear y luego iniciar el trabajo en un solo paso mediante el método estático start() en la clase de trabajo adecuada.

Para los trabajos de Map, debes crear las clases Input y Output, además de la clase Map que realiza la asignación. Para los trabajos de App Engine MapReduce, debes crear las clases Input y Output, y definir las clases Mapper y Reducer para las transformaciones de datos.

Con Apache Beam, el proceso es un poco distinto; debes crear una canalización. Debes usar conectores de entrada y salida para leer y escribir en tus receptores y fuentes de datos. Debes usar transformaciones de datos predefinidas (o escribir las tuyas) para implementar tus transformaciones de datos. Una vez que tu código esté listo, debes implementar tu canalización en el servicio de Cloud Dataflow.

Convierte trabajos de App Engine MapReduce 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 App Engine MapReduce.

Java: SDK 2.x

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

Suele usarse Combine.PerKey<K,InputT,OutputT> en lugar de GroupByKey y CombineValues.

Python

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

Suele usarse beam.CombinePerKey en lugar de beam.GroupByKey y beam.CombineValues.


En el siguiente código de ejemplo, se muestra cómo implementar el modelo de App Engine MapReduce 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 Cloud Dataflow

Si eliges migrar tus trabajos de App Engine MapReduce a canalizaciones de Apache Beam, podrás aprovechar varias características que ofrecen Apache Beam y Cloud 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 App Engine Cron para programar tus canalizaciones de Apache Beam.

Hay varias formas adicionales de programar la ejecución de tu canalización. Puedes llevar a cabo las siguientes acciones:

Supervisa los trabajos de Cloud Dataflow

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

Cuando ejecutas tus canalizaciones con el servicio administrado de Cloud Dataflow, puedes supervisarlas con la conveniente interfaz de usuario de supervisión basada en la Web de Cloud Dataflow. También puedes usar Stackdriver Monitoring para obtener información adicional acerca de tus canalizaciones.

Lee y escribe

En Apache Beam, los Lectores y Escritores de App Engine MapReduce se llaman 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 Cloud Bigtable, BigQuery, Cloud 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.

Pasos siguientes

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.