朱德平的博客

记录学习和生活

0%

Golang 微服务教程（四）

发表于

原文链接：ewanvalentine.io，翻译已获作者 Ewan Valentine 授权。

本文完整代码：GitHub

上节引入 user-service 微服务并在 Postgres 中存储了用户数据，包括明文密码。本节将对密码进行安全的加密处理，并使用唯一的 token 来在各微服务之间识别用户。

在开始之前，需要手动运行数据库容器：

1
2
$ docker run -d -p 5432:5432 postgres
$ docker run -d -p 27017:27017 mongo

密码的哈希处理

安全原则

遵循 ”即使发生数据泄露，密码等敏感数据也不能被还原“ 的原则，永远都不要明文存储用户的密码。尽管一直这么说，但仍有项目是明文存储，比如以前的 CSDN

哈希处理

现在更新一下 user-service/handler.go 中处理密码的逻辑，将密码进行哈希处理，再进行存储：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// user-service/hander.go

func (h *handler) Create(ctx context.Context, req *pb.User, resp *pb.Response) error {
	// 哈希处理用户输入的密码
	hashedPwd, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
	if err != nil {
		return err
	}
	req.Password = string(hashedPwd)
	if err := h.repo.Create(req); err != nil {
		return nil
	}
	resp.User = req
	return nil
}

func (h *handler) Auth(ctx context.Context, req *pb.User, resp *pb.Token) error {
	u, err := h.repo.GetByEmailAndPassword(req)
	if err != nil {
		return err
	}

	// 进行密码验证
	if err := bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(req.Password)); err != nil {
		return err
	}
	t, err := h.tokenService.Encode(u)
	if err != nil {
		return err
	}
	resp.Token = t
	return nil
}

只在两个函数上有改动：在 Create() 中添加了密码哈希处理的逻辑，在 Auth() 中用密码的哈希值做验证。重新创建用户，密码如下：

image-20180527150635158

现在已经成功结合数据库完成用户的密码验证，在多个微服务之间进行用户验证有很多选择方案，本文使用 JWT

JWT

简介

JWT 是 JSON web tokens 的缩写，是一种类似 OAuth 的分布式安全协议。理解起来很简单，JWT 协议算法能为每个用户生成独特的哈希字符串，并以此来做校验和识别。此外，用户的 metadata（信息数据）也能作为加密字符串的一部分。比如：

1
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

可以看到 token 是被 “.” 分割为三部分的字符串：header.payload.signature

JWT 头部包含两部分：声明 token 类型、加密 token 的算法，其进行 base64 加密后作为 token 的第一部分：

1
2
3
4
{
  "typ": "JWT",
  "alg": "HS256"
}

用于告知客户端如何解码 token

payload

存放 metadata 的地方，比如用户数据、token 过期时间等。

signature

将 header、payload 及密钥共同加密后获取，用于客户端做数据校验，保证 token 在传输过程中没有被更改。当然，JWT 也有其不足之处，可参考：Stop using JWT for sessions

我建议你把创建用户信息的 IP 也放到 payload 中一起生成 token，这样能有效避免其他人盗用 token 后在其他设备伪造用户身份使用，此外也可使用 HTTPS 加密传输来避免中间人攻击。

JWT 的哈希算法大致可分为两类，对称加密和非对称加密。前者使用同一个私钥进行加解密，后者使用公钥加密私钥解密，非对称加密算法在微服务间做认证用得比较多。可参考：JWT Signing Algorithms Overview 、JSON Web Algorithms

使用

我们使用第三方开源库：dgrijalva/jwt-go，使用示例直接参考文档。

JWT 加密与解密

根据用户的信息生成 JWT token 字符串，修改 user-service/token_service.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// user-service/token_service.go
package main
import (...)

type Authable interface {
	Decode(tokenStr string) (*CustomClaims, error)
	Encode(user *pb.User) (string, error)
}

// 定义加盐哈希密码时所用的盐，要保证其生成和保存都足够安全，比如使用 md5 来生成
var privateKey = []byte("`xs#a_1-!")

// 自定义的 metadata，在加密后作为 JWT 的第二部分返回给客户端
type CustomClaims struct {
	User *pb.User
	// 使用标准的 payload
	jwt.StandardClaims
}

type TokenService struct {
	repo Repository
}

// 将 JWT 字符串解密为 CustomClaims 对象
func (srv *TokenService) Decode(tokenStr string) (*CustomClaims, error) {
	t, err := jwt.ParseWithClaims(tokenStr, &CustomClaims{}, func(token *jwt.Token) (interface{}, error) {
		return privateKey, nil
	})
	// 解密转换类型并返回
	if claims, ok := t.Claims.(*CustomClaims); ok && t.Valid {
		return claims, nil
	} else {
		return nil, err
	}
}

