目前，go语言已然成为各大厂的标配开发语言，各大厂都在使用go语言构建一些重要的支撑系统。当今最流行的容器Docker及容器编排和管理工具k8s都是使用go来构建的，并且是开源的，这给go开发者提供了很好的学习资料。但是，这些项目对初学者来说过于复杂，很难通读其源码。国内大厂也开源了一些go开发的项目，比如baidu的应用负载均衡产品bfe、bilibili开源的go微服务框架kratos、didi最近开源的gatekeeper都是开发者值得学习的好项目。
接下来，通过didi开源的gatekeeper为例，来深入学习go语言。为什么选择gatekeeper为例来学习go语言呢？
- 微服务已经成为各个公司构建系统首先倡导的架构风格，对于微服务架构来说一个很重要的组件就是网关，gatekeeper就是一个这样的项目
- go语言以其简单和高性能，部署快捷简单著称，很多公司都是用go开发前端接口服务，getekeeper使用了最著名的一个http web开发框架gin
- gatekeeper既包含了接口服务也包括了管理后台，使用了mysql也使用了redis
鉴于以上原因，笔者选中了它来作为需要使用go语言开发生产级项目的剖析原型。
在此也非常感谢didi的gatekeeper团队开源出来这么优秀的产品。
项目介绍
GateKeeper 是一个使用 Go (golang) 编写的不依赖分布式数据库的 API 网关, 使用它可以高效进行服务代理 以及 在线化服务配置并且你无需重启服务器。具备以下特性：
- http、websocket、tcp服务代理
- 服务探测
- 加权负载轮询
- URL地址重写
- 服务限流：支持独立IP限流
- 高拓展性：支持自定义 请求前验证request方法、请求后更改response方法、tcp中间件、http中间件 等。
- 高可用性：单个服务异常不影响其他服务。
- 最少依赖：无需任何额外组件即可运行，mysql、redis 只做管理和统计使用可随时关闭。
通过官方的介绍，我们可以看到getekeeper具备了网关的几乎全部功能。其中最重要的特性就是支持http的代理，还支持websocket和tcp，同时也支持插件。gatekeeper处理http代理时，直接是使用了go内置的代理组件ReverseProxy。
运行
getakeeper官方给了很详细的运行说明，我们看一下其部署的步骤：
- 下载github上的源代码到本地
git clone git@github.com:didichuxing/gatekeeper.git
- 设置运行环境，gatekeeper是通过go mod来管理构建项目的，需要按照如下步骤开启go mod模式
export GO111MODULE=on
export GOPROXY=https://goproxy.cn
3.getekeeper为我们提供了管理后台，用于配置管理的api和租户，查看调用统计，需要我们设置mysql和redis
创建数据库
mysql -h localhost -u root -p -e "CREATE DATABASE gatekeeper DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;"
mysql -h localhost -u root -p gatekeeper < install/db.sql --default-character-set=utf8
创建数据库导入表后，我们看到创建了如下表：
redis为了方便将通过docker启动
docker run -p 6379:6379 -d redis:latest redis-server
6fce8bf5cc2faa0ca462939161960dcdf137a07f1fd587d93da51dc2b5f3a8cb
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
6fce8bf5cc2f redis:latest "docker-entrypoint.s…" 4 seconds ago Up 3 seconds 0.0.0.0:6379->6379/tcp brave_shtern
4.调整配置文件，修改 ./conf/dev/mysql.toml 和 ./conf/dev/redis.toml 为自己的环境配置
# this is mysql config 将数据库的用户名和密码 数据库ip和端口修改成实际的环境配置即可
[list]
[list.default]
driver_name = "mysql"
data_source_name = "root:123456@tcp(127.0.0.1:3306)/gatekeeper?charset=utf8&parseTime=true&loc=Asia%2FChongqing"
max_open_conn = 20
max_idle_conn = 10
max_conn_life_time = 100
# this is redis config file 将redis地址和端口修改为实际环境配置
[list]
[list.default]
proxy_list = ["127.0.0.1:6379"]
conn_timeout = 50 #ms
read_timeout = 100
write_timeout = 100
5.运行
go run main.go
2019/12/12 21:12:16 ------------------------------------------------------------------------
2019/12/12 21:12:16 [INFO] config=./conf/dev/
2019/12/12 21:12:16 [INFO] start loading resources.
2019/12/12 21:12:16 [INFO] success loading resources.
2019/12/12 21:12:16 ------------------------------------------------------------------------
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
- using env: export GIN_MODE=release
- using code: gin.SetMode(gin.ReleaseMode)
....省略路由映射日志
2019/12/12 21:12:16 [INFO] HttpServer :8081 listening
2019/12/12 21:12:16 [INFO] TCPServer :8900 listening
访问：http://127.0.0.1:8081/admin/login，打开页面登陆：admin / 123456
6.配置一个http api
访问http://127.0.0.1:8081/gatekeeper/pvst/stat/ping
至此，api网关已经正常运行起来了。
组件分析
在上文中我们也提到getekeeper的http部分是基于优秀的框架gin构建的，由gin来处理全部的http请求。
//HTTPServerRun 服务启动
func HTTPServerRun() {
gin.SetMode(lib.ConfBase.DebugMode)
//初始化engine
r := InitRouter()
HTTPSrvHandler = &http.Server{
Addr: lib.GetStringConf("base.http.addr"),
Handler: r,
ReadTimeout: time.Duration(lib.GetIntConf("base.http.read_timeout")) * time.Second,
WriteTimeout: time.Duration(lib.GetIntConf("base.http.write_timeout")) * time.Second,
MaxHeaderBytes: 1 << uint(lib.GetIntConf("base.http.max_header_bytes")),
}
go func() {
defer func() {
if err := recover(); err != nil {
public.SysLogger.Error("HttpServerRun_recover:%v", err)
}
}()
log.Printf(" [INFO] HttpServer %s listening\n",lib.GetStringConf("base.http.addr"))
if err := HTTPSrvHandler.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatalf(" [ERROR] HttpServer %s err:%v\n", lib.GetStringConf("base.http.addr"), err)
}
}()
}
通过r := InitRouter()，对gin Engine进行初始化，以接管来自外部的全部http请求，接下来我们看看 InitRouter()做了哪些事。
//InitRouter 声明http路由
func InitRouter() *gin.Engine {
router := gin.New()
router.Use(middleware.Recovery())
//admin
admin := router.Group("/admin")
admin.Use(middleware.RequestTraceLog())
{
controller.AdminRegister(admin)
}
//assets
router.Static("/assets", "./tmpl/green/assets")
//gateway
gateway := controller.Gateway{}
router.GET("/ping", gateway.Ping)
//cluster
csr:=router.Group("/")
csr.Use(middleware.ClusterAuth())
csr.GET("/reload", gateway.Reload)
//注册网关路由
gw:=router.Group(lib.GetStringConf("base.http.route_prefix"))
gw.Use(
middleware.RequestTraceLog(),
middleware.MatchRule(),
middleware.AccessControl(),
middleware.HTTPLimit(),
//todo 拓展中间件
middleware.LoadBalance())
{
gw.GET("/*action", gateway.Index)
gw.POST("/*action", gateway.Index)
gw.DELETE("/*action", gateway.Index)
gw.OPTIONS("/*action", gateway.Index)
}
return router
}
通过gw:=router.Group(lib.GetStringConf("base.http.route_prefix"))注册了请求URI以/gatekeeper开头的全部请求会进入gw路由组的处理逻辑，即经过注册的一系列的插件转发到实际的realserver进行请求的处理和响应。
在请求代理处理部分，getekeeper直接使用了go内置的代理组件ReverseProxy来处理请求的转发代理：proxy.ServeHTTP(c.Writer, c.Request)。
//LoadBalance 负载均衡中间件
func LoadBalance() gin.HandlerFunc {
return func(c *gin.Context) {
gws,ok:=c.MustGet(MiddlewareServiceKey).(*service.GateWayService)
if !ok{
public.ResponseError(c, http.StatusBadRequest, errors.New("gateway_service not valid"))
return
}
proxy, err := gws.LoadBalance()
if err != nil {
public.ResponseError(c, http.StatusProxyAuthRequired, err)
return
}
requestBody,ok:=c.MustGet(MiddlewareRequestBodyKey).([]byte)
if !ok{
public.ResponseError(c, http.StatusBadRequest, errors.New("request_body not valid"))
return
}
c.Request.Body = ioutil.NopCloser(bytes.NewBuffer(requestBody))
proxy.ServeHTTP(c.Writer, c.Request)
c.Abort()
}
}
go语言net包为我们提供了丰富的关于http的处理工具，其中http代理就是其提供的一个强大的正向代理和反向代理的工具，在这里我们就对其进行展开分析了。
本节完。
