Migre do App Engine MapReduce para o Apache Beam e o Dataflow

Este tutorial destina-se a utilizadores do App Engine MapReduce. Mostra como migrar da utilização do App Engine MapReduce para o Apache Beam e o Dataflow.

Por que motivo deve migrar?

O App Engine MapReduce é um modelo de programação para processar grandes quantidades de dados de forma paralela e distribuída. É útil para tarefas grandes e de longa duração que não podem ser processadas no âmbito de um único pedido, como:

  • Analisar registos de aplicações
  • Agregação de dados relacionados de origens externas
  • Transformar dados de um formato para outro
  • Exportar dados para análise externa

No entanto, o App Engine MapReduce é uma biblioteca de código aberto mantida pela comunidade que é criada com base nos serviços do App Engine e já não é suportada pela Google.

Por outro lado, o Dataflow é totalmente suportado pela Google e oferece uma funcionalidade alargada em comparação com o App Engine MapReduce.

Exemplos de migração

Seguem-se alguns exemplos de casos em que pode beneficiar da migração do App Engine MapReduce para o Apache Beam e o Dataflow:

  • Armazene os dados da aplicação da base de dados do Datastore num armazém de dados do BigQuery para processamento analítico através de SQL.
  • Use o Dataflow como alternativa ao App Engine MapReduce para a manutenção e/ou as atualizações do seu conjunto de dados do Datastore.
  • Fazer uma cópia de segurança de partes da sua base de dados do Armazenamento de dados no Cloud Storage.

O que são o Dataflow e o Apache Beam?

O Dataflow é um serviço gerido para executar uma grande variedade de padrões de processamento de dados. O Apache Beam é um modelo de programação unificado que fornece SDKs para definir fluxos de trabalho de processamento de dados. Use o Apache Beam para criar pipelines complexos para processamento em lote e por streaming, e execute-os no Dataflow.

Introdução ao Dataflow e ao Apache Beam

Para começar, siga o início rápido da sua escolha:

Criar e executar um pipeline

Quando usa o App Engine MapReduce, cria classes de processamento de dados, adiciona a biblioteca MapReduce e, assim que a especificação e as definições da tarefa estiverem definidas, cria e inicia a tarefa num único passo através do método estático start() na classe de tarefa adequada.

Para tarefas de mapa, cria as classes Input e Output, bem como a classe Map que faz o mapeamento. Para tarefas MapReduce do App Engine, cria classes Input e Output e define as classes Mapper e Reducer para transformações de dados.

Com o Apache Beam, faz as coisas de forma ligeiramente diferente. Cria um pipeline. Usa conetores de entrada e saída para ler e escrever a partir das suas origens de dados e destinos de dados. Usa transformações de dados predefinidas (ou escreve as suas próprias) para implementar as transformações de dados. Em seguida, quando o código estiver pronto, implementa o pipeline no serviço Dataflow.

Converter tarefas do App Engine MapReduce em pipelines do Apache Beam

A tabela seguinte apresenta os equivalentes do Apache Beam dos passos map, shuffle e reduce do modelo MapReduce do App Engine.

Java

App Engine MapReduce Equivalente do Apache Beam
Mapa MapElements<InputT,OutputT>
Aleatório GroupByKey<K,V>
Reduza Combine.GroupedValues<K,InputT,OutputT>

Uma prática comum é usar Combine.PerKey<K,InputT,OutputT> em vez de GroupByKey e CombineValues.

Python

App Engine MapReduce Equivalente do Apache Beam
Mapa beam.Map
Aleatório beam.GroupByKey
Reduza beam.CombineValues

Uma prática comum é usar beam.CombinePerKey em vez de beam.GroupByKey e beam.CombineValues.

Go

App Engine MapReduce Equivalente do Apache Beam
Mapa beam.ParDo
Aleatório beam.GroupByKey
Reduza beam.Combine


O seguinte exemplo de código demonstra como implementar o modelo MapReduce do App Engine no Apache Beam:

Java

Retirado 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<String, String>() {
                   @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<KV<String, Long>, String>() {
                   @Override
                   public String apply(KV<String, Long> 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

Retirado 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)

Go

Retirado de minimal_wordcount.go: 
// beam.Init() is an initialization hook that must be called on startup.
beam.Init()

// Create the Pipeline object and root scope.
p := beam.NewPipeline()
s := p.Root()
lines := textio.Read(s, "gs://apache-beam-samples/shakespeare/kinglear.txt")

// Invoke a ParDo transform on our PCollection of text lines.
// This ParDo invokes a DoFn (defined in-line) on each element that
// tokenizes the text line into individual words. The ParDo returns a
// PCollection of type string, where each element is an individual word in
// Shakespeare's collected texts.
words := beam.ParDo(s, func(line string, emit func(string)) {
    for _, word := range wordRE.FindAllString(line, -1) {
        emit(word)
    }
}, lines)

// Invoke the stats.Count transform on our PCollection of
// individual words. The Count transform returns a new PCollection of
// key/value pairs, where each key represents a unique word in the text.
// The associated value is the occurrence count for that word.
counted := stats.Count(s, words)

// Use a ParDo to format our PCollection of word counts into a printable
// string, suitable for writing to an output file. When each element
// produces exactly one element, the DoFn can simply return it.
formatted := beam.ParDo(s, func(w string, c int) string {
    return fmt.Sprintf("%s: %v", w, c)
}, counted)

// Invoke textio.Write at the end of the pipeline to write
// the contents of a PCollection (in this case, our PCollection of
// formatted strings) to a text file.
textio.Write(s, "wordcounts.txt", formatted)

Vantagens adicionais do Apache Beam e do Dataflow

Se optar por migrar as tarefas do App Engine MapReduce para pipelines do Apache Beam, vai beneficiar de várias funcionalidades que o Apache Beam e o Dataflow têm para oferecer.

Agendar tarefas do Cloud Dataflow

Se estiver familiarizado com as filas de tarefas do App Engine, pode agendar os seus trabalhos recorrentes através do Cron. Este exemplo demonstra como usar o App Engine Cron para agendar os seus pipelines do Apache Beam.

Existem várias formas adicionais de agendar a execução do pipeline. Pode:

Monitorizar tarefas do Cloud Dataflow

Para monitorizar as tarefas do App Engine MapReduce, depende de um URL alojado no appspot.com.

Quando executa os seus pipelines através do serviço gerido do Dataflow, pode monitorizá-los através da prática interface do utilizador de monitorização baseada na Web do Dataflow. Também pode usar o Cloud Monitoring para ver informações adicionais sobre os seus pipelines.

Leitura e escrita

No Apache Beam, os leitores e os escritores do App Engine MapReduce são denominados origens de dados e destinos, ou conetores de E/S.

O Apache Beam tem muitos conetores de E/S para vários serviços do Google Cloud, como o Bigtable, o BigQuery, o Datastore, o Cloud SQL e outros. Também existem conetores de E/S criados por colaboradores do Apache Beam para serviços não pertencentes à Google, como o Apache Cassandra e o MongoDB.

O que se segue?