gRPC

1 Example

项目地址gRPC - 图1 (opens new window)

ego版本：ego@v0.5.3

2 gRPC配置

  1. type Config struct {
  2.     Addr                       string        // 连接地址，直连为127.0.0.1:9001，服务发现为etcd:///appname
  3.     BalancerName               string        // 负载均衡方式，默认round robin
  4.     OnFail                     string        // 失败后的处理方式，panic | error
  5.     DialTimeout                time.Duration // 连接超时，默认3s
  6.     ReadTimeout                time.Duration // 读超时，默认1s
  7.     SlowLogThreshold           time.Duration // 慢日志记录的阈值，默认600ms
  8.     Debug                      bool          // 是否开启调试，默认不开启，开启后并加上export EGO_DEBUG=true，可以看到每次请求，配置名、地址、耗时、请求数据、响应数据
  9.     EnableBlock                bool          // 是否开启阻塞，默认开启
  10.     EnableWithInsecure         bool          // 是否开启非安全传输，默认开启
  11.     EnableMetricInterceptor    bool          // 是否开启监控，默认开启
  12.     EnableTraceInterceptor     bool          // 是否开启链路追踪，默认开启
  13.     EnableAppNameInterceptor   bool          // 是否开启传递应用名，默认开启
  14.     EnableTimeoutInterceptor   bool          // 是否开启超时传递，默认开启
  15.     EnableAccessInterceptor    bool          // 是否开启记录请求数据，默认不开启
  16.     EnableAccessInterceptorReq bool          // 是否开启记录请求参数，默认不开启
  17.     EnableAccessInterceptorRes bool          // 是否开启记录响应参数，默认不开启
  18. }

3 优雅的Debug

通过开启debug配置和命令行的export EGO_DEBUG=true， 我们可以在测试环境里看到请求里的行号、配置名、请求地址、耗时、请求数据、响应数据

img_1.png

并且使用Goland同学，可以直接通过行号点击到对应的代码路径

4 直连gRPC

4.1 用户配置

  1. [grpc.test]
  2. debug = true # 开启后并加上export EGO_DEBUG=true，可以看到每次grpc请求，配置名、地址、耗时、请求数据、响应数据
  3. addr = "127.0.0.1:9002"

4.2 用户代码

配置创建一个 grpc 的配置项，其中内容按照上文配置进行填写。以上这个示例里这个配置key是grpc.test

代码中创建一个 gRPC 客户端， egrpc.Load("key").Build()，代码中的 key 和配置中的 key 要保持一致。创建完 gRPC 客户端后， 将他添加到你所需要的Client里即可。

  1. package main
  3. import (
  4.     "context"
  5.     "github.com/gotomicro/ego"
  6.     "github.com/gotomicro/ego/client/egrpc"
  7.     "github.com/gotomicro/ego/core/elog"
  8.     "google.golang.org/grpc/examples/helloworld/helloworld"
  9. )
  11. func main() {
  12.     if err := ego.New().Invoker(
  13.         invokerGrpc,
  14.         callGrpc,
  15.     ).Run(); err != nil {
  16.         elog.Error("startup", elog.FieldErr(err))
  17.     }
  18. }
  20. var grpcComp helloworld.GreeterClient
  22. func invokerGrpc() error {
  23.     grpcConn := egrpc.Load("grpc.test").Build()
  24.     grpcComp = helloworld.NewGreeterClient(grpcConn.ClientConn)
  25.     return nil
  26. }
  28. func callGrpc() error {
  29.     _, err := grpcComp.SayHello(context.Background(), &helloworld.HelloRequest{
  30.         Name: "i am client",
  31.     })
  32.     if err != nil {
  33.         return err
  34.     }
  36.     _, err = grpcComp.SayHello(context.Background(), &helloworld.HelloRequest{
  37.         Name: "error",
  38.     })
  39.     if err != nil {
  40.         return err
  41.     }
  42.     return nil
  43. }

5 使用ETCD的gRPC

5.1 用户配置

  1. [grpc.test]
  2. debug = true # 开启后并加上export EGO_DEBUG=true，可以看到每次grpc请求，配置名、地址、耗时、请求数据、响应数据
  3. addr = "etcd:///name-srv"

5.2 用户代码

配置创建一个 grpc 的配置项，其中内容按照上文配置进行填写。以上这个示例里这个配置key是grpc.test