// 将 User 用户信息加密为 JWT 字符串
func (srv *TokenService) Encode(user *pb.User) (string, error) {
	// 三天后过期
	expireTime := time.Now().Add(time.Hour * 24 * 3).Unix()
	claims := CustomClaims{
		user,
		jwt.StandardClaims{
			Issuer:    "go.micro.srv.user", // 签发者
			ExpiresAt: expireTime,
		},
	}
	jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	return jwtToken.SignedString(privateKey)
}

代码中我们使用了 privateKey 作为 JWT 加密的盐，在生产环境中一定要使用更安全的值而且要妥善保管。上边代码的注释比较详细，大致内容是：

Decode() 接受一个 string 参数，将其解析为 jwt token 对象，并验证其信息是不是用户信息，是的话则取出 metadata 获取用户信息。

Encode() 接受一个 user metadata 数据，哈希处理为 JWT token 字符串后返回。

token 生成

现在我们有了验证 token 的 service，来更新一下 user-cli 的代码，在这里只是为了跑一遍 token_service 的验证过程，用户数据先写死在代码中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package main
import (...)

func main() {

	cmd.Init()
	// 创建 user-service 微服务的客户端
	client := pb.NewUserServiceClient("go.micro.srv.user", microclient.DefaultClient)

	// 暂时将用户信息写死在代码中
	name := "Ewan Valentine"
	email := "ewan.valentine89@gmail.com"
	password := "test123"
	company := "BBC"

	resp, err := client.Create(context.TODO(), &pb.User{
		Name:     name,
		Email:    email,
		Password: password,
		Company:  company,
	})
	if err != nil {
		log.Fatalf("call Create error: %v", err)
	}
	log.Println("created: ", resp.User.Id)

	allResp, err := client.GetAll(context.Background(), &pb.Request{})
	if err != nil {
		log.Fatalf("call GetAll error: %v", err)
	}
	for _, u := range allResp.Users {
		log.Printf("%v\n", u)
	}

	authResp, err := client.Auth(context.TODO(), &pb.User{
		Email:    email,
		Password: password,
	})
	if err != nil {
		log.Fatalf("auth failed: %v", err)
	}
	log.Println("token: ", authResp.Token)

	// 直接退出即可
	os.Exit(0)
}

对 user-service 和 user-cli 都重新进行 make build 后，生成 token 的效果如下：

4.1

把这个 token 保存下来，后边有用。

token 验证

现在为用户生成 token 的逻辑已经有了，可将其使用在 consignment-service 微服务中了，使 consignment-cli 与 consignment-service 之间通过 token 来识别用户。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// consignment-cli/cli.go
// ...

func main() {

	cmd.Init()
	// 创建微服务的客户端，简化了手动 Dial 连接服务端的步骤
	client := pb.NewShippingServiceClient("go.micro.srv.consignment", microclient.DefaultClient)

	// 在命令行中指定新的货物信息 json 件
	if len(os.Args) < 3 {
		log.Fatalln("Not enough arguments, expecing file and token.")
	}
	infoFile := os.Args[1]
	token := os.Args[2]

	// 解析货物信息
	consignment, err := parseFile(infoFile)
	if err != nil {
		log.Fatalf("parse info file error: %v", err)
	}

	// 创建带有用户 token 的 context
	// consignment-service 服务端将从中取出 token，解密取出用户身份
	tokenContext := metadata.NewContext(context.Background(), map[string]string{
		"token": token,
	})

	// 调用 RPC
	// 将货物存储到指定用户的仓库里
	resp, err := client.CreateConsignment(tokenContext, consignment)
	if err != nil {
		log.Fatalf("create consignment error: %v", err)
	}
	log.Printf("created: %t", resp.Created)

	// 列出目前所有托运的货物
	resp, err = client.GetConsignments(tokenContext, &pb.GetRequest{})
	if err != nil {
		log.Fatalf("failed to list consignments: %v", err)
	}
	for i, c := range resp.Consignments {
		log.Printf("consignment_%d: %v\n", i, c)
	}
}

修改 consignment-service 监听请求，从中取出 token 并调用 user-service 进行验证：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package main
import (...)

const (
	DEFAULT_HOST = "127.0.0.1:27017"
)


func main() {

	// ...
	srv := micro.NewService(
		// 必须和 consignment.proto 中的 package 一致
		micro.Name("go.micro.srv.consignment"),
		micro.Version("latest"),
		micro.WrapHandler(AuthWrapper),
	)
	// ...
}

