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