Bina pelayan cache yang sangat tersedia menggunakan bahasa Go

Dalam sistem teragih moden, caching merupakan komponen yang amat diperlukan yang boleh meningkatkan prestasi dan kebolehskalaan sistem dengan ketara. Walau bagaimanapun, apabila saiz sistem berkembang, ketersediaan pelayan cache menjadi masalah yang semakin serius. Oleh itu, kita perlu membina pelayan cache yang sangat tersedia untuk memastikan kestabilan sistem. Dalam artikel ini, kami akan memperkenalkan cara membina pelayan cache yang sangat tersedia menggunakan bahasa Go.

1. Cara memilih pelayan cache

Apabila memilih pelayan cache, kita perlu mengambil kira faktor berikut:

1. Ketekalan data

Dalam sistem teragih, ketekalan data adalah isu teras. Kita perlu memastikan bahawa data dalam cache sentiasa terkini dan tidak lapuk atau tidak konsisten.

2. Prestasi

Prestasi tinggi ialah ciri penting pelayan cache yang baik. Kami perlu memastikan bahawa pelayan cache boleh bertindak balas kepada permintaan dengan cepat dan dengan kependaman sesedikit mungkin.

3. Skalabiliti

Pelayan cache perlu mempunyai kebolehskalaan yang baik supaya kita boleh menambah bilangan pelayan apabila beban meningkat.

4. Kebolehpercayaan

Ketersediaan tinggi ialah satu lagi ciri penting pelayan cache. Kita perlu memastikan bahawa walaupun satu pelayan gagal, sistem akan tetap berfungsi dengan baik.

Berdasarkan pertimbangan di atas, kami boleh memilih pelayan cache berikut:

1. Memcached

Memcached ialah pelayan cache berasaskan memori Sangat pantas , berskala dan stabil. Walau bagaimanapun, Memcached tidak menyokong kegigihan data, yang bermaksud bahawa jika pelayan turun, semua data akan hilang.

2. Redis

Redis ialah pangkalan data dalam memori yang menyokong struktur data nilai kunci. Ia bukan sahaja menyokong kegigihan data, tetapi juga menyediakan beberapa ciri lanjutan seperti terbitkan/langganan, transaksi dan skrip Lua. Disebabkan sifat redis satu benang, ia berfungsi dengan sangat baik apabila mengendalikan permintaan serentak yang tinggi.

3. Couchbase

Couchbase ialah pelayan cache teragih berasaskan memori yang menyokong nilai kunci dan data jenis dokumen. Salah satu faedah Couchbase ialah keupayaannya untuk mengimbangi semula data secara automatik untuk memastikan prestasi dan kebolehskalaan.

Berdasarkan faktor di atas, saya memilih Redis sebagai penyelesaian pelaksanaan untuk pelayan cache ketersediaan tinggi yang diperkenalkan dalam artikel ini.

2. Gunakan bahasa Go untuk membina pelayan cache yang sangat tersedia

Dalam bahagian ini, kami akan memperkenalkan cara menggunakan bahasa Go untuk membina pelayan cache yang sangat tersedia.

1. Pasang Redis

Mula-mula, kita perlu memasang Redis. Kaedah pemasangan khusus adalah di luar skop artikel ini Pembaca boleh merujuk kepada dokumentasi Redis rasmi atau tutorial lain.

2. Menyambung ke Redis

Dalam bahasa Go, kami boleh menggunakan perpustakaan pihak ketiga github.com/go-redis/redis untuk menyambung ke pelayan Redis. Kod khusus adalah seperti berikut:

import "github.com/go-redis/redis"

func main() {
    // 创建Redis客户端
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    // 测试连接
    pong, err := client.Ping().Result()
    fmt.Println(pong, err)
}

3. Laksanakan logik cache

Seterusnya, kita perlu melaksanakan logik cache khusus mengikut keperluan perniagaan. Dalam artikel ini, kami melaksanakan logik cache asas, termasuk cache baca, tulis cache dan padam cache. Kod khusus adalah seperti berikut:

