从源代码级别看懂MinIO对象存储网关的实现
我在 《MinIO对象存储的网关架构设计》一文中介绍了MinIO的网关架构设计，它的整体架构如下图所示：
从架构图可以很清楚的看到MinIO网关的分层结构，那么这一篇我就从MinIO网关的具体代码分析它是如何实现的。
网关启动
MinIO内部已经实现了GCS、S3、NAS等几个网关，支持的网关列表如下：
nas Network-attached storage (NAS)
azure Microsoft Azure Blob Storage
s3 Amazon Simple Storage Service (S3)
hdfs Hadoop Distributed File System (HDFS)
gcs Google Cloud Storage
假如要启动一个NAS网关，可以使用如下命令：
minio gateway nas PATH
以上命令中的PATH是一个NAS挂载点路径，当然你也可以使用本地路径。假如我的NAS挂载点路径为/tmp/nas/ ，那么我通过如下命令就可以启动一个NAS网关。
minio gateway nas /tmp/nas/
小提示：因为MinIO需要用户名和密码，所以在启动网关之前一定要设置，通过如下命令即可：
export MINIO_ACCESS_KEY=accesskey
export MINIO_SECRET_KEY=secretkey其实就是设置MINIO_ACCESS_KEY和MINIO_SECRET_KEY环境变量，可以改成自己想要的用户名和密码。
启动后你可以像使用MinIO Server一样使用网关。
网关启动代码分析
MinIO的命令行启动只有2个命令，一个是server、一个是gateway，分别用于启动服务和网关，而整个MinIO的启动是从minio/main.go文件(假设存放MinIO源代码的根目录是minio)开始的。
minio/main.go
package main
import (
"os"
minio "github.com/minio/minio/cmd"
// Import gateway
_ "github.com/minio/minio/cmd/gateway"
)
func main() {
minio.Main(os.Args)
}
整个源代码文件比较简单，主要是把命令行输入的参数交给minio.Main这个函数处理。这里需要注意的是github.com/minio/minio/cmd/gateway包的导入，它会调用github.com/minio/minio/cmd/gateway包的init函数，初始化支持的网关，后面会详细讲到。
继续跟踪minio.Main函数,它的代码实现在minio/cmd/main.go文件中，核心代码如下：
minio/cmd/main.go
func newApp(name string) *cli.App {
// Collection of minio commands currently supported are.
commands := []cli.Command{}
//省略无关代码
// registerCommand registers a cli command.
registerCommand := func(command cli.Command) {
commands = append(commands, command)
}
//省略无关代码
// Register all commands.
registerCommand(serverCmd)
registerCommand(gatewayCmd)//注册的网关命令。
app := cli.NewApp()
app.Name = name
//省略无关代码
app.Commands = commands
app.CustomAppHelpTemplate = minioHelpTemplate
//省略无关代码
return app
}
// Main main for minio server.
func Main(args []string) {
// Set the minio app name.
appName := filepath.Base(args[0])
// Run the app - exit on error.
if err := newApp(appName).Run(args); err != nil {
os.Exit(1)
}
}
以上源代码我省略了很多和网关无关的，便于分析查看。从以上源代码可以清晰的看到MinIO是通过registerCommand函数注册了server和gateway这两个命令:registerCommand(serverCmd)和registerCommand(gatewayCmd)。这样当你在终端输入minio回车的时候就可以看到server和gateway这两个命令的提示。
➜ minio
NAME:
minio - High Performance Object Storage
USAGE:
minio [FLAGS] COMMAND [ARGS...]
COMMANDS:
server start object storage server
gateway start object storage gateway
到了这里，相信你已经清楚网关整体的启动流程了，那么如何启动一个具体的网关呢，比如NAS，这就要具体分析刚刚源代码中注册的gatewayCmd命令了。
gatewayCmd命令分析
gatewayCmd是一个定义在cmd包中的全局变量，它的源代码在minio/cmd/gateway-main.go文件中:
minio/cmd/gateway-main.go
var (
gatewayCmd = cli.Command{
Name: "gateway",
Usage: "start object storage gateway",
Flags: append(ServerFlags, GlobalFlags...),
HideHelpCommand: true,
}
)
gatewayCmd是一个比较顶层的命令，它下面还有很多子命令，比如nas、gcs等，一个子命令代表一个网关，那么这些子命令是如何注册作为gatewayCmd的子命令的呢？我以比较简单的NAS网关为例分析nas子命令的注册逻辑。
NAS网关子命令分析
还记得「网关启动代码分析」小节中留的github.com/minio/minio/cmd/gateway包导入使用init函数初始化的提示吧？现在就详细分析下，看MinIO是如何通过包的init函数实现nas子命令注册的。
minio/cmd/gateway/gateway.go
package gateway
import (
// Import all gateways please keep the order
// NAS
_ "github.com/minio/minio/cmd/gateway/nas"
// Azure
_ "github.com/minio/minio/cmd/gateway/azure"
// S3
_ "github.com/minio/minio/cmd/gateway/s3"
// HDFS
_ "github.com/minio/minio/cmd/gateway/hdfs"
// GCS (use only if you must, GCS already supports S3 API)
_ "github.com/minio/minio/cmd/gateway/gcs"
// gateway functionality is frozen, no new gateways are being implemented
// or considered for upstream inclusion at this point in time. if needed
// please keep a fork of the project.
)
github.com/minio/minio/cmd/gateway包的源代码实现如上所示，没有啥东西，还是一堆包的导入，这次的每个包就代表一个网关的具体实现，比如NAS网关的实现在github.com/minio/minio/cmd/gateway/nas包中，它的命令注册源代码如下：
minio/cmd/gateway/nas/gateway-nas.go
func init() {
const nasGatewayTemplate = `NAME:`//省略很多字符串
minio.RegisterGatewayCommand(cli.Command{
Name: minio.NASBackendGateway,
Usage: "Network-attached storage (NAS)",
Action: nasGatewayMain,
CustomHelpTemplate: nasGatewayTemplate,
HideHelpCommand: true,
})
}
看到关键了吧？就是这个RegisterGatewayCommand函数，通过它把nas这个子命令注册给gateway这个父命令。再看下RegisterGatewayCommand函数的具体实现就可以证明了：
minio/cmd/gateway-main.go
// RegisterGatewayCommand registers a new command for gateway.
func RegisterGatewayCommand(cmd cli.Command) error {
cmd.Flags = append(append(cmd.Flags, ServerFlags...), GlobalFlags...)
gatewayCmd.Subcommands = append(gatewayCmd.Subcommands, cmd)
return nil
}
看以上RegisterGatewayCommand函数 的源代码，把传入的命令作为gatewayCmd的子命令完成注册，而gatewayCmd就是我刚刚讲过的cmd包中的全局变量。
NAS网关启动分析
好了，nas子命令也注册好了，那么如果在终端中输入如下命令，程序会怎么运行呢？
minio gateway nas /tmp/nas/
这就需要分析刚刚注册的nas子命令了,我再把注册nas子命令这段代码粘贴出来便于分析。
minio/cmd/gateway/nas/gateway-nas.go
func init() {
const nasGatewayTemplate = `NAME:`//省略很多字符串
minio.RegisterGatewayCommand(cli.Command{
Name: minio.NASBackendGateway,
Usage: "Network-attached storage (NAS)",
Action: nasGatewayMain,
CustomHelpTemplate: nasGatewayTemplate,
HideHelpCommand: true,
})
}
仔细看如上源代码，看到cli.Command这个结构体的Action字段了吗？他就是一个命令在执行时运行的函数，也就是命令的处理逻辑都在这个函数中，对应nas子命令就是nasGatewayMain这个函数，现在只需要分析nasGatewayMain函数的源代码实现即可分析NAS网关的启动逻辑。
minio/cmd/gateway/nas/gateway-nas.go
// Handler for 'minio gateway nas' command line.
func nasGatewayMain(ctx *cli.Context) {
// Validate gateway arguments.
if !ctx.Args().Present() || ctx.Args().First() == "help" {
cli.ShowCommandHelpAndExit(ctx, minio.NASBackendGateway, 1)
}
minio.StartGateway(ctx, &NAS{ctx.Args().First()})
}
以上源代码的核心在于StartGateway函数，它可以根据参数启动相应的网关。
minio/cmd/gateway-main.go
// StartGateway - handler for 'minio gateway '.
func StartGateway(ctx *cli.Context, gw Gateway) {
//为了分析过程，我先省略这个函数的逻辑
}
StartGateway函数有两个参数，一个ctx是命令行的信息，比如你在终端输入的命令、参数以及Flag等，第二个Gateway就是你要启动哪个网关，这是一个接口：
minio/cmd/gateway-interface.go
// Gateway represents a gateway backend.
type Gateway interface {
// Name returns the unique name of the gateway.
Name() string
// NewGatewayLayer returns a new ObjectLayer.
NewGatewayLayer(creds auth.Credentials) (ObjectLayer, error)
// Returns true if gateway is ready for production.
Production() bool
}
这个Gateway接口里关键的方法就是NewGatewayLayer，通过它可以获得一个ObjectLayer来操作不同网关的文件或者对象数据（参考我画的网关架构图ObjectLayer那一层）。
NAS网关实现Gateway接口
Gateway是一个通用的网关操作接口，所以每个网关都有自己的实现，NAS网关也不例外，它的实现就是NAS这个结构体。
minio/cmd/gateway/nas/gateway-nas.go
// NAS implements Gateway.
type NAS struct {
path string
}
// Name implements Gateway interface.
func (g *NAS) Name() string {
return minio.NASBackendGateway
}
// NewGatewayLayer returns nas gatewaylayer.
func (g *NAS) NewGatewayLayer(creds auth.Credentials) (minio.ObjectLayer, error) {
var err error
newObject, err := minio.NewFSObjectLayer(g.path)
if err != nil {
return nil, err
}
return &nasObjects{newObject}, nil
}
// Production - nas gateway is production ready.
func (g *NAS) Production() bool {
return true
}
从以上NAS结构体实现Gateway接口的源代码可以看到，NAS本质上对于对象的操作使用的是MinIO自带的单点模式下的文件对象操作结构体FSObjects，这是很合理的，因为NAS操作的就是一个文件夹路径，这是MinIO的单点模式是一样的。
小提示：MinIO server启动有两种模式，一个是单点模式，一种是纠删码模式，其中单点模式就是只传了一个endpoint给minio，使用的是文件系统的操作方式，更详细的可以研究FSObjects的源代码实现。
最终网关启动
好了，NAS网关的具体实现也有了，生成的ObjectLayer也有了，那么就剩下最终网关的启动了，又回到了刚刚的nasGatewayMain函数，这部分函数的代码对所有网关都是一样的，因为它是针对Gateway接口的编程。
minio/cmd/gateway-main.go
// StartGateway - handler for 'minio gateway '.
func StartGateway(ctx *cli.Context, gw Gateway) {
//省略无关很多紧要的代码
// Handle common command args.
handleCommonCmdArgs(ctx)
// Handle gateway specific env
gatewayHandleEnvVars()
// Set when gateway is enabled
globalIsGateway = true
// Initialize router. `SkipClean(true)` stops gorilla/mux from
// normalizing URL path minio/minio#3256
// avoid URL path encoding minio/minio#8950
router := mux.NewRouter().SkipClean(true).UseEncodedPath()
// operations such as profiling, server info etc.
registerAdminRouter(router, enableConfigOps, enableIAMOps)
// Add API router.
registerAPIRouter(router)
// Use all the middlewares
router.Use(registerMiddlewares)
newObject, err := gw.NewGatewayLayer(globalActiveCred)
newObject = NewGatewayLayerWithLocker(newObject)
// Once endpoints are finalized, initialize the new object api in safe mode.
globalObjLayerMutex.Lock()
globalObjectAPI = newObject //关键代码，使用网关接口生成的ObjectLayer
globalObjLayerMutex.Unlock()
handleSignals()
}
以上是nasGatewayMain函数的源代码，我已经省略了很多无关紧要的代码，便于分析网关的启动。nasGatewayMain函数整体的代码逻辑和启动一个MinIO server很像，只不过全局的处理对象存储的globalObjectAPI换成了网关返回的ObjectLayer，这样通过API接口对对象的操作才会转换为底层真实网关的操作。
该函数其他的代码主要注册路由，比如前台的S3兼容API以及后台的Admin管理API等，并且通过globalIsGateway = true把这次启动标记为是作为网关启动的，便于MinIO内部其他代码逻辑的处理。
小结
这篇文章我主要以比较容易的NAS网关为例分析整个网关的启动，其他网关大同小异，主要是对于接口Gateway的具体代码实现不一样，其他都是一样的，所以当我们为MinIO新增一个网关时，只需要实现Gateway接口，然后通过init函数注册一个该网关的子命令给gatewayCmd即可，非常简单，这些都是得益于MinIO对网关架构的优秀设计。
更多精彩推荐
MinIO对象存储的网关架构设计
对象存储和 CDN 实现分析揭秘
聊聊越来越火的对象存储
Golang Gin 实战（十四）| 文件托管、代理百度网站、自实现API网关
Golang Gin 实战（十三）| 中间件详解看这一篇就够了
Golang Gin 实战（十二）| ProtoBuf 使用和源码分析原理实现
本文为原创文章，转载注明出处,欢迎扫码关注公众号
flysnow_org或者网站 https://www.flysnow.org/ ，第一时间看后续精彩文章。觉得好的话，请顺手点个赞吧。
