Sistem teragih ialah sistem yang terdiri daripada berbilang komputer bebas dengan data dan tugas dikongsi sesama mereka. Komputer ini berkomunikasi antara satu sama lain melalui rangkaian untuk menyelesaikan tugas bersama-sama. Dalam sistem ini, setiap komputer adalah bebas dan mereka boleh menggunakan sistem pengendalian dan bahasa pengaturcaraan yang berbeza. Untuk membolehkan komputer ini berfungsi bersama, kita memerlukan rangka kerja untuk menyelaraskan operasinya. Dalam artikel ini, kami akan memperkenalkan cara menggunakan rangka kerja Buffalo Golang untuk melaksanakan sistem teragih.

Golang ialah bahasa pengaturcaraan yang cekap, dan menggunakan Golang dalam sistem teragih adalah lebih baik daripada bahasa lain. Oleh itu, kami memilih Golang sebagai bahasa pembangunan kami. Rangka kerja Buffalo ialah rangka kerja web Golang yang popular yang menawarkan kelebihan pembangunan pesat dan pembangunan kolaboratif. Dalam rangka kerja ini, kami boleh menggunakan perkhidmatan automasinya untuk mencipta dan mengurus aplikasi.

Apabila mencipta sistem teragih, kita perlu mempertimbangkan faktor berikut:

1. Berkomunikasi antara satu sama lain: Komputer dalam sistem teragih perlu berkomunikasi antara satu sama lain untuk berfungsi bersama. Untuk mencapai ini, kami boleh menggunakan RESTful API atau protokol gRPC.
2. Penyegerakan data: Memandangkan komputer dalam sistem teragih adalah bebas, ia mungkin mempunyai data yang berbeza. Oleh itu, kita perlu mempertimbangkan cara menyegerakkan data ini.
3. Pengimbangan Beban: Untuk menjadikan sistem teragih lebih cekap, kita perlu memperuntukkan tugas kepada komputer dengan sumber pengkomputeran ganti.

Sekarang mari kita lihat cara menggunakan rangka kerja Buffalo untuk melaksanakan fungsi ini.

Buat aplikasi Buffalo

Kita perlu membuat aplikasi Buffalo pada pelayan terlebih dahulu. Kita boleh menggunakan Buffalo CLI untuk menyelesaikan tugas ini. Pasang Buffalo CLI dan buat aplikasi Buffalo baharu melalui baris arahan berikut:

$ go get -u -v github.com/gobuffalo/buffalo/cli/v2
$ buffalo new appname

Buffalo akan menjana struktur aplikasi asas. Kita boleh menggunakan arahan berikut untuk memulakan pelayan:

$ buffalo dev

Arahan ini akan memulakan pelayan web, dan kemudian kita boleh melawati http://127.0.0.1:3000 dalam penyemak imbas untuk melihat aplikasi.

Buat API RESTful

Seterusnya, kita perlu mencipta API RESTful untuk komputer dalam sistem teragih untuk berkomunikasi antara satu sama lain. Kami boleh menggunakan perkhidmatan automasi dalam rangka kerja Buffalo untuk menyelesaikan tugas ini.

Pertama, kita perlu mencipta pengawal yang mengendalikan permintaan API. Kita boleh menggunakan arahan berikut untuk mencipta pengawal:

$ buffalo generate resource user name email

Arahan ini akan menjana pengawal bernama "pengguna", dan pengawal mengandungi dua parameter: "nama" dan "e-mel". Kita boleh menambah logik pada pengawal untuk membolehkannya bertindak balas kepada pelbagai jenis permintaan.

Untuk komputer dalam sistem teragih untuk berkomunikasi antara satu sama lain, kita perlu membuat permintaan POST dan GET. Kami boleh menambah kod berikut dalam pengawal untuk mengendalikan permintaan ini:

func (v *UsersResource) Create(c buffalo.Context) error {
    user := &models.User{}
    if err := c.Bind(user); err != nil {
        return err
    }

    // Add validation logic here!

    tx := c.Value("tx").(*pop.Connection)
    if err := tx.Create(user); err != nil {
        return err
    }

    return c.Render(201, r.JSON(user))
}

func (v *UsersResource) List(c buffalo.Context) error {
    users := &models.Users{}
    tx := c.Value("tx").(*pop.Connection)
    if err := tx.All(users); err != nil {
        return err
    }

    return c.Render(200, r.JSON(users))
}

Kod ini akan mengendalikan permintaan POST dan GET dan mengembalikan data respons berformat JSON kepada klien.

Menggunakan protokol gRPC

Selain API RESTful, kami juga boleh menggunakan protokol gRPC untuk melaksanakan komunikasi antara komputer. Rangka kerja Buffalo menyokong protokol gRPC dan kami boleh memasang pemalam Buffalo-gRPC menggunakan arahan berikut:

