1. 认证

gRPC默认内置了两种认证方式：

  • SSL/TLS认证方式

  • 基于Token的认证方式

同时，gRPC提供了接口用于扩展自定义认证方式

1.1. TLS认证示例

这里直接扩展hello项目，实现TLS认证机制

首先需要准备证书，在hello目录新建keys目录用于存放证书文件。

1.1.1. 证书制作

制作私钥 (.key)

  1. # Key considerations for algorithm "RSA" ≥ 2048-bit
  2. $ openssl genrsa -out server.key 2048
  4. # Key considerations for algorithm "ECDSA" ≥ secp384r1
  5. # List ECDSA the supported curves (openssl ecparam -list_curves)
  6. $ openssl ecparam -genkey -name secp384r1 -out server.key

自签名公钥(x509) (PEM-encodings .pem|.crt)

  1. $ openssl req -new -x509 -sha256 -key server.key -out server.pem -days 3650

自定义信息

  1. -----
  2. Country Name (2 letter code) [AU]:CN  //这个是中国的缩写
  3. State or Province Name (full name) [Some-State]:XxXx  //省份
  4. Locality Name (eg, city) []:XxXx  //城市
  5. Organization Name (eg, company) [Internet Widgits Pty Ltd]:XX Co. Ltd  //公司名称
  6. Organizational Unit Name (eg, section) []:Dev   //部门名称
  7. Common Name (e.g. server FQDN or YOUR name) []:server name   //服务名称 例如www.topgoer.com
  8. Email Address []:xxx@xxx.com  //邮箱地址

1.1.2. 目录结构

  1. |—— hello-tls/
  2.     |—— client/
  3.         |—— main.go   // 客户端
  4.     |—— server/
  5.         |—— main.go   // 服务端
  6. |—— keys/                 // 证书目录
  7.     |—— server.key
  8.     |—— server.pem
  9. |—— proto/
  10.     |—— hello/
  11.         |—— hello.proto   // proto描述文件
  12.         |—— hello.pb.go   // proto编译后文件

1.1.3. 示例代码

proto/helloworld.proto及proto/hello.pb.go文件不需要改动

修改服务端代码：server/main.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  7.     pb "github.com/jergoo/go-grpc-example/proto/hello"
  9.     "golang.org/x/net/context"
  10.     "google.golang.org/grpc"
  11.     "google.golang.org/grpc/credentials" // 引入grpc认证包
  12.     "google.golang.org/grpc/grpclog"
  13. )
  15. const (
  16.     // Address gRPC服务地址
  17.     Address = "127.0.0.1:50052"
  18. )
  20. // 定义helloService并实现约定的接口
  21. type helloService struct{}
  23. // HelloService Hello服务
  24. var HelloService = helloService{}
  26. // SayHello 实现Hello服务接口
  27. func (h helloService) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
  28.     resp := new(pb.HelloResponse)
  29.     resp.Message = fmt.Sprintf("Hello %s.", in.Name)
  31.     return resp, nil
  32. }
  34. func main() {
  35.     listen, err := net.Listen("tcp", Address)
  36.     if err != nil {
  37.         grpclog.Fatalf("Failed to listen: %v", err)
  38.     }
  40.     // TLS认证
  41.     creds, err := credentials.NewServerTLSFromFile("../../keys/server.pem", "../../keys/server.key")
  42.     if err != nil {
  43.         grpclog.Fatalf("Failed to generate credentials %v", err)
  44.     }
  46.     // 实例化grpc Server, 并开启TLS认证
  47.     s := grpc.NewServer(grpc.Creds(creds))
  49.     // 注册HelloService
  50.     pb.RegisterHelloServer(s, HelloService)
  52.     grpclog.Println("Listen on " + Address + " with TLS")
  54.     s.Serve(listen)
  55. }

运行：

  1. $ go run main.go
  3. Listen on 127.0.0.1:50052 with TLS

服务端在实例化grpc Server时，可配置多种选项，TLS认证是其中之一