// 读取缓存
func get(key string) (string, error) {
    val, err := client.Get(key).Result()
    if err == redis.Nil {
        return "", nil
    } else if err != nil {
        return "", err
    } else {
        return val, nil
    }
}

// 写入缓存
func set(key string, val string) error {
    err := client.Set(key, val, 0).Err()
    if err != nil {
        return err
    } else {
        return nil
    }
}

// 删除缓存
func del(key string) error {
    err := client.Del(key).Err()
    if err != nil {
        return err
    } else {
        return nil
    }
}

4. Mencapai ketersediaan tinggi

Untuk mencapai ketersediaan tinggi, kita perlu menggunakan fungsi replikasi tuan-hamba Redis. Langkah-langkah khusus adalah seperti berikut:

• Tetapkan kata laluan pada pelayan utama Redis, dan tetapkan requirepass item konfigurasi dalam fail konfigurasi Redis kepada kata laluan.
• Pada pelayan hamba Redis, edit fail konfigurasi Redis dan tetapkan slaveof item konfigurasi ke alamat dan port pelayan induk, seperti: slaveof localhost 6379.
• Dalam program Go, gunakan kaedah github.com/go-redis/redis pustaka NewFailoverClient untuk menyambung ke pelayan Redis. Kaedah ini secara automatik mengesan status pelayan induk dan pelayan hamba Redis dan secara automatik mengarahkan permintaan baca dan tulis.

Kod khusus adalah seperti berikut:

// 创建Redis客户端
client := redis.NewFailoverClient(&redis.FailoverOptions{
    MasterName:    "mymaster",
    SentinelAddrs: []string{"localhost:26379"},
    Password:      "password",
})

Dalam contoh ini, kami menggunakan Redis Sentinel untuk melaksanakan penukaran master-slave. Sentinel ialah komponen dalam Redis yang boleh memantau status nod induk dan hamba Redis secara automatik dan bertukar kepada pelayan sandaran apabila pelayan induk tidak tersedia.

5. Kod contoh lengkap

import (
    "fmt"
    "github.com/go-redis/redis"
)

var client *redis.Client

func main() {
    // 创建Redis客户端
    client = redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "password",
        DB:       0,
    })

    // 测试连接
    pong, err := client.Ping().Result()
    if err != nil {
        fmt.Println("Failed to connect to Redis!")
        return
    }
    fmt.Println("Connected to Redis:", pong)

    // 缓存操作示例
    key := "foo"
    val := "bar"
    set(key, val)
    res, err := get(key)
    if err != nil {
        fmt.Println("Failed to get value from cache!")
    } else {
        fmt.Println("Value from cache:", res)
    }
    del(key)
}

// 读取缓存
func get(key string) (string, error) {
    val, err := client.Get(key).Result()
    if err == redis.Nil {
        return "", nil
    } else if err != nil {
        return "", err
    } else {
        return val, nil
    }
}

// 写入缓存
func set(key string, val string) error {
    err := client.Set(key, val, 0).Err()
    if err != nil {
        return err
    } else {
        return nil
    }
}

// 删除缓存
func del(key string) error {
    err := client.Del(key).Err()
    if err != nil {
        return err
    } else {
        return nil
    }
}

3 Ringkasan

Artikel ini memperkenalkan cara menggunakan bahasa Go untuk membina pelayan cache yang sangat tersedia, termasuk menyambung ke. Redis, Laksanakan logik caching dan capai ketersediaan tinggi. Menggunakan Redis sebagai pelayan cache boleh meningkatkan prestasi dan kebolehskalaan sistem, dan pada masa yang sama memastikan ketersediaan sistem yang tinggi melalui mekanisme replikasi tuan-hamba. Saya harap artikel ini dapat membantu pembaca lebih memahami cara cache yang diedarkan dilaksanakan.

Atas ialah kandungan terperinci Bina pelayan cache yang sangat tersedia menggunakan bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!