Artikel yang memperkenalkan cara menggunakan gRPC Golang

PHPz
Lepaskan: 2023-04-13 09:54:25
asal
1053 orang telah melayarinya

gRPC ialah rangka kerja RPC sumber terbuka berprestasi tinggi, serba boleh dan terbuka yang dibangunkan dan sumber terbuka oleh Google. gRPC menyokong berbilang bahasa pengaturcaraan, termasuk Golang. Artikel ini akan memperkenalkan cara menggunakan gRPC Golang.

1. Pasang gRPC

Sebelum membangunkan gRPC Golang, anda perlu memasang gRPC terlebih dahulu. Anda boleh memasangnya dengan arahan berikut:

go get -u google.golang.org/grpc
Salin selepas log masuk

Selepas pemasangan selesai, anda juga perlu memasang gRPC's Go language code generator protoc-gen-go, yang boleh dipasang dengan arahan berikut:

go get -u github.com/golang/protobuf/protoc-gen-go
Salin selepas log masuk

2. Cipta fail .proto

Sebelum menggunakan gRPC Golang untuk pembangunan, anda perlu mentakrifkan fail .proto terlebih dahulu. Fail .proto mentakrifkan antara muka perkhidmatan dan format mesej. Berikut ialah contoh fail .proto:

syntax = "proto3";

package helloworld;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}
Salin selepas log masuk
  • sintaks mentakrifkan versi sintaks yang digunakan oleh fail .proto
  • pakej mentakrifkan nama pakej
  • perkhidmatan mentakrifkan perkhidmatan
  • rpc mentakrifkan kaedah, termasuk permintaan input dan pulangan output
  • mesej mentakrifkan format mesej

3. Jana kod bahasa Go

dalam Selepas fail .proto ditakrifkan, anda perlu menggunakan alat protoc untuk menjana kod bahasa Go. Ia boleh dijana dengan arahan berikut:

protoc -I helloworld/ helloworld/helloworld.proto --go_out=plugins=grpc:helloworld
Salin selepas log masuk

Kod bahasa Go yang dijana akan disimpan dalam direktori helloworld yang ditentukan.

4. Laksanakan pelayan

Selepas menjana kod bahasa Go, anda perlu melaksanakan perkhidmatan tersebut. Berikut ialah contoh perkhidmatan yang melaksanakan kaedah SayHello:

package main

import (
    "context"
    "fmt"
    "net"

    "google.golang.org/grpc"
    pb "github.com/your_username/helloworld"
)

const (
    port = ":50051"
)

type server struct{}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

func main() {
    lis, err := net.Listen("tcp", port)
    if err != nil {
        fmt.Printf("failed to listen: %v", err)
        return
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    fmt.Printf("server listening at %v", lis.Addr())
    if err := s.Serve(lis); err != nil {
        fmt.Printf("failed to serve: %v", err)
    }
}
Salin selepas log masuk
  • Struktur pelayan yang melaksanakan kaedah SayHello
  • Kaedah SayHello menerima konteks (ctx) dan objek HelloRequest sebagai Input, kembalikan objek HelloReply dan ralat
  • Buat pelayan gRPC melalui grpc.NewServer()
  • Gunakan pb.RegisterGreeterServer untuk mendaftarkan perkhidmatan pada pelayan
  • Mulakan pelayan

5. Laksanakan klien

Perkhidmatan boleh dipanggil dengan melaksanakan klien. Berikut ialah contoh klien yang melaksanakan panggilan kaedah SayHello:

package main

import (
    "context"
    "log"
    "os"
    "time"

    "google.golang.org/grpc"
    pb "github.com/your_username/helloworld"
)

const (
    address     = "localhost:50051"
    defaultName = "world"
)

func main() {
    // Set up a connection to the server.
    conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithTimeout(10*time.Second))
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := pb.NewGreeterClient(conn)

    // Contact the server and print out its response.
    name := defaultName
    if len(os.Args) > 1 {
        name = os.Args[1]
    }
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
}
Salin selepas log masuk
  • Buat sambungan menggunakan kaedah grpc.Dail
  • Buat objek GreeterClient c
  • Gunakan kaedah c.SayHello untuk meminta perkhidmatan
  • Cetak respons perkhidmatan

6. Susun dan jalankan atur cara

Gunakan arahan berikut untuk menyusun program pelayan dan klien:

go build -o server ./server/main.go
go build -o client ./client/main.go
Salin selepas log masuk

Jalankan program pelayan:

./server
Salin selepas log masuk

Jalankan program klien:

./client
Salin selepas log masuk

Ringkasan

Artikel ini memperkenalkan kaedah Penggunaan gRPC Golang termasuk memasang gRPC dan protoc-gen-go, mencipta fail .proto, menjana kod bahasa Go, melaksanakan pelayan dan klien, dan akhirnya menyusun dan menjalankan program. gRPC Golang menyediakan rangka kerja RPC serba boleh berprestasi tinggi yang boleh digunakan untuk komunikasi antara perkhidmatan dalam sistem teragih.

Atas ialah kandungan terperinci Artikel yang memperkenalkan cara menggunakan gRPC Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

sumber:php.cn
Kenyataan Laman Web ini
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
Tutorial Popular
Lagi>
Muat turun terkini
Lagi>
kesan web
Kod sumber laman web
Bahan laman web
Templat hujung hadapan