gRPC（七）进阶：自定义身份验证

前言

个人网站：linzyblog.netlify.app/
示例代码已经上传到github：点击跳转
gRPC官方文档：点击跳转
在前面的章节中，我们介绍了两种可全局认证的方法：

基于 CA 的 TLS 证书认证
拦截器 interceptor

而在实际需求中，常常会对某些模块的 RPC 方法做特殊认证或校验，而gRPC也专门提供了这类特殊认证的接口。

一、概述

gRPC为每个gRPC方法调用提供了Token认证支持，可以基于用户传入的Token判断用户是否登陆、以及权限等，实现Token认证的前提是，需要定义一个结构体，并实现credentials.PerRPCCredentials接口。

1、credentials.PerRPCCredentials 接口

类型定义：

type PerRPCCredentials interface {
    // 返回需要认证的必要信息
    GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error)
    // 是否使用安全链接(TLS)
    RequireTransportSecurity() bool
}

在 gRPC 中默认定义了 PerRPCCredentials，是 gRPC 默认提供用于自定义认证的接口，它的作用是将所需的安全认证信息添加到每个 RPC 方法的上下文中。其包含 2 个方法：

GetRequestMetadata：获取当前请求认证所需的元数据（metadata），以 map 的形式返回本次调用的授权信息，ctx 是用来控制超时的
RequireTransportSecurity：是否需要基于 TLS 认证进行安全传输，如果返回 true 则说明该 Credentials 需要在一个有 TLS 认证的安全连接上传输，如果当前连接并没有使用 TLS 则会报错：

transport: cannot send secure credentials on an insecure connection

2、实现流程

在发出请求之前，gRPC 会将 Credentials（认证凭证）存放在 metadata（元数据）中进行传递。
在真正发起调用之前，gRPC 会通过 GetRequestMetadata函数，将用户定义的 Credentials（认证凭证）提取出来，并添加到 metadata（元数据）中，随着请求一起传递到服务端。
然后服务端从 metadata 中取出 Credentials 进行有效性校验。

二、实现自定义身份验证

具体分为以下两步：

1）客户端请求时带上 Credentials；
2）服务端取出 Credentials，并验证有效性，一般配合拦截器使用（这里我们使用两种方法，拦截器以及RPC方法）。

1、目录结构

go-grpc-example
├─client
│  ├─token_client
│  │   └──client.go
├─pkg
│  ├─token
│  │   └──token.go
├─proto
│  ├─token
│  │   └──token.proto
└─server
    ├─token_server
    │  └──server.go

2、编写IDL

在 proto/token 文件夹下的 token.proto 文件中，写入如下内容：

syntax = "proto3";

option go_package = "./proto/token;token";
package tokenservice;

// 验证参数
message TokenValidateParam {
  string token = 1;
  int32 uid = 2;
}

// 请求参数
message Request {
  string name = 1;
}

// 请求返回
message Response {
  int32 uid = 1;
  string name = 2;
}

// 服务
service TokenService {
  rpc Token(Request) returns (Response);
}

在Makefile文件中写入：

