grpc golang installation

gRPC (Google Remote Procedure Call) is a high-performance, cross-language remote procedure call framework that defines service interfaces through Protocol Buffers (ProtoBuf) and supports many programming languages. gRPC is widely used in the development of distributed systems. Its efficient serialization and deserialization mechanism, HTTP/2-based flow control and chunked transmission and other features give it obvious advantages in network transmission.

This article mainly introduces how to install gRPC in Golang and writes a simple client and server sample code.

1. Install gRPC

Before installing gRPC, you need to install Protocol Buffers 3. Protocol Buffers is a tool required for gRPC to automatically generate code, and it is also a tool for serializing data.

First, download the installation package of Protocol Buffers 3, taking Mac OS as an example:

$ curl -OL https://github.com/google/protobuf/releases/download/v3.9.1/protobuf-all-3.9.1.zip
$ unzip protobuf-all-3.9.1.zip
$ cd protobuf-3.9.1

Execute configure, make, make install to install Protocol Buffers:

$ ./configure
$ make
$ sudo make install

Installation After completing Protocol Buffers, use the following command to install Go's gRPC and related tools:

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

2. Write the ProtoBuf file

The ProtoBuf file is used to define the service interface and data structure, and automatically through the gRPC tool Generate the corresponding code (including client and server code).

We write a simple example here to define a calculator service interface that supports addition operations:

syntax = "proto3";

package calculator;

service Calculator {
  rpc Add(AddRequest) returns (AddResponse) {}
}

message AddRequest {
  int32 left = 1;
  int32 right = 2;
}

message AddResponse {
  int32 sum = 1;
}

In this example, define a service interface named Calculator, including an Add Method that receives an AddRequest parameter and returns an AddResponse parameter.

AddRequest and AddResponse are both message structures, each containing two fields of type int32, representing the two operands and the result of addition.

3. Generate code

After writing the ProtoBuf file, use the following command to generate client and server code:

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

This command generates a file named calculator.pb. Go file for go, which defines the client and server code for the calculator service.

4. Write client and server code

After generating the client and server code, you can start writing the actual client and server.

First is the server code. We create a file named server.go to implement the Calculator interface:

package main

import (
    "context"
    "log"
    "net"

    pb "calculator/calculator"

    "google.golang.org/grpc"
)

type server struct{}

func (s *server) Add(ctx context.Context, in *pb.AddRequest) (*pb.AddResponse, error) {
    sum := in.Left + in.Right
    return &pb.AddResponse{Sum: sum}, nil
}

const (
    port = ":50051"
)

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

In this example, we define a structure named server, Implemented the Add method in the Calculator interface. The Add method receives an AddRequest parameter, calculates the sum of the two operands, and returns an AddResponse parameter.

Finally, register the service into the gRPC server through the RegisterCalculatorServer method provided by the gRPC framework and start the gRPC server.

Next to write the client code, we create a file named client.go to implement a simple example of addition through the calculator service:

package main

import (
    "context"
    "log"
    "os"
    "strconv"

    pb "calculator/calculator"

    "google.golang.org/grpc"
)

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

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

    // Contact the server and print out its response.
    left, err := strconv.Atoi(os.Args[1])
    if err != nil {
        log.Fatalf("could not parse left operand: %v", err)
    }
    right, err := strconv.Atoi(os.Args[2])
    if err != nil {
        log.Fatalf("could not parse right operand: %v", err)
    }
    r, err := c.Add(context.Background(), &pb.AddRequest{Left: int32(left), Right: int32(right)})
    if err != nil {
        log.Fatalf("could not add: %v", err)
    }
    log.Printf("Sum: %d", r.Sum)
}

In this example, We create a client object named client and connect to the server through the grpc.Dial method. Then, we parse the two operands of the addition from the command line parameters, and call the Add method to send the request, get the results returned by the server, and output them.

5. Run the example

After both files are written, use the following command to compile and run the two programs:

$ go build server.go
$ go build client.go
$ ./server

Then execute the following in another terminal Command to run the client program:

$ ./client 1 2

The running result will output the calculation result 3.

The above is the installation and use of gRPC in Golang. Writing efficient distributed systems through gRPC will become very simple.

The above is the detailed content of grpc golang installation. For more information, please follow other related articles on the PHP Chinese website!