代码中创建一个 gRPC 客户端， egrpc.Load("key").Build()，代码中的 key 和配置中的 key 要保持一致。创建完 gRPC 客户端后， 将他添加到你所需要的Client里即可。

  1. package main
  3. import (
  4.     "context"
  5.     "github.com/gotomicro/ego"
  6.     "github.com/gotomicro/ego/core/elog"
  7.     "github.com/gotomicro/ego-component/eetcd"
  8.     "github.com/gotomicro/ego-component/eetcd/registry"
  9.     "github.com/gotomicro/ego/client/egrpc"
  10.     "github.com/gotomicro/ego/client/egrpc/resolver"
  11.     "google.golang.org/grpc/examples/helloworld/helloworld"
  12. )
  14. func main() {
  15.     if err := ego.New().Invoker(
  16.         invokerGrpc,
  17.         callGrpc,
  18.     ).Run(); err != nil {
  19.         elog.Error("startup", elog.FieldErr(err))
  20.     }
  21. }
  23. var grpcComp helloworld.GreeterClient
  25. func invokerGrpc() error {
  26.     // 必须注册在grpc前面
  27.     resolver.Register("etcd",  registry.Load("registry").Build(registry.WithClientEtcd(eetcd.Load("etcd").Build())))
  29.     grpcConn := egrpc.Load("grpc.test").Build()
  30.     grpcComp = helloworld.NewGreeterClient(grpcConn.ClientConn)
  31.     return nil
  32. }
  34. func callGrpc() error {
  35.     _, err := grpcComp.SayHello(context.Background(), &helloworld.HelloRequest{
  36.         Name: "i am client",
  37.     })
  38.     if err != nil {
  39.         return err
  40.     }
  42.     _, err = grpcComp.SayHello(context.Background(), &helloworld.HelloRequest{
  43.         Name: "error",
  44.     })
  45.     if err != nil {
  46.         return err
  47.     }
  48.     return nil
  49. }

6 使用K8S的gRPC

6.1 用户配置

  1. [grpc.test]
  2. debug = true # 开启后并加上export EGO_DEBUG=true，可以看到每次grpc请求，配置名、地址、耗时、请求数据、响应数据
  3. addr = "k8s:///name-srv"

6.2 用户代码

配置创建一个 grpc 的配置项，其中内容按照上文配置进行填写。以上这个示例里这个配置key是grpc.test

代码中创建一个 gRPC 客户端， egrpc.Load("key").Build()，代码中的 key 和配置中的 key 要保持一致。创建完 gRPC 客户端后， 将他添加到你所需要的Client里即可。

  1. package main
  3. import (
  4.     "context"
  5.     "github.com/gotomicro/ego"
  6.     "github.com/gotomicro/ego/core/elog"
  7.     "github.com/gotomicro/ego-component/ek8s"
  8.     "github.com/gotomicro/ego-component/ek8s/registry"
  9.     "github.com/gotomicro/ego/client/egrpc"
  10.     "github.com/gotomicro/ego/client/egrpc/resolver"
  11.     "google.golang.org/grpc/examples/helloworld/helloworld"
  12. )
  14. func main() {
  15.     if err := ego.New().Invoker(
  16.         invokerGrpc,
  17.         callGrpc,
  18.     ).Run(); err != nil {
  19.         elog.Error("startup", elog.FieldErr(err))
  20.     }
  21. }
  23. var grpcComp helloworld.GreeterClient
  25. func invokerGrpc() error {
  26.     // 必须注册在grpc前面
  27.      resolver.Register("k8s", registry.Load("registry").Build(registry.WithClientKubernetes(ek8s.Load("k8s").Build())))
  29.     grpcConn := egrpc.Load("grpc.test").Build()
  30.     grpcComp = helloworld.NewGreeterClient(grpcConn.ClientConn)
  31.     return nil
  32. }
  34. func callGrpc() error {
  35.     _, err := grpcComp.SayHello(context.Background(), &helloworld.HelloRequest{
  36.         Name: "i am client",
  37.     })
  38.     if err != nil {
  39.         return err
  40.     }
  42.     _, err = grpcComp.SayHello(context.Background(), &helloworld.HelloRequest{
  43.         Name: "error",
  44.     })
  45.     if err != nil {
  46.         return err
  47.     }
  48.     return nil
  49. }

7 使用gRPC的链路

7.1 用户配置

  1. [trace.jaeger] # 启用链路的核心配置
  2.     ServiceName = "client"
  3. [grpc.test]
  4.     debug = true # 开启后并加上export EGO_DEBUG=true，可以看到每次grpc请求，配置名、地址、耗时、请求数据、响应数据
  5.     addr = "127.0.0.1:9002"

7.2 测试代码

gRPC直连查看链路idgRPC - 图3 (opens new window)

7.2.1 服务端链路信息

image

7.2.2 客户端链路信息

image

8 开启客户端详细日志信息

8.1 测试代码

gRPC查看详细信息gRPC - 图6 (opens new window)

8.2 用户配置

  1. [grpc.test]
  2.     debug = true # 开启后并加上export EGO_DEBUG=true，可以看到每次grpc请求，配置名、地址、耗时、请求数据、响应数据
  3.     addr = "127.0.0.1:9002"
  4.     enableAccessInterceptor=true             #  是否开启记录请求数据，默认不开启
  5.     enableAccessInterceptorReq=true          # 是否开启记录请求参数，默认不开启
  6.     enableAccessInterceptorRes=true          # 是否开启记录响应参数，默认不开启

8.3 服务端详细信息

image