token:
    protoc --go_out=. --go-grpc_out=. ./proto/token/*.proto

用make token指令生成Go代码：

➜ make token
protoc --go_out=. --go-grpc_out=. ./proto/token/*.proto

在这里插入图片描述

3、编写基础模板和空定义

我们先把基础的模板和空定义写出来在进行完善

1）server.go

const Address = "127.0.0.1:8888"

type TokenService struct {
    token.UnimplementedTokenServiceServer
}

func main() {
    listen, err := net.Listen("tcp", Address)
    if err != nil {
        fmt.Println("start error:", err)
        return
    }

    var opts []grpc.ServerOption

    server := grpc.NewServer(opts...)
    token.RegisterTokenServiceServer(server, &TokenService{})

    fmt.Println("服务启动成功....")
    server.Serve(listen)
}

2）client.go

const Address = "127.0.0.1:8888"

func main() {
    var opts []grpc.DialOption

    conn, err := grpc.Dial(Address, opts...)
    if err != nil {
        fmt.Println("grpc.Dial error:", err)
        return
    }
    defer conn.Close()
    // 实例化客户端
    client := token.NewTokenServiceClient(conn)

    // 调用具体方法
    token, err := client.Token(context.Background(), &token.Request{Name: "linzy"})
    if err != nil {
        fmt.Println("client.Token error:", err)
        return
    }
    fmt.Println("return result:", token)
}

4、实现PerRPCCredentials 接口

我们在 pkg/token 目录里的 token.go 文件内实现PerRPCCredentials 接口的方法：

const IsTLS = false

// 定义一个认证的结构体，这里是因为我在porto写好了一个数据结构
// 也可以自定义认证字段
type TokenAuth struct {
    token.TokenValidateParam
}

func (x *TokenAuth) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
    // 将 Credentials（认证凭证）存放在 metadata（元数据）中进行传递。
    return map[string]string{
        "uid":   strconv.FormatInt(int64(x.GetUid()), 10),
        "token": x.GetToken(),
    }, nil
}

func (x *TokenAuth) RequireTransportSecurity() bool {
    return IsTLS
}

5、实现认证功能

我们已经实现了客户端请求时带上 Credentials 凭证，后面就需要实现服务端的功能，在获取授权信息并校验有效性。

1）实现拦截器认证

在 pkg/Interceptor 目录下的 Interceptor.go 文件内写入以下内容：

// 用一元拦截器实现认证
func ServerInterceptorCheckToken() grpc.UnaryServerInterceptor {
    return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo,
        handler grpc.UnaryHandler) (resp interface{}, err error) {
        // 验证token
        _, err = CheckToken(ctx)
        if err != nil {
            fmt.Println("Interceptor 拦截器内token认证失败\n")
            return nil, err
        }
        fmt.Println("Interceptor 拦截器内token认证成功\n")
        return handler(ctx, req)
    }
}

// 验证
func CheckToken(ctx context.Context) (*token.Response, error) {
    // 取出元数据
    md, b := metadata.FromIncomingContext(ctx)
    if !b {
        return nil, status.Error(codes.InvalidArgument, "token信息不存在")
    }

    var token, uid string
    // 取出token
    tokenInfo, ok := md["token"]
    if !ok {
        return nil, status.Error(codes.InvalidArgument, "token不存在")
    }

    token = tokenInfo[0]

    // 取出uid
    uidTmp, ok := md["uid"]
    if !ok {
        return nil, status.Error(codes.InvalidArgument, "uid不存在")
    }
    uid = uidTmp[0]

    //验证
    sum := md5.Sum([]byte(uid))
    md5Str := fmt.Sprintf("%x", sum)
    if md5Str != token {
        fmt.Println("md5Str:", md5Str)
        fmt.Println("uid:", uid)
        fmt.Println("token:", token)
        return nil, status.Error(codes.InvalidArgument, "token验证失败")
    }
    return nil, nil
}

gPRC 传输的时候把授权信息存放在 metada 的，所以需要先获取 metadata。通过metadata.FromIncomingContext可以从 ctx 中取出本次调用的 metadata，然后再从 md 中取出授权信息并校验即可。

在server.go文件内添加拦截器：

opts = append(opts, grpc.UnaryInterceptor(Interceptor.ServerInterceptorCheckToken()))

2）实现RPC方法认证

实现了校验有效性我们就需要在 server.go 服务端实现Token RPC的方法进行授权认证：

type TokenService struct {
    token.UnimplementedTokenServiceServer
    tokenAuth.TokenAuth
}

func (u TokenService) Token(ctx context.Context, r *token.Request) (*token.Response, error) {
    // 验证token
    _, err := Interceptor.CheckToken(ctx)
    if err != nil {
        fmt.Println("Token RPC方法内token认证失败\n")
        return nil, err
    }
    fmt.Printf("%v Token RPC方法内token认证成功\n", r.GetName())
    return &token.Response{Name: r.GetName()}, nil
}

同样的在client.go 文件内输入token信息，并调用grpc.WithPerRPCCredentials:

// token信息
auth := tokenAuth.TokenAuth{
    token.TokenValidateParam{
        Token: "81dc9bdb52d04dc20036dbd8313ed055",
        Uid:   1234,
    },
}
opts = append(opts, grpc.WithPerRPCCredentials(&auth))

6、启动 & 请求

输入一个正确的token：

# 启动服务端
$ go run server.go
API server listening at: 127.0.0.1:52505
服务启动成功....
Interceptor 拦截器内token认证成功

linzy Token RPC方法内token认证成功

# 启动客户端
$ go run client.go 
API server listening at: 127.0.0.1:52545
return result: name:"linzy"

修改token信息为：

// token信息
    auth := tokenAuth.TokenAuth{
        token.TokenValidateParam{
            Token: "81dc9bdb52d0ed0585",
            Uid:   1234,
        },
    }

测试一下：

# 启动服务端
$ go run server.go
API server listening at: 127.0.0.1:52505
服务启动成功....
md5Str: 81dc9bdb52d04dc20036dbd8313ed055
uid: 1234
token: 81dc9bdb52d0ed0585
Interceptor 拦截器内token认证失败

# 启动客户端
$ go run client.go 
API server listening at: 127.0.0.1:52857
client.Token error: rpc error: code = InvalidArgument desc = token验证失败

7、实现RequireTransportSecurity()方法

身份认证功能已经完成，但是我们gRPC通信还是明文传输，对于如此重要的信息肯定要建立安全连接，所以要实现 RequireTransportSecurity 方法。

方法实现很简单，我们只需要建立安全连接的时候，返回一个true就行，使用我们之前的证书进行TLS连接即可。

具体可以看我的上一篇《通过TLS建立安全连接》

server.go添加以下内容：

if tokenAuth.IsTLS {
    // TLS认证
    // 根据服务端输入的证书文件和密钥构造 TLS 凭证
    c, err := credentials.NewServerTLSFromFile("./conf/server_side_TLS/server.pem", "./conf/server_side_TLS/server.key")
    if err != nil {
        log.Fatalf("credentials.NewServerTLSFromFile err: %v", err)
    }
    opts = append(opts, grpc.Creds(c))
}

client.go添加以下内容：

if tokenAuth.IsTLS {
    //打开tls 走tls认证
    // 根据客户端输入的证书文件和密钥构造 TLS 凭证。
    // 第二个参数 serverNameOverride 为服务名称。
    c, err := credentials.NewClientTLSFromFile("./conf/server_side_TLS/server.pem", "go-grpc-example")
    if err != nil {
        log.Fatalf("credentials.NewClientTLSFromFile err: %v", err)
    }
    opts = append(opts, grpc.WithTransportCredentials(c))
} else {
    opts = append(opts, grpc.WithInsecure())
}

我们只需要修改token.go文件内的IsTLS变量就可以实现是否使用安全链接(TLS)。

启动 & 请求之后我们抓个包看一下是否已经建立安全链接了了。

在这里插入图片描述

三、小结

1）实现credentials.PerRPCCredentials接口就可以把数据当做 gRPC 中的 Credential 在添加到 metadata 中，跟着请求一起传递到服务端；
2）服务端从 ctx 中解析 metadata，然后从 metadata 中获取授权信息并进行验证；
3）可以借助 Interceptor 实现全局身份验证。

微服务 go rpc

本作品采用《CC 协议》，转载必须注明作者和本文链接

lin钟一

课程读者 49 声望

毕竟几人真得鹿，不知终日梦为鱼。

1 人点赞

讨论数量: 0

(=￣ω￣=)··· 暂无内容！

讨论应以学习和精进为目的。请勿发布不友善或者负能量的内容，与人为善，比聪明更重要！

帮助

gRPC（七）进阶：自定义身份验证

前言

一、概述

1、credentials.PerRPCCredentials 接口

2、实现流程

二、实现自定义身份验证

1、目录结构

2、编写IDL

3、编写基础模板和空定义

1）server.go

2）client.go

4、实现PerRPCCredentials 接口

5、实现认证功能

1）实现拦截器认证

2）实现RPC方法认证

6、启动 & 请求

7、实现RequireTransportSecurity()方法

三、小结

社区赞助商

关于 LearnKu

资源推荐

服务提供商

其他信息

gRPC（七）进阶：自定义身份验证

前言

一、概述

1、credentials.PerRPCCredentials 接口

2、实现流程

二、实现自定义身份验证

1、目录结构

2、编写IDL

3、编写基础模板和空定义

1）server.go

2）client.go

4、实现PerRPCCredentials 接口

5、实现认证功能

1）实现拦截器认证

2）实现RPC方法认证

6、启动 & 请求

7、实现RequireTransportSecurity()方法

三、小结

社区赞助商

关于 LearnKu

资源推荐

服务提供商

其他信息

请登录