$ buffalo plugins install buffalo-grpc

Seterusnya, kami perlu menjana kod perkhidmatan gRPC untuk aplikasi kami. Kita boleh menggunakan arahan berikut untuk menjana kod:

$ buffalo generate grpc user

Arahan ini akan menjana perkhidmatan gRPC bernama "pengguna".

Dalam kod pelayan, kami perlu melaksanakan kaedah yang ditakrifkan dalam perkhidmatan gRPC. Kami boleh melaksanakan kaedah ini dalam kod berikut:

type UserServer struct{}

func (s *UserServer) GetUser(ctx context.Context, req *user.GetUserRequest) (*user.GetUserResponse, error) {
    // Insert user retrieval logic here
}

func (s *UserServer) CreateUser(ctx context.Context, req *user.CreateUserRequest) (*user.User, error) {
    // Insert user creation logic here
}

Dalam kod pelanggan, kami boleh menggunakan kod berikut untuk memanggil perkhidmatan gRPC:

conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
if err != nil {
    log.Fatalf("failed to connect: %s", err)
}
defer conn.Close()

client := user.NewUserClient(conn)
res, err := client.GetUser(context.Background(), &user.GetUserRequest{Id: "123"})
if err != nil {
    log.Fatalf("failed to get user: %s", err)
}

log.Printf("user: %v", res)

Menggunakan Redis sebagai cache dalam sistem teragih

Dalam sistem teragih, untuk mempercepatkan capaian data, kami biasanya menggunakan cache. Redis ialah alat caching popular yang menyokong sistem teragih dan membolehkan kami menyimpan dan mendapatkan data dengan cepat. Kita boleh memasang Redis menggunakan arahan berikut:

$ brew install redis

Seterusnya, kita boleh menggunakan Redis sebagai cache dalam aplikasi kita. Kita boleh menggunakan arahan berikut untuk memasang pemalam Redis:

$ buffalo plugins install buffalo-redis

Seterusnya, kita boleh menggunakan kod berikut dalam aplikasi untuk mengkonfigurasi Redis:

var (
    RedisClient *redis.Client
)

func init() {
    RedisClient = redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })
}

func main() {
    app := buffalo.New(buffalo.Options{})
    app.Use(midware.Redis(RedisClient))
    // ...
}

Seterusnya, kita boleh gunakan dalam pengawal The kod berikut digunakan untuk menyimpan data ke dalam Redis:

func (v *UsersResource) Create(c buffalo.Context) error {
    user := &models.User{}
    if err := c.Bind(user); err != nil {
        return err
    }

    // Add validation logic here!

    if err := RedisClient.Set("user_"+user.ID.String(), user, 0).Err(); err != nil {
        return err
    }

    // Add logic to store user in database

    return c.Render(201, r.JSON(user))
}

Dalam contoh ini, kami menyimpan pengguna ke dalam cache Redis dan menggunakan ID pengguna sebagai kunci. Ini akan membolehkan kami mendapatkan semula data pengguna dengan cepat kemudian.

Mencapai pengimbangan beban

Akhir sekali, kita perlu melaksanakan fungsi pengimbangan beban. Dalam sistem teragih, kami mahu dapat memperuntukkan tugas pengkomputeran kepada komputer dengan sumber pengkomputeran ganti. Kami boleh menggunakan pelayan proksi terbalik untuk mencapai tugas ini.

Nginx ialah pelayan proksi terbalik yang popular yang menyokong pengimbangan beban dan penyulitan HTTPS. Kami boleh memasang Nginx pada pelayan dan menggunakan fail konfigurasi berikut untuk mencapai pengimbangan beban:

http {
    upstream app_servers {
        server 127.0.0.1:3001;
        server 127.0.0.1:3002;
        server 127.0.0.1:3003;
    }

    server {
        listen 80;
        server_name example.com;

        location / {
            proxy_pass http://app_servers;
        }
    }
}

Fail konfigurasi ini mengedarkan permintaan kepada tiga pelayan berbeza dan menggunakan algoritma round-robin untuk menentukan tempat untuk mengedarkan pelayan permintaan.

Kesimpulan

Dengan menggunakan rangka kerja Buffalo, kami boleh melaksanakan sistem teragih dengan cepat dan menyokong berbilang protokol komunikasi, termasuk RESTful API dan gRPC. Kami juga boleh menggunakan Redis untuk mempercepatkan akses data dan mencapai pengimbangan beban dengan menggunakan pelayan proksi terbalik. Melalui kaedah ini, kami boleh menjadikan sistem teragih lebih cekap dan mencapai kelajuan pengkomputeran yang lebih pantas.

Atas ialah kandungan terperinci Melaksanakan sistem teragih menggunakan rangka kerja Web Golang rangka kerja Buffalo. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!