Bermigrasi dari MapReduce App Engine ke Apache Beam dan Dataflow

Apache Beam dan Dataflow memungkinkan Anda memodernisasi tugas MapReduce App Engine lama dengan pemrosesan batch dan streaming terpadu pada infrastruktur terkelola sepenuhnya. Dalam tutorial ini, Anda akan mempelajari cara menerjemahkan konsep MapReduce App Engine ke dalam pipeline Apache Beam dan menjalankannya di Dataflow.

Mengapa harus bermigrasi?

App Engine MapReduce adalah model pemrograman untuk memproses data dalam jumlah besar secara paralel dan terdistribusi. Model ini berguna untuk tugas besar dan berjalan lama yang tidak dapat ditangani dalam cakupan permintaan tunggal, seperti:

  • Menganalisis log aplikasi
  • Menggabungkan data terkait dari sumber eksternal
  • Mengubah data dari satu format ke format lainnya
  • Mengekspor data untuk analisis eksternal

Namun, App Engine MapReduce adalah library open source yang dikelola komunitas dan dibangun berdasarkan layanan App Engine serta tidak lagi didukung oleh Google.

Di sisi lain, Dataflow didukung sepenuhnya oleh Google, dan menyediakan fungsi yang lebih luas dibandingkan dengan App Engine MapReduce.

Kasus migrasi

Berikut adalah beberapa contoh kasus saat Anda dapat memperoleh manfaat dari migrasi dari App Engine MapReduce ke Apache Beam dan Dataflow:

  • Simpan data aplikasi database Datastore Anda di data warehouse BigQuery untuk pemrosesan analitis menggunakan SQL.
  • Gunakan Dataflow sebagai alternatif untuk App Engine MapReduce guna melakukan pemeliharaan atau update set data Datastore Anda.
  • Mencadangkan bagian database Datastore Anda ke Cloud Storage.

Apa itu Dataflow dan Apache Beam?

Dataflow adalah layanan terkelola untuk menjalankan berbagai macam pola pemrosesan data. Apache Beam adalah model pemrograman terpadu yang menyediakan SDK untuk menentukan alur kerja pemrosesan data. Gunakan Apache Beam untuk membuat pipeline yang kompleks untuk batch dan streaming, lalu jalankan di Dataflow.

Mulai menggunakan Dataflow dan Apache Beam

Untuk memulai, ikuti panduan memulai pilihan Anda:

Membuat dan menjalankan pipeline

Saat menggunakan MapReduce App Engine, Anda membuat class pemrosesan data, menambahkan library MapReduce, dan setelah spesifikasi serta setelan tugas ditentukan, Anda membuat dan memulai tugas dalam satu langkah menggunakan metode start() statis pada class tugas yang sesuai.

Untuk tugas Peta, Anda membuat class Input dan Output serta class Map yang melakukan pemetaan. Untuk tugas MapReduce App Engine, Anda membuat class Input dan Output, serta menentukan class Mapper dan Reducer untuk transformasi data.

Dengan Apache Beam, Anda melakukan sesuatu yang sedikit berbeda; Anda membuat pipeline. Anda menggunakan konektor input dan output untuk membaca dan menulis dari sumber dan tujuan data. Anda menggunakan transformasi data yang telah ditentukan sebelumnya (atau menulis sendiri) untuk menerapkan transformasi data. Kemudian, setelah kode siap, Anda men-deploy pipeline ke layanan Dataflow.

Mengonversi tugas MapReduce App Engine menjadi pipeline Apache Beam

Tabel berikut menyajikan padanan Apache Beam untuk langkah-langkah map, shuffle, dan reduce dari model MapReduce App Engine.

Java

MapReduce App Engine Setara dengan Apache Beam
Peta MapElements<InputT,OutputT>
Acak GroupByKey<K,V>
Kurangi Combine.GroupedValues<K,InputT,OutputT>

Praktik umum adalah menggunakan Combine.PerKey<K,InputT,OutputT> daripada GroupByKey dan CombineValues.

Python

MapReduce App Engine Setara dengan Apache Beam
Peta beam.Map
Acak beam.GroupByKey
Kurangi beam.CombineValues

Praktik umum adalah menggunakan beam.CombinePerKey, bukan beam.GroupByKey dan beam.CombineValues.

Go

MapReduce App Engine Setara dengan Apache Beam
Peta beam.ParDo
Acak beam.GroupByKey
Kurangi beam.Combine


Kode contoh berikut menunjukkan cara menerapkan model MapReduce App Engine di Apache Beam:

Java

Diambil dari 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

Diambil dari 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

Diambil dari 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 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)

Manfaat tambahan Apache Beam dan Dataflow

Jika memilih untuk memigrasikan tugas MapReduce App Engine ke pipeline Apache Beam, Anda akan mendapatkan manfaat dari beberapa fitur yang ditawarkan Apache Beam dan Dataflow.

Menjadwalkan tugas Dataflow

Jika Anda sudah memahami antrean tugas App Engine, Anda dapat menjadwalkan tugas berulang menggunakan Cron. Contoh ini menunjukkan cara menggunakan App Engine Cron untuk menjadwalkan pipeline Apache Beam.

Ada beberapa cara tambahan untuk menjadwalkan eksekusi pipeline Anda. Anda dapat:

Memantau tugas Dataflow

Untuk memantau tugas MapReduce App Engine, Anda bergantung pada URL yang dihosting appspot.com.

Saat menjalankan pipeline menggunakan layanan terkelola Dataflow, Anda dapat memantau pipeline menggunakan antarmuka pengguna pemantauan berbasis web Dataflow yang praktis. Anda juga dapat menggunakan Cloud Monitoring untuk mendapatkan informasi tambahan tentang pipeline Anda.

Membaca dan menulis

Di Apache Beam, Reader dan Writer App Engine MapReduce disebut sumber dan tujuan data, atau konektor I/O .

Apache Beam memiliki banyak konektor I/O untuk beberapa layanan Google Cloud, seperti Bigtable, BigQuery, Datastore, Cloud SQL, dan lainnya. Ada juga konektor I/O yang dibuat oleh kontributor Apache Beam untuk layanan non-Google, seperti Apache Cassandra dan MongoDB.

Langkah berikutnya