客户端添加TLS认证：client/main.go

  1. package main
  3. import (
  4.     pb "github.com/jergoo/go-grpc-example/proto/hello" // 引入proto包
  6.     "golang.org/x/net/context"
  7.     "google.golang.org/grpc"
  8.     "google.golang.org/grpc/credentials" // 引入grpc认证包
  9.     "google.golang.org/grpc/grpclog"
  10. )
  12. const (
  13.     // Address gRPC服务地址
  14.     Address = "127.0.0.1:50052"
  15. )
  17. func main() {
  18.     // TLS连接  记得把server name改成你写的服务器地址
  19.     creds, err := credentials.NewClientTLSFromFile("../../keys/server.pem", "server name")
  20.     if err != nil {
  21.         grpclog.Fatalf("Failed to create TLS credentials %v", err)
  22.     }
  24.     conn, err := grpc.Dial(Address, grpc.WithTransportCredentials(creds))
  25.     if err != nil {
  26.         grpclog.Fatalln(err)
  27.     }
  28.     defer conn.Close()
  30.     // 初始化客户端
  31.     c := pb.NewHelloClient(conn)
  33.     // 调用方法
  34.     req := &pb.HelloRequest{Name: "gRPC"}
  35.     res, err := c.SayHello(context.Background(), req)
  36.     if err != nil {
  37.         grpclog.Fatalln(err)
  38.     }
  40.     grpclog.Println(res.Message)
  41. }

运行：

  1. $ go run main.go
  3. Hello gRPC

客户端添加TLS认证的方式和服务端类似，在创建连接Dial时，同样可以配置多种选项，后面的示例中会看到更多的选项。

1.2. Token认证示例

再进一步，继续扩展hello-tls项目，实现TLS + Token认证机制

1.2.1. 目录结构

  1. |—— hello_token/
  2.     |—— client/
  3.         |—— main.go   // 客户端
  4.     |—— server/
  5.         |—— main.go   // 服务端
  6. |—— keys/             // 证书目录
  7.     |—— server.key
  8.     |—— server.pem
  9. |—— proto/
  10.     |—— hello/
  11.         |—— hello.proto   // proto描述文件
  12.         |—— hello.pb.go   // proto编译后文件

1.2.2. 示例代码

先修改客户端实现：client/main.go

  1. package main
  3. import (
  4.     pb "github.com/jergoo/go-grpc-example/proto/hello" // 引入proto包
  6.     "golang.org/x/net/context"
  7.     "google.golang.org/grpc"
  8.     "google.golang.org/grpc/credentials" // 引入grpc认证包
  9.     "google.golang.org/grpc/grpclog"
  10. )
  12. const (
  13.     // Address gRPC服务地址
  14.     Address = "127.0.0.1:50052"
  16.     // OpenTLS 是否开启TLS认证
  17.     OpenTLS = true
  18. )
  20. // customCredential 自定义认证
  21. type customCredential struct{}
  23. // GetRequestMetadata 实现自定义认证接口
  24. func (c customCredential) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
  25.     return map[string]string{
  26.         "appid":  "101010",
  27.         "appkey": "i am key",
  28.     }, nil
  29. }
  31. // RequireTransportSecurity 自定义认证是否开启TLS
  32. func (c customCredential) RequireTransportSecurity() bool {
  33.     return OpenTLS
  34. }
  36. func main() {
  37.     var err error
  38.     var opts []grpc.DialOption
  40.     if OpenTLS {
  41.         // TLS连接
  42.         creds, err := credentials.NewClientTLSFromFile("../../keys/server.pem", "server name")
  43.         if err != nil {
  44.             grpclog.Fatalf("Failed to create TLS credentials %v", err)
  45.         }
  46.         opts = append(opts, grpc.WithTransportCredentials(creds))
  47.     } else {
  48.         opts = append(opts, grpc.WithInsecure())
  49.     }
  51.     // 使用自定义认证
  52.     opts = append(opts, grpc.WithPerRPCCredentials(new(customCredential)))
  54.     conn, err := grpc.Dial(Address, opts...)
  56.     if err != nil {
  57.         grpclog.Fatalln(err)
  58.     }
  60.     defer conn.Close()
  62.     // 初始化客户端
  63.     c := pb.NewHelloClient(conn)
  65.     // 调用方法
  66.     req := &pb.HelloRequest{Name: "gRPC"}
  67.     res, err := c.SayHello(context.Background(), req)
  68.     if err != nil {
  69.         grpclog.Fatalln(err)
  70.     }
  72.     grpclog.Println(res.Message)
  73. }

