Home > Article > Backend Development > An article introducing how to use gRPC Golang
gRPC is a high-performance, versatile and open source RPC framework developed and open sourced by Google. gRPC supports multiple programming languages, including Golang. This article will introduce how to use gRPC Golang.
1. Install gRPC
Before developing gRPC Golang, you need to install gRPC first. You can install it through the following command:
go get -u google.golang.org/grpc
After the installation is complete, you also need to install gRPC’s Go language code generator protoc-gen-go, which can be installed through the following command:
go get -u github.com/golang/protobuf/protoc-gen-go
2. Create. proto file
Before using gRPC Golang for development, you need to first define the .proto file. The .proto file defines the service interface and message format. The following is an example of a .proto file:
syntax = "proto3"; package helloworld; service Greeter { rpc SayHello (HelloRequest) returns (HelloReply) {} } message HelloRequest { string name = 1; } message HelloReply { string message = 1; }
3. Generate Go language code
In .proto After the file is defined, you need to use the protoc tool to generate Go language code. It can be generated through the following command:
protoc -I helloworld/ helloworld/helloworld.proto --go_out=plugins=grpc:helloworld
The generated Go language code will be saved in the specified directory helloworld.
4. Implement the server
After generating the Go language code, you need to implement the service. The following is an example of a service that implements the SayHello method:
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) } }
5. Implement the client
The service can be called by implementing the client. The following is an example of a client that implements calling the SayHello method:
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) }
6. Compile and run the program
Use the following commands to compile the server and client programs:
go build -o server ./server/main.go go build -o client ./client/main.go
Run the server program:
./server
Run the client program:
./client
7. Summary
This article introduces how to use gRPC Golang, including installing gRPC and protoc- gen-go, creates .proto files, generates Go language code, implements server and client, and finally compiles and runs the program. gRPC Golang provides a high-performance, versatile RPC framework that can be used for communication between services in distributed systems.
The above is the detailed content of An article introducing how to use gRPC Golang. For more information, please follow other related articles on the PHP Chinese website!