Migrer d'un modèle MapReduce App Engine à Apache Beam et Cloud Dataflow

Ce tutoriel est destiné aux utilisateurs de MapReduce App Engine. Il explique comment migrer d'un modèle MapReduce App Engine à Apache Beam et Cloud Dataflow.

Pourquoi migrer ?

MapReduce App Engine est un modèle de programmation qui permet de traiter de grands volumes de données de façon parallèle et distribuée. Il s'avère utile pour exécuter des tâches importantes de longue durée ne pouvant pas être traitées en une seule requête, telles que les suivantes :

  • Analyse de journaux d'application
  • Agrégation de données connexes provenant de sources externes
  • Conversion de formats de données
  • Exportation de données à des fins d'analyse externe

Sachez toutefois que MapReduce App Engine est une bibliothèque Open Source gérée par la communauté. Elle repose sur les services App Engine et n'est plus couverte par Google.

À l'inverse, le service Cloud Dataflow est entièrement couvert par Google et propose des fonctionnalités plus étendues que MapReduce App Engine.

Cas de migration

Vous trouverez ci-dessous des exemples de situations dans lesquelles il peut être intéressant de migrer de MapReduce App Engine à Apache Beam et Cloud Dataflow :

  • Stockez vos données d'application de base de données Cloud Datastore dans un entrepôt de données BigQuery pour effectuer des analyses à l'aide de SQL.
  • Exploitez Cloud Dataflow au lieu de MapReduce App Engine pour gérer et/ou mettre à jour votre ensemble de données Cloud Datastore.
  • Sauvegardez des parties de votre base de données Cloud Datastore sur Cloud Storage.

Qu'est-ce que Cloud Dataflow et Apache Beam ?

Cloud Dataflow est un service géré permettant d'exécuter une grande variété de schémas de traitement de données. Apache Beam est un modèle de programmation unifié qui propose des SDK servant à définir des workflows de traitement de données. Vous pouvez donc créer des pipelines complexes de traitement par lots et par flux à l'aide d'Apache Beam, puis les exécuter sur Cloud Dataflow.

Premiers pas avec Cloud Dataflow et Apache Beam

Pour débuter avec Cloud Dataflow et Apache Beam, suivez le guide de démarrage rapide de votre choix :

Créer et exécuter un pipeline

Lorsque vous utilisez MapReduce App Engine, vous générez des classes de traitement de données, vous ajoutez la bibliothèque MapReduce, vous définissez la spécification et les paramètres de la tâche, puis vous créez et démarrez celle-ci en une seule étape en employant la méthode statique start() sur la classe de tâche appropriée.

Pour exécuter des tâches de mappage, vous devez créer les classes Input et Output, ainsi que la classe Map qui se charge du mappage. Dans le cas des tâches MapReduce App Engine, vous devez créer les classes Input et Output, puis définir les classes Mapper et Reducer pour les transformations de données.

Apache Beam fonctionne toutefois différemment et nécessite la création d'un pipeline. Lors de l'utilisation du service, vous exploitez des connecteurs d'entrée et de sortie pour lire et écrire des données à partir de vos sources et récepteurs de données. Vous mettez ensuite en œuvre vos transformations de données à l'aide de transformations prédéfinies ou personnalisées. Et lorsque votre code est prêt, vous pouvez déployer votre pipeline sur le service Cloud Dataflow.

Convertir des tâches MapReduce App Engine en pipelines Apache Beam

Le tableau suivant présente les équivalents Apache Beam des étapes de mappage, de brassage et de réduction du modèle MapReduce App Engine.

Java : SDK 2.x

MapReduce App Engine Équivalent Apache Beam
Mappage MapElements<InputT,OutputT>
Brassage GroupByKey<K,V>
Réduction Combine.GroupedValues<K,InputT,OutputT>

Une pratique courante consiste à utiliser Combine.PerKey<K,InputT,OutputT> au lieu de GroupByKey et CombineValues.

Python

MapReduce App Engine Équivalent Apache Beam
Mappage beam.Map
Brassage beam.GroupByKey
Réduction beam.CombineValues

Une pratique courante consiste à utiliser beam.CombinePerKey au lieu de beam.GroupByKey et beam.CombineValues.


L'exemple de code suivant décrit comment mettre en œuvre le modèle MapReduce App Engine dans Apache Beam :

Java : SDK 2.x

Code issu du fichier 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

Code issu du fichier 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)

Avantages supplémentaires d'Apache Beam et de Cloud Dataflow

Si vous choisissez de migrer vos tâches MapReduce App Engine vers des pipelines Apache Beam, vous pouvez profiter d'un certain nombre de fonctionnalités offertes par Apache Beam et Cloud Dataflow.

Planifier des tâches Cloud Dataflow

Si vous maîtrisez déjà les files d'attente de tâches d'App Engine, vous pouvez planifier vos tâches récurrentes à l'aide de Cron. Consultez cet exemple pour découvrir comment planifier des pipelines Apache Beam à l'aide du service Cron d'App Engine.

D'autres méthodes vous permettent également de planifier l'exécution de votre pipeline, telles que les suivantes :

Surveiller les tâches Cloud Dataflow

Pour surveiller vos tâches MapReduce App Engine, vous dépendez d'une URL hébergée sur appspot.com.

Lorsque vous exécutez vos pipelines à l'aide du service géré Cloud Dataflow, vous pouvez les surveiller à l'aide de l'interface utilisateur Web de surveillance de Cloud Dataflow. Vous pouvez également obtenir des informations supplémentaires concernant vos pipelines grâce à Stackdriver Monitoring.

Lecture et écriture

Dans Apache Beam, les lecteurs et rédacteurs de MapReduce App Engine sont appelés sources et récepteurs de données, ou connecteurs d'E/S.

Apache Beam dispose de nombreux connecteurs d'E/S pour plusieurs services Google Cloud tels que Cloud Bigtable, BigQuery, Cloud Datastore, Cloud SQL, etc. Des contributeurs Apache Beam ont également créé d'autres connecteurs d'E/S pour des services autres que Google, tels qu'Apache Cassandra et MongoDB.

Étapes suivantes

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

Envoyer des commentaires concernant…

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