Bermigrasi dari MapReduce App Engine ke Apache Beam dan Dataflow

Tutorial ini ditujukan untuk pengguna MapReduce App Engine. Contoh ini menunjukkan cara melakukan migrasi dari menggunakan MapReduce App Engine ke Apache Beam dan Dataflow.

Mengapa bermigrasi?

MapReduce App Engine adalah model pemrograman untuk memproses data dalam jumlah besar secara paralel dan terdistribusi. Hal ini berguna untuk tugas besar yang berjalan lama dan 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 dikembangkan dari layanan App Engine dan tidak lagi didukung oleh Google.

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

Kasus migrasi

Berikut adalah beberapa contoh kasus yang dapat Anda gunakan untuk melakukan migrasi dari MapReduce App Engine ke Apache Beam dan Dataflow:

  • Simpan data aplikasi database Datastore Anda di data warehouse BigQuery untuk pemrosesan analisis menggunakan SQL.
  • Gunakan Dataflow sebagai alternatif MapReduce App Engine untuk pemeliharaan dan/atau update 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 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 menjalankannya 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 akan 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, buat class Input dan Output, serta tentukan class Mapper dan Reducer untuk transformasi data.

Dengan Apache Beam, Anda melakukan sesuatu dengan sedikit berbeda; Anda membuat pipeline. Anda menggunakan konektor input dan output untuk membaca dan menulis dari sumber data dan sink Anda. Anda menggunakan transformasi data yang telah ditentukan (atau menulis sendiri) untuk mengimplementasikan transformasi data Anda. 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 dengan Apache Beam
Peta MapElements<InputT,OutputT>
Acak GroupByKey<K,V>
Kurangi Gabungkan.GroupedValues<K,InputT,OutputT>

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

Python

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

Praktik yang 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<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"));
string,>string,>string,>

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 tambahan Apache Beam dan Dataflow

Jika Anda 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 terbiasa dengan task queue App Engine, Anda dapat menjadwalkan tugas berulang menggunakan Cron. Contoh ini menunjukkan cara menggunakan App Engine Cron untuk menjadwalkan pipeline Apache Beam Anda.

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 oleh appspot.com.

Ketika 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 mengetahui informasi tambahan tentang pipeline Anda.

Membaca dan menulis

Di Apache Beam, Readers and Writers 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 selanjutnya