这里我们定义了一个customCredential结构，并实现了两个方法GetRequestMetadata和RequireTransportSecurity。这是gRPC提供的自定义认证方式，每次RPC调用都会传输认证信息。customCredential其实是实现了grpc/credential包内的PerRPCCredentials接口。每次调用，token信息会通过请求的metadata传输到服务端。下面具体看一下服务端如何获取metadata中的信息。

修改server/main.go中的SayHello方法：

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  7.     pb "github.com/jergoo/go-grpc-example/proto/hello"
  9.     "golang.org/x/net/context"
  10.     "google.golang.org/grpc"
  11.     "google.golang.org/grpc/codes"
  12.     "google.golang.org/grpc/credentials" // 引入grpc认证包
  13.     "google.golang.org/grpc/grpclog"
  14.     "google.golang.org/grpc/metadata" // 引入grpc meta包
  15. )
  17. const (
  18.     // Address gRPC服务地址
  19.     Address = "127.0.0.1:50052"
  20. )
  22. // 定义helloService并实现约定的接口
  23. type helloService struct{}
  25. // HelloService ...
  26. var HelloService = helloService{}
  28. // SayHello 实现Hello服务接口
  29. func (h helloService) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
  30.     // 解析metada中的信息并验证
  31.     md, ok := metadata.FromContext(ctx)
  32.     if !ok {
  33.         return nil, grpc.Errorf(codes.Unauthenticated, "无Token认证信息")
  34.     }
  36.     var (
  37.         appid  string
  38.         appkey string
  39.     )
  41.     if val, ok := md["appid"]; ok {
  42.         appid = val[0]
  43.     }
  45.     if val, ok := md["appkey"]; ok {
  46.         appkey = val[0]
  47.     }
  49.     if appid != "101010" || appkey != "i am key" {
  50.         return nil, grpc.Errorf(codes.Unauthenticated, "Token认证信息无效: appid=%s, appkey=%s", appid, appkey)
  51.     }
  53.     resp := new(pb.HelloResponse)
  54.     resp.Message = fmt.Sprintf("Hello %s.\nToken info: appid=%s,appkey=%s", in.Name, appid, appkey)
  56.     return resp, nil
  57. }
  59. func main() {
  60.     listen, err := net.Listen("tcp", Address)
  61.     if err != nil {
  62.         grpclog.Fatalf("failed to listen: %v", err)
  63.     }
  65.     // TLS认证
  66.     creds, err := credentials.NewServerTLSFromFile("../../keys/server.pem", "../../keys/server.key")
  67.     if err != nil {
  68.         grpclog.Fatalf("Failed to generate credentials %v", err)
  69.     }
  71.     // 实例化grpc Server, 并开启TLS认证
  72.     s := grpc.NewServer(grpc.Creds(creds))
  74.     // 注册HelloService
  75.     pb.RegisterHelloServer(s, HelloService)
  77.     grpclog.Println("Listen on " + Address + " with TLS + Token")
  79.     s.Serve(listen)
  80. }

服务端可以从context中获取每次请求的metadata，从中读取客户端发送的token信息并验证有效性。

运行：

  1. $ go run main.go
  3. Listen on 50052 with TLS + Token

运行客户端程序 client/main.go：

  1. $ go run main.go
  3. // 认证成功结果
  4. Hello gRPC
  5. Token info: appid=101010,appkey=i am key
  7. // 修改key验证认证失败结果：
  8. rpc error: code = 16 desc = Token认证信息无效: appID=101010, appKey=i am not key

google.golang.org/grpc/credentials/oauth包已实现了用于Google API的oauth和jwt验证的方法，使用方法可以参考官方文档。在实际应用中，我们可以根据自己的业务需求实现合适的验证方式。