从源代码级别看懂MinIO对象存储网关的实现

发表时间：2022-03-26来源：网络

我在《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

仔细看如上源代码，看到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对网关架构的优秀设计。