Best practices for using gRPC to implement concurrent data transmission in Golang

Best practices for using gRPC to implement concurrent data transmission in Golang

Introduction:
With the development of cloud computing and big data technology, the demand for data transmission is becoming more and more urgent. As Google's open source high-performance remote procedure call framework, gRPC has become the first choice of many developers because of its efficiency, flexibility and cross-language features. This article will introduce the best practices on how to use gRPC to implement concurrent data transmission in Golang, including the construction of project structure, the use of connection pools and error handling, etc.

1. Build the project structure
Before starting to use gRPC, we need to build a suitable project structure to make the organization and management of the program clearer.

1. Create project directory
   First, we need to create a project directory to store gRPC-related code and resource files. It can be organized according to the following directory structure:

myproject
├── api
│   └── myservice.proto
│
├── client
│   ├── client.go
│   └── main.go
│
└── server
    ├── server.go
    ├── handler.go
    └── main.go

Among them, the api directory is used to store the interface definition of the gRPC service, the client directory stores client-related codes and main functions, and the server directory stores server-related ones. code and main function.

2. Define service interface
   Create a file named myservice.proto in the api directory to define our service interface. The sample code is as follows:

syntax = "proto3";

package myproject;

service MyService {
    rpc GetData (GetDataRequest) returns (GetDataResponse) {}
}

message GetDataRequest {
    string id = 1;
}

message GetDataResponse {
    string data = 1;
}

A service named MyService is defined here, including an RPC method named GetData, which receives a GetDataRequest parameter and returns a GetDataResponse parameter.

3. Generate code
   Execute the following command in the root directory of the project to generate the Golang code file:

protoc --proto_path=./api --go_out=plugins=grpc:./api ./api/myservice.proto 

This will generate a file named The file myservice.pb.go contains gRPC service and message definitions and other related codes.

2. Create the client
Next we will start writing the client code to send concurrent requests to the server and receive the returned data.

1. Import dependencies
   In client/main.go, we first need to import related dependencies, including gRPC, context and sync, etc.:

package main

import (
    "context"
    "log"
    "sync"
    "time"

    "google.golang.org/grpc"
    pb "myproject/api" // 导入生成的代码
)

2. Create connection
   In the main function, we need to create a connection with the server. Connections can be created using the grpc.Dial function. The sample code is as follows:

func main() {
    // 创建连接并指定服务端地址和端口
    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("failed to connect: %v", err)
    }
    defer conn.Close()

    // 创建客户端
    client := pb.NewMyServiceClient(conn)
    
    // 发送并发请求
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()

            // 创建上下文和请求
            ctx, cancel := context.WithTimeout(context.Background(), time.Second)
            defer cancel()
            req := &pb.GetDataRequest{
                Id: strconv.Itoa(id),
            }

            // 调用服务端方法
            resp, err := client.GetData(ctx, req)
            if err != nil {
                log.Printf("failed to get data: %v", err)
                return
            }

            // 输出结果
            log.Printf("data: %s", resp.Data)
        }(i)
    }
    
    // 等待所有请求完成
    wg.Wait()
}

In the above code, we first use the grpc.Dial function to create a connection with the server. The insecure connection mode (Insecure) is used here to simplify the example. In practical applications, it is recommended to use the secure connection mode (Secure).

Then, we created a MyServiceClient instance for calling server-side methods.

Next, we use sync.WaitGroup to coordinate concurrent requests. Within the loop, we create an anonymous function to initiate concurrent requests. In each concurrently executed request, we create a context and request object, and then call the server-side method GetData.

Finally, we use wg.Wait to wait for all concurrent requests to complete.

3. Create the server
Next we will start writing the server code to receive the client's request and return the processed data.

1. Import dependencies
   In server/main.go, we first need to import related dependencies, including gRPC, log and net, etc.:

package main

import (
    "log"
    "net"

    "google.golang.org/grpc"
    pb "myproject/api" // 导入生成的代码
)

2. Implement interface
   In handler.go, we need to implement the defined service interface. The sample code is as follows:

package main

import (
    "context"
)

// 定义服务
type MyServiceServer struct{}

// 实现方法
func (s *MyServiceServer) GetData(ctx context.Context, req *pb.GetDataRequest) (*pb.GetDataResponse, error) {
    // 处理请求
    data := "Hello, " + req.Id

    // 构造响应
    resp := &pb.GetDataResponse{
        Data: data,
    }

    return resp, nil
}

Here we implement the MyServiceServer structure and the GetData method. In this method, we first handle the request, then construct the response and return it.

3. Create service
   In the main function, we need to create and start the gRPC service. Services can be created using the grpc.NewServer function. The sample code is as follows:

func main() {
    // 监听TCP端口
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }

    // 创建gRPC服务
    s := grpc.NewServer()

    // 注册服务
    pb.RegisterMyServiceServer(s, &MyServiceServer{})

    // 启动服务
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

In the above code, we first use the net.Listen function to create a TCP listener and specify the listening port as 50051.

Then, we create a gRPC service using the grpc.NewServer function and register the service we implemented into the service using the pb.RegisterMyServiceServer method.

Finally, we use the s.Serve(lis) method to start the service and listen to the specified port.

4. Code Example Demonstration
Below we use a complete example to demonstrate how to use gRPC to implement concurrent data transmission in Golang.

First, we need to add the following code in server/main.go:

package main

// main函数入口
func main() {
    // 注册服务
    pb.RegisterMyServiceServer(s, &MyServiceServer{})
    
    // 启动服务
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

Then, add the following code in client/main.go:

package main

// main函数入口
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    req := &pb.GetDataRequest{
        Id: "1",
    }

    resp, err := client.GetData(ctx, req)
    if err != nil {
        log.Fatalf("failed to get data: %v", err)
    }

    log.Printf("data: %s", resp.Data)
}

Finally, We can execute the following commands in the project root directory to start the server and client:

go run server/main.go
go run client/main.go

The running results are as follows:

2021/01/01 15:00:00 data: Hello, 1

It can be seen that the server successfully received the client's request and The processed data is returned.

Summary:
This article introduces the best practices on how to use gRPC to implement concurrent data transmission in Golang. By building a suitable project structure, creating connections, implementing service interfaces, and starting services, we can easily use gRPC for concurrent data transmission. I hope this article can help developers who are using or will use gRPC.

The above is the detailed content of Best practices for using gRPC to implement concurrent data transmission in Golang. For more information, please follow other related articles on the PHP Chinese website!