pemasangan golang grpc

Golang ialah bahasa pengaturcaraan yang sangat popular yang popular secara meluas kerana kesesuaian dan prestasinya yang sangat baik. Baru-baru ini, gRPC telah menjadi semakin popular di dunia pembangun dengan peningkatan seni bina pengkomputeran awan dan perkhidmatan mikro. gRPC ialah rangka kerja RPC berprestasi tinggi, sumber terbuka, tujuan umum yang dibangunkan dan dipromosikan oleh Google. Ia menyokong berbilang bahasa dan menyediakan kebolehlanjutan yang kuat, menjadikannya salah satu rangka kerja pilihan untuk membina aplikasi teragih. Artikel ini akan menunjukkan kepada anda cara memasang gRPC di Golang dan bermula dengan cepat.

Langkah 1: Pasang Penampan Protokol

Untuk mula menggunakan gRPC, anda mesti memasang Penampan Protokol terlebih dahulu. Penampan Protokol ialah format siri data berstruktur intuitif yang membolehkan anda menghantar dan menyimpan data dengan mudah antara aplikasi yang berbeza. Penampan Protokol menyokong berbilang bahasa pengaturcaraan, termasuk Java, C++ dan Golang.

Untuk memasang Penampan Protokol di Golang, sila lakukan perkara berikut:

Langkah 1: Dapatkan Penampan Protokol daripada GitHub

Penimbal Protokol di Golang diedarkan melalui repositori GitHub. Pertama, anda perlu mendapatkan kod sumber Protocol Buffers daripada GitHub. Buka terminal dan jalankan arahan berikut:

$ go get -u github.com/golang/protobuf/protoc-gen-go

Langkah 2: Pasang Protocol Buffers

Memasang Protocol Buffers memerlukan penggunaan pengurus pakej seperti Homebrew atau pengurus pakej Linux yang besar (seperti sedap). Buka terminal dan jalankan arahan berikut:

Homebrew

$ brew install protobuf

Linux

$ yum install protobuf

Langkah Kedua: Pasang gRPC

Selepas memasang Protocol Buffers, anda kini boleh pasang gRPC. Di Golang, anda boleh memasang gRPC daripada repositori GitHub menggunakan arahan go get. Buka terminal dan jalankan arahan berikut:

$ go get -u google.golang.org/grpc

Arahan ini akan memuat turun dan memasang rangka kerja gRPC dan kebergantungan berkaitannya.

Langkah 3: Menggunakan gRPC

Sekarang anda telah melengkapkan langkah pemasangan gRPC, anda boleh mula menggunakannya di Golang. Seterusnya, kami akan melihat contoh mudah yang menunjukkan kepada anda cara menggunakan gRPC dengan Golang.

Langkah 1: Cipta fail .proto

Dalam contoh ini, kami akan mencipta fail .proto bernama "hello.proto", yang mengandungi titik akhir perkhidmatan gRPC yang ringkas :

syntax = "proto3";
package hello;

// 定义HelloRequest消息
message HelloRequest {
  string name = 1;
}

// 定义HelloResponse消息
message HelloResponse {
  string message = 1;
}

// 定义Hello服务
service Hello {
  // 定义SayHello方法
  rpc SayHello (HelloRequest) returns (HelloResponse);
}

Dalam fail .proto ini, kami mentakrifkan perkhidmatan gRPC bernama "Hello", yang mengandungi kaedah bernama "SayHello". Kaedah ini menerima mesej jenis "HelloRequest" daripada klien dan mengembalikan respons jenis "HelloResponse".

Langkah 2: Jana kod gRPC

Selepas anda mencipta fail .proto, anda perlu menggunakan pengkompil Protocol Buffers untuk menjana kod Golang. Untuk melakukan ini, buka terminal dan jalankan arahan berikut:

$ protoc --go_out=plugins=grpc:. hello.proto

Arahan ini akan menjana fail bernama "hello.pb.go" yang mengandungi mesej dan perkhidmatan yang anda takrifkan dalam .proto file kod Golang.

Langkah 3: Laksanakan perkhidmatan gRPC

Sekarang anda telah menjana kod gRPC Golang, anda boleh mula melaksanakan perkhidmatan gRPC anda. Berikut ialah contoh mudah:

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "path/to/hello.pb.go"
)

type server struct{}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
    log.Printf("Received: %v", in.GetName())
    return &pb.HelloResponse{Message: "Hello " + in.GetName()}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterHelloServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

Dalam contoh ini, kita mula-mula mentakrifkan struktur "pelayan" dan menambah kaedah bernama "SayHello" padanya. Kaedah ini akan menerima mesej "HelloRequest" yang dihantar oleh pelanggan dan mengembalikan mesej "HelloResponse". Akhir sekali, kami juga menyediakan fungsi yang dipanggil "utama" yang akan memulakan perkhidmatan gRPC dan mendengar pada nombor port 50051.

Langkah 4: Jalankan perkhidmatan gRPC

Sekarang anda telah menyelesaikan pelaksanaan perkhidmatan gRPC, anda boleh memulakan perkhidmatan dalam terminal:

$ go run main.go

Kesimpulan

gRPC ialah rangka kerja RPC tujuan umum sumber terbuka yang telah digunakan secara meluas. Di Golang, anda boleh memasang dan menggunakan gRPC dalam beberapa langkah mudah, yang memudahkan membina aplikasi yang diedarkan. Kami berharap artikel ini membantu anda memulakan gRPC dan memperkasakan anda untuk membina perkhidmatan edaran yang cekap, berskala dan boleh dipercayai.

Atas ialah kandungan terperinci pemasangan golang grpc. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!