Golang 微服务教程（四）

发表于 2018-05-27 | 阅读次数: | 字数统计: 2,953

原文链接：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 中处理密码的逻辑，将密码进行哈希处理，再进行存储：

// 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() 中用密码的哈希值做验证。重新创建用户，密码如下：

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

JWT

简介

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

1
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ
 

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

header

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

{
 "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

// 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 的验证过程，用户数据先写死在代码中。

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 的效果如下：

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

token 验证

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

// 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 进行验证：

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 使修改生效。重新构建镜像：

$ 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 手册

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

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

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

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

gRPC 实现

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

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 的认证中间件：

// 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 中就可设置：

// 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 插件进行消息发布。