Bermigrasi dari MapReduce App Engine ke Apache Beam dan Dataflow

Tutorial ini ditujukan untuk pengguna MapReduce App Engine. Panduan ini menunjukkan cara bermigrasi dari penggunaan App Engine MapReduce ke Apache Beam dan Dataflow.

Mengapa melakukan migrasi?

App Engine MapReduce adalah model pemrograman untuk memproses data dalam jumlah besar secara paralel dan terdistribusi. Model ini berguna untuk tugas besar dan berlangsung 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, MapReduce App Engine 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 diperluas dibandingkan dengan App Engine MapReduce.

Kasus migrasi

Berikut adalah beberapa contoh kasus yang dapat Anda manfaatkan dengan bermigrasi dari App Engine MapReduce ke Apache Beam dan Dataflow:

  • Simpan data aplikasi database Datastore Anda di cloud data warehouse BigQuery untuk pemrosesan analitis menggunakan SQL.
  • Gunakan Dataflow sebagai alternatif untuk App Engine MapReduce untuk pemeliharaan dan/atau pembaruan set data Datastore Anda.
  • Cadangkan bagian database Datastore Anda ke Cloud Storage.

Apa yang dimaksud dengan 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 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 App Engine MapReduce, Anda membuat class pemrosesan data, menambahkan library MapReduce, dan setelah spesifikasi dan setelan tugas ditentukan, Anda membuat dan memulai tugas dalam satu langkah menggunakan metode start() statis di 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 hal-hal dengan cara yang sedikit berbeda; Anda membuat pipeline. Anda menggunakan konektor input dan output untuk membaca dan menulis dari sumber dan sink data. Anda menggunakan transformasi data standar (atau menulis transformasi data Anda sendiri) untuk menerapkan transformasi data. Kemudian, setelah kode siap, Anda men-deploy pipeline ke layanan Dataflow.

Mengonversi tugas MapReduce App Engine ke pipeline Apache Beam

Tabel berikut menampilkan Apache Beam yang setara dengan langkah map, shuffle, dan reduce dari model MapReduce App Engine.

Java

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

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

Python

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

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

Go

MapReduce App Engine Setara Apache Beam
Peta beam.ParDo
Acak beam.GroupByKey
Mengurangi 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 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)

Manfaat Apache Beam dan Dataflow tambahan

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 Cloud Dataflow

Jika 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 Cloud Dataflow

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

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

Membaca dan menulis

Di Apache Beam, Pembaca dan Penulis App Engine MapReduce disebut sumber data dan sink, 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