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" // 導(dǎo)入生成的代碼
)

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() {
    // 創(chuàng)建連接并指定服務(wù)端地址和端口
    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("failed to connect: %v", err)
    }
    defer conn.Close()

    // 創(chuàng)建客戶端
    client := pb.NewMyServiceClient(conn)
    
    // 發(fā)送并發(fā)請求
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()

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

            // 調(diào)用服務(wù)端方法
            resp, err := client.GetData(ctx, req)
            if err != nil {
                log.Printf("failed to get data: %v", err)
                return
            }

            // 輸出結(jié)果
            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" // 導(dǎo)入生成的代碼
)

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

package main

import (
    "context"
)

// 定義服務(wù)
type MyServiceServer struct{}

// 實現(xiàn)方法
func (s *MyServiceServer) GetData(ctx context.Context, req *pb.GetDataRequest) (*pb.GetDataResponse, error) {
    // 處理請求
    data := "Hello, " + req.Id

    // 構(gòu)造響應(yīng)
    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() {
    // 監(jiān)聽TCP端口
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }

    // 創(chuàng)建gRPC服務(wù)
    s := grpc.NewServer()

    // 注冊服務(wù)
    pb.RegisterMyServiceServer(s, &MyServiceServer{})

    // 啟動服務(wù)
    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函數(shù)入口
func main() {
    // 注冊服務(wù)
    pb.RegisterMyServiceServer(s, &MyServiceServer{})
    
    // 啟動服務(wù)
    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函數(shù)入口
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!