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;
}

• syntax defines the syntax version used by the .proto file
• package defines the package name
• service defines a service
• rpc defines a method, including request input and return output
• message defines the format of the message

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)
    }
}

• The server structure that implements the SayHello method
• The SayHello method receives a context (ctx) and a HelloRequest object as input, Return a HelloReply object and an error
• Create a gRPC server through grpc.NewServer()
• Use pb.RegisterGreeterServer to register the service on the server
• Start the server

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)
}

• Use the grpc.Dial method to create a connection
• Create a GreeterClient object c
• Use c. SayHello method request service
• Print service response

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!