go micro jwt 网关鉴权

本文介绍go micro中的api访问权限控制，这里仅仅介绍内部服务间的互相调用鉴权(jwt)，不是针对用户系统的细致rbac模式。

目标：

1. 内部服务间调用应在header上带上jwt token，否则返回错误提示信息

2. 有2种方式

   1. 在每个服务上各自鉴权
   2. 在网关上鉴权，各服务只需注册一个wrapper检查header中jwt信息鉴权。这样做有个前提，所有服务需放到同一个网络内，走统一的服务注册中心，这里主要介绍这种方式。

3. 先创建一个myauth的服务，对外提供2个接口

   1. GetJwt() 返回jwt token，可以用用户名密码或其他方式验证，根据具体业务灵活决定即可，这里示例采用服务名和密钥方
   2. InspectJwt() 验证jwt token是否有效
4. 自定义一个网关，通过插件方式wrapper指定一个鉴权函数，除了第3步中的2个接口外，其他都需要header中有jwt的token
5. 其他业务只需要注册一个wrapper检查header中jwt信息鉴权

6. 业务调用步骤

   1. 调用GetJwt()获取jwt token
   2. 调用其他接口时，在header加入jwt token

首先创建一个api项目

micro new --type=api myauth

GetJwt()、InspectJwt()相关代码

// Myauth.Call is called by the API as /myauth/call with post body {"name": "foo"}
func (e *Myauth) GetJwt(ctx context.Context, req *api.Request, rsp *api.Response) error {
    log.Info("Received Myauth.GetJwt request")

    getmap := req.GetGet()
    log.Info("Received getmap %+v\n", getmap)
    postmap := req.GetPost()
    log.Info("Received postmap %+v\n", postmap)

    // 内部服务调用底层service，通过jwt验证
    // 定义服务名和key，通过这2个参数获取jwt access token
    // serviceName := "order"
    // serviceKey := "123456"
    // 对比serviceName\serviceKey 也可以是用户名密码等，这里的示例为了方便硬编码在代码中
    // 实际项目中应该从数据库或文件读取
    serviceName := extractValue(postmap["service"])
    serviceKey := extractValue(postmap["key"])
    log.Info("serviceName %+v\n", serviceName, serviceKey)
    if serviceName != "order" || serviceKey != "123456" {
        Rsp(rsp, 403, "服务名称或key错误", nil)
        return nil
    }

    //生成jwt
    // expireTime := time.Now().Add(time.Hour * 24 * 3).Unix()
    expireTime := time.Now().Add(time.Second * 60 * 60).Unix()
    token := &token.Token{}
    token.Init([]byte("key123456")) //实际项目需从数据库或文件读取
    jwtstring, err := token.Encode("auth jwt", serviceName, expireTime)
    if err != nil {
        Rsp(rsp, 403, "jwt 生成错误", nil)
        return nil
    }

    msg := make(map[string]interface{})
    msg["jwt"] = jwtstring
    Rsp(rsp, 200, "ok", msg)
    return nil
}

// 验证jwt
func (e *Myauth) InspectJwt(ctx context.Context, req *api.Request, rsp *api.Response) error {
    log.Info("Received Myauth.InspectJwt request")
    // getmap := req.GetGet()
    // log.Info("Received getmap %+v\n", getmap)
    postmap := req.GetPost()
    // log.Info("Received postmap %+v\n", postmap)

    jwtString := extractValue(postmap["jwt"])
    log.Info("jwtString %+v\n", jwtString)
    if len(jwtString) == 0 {
        Rsp(rsp, 403, "jwt参数错误", nil)
        return nil
    }

    //解析jwt
    token := &token.Token{}
    token.Init([]byte("key123456"))
    info, err := token.Decode(jwtString)
    if err != nil {
        Rsp(rsp, 403, "jwt 解析错误", nil) //过期或jwt有问题
        return nil
    }

    t := make(map[string]interface{})
    t["data"] = info
    Rsp(rsp, 200, "ok", t)
    return nil
}

// 返回func
func Rsp(rsp *api.Response, code int, err string, msg map[string]interface{}) error {
    if msg == nil {
        msg = make(map[string]interface{})
    }
    r := &rspMsg{
        Code: code,
        Err:  err,
        Msg:  msg,
    }

    b, err2 := json.Marshal(r)
    if err2 != nil {
        log.Info("json.Marshal err", err2)
    }
    rsp.StatusCode = int32(code)
    rsp.Body = string(b)
    return nil
}

自定义micro网关代码

package main

import (
    "net/http"

    "myauth/lib/token"

    log "github.com/micro/go-micro/v2/logger"
    "github.com/micro/micro/v2/cmd"
    "github.com/micro/micro/v2/plugin"
)

func main() {
    tk := &token.Token{}
    tk.Init([]byte("key123456"))
    plugin.Register(plugin.NewPlugin(
        plugin.WithName("auth"),
        plugin.WithHandler(
            JWTAuthWrapper(tk),
        ),
    ))

    cmd.Init()
}

func JWTAuthWrapper(t *token.Token) plugin.Handler {
    return func(h http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            log.Info("===========", r.URL.Path)
            //不需要登录的url地址 strings.HasPrefix(r.URL.Path, "/hello") ||
            if r.URL.Path == "/myauth/Myauth/GetJwt" ||
                r.URL.Path == "/myauth/Myauth/InspectJwt" {
                h.ServeHTTP(w, r)
                return
            }

            // tokenstr := r.Header.Get("Authorization")//现在不可以用Authorization，需要用Bearer
            tokenstr := r.Header.Get("Bearer")
            log.Info("tokenstr", tokenstr)
            userFromToken, e := t.Decode(tokenstr)
            log.Info("userFromToken", userFromToken)
            if e != nil {
                _, _ = w.Write([]byte("unauthorized"))
                return
            }

            // r.Header.Set("X-Example-Username", userFromToken.UserName)
            h.ServeHTTP(w, r)
            return
        })
    }
}

示例代码见https://github.com/wulinlw/mi...

参考

go-micro网关鉴权之jwt

https://www.jianshu.com/p/426...

【go语言微服务实践】#5-go-micro实现JWT认证

https://juejin.im/post/5e6123...

https://github.com/Allenxuxu/...

go micro 分析系列文章
go micro server 启动分析
go micro client
go micro broker
go micro cmd
go micro config
go micro store
go micro registry
go micro router
go micro runtime
go micro transport
go micro web
go micro registry 插件consul
go micro plugin
go micro jwt 网关鉴权
go micro 链路追踪
go micro 熔断与限流
go micro wrapper 中间件
go micro metrics 接入Prometheus、Grafana

有疑问加站长微信联系（非本文作者）