Esegui la migrazione da MapReduce di App Engine ad Apache Beam e Dataflow

Questo tutorial è destinato agli utenti di MapReduce di App Engine. Mostra come eseguire la migrazione da App Engine MapReduce ad Apache Beam e Dataflow.

Perché eseguire la migrazione?

MapReduce di App Engine è un modello di programmazione per l'elaborazione di grandi quantità di dati in modo parallelo e distribuito. È utile per attività di grandi dimensioni e a lunga esecuzione che non possono essere gestite nell'ambito di una singola richiesta, ad esempio:

  • Analisi dei log delle applicazioni
  • Aggregazione di dati correlati da fonti esterne
  • Trasformare i dati da un formato a un altro
  • Esportazione di dati per l'analisi esterna

Tuttavia, MapReduce di App Engine è una libreria open source gestita dalla community, basata sui servizi App Engine e non più supportata da Google.

Dataflow, invece, è completamente supportato da Google e fornisce funzionalità estese rispetto ad App Engine MapReduce.

Casi di migrazione

Di seguito sono riportati alcuni casi di esempio in cui potresti trarre vantaggio dalla migrazione da App Engine MapReduce ad Apache Beam e Dataflow:

  • Archivia i dati dell'applicazione di database Datastore in un data warehouse BigQuery per l'elaborazione analitica mediante SQL.
  • Utilizza Dataflow come alternativa ad App Engine MapReduce per la manutenzione e/o gli aggiornamenti del set di dati Datastore.
  • Esegui il backup di parti del tuo database Datastore in Cloud Storage.

Che cosa sono Dataflow e Apache Beam?

Dataflow è un servizio gestito per l'esecuzione di un'ampia varietà di pattern di elaborazione dati. Apache Beam è un modello di programmazione unificato che fornisce SDK per la definizione dei flussi di lavoro di elaborazione dati. Utilizza Apache Beam per creare pipeline complesse sia in modalità batch che per flussi di dati ed eseguirle su Dataflow.

Introduzione a Dataflow e Apache Beam

Per iniziare, segui la guida rapida che preferisci:

Creazione ed esecuzione di una pipeline

Quando utilizzi MapReduce di App Engine, crei classi di elaborazione dati, aggiungi la libreria MapReduce e, dopo aver definito la specifica e le impostazioni del job, puoi creare e avviare il job in un solo passaggio utilizzando il metodo start() statico nella classe job appropriata.

Per i job della mappa, devi creare le classi Input e Output e la classe Map che esegue la mappatura. Per i job MapReduce di App Engine, devi creare le classi Input e Output e definire le classi Mapper e Reducer per le trasformazioni dei dati.

Con Apache Beam le operazioni sono leggermente diverse: crei una pipeline. Puoi utilizzare i connettori di input e di output per leggere e scrivere dalle origini dati e dai sink. Puoi utilizzare trasformazioni di dati predefinite (o scriverne di personalizzate) per implementare le trasformazioni dei dati. Quando il codice è pronto, esegui il deployment della pipeline nel servizio Dataflow.

Conversione dei job MapReduce di App Engine in pipeline Apache Beam

La seguente tabella presenta gli equivalenti Apache Beam dei passaggi map, shuffle e reduce del modello MapReduce di App Engine.

Java

MapReduce di App Engine Equivalente Apache Beam
Mappa MapElements<InputT,OutputT>
Shuffling GroupByKey<K,V>
Riduci Combina.Valori raggruppati<K,InputT,OutputT>

Una prassi comune è utilizzare Combine.PerKey<K,InputT,OutputT> anziché GroupByKey e CombineValues.

Python

MapReduce di App Engine Equivalente Apache Beam
Mappa beam.Map
Shuffling beam.GroupByKey
Riduci beam.CombineValues

Una pratica comune è utilizzare beam.CombinePerKey anziché beam.GroupByKey e beam.CombineValues.

Go

MapReduce di App Engine Equivalente Apache Beam
Mappa beam.ParDo
Shuffling beam.GroupByKey
Riduci beam.Combine


Il seguente codice campione mostra come implementare il modello MapReduce di App Engine in Apache Beam:

Java

Tratto da 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

Tratto da 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

Tratto da 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)

Ulteriori vantaggi di Apache Beam e Dataflow

Se scegli di eseguire la migrazione dei job MapReduce di App Engine alle pipeline Apache Beam, potrai beneficiare delle diverse funzionalità offerte da Apache Beam e Dataflow.

Pianificazione dei job Cloud Dataflow

Se hai dimestichezza con le code di attività di App Engine, puoi pianificare i job ricorrenti utilizzando Cron. Questo esempio mostra come utilizzare App Engine Cron per pianificare le pipeline di Apache Beam.

Esistono diversi modi aggiuntivi per pianificare l'esecuzione della pipeline. Puoi:

Monitoraggio dei job Cloud Dataflow

Per monitorare i job MapReduce di App Engine, devi dipendere da un URL ospitato da appspot.com.

Quando esegui le pipeline utilizzando il servizio gestito Dataflow, puoi monitorarle utilizzando la pratica interfaccia utente di monitoraggio basata sul web di Dataflow. Puoi anche utilizzare Cloud Monitoring per ulteriori informazioni sulle tue pipeline.

Lettura e scrittura

In Apache Beam, i lettori e gli autori di App Engine MapReduce sono chiamati origini dati e sink o connettori I/O.

Apache Beam ha molti connettori I/O per diversi servizi Google Cloud, come Bigtable, BigQuery, Datastore, Cloud SQL e altri. Esistono anche connettori I/O creati dai collaboratori di Apache Beam per servizi non Google, come Apache Cassandra e MongoDB.

Passaggi successivi