Golang 中的 GRPC 连接管理

Question

我对 GRPC 比较陌生，希望确保我正在使用 golang 正确进行连接管理。我不想为每次调用都创建一个新连接，但我也不想在扩展时产生瓶颈。

我所做的是在 init 函数中创建一个连接：

var userConn *grpc.ClientConn
var userServiceName string

func init() {
    userServiceName := os.Getenv("USER_SERVICE_URL")
    if userServiceName == "" {
        userServiceName = "localhost"
    }
    logging.LogDebug("userClient:  Connecting to: "+userServiceName, "")
    tempConn, err := grpc.Dial(userServiceName, grpc.WithInsecure())
    if err != nil {
        logging.LogEmergency("account_user_client.Init()  Could not get the connection.  "+err.Error(), "")
        return
    }
    userConn = tempConn
}

然后对于每个函数，我将使用该连接创建一个客户端：

c := user.NewUserClient(userConn)
// Contact the server and print out its response.
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
r, err := c.GetUserFromTokenID(ctx, &user.GetUserFromTokenRequest{TransactionID: transactionID, OathToken: *oathToken})
//Handle Error and Response

这是处理grpc连接的可接受方式吗？关于更好的方法有什么建议吗？

非常感谢。

Answer 1

是的，每个服务有一个 GRPC 客户端连接是可以的。此外，我在这里看不到任何其他选项。GRPC 在幕后完成所有繁重的工作：例如，您不需要编写自己的客户端连接池（就像您为典型的 RDBMS 所做的那样），因为它不会提供比单个 GRPC 连接更好的结果。

但是，我建议您避免使用全局变量和 init 函数，尤其是对于网络设置。此外，您不需要在c := user.NewUserClient(userConn)每次向 GRPC 服务发布请求时都创建 GRPC 客户端 ( )：这只是垃圾收集器的一项额外工作，您可以在应用程序启动时创建客户端的唯一实例。

更新

假设您正在编写服务器应用程序（因为它可以从您在远程 GRPC 服务上调用的方法中看出），您可以简单地定义一个类型，该类型将包含与整个应用程序本身具有相同生命周期的所有对象。按照传统，这些类型通常被称为“服务器上下文”，尽管这有点令人困惑，因为 Gocontext在其标准库中有非常重要的概念。

   // this type contains state of the server
   type serverContext struct {
       // client to GRPC service
       userClient user.UserClient

       // default timeout
       timeout time.Duration

       // some other useful objects, like config 
       // or logger (to replace global logging)
       // (...)       
   }

   // constructor for server context
   func newServerContext(endpoint string) (*serverContext, error) {
       userConn, err := grpc.Dial(endpoint, grpc.WithInsecure())
       if err != nil {
           return nil, err
       }
       ctx := &serverContext{
          userClient: user.NewUserClient(userConn),
          timeout: time.Second,
       }
       return ctx, nil
   }

   type server struct {
       context *serverContext
   }

   func (s *server) Handler(ctx context.Context, request *Request) (*Response, error) {
       clientCtx, cancel := context.WithTimeout(ctx, time.Second)
       defer cancel()
       response, err := c.GetUserFromTokenID(
          clientCtx, 
          &user.GetUserFromTokenRequest{
              TransactionID: transactionID,
              OathToken: *oathToken,
          },
       )
       if err != nil {
            return nil, err
       }
       // ...
   }

   func main() {
       serverCtx, err := newServerContext(os.Getenv("USER_SERVICE_URL"))
       if err != nil {
          log.Fatal(err)
       }
       s := &server{serverCtx}

       // listen and serve etc...
   }

细节可能会根据您实际工作的内容而变化，但我只是想表明，将应用程序的状态封装在不同类型的实例中比感染全局命名空间要好得多。