// AuthWrapper 是一个高阶函数，入参是 ”下一步“ 函数，出参是认证函数
// 在返回的函数内部处理完认证逻辑后，再手动调用 fn() 进行下一步处理
// token 是从 consignment-ci 上下文中取出的，再调用 user-service 将其做验证
// 认证通过则 fn() 继续执行，否则报错
func AuthWrapper(fn server.HandlerFunc) server.HandlerFunc {
	return func(ctx context.Context, req server.Request, resp interface{}) error {
		meta, ok := metadata.FromContext(ctx)
		if !ok {
			return errors.New("no auth meta-data found in request")
		}

		// Note this is now uppercase (not entirely sure why this is...)
		token := meta["Token"]

		// Auth here
		authClient := userPb.NewUserServiceClient("go.micro.srv.user", client.DefaultClient)
		authResp, err := authClient.ValidateToken(context.Background(), &userPb.Token{
			Token: token,
		})
		log.Println("Auth Resp:", authResp)
		if err != nil {
			return err
		}
		err = fn(ctx, req, resp)
		return err
	}
}

分别在 consignment-service 和 consignment-cli 下均重新 make build 使修改生效。重新构建镜像：

1
2
3
4
$ docker run --net="host" \
	-e MICRO_REGISTRY=mdns \
	consignment-cli consignment.json \
	<TOKEN_HERE>

这里使用了 --net="host" 来指定容器运行在宿主主机的本地网络，比如 127.0.0.1 或 localhost，而非 docker 自己的内部网络。如此便不再需要再进行端口映射，直接使用 -p 8080 代替 -p 8080:8080 即可。更多参考：Docker 手册

现在运行上述命令，将看到创建了新的货物托运，效果如下：

4.2

如果删掉 token 中的几个字符，将会收到 illegal base64 data at input byte 41 类似的认证错误。

到目前为止，我们在 user-service 中实现了 JWT 的加解密，并在 consignment-cli 与 consignment-service 之间作为中间层认证用户使用。整个运行流程如下：

image-20180528105549866

所以在运行之前，要把 user-service 和 vessel-service 同样运行起来。在 MongoDB 中也可看到货轮与货物数据存储成功：

image-20180528105927785

gRPC 实现

如果你还在用 gRPC 而不是 go-mirco，那你的认证中间件应该如下实现，搞复杂了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
func main() {
    ... 
    myServer := grpc.NewServer(
        grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(AuthInterceptor),
    )
    ... 
}

func AuthInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {

    // Set up a connection to the server.
    conn, err := grpc.Dial(authAddress, grpc.WithInsecure())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := pb.NewAuthClient(conn)
    r, err := c.ValidateToken(ctx, &pb.ValidateToken{Token: token})

    if err != nil {
	    log.Fatalf("could not authenticate: %v", err)
    }

    return handler(ctx, req)
}

调用切换

此外，我们不需要在本地把所有微服务都运行起来，微服务之间应该相互独立，能在隔离的环境中进行测试。比如在当前的项目中，如果只要测试 consignment-service 自己的 RPC，那就没有必要调用 user-service 做认证，我觉得在代码能切换是否调用其他服务的做法是比较好的。

更新 consignment-service 的认证中间件：

1
2
3
4
5
6
7
8
9
10
11
// shippy-user-service/main.go
...
func AuthWrapper(fn server.HandlerFunc) server.HandlerFunc {
	return func(ctx context.Context, req server.Request, resp interface{}) error {
		// consignment-service 独立测试时不进行认证
		if os.Getenv("DISABLE_AUTH") == "true" {
			return fn(ctx, req, resp)
		}
		...
	}
}

在我们的 Makefile 中就可设置：

1
2
3
4
5
6
7
8
9
// shippy-user-service/Makefile
...
run:
	docker run -d --net="host" \
		-p 50052 \
		-e MICRO_SERVER_ADDRESS=:50052 \
		-e MICRO_REGISTRY=mdns \
		-e DISABLE_AUTH=true \
		consignment-service

使用环境变量来决定是否调用其他服务，从而使你的微服务能隔离的进行测试，我认为这么做最为简单。

总结

本节对密码进行哈希处理后存储，并引入 JWT 进行了用户数据的加解密，使用其生成的 token 在微服务之间做用户身份的验证。从第一节到第四节，我们把 consignment-service、vessel-service、user-service 三个微服务作为一个完整系统实现了，完成了货物管理系统的基本功能，后续章节进行完善。下节将使用 go-micro 的 NATS 插件进行消息发布。