Teknologi MapReduce dalam bahasa Go

Dengan pertumbuhan volum data dan peningkatan keperluan pemprosesan, beberapa teknologi pemprosesan data juga menjadi popular. MapReduce ialah teknologi pemprosesan data teragih yang sangat baik dan boleh skala. Sebagai bahasa yang baru muncul, bahasa Go telah mula menyokong MapReduce secara beransur-ansur. Dalam artikel ini, kami akan memperkenalkan teknologi MapReduce dalam bahasa Go.

Apakah itu MapReduce?

MapReduce ialah model pengaturcaraan untuk memproses set data berskala besar. Ia pada asalnya dicadangkan oleh Google untuk menyokong pembinaan indeks untuk perangkak web. Idea asas MapReduce adalah untuk membahagikan set data kepada banyak blok data kecil, melaksanakan fungsi pemetaan pada blok data kecil ini, dan melaksanakan fungsi pengurangan pada hasil output fungsi pemetaan. Biasanya, proses ini dilakukan pada kluster yang diedarkan, dengan setiap nod melaksanakan bahagian tugasnya sendiri dan hasil akhir digabungkan merentasi semua nod.

Bagaimana untuk menggunakan MapReduce dalam Go?

Bahasa Go menyediakan cara yang mudah untuk menggunakan MapReduce dalam persekitaran yang diedarkan. Pustaka standard Go menyediakan rangka kerja MapReduce yang boleh memudahkan pemprosesan data teragih.

Rangka kerja Go's MapReduce merangkumi 3 komponen:

1. Fungsi peta: Fungsi ini menyediakan sharding set data input. Fungsi Peta membahagikan set data kepada banyak kepingan kecil dan mengembalikan sepotong pasangan kunci/nilai. Setiap pasangan kunci/nilai mewakili hasil pengiraan.
2. Fungsi Kurangkan: Fungsi ini menerima kepingan pasangan kunci/nilai yang dikembalikan oleh fungsi Peta dan mengagregatkan pasangan kunci/nilai. Output fungsi Reduce ialah kepingan baru pasangan kunci/nilai.
3. Fungsi kerja: Fungsi ini mentakrifkan semua parameter yang diperlukan oleh tugas MapReduce, seperti laluan data input, fungsi Peta, fungsi Kurangkan, dsb.

Menggunakan rangka kerja MapReduce Go, kita perlu melakukan langkah berikut:

1. Laksanakan fungsi Map dan fungsi Reduce.
2. Isytiharkan objek Kerja dan tetapkan parameter seperti laluan data input, fungsi Peta dan fungsi Kurangkan.
3. Panggil fungsi Run objek Job untuk menjalankan tugas MapReduce dalam persekitaran yang diedarkan.

Berikut ialah contoh kod ringkas:

package main

import (
    "fmt"
    "strconv"
    "strings"

    "github.com/dustin/go-humanize"
    "github.com/syndtr/goleveldb/leveldb"
    "github.com/syndtr/goleveldb/leveldb/util"
)

func mapper(data []byte) (res []leveldb.KeyValue, err error) {
    lines := strings.Split(string(data), "
")
    for _, line := range lines {
        if len(line) == 0 {
            continue
        }
        fields := strings.Fields(line)
        if len(fields) != 2 {
            continue
        }
        k, err := strconv.Atoi(fields[1])
        if err != nil {
            continue
        }
        v, err := humanize.ParseBytes(fields[0])
        if err != nil {
            continue
        }
        res = append(res, leveldb.KeyValue{
            Key:   []byte(fields[1]),
            Value: []byte(strconv.Itoa(int(v))),
        })
    }
    return
}

func reducer(key []byte, values [][]byte) (res []leveldb.KeyValue, err error) {
    var total int
    for _, v := range values {
        i, _ := strconv.Atoi(string(v))
        total += i
    }
    res = []leveldb.KeyValue{
        leveldb.KeyValue{
            Key:   key,
            Value: []byte(strconv.Itoa(total)),
        },
    }
    return
}

func main() {
    db, err := leveldb.OpenFile("/tmp/data", nil)
    if err != nil {
        panic(err)
    }
    defer db.Close()

    job := &util.Job{
        Name:   "word-count",
        NumMap: 10,
        Map: func(data []byte, h util.Handler) (err error) {
            kvs, err := mapper(data)
            if err != nil {
                return err
            }
            h.ServeMap(kvs)
            return
        },
        NumReduce: 2,
        Reduce: func(key []byte, values [][]byte, h util.Handler) (err error) {
            kvs, err := reducer(key, values)
            if err != nil {
                return err
            }
            h.ServeReduce(kvs)
            return
        },
        Input:    util.NewFileInput("/tmp/data/raw"),
        Output:   util.NewFileOutput("/tmp/data/output"),
        MapBatch: 100,
    }
    err = job.Run()
    if err != nil {
        panic(err)
    }

    fmt.Println("MapReduce task done")
}

Dalam contoh ini, kami melaksanakan program WordCount mudah untuk mengira bilangan perkataan dalam fail teks. Antaranya, fungsi pemeta digunakan untuk membahagikan data input kepada ketulan dan keping pasangan kunci/nilai kembali digunakan untuk mengagregat pasangan kunci/nilai dan mengembalikan kepingan pasangan kunci/nilai baharu; Kemudian, kami mengisytiharkan objek Kerja dan menetapkan parameter seperti fungsi Peta dan fungsi Kurangkan. Akhir sekali, kami memanggil fungsi Run objek Job untuk menjalankan tugas MapReduce dalam persekitaran yang diedarkan.

Ringkasan

MapReduce ialah teknologi pemprosesan data teragih yang sangat praktikal yang boleh digunakan untuk memproses set data berskala besar. Bahasa Go, sebagai bahasa pengaturcaraan yang baru muncul, juga telah mula menyokong MapReduce. Dalam artikel ini, kami memperkenalkan kaedah menggunakan MapReduce dalam Go, termasuk langkah-langkah melaksanakan fungsi Map dan fungsi Reduce, mengisytiharkan objek Job dan memanggil fungsi Run objek Job. Saya harap artikel ini dapat membantu anda memahami teknologi MapReduce.

Atas ialah kandungan terperinci Teknologi MapReduce dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!