我在 《MinIO对象存储的网关架构设计》一文中介绍了MinIO的网关架构设计,它的整体架构如下图所示:

MinIO对象存储的网关架构设计

从架构图可以很清楚的看到MinIO网关的分层结构,那么这一篇我就从MinIO网关的具体代码分析它是如何实现的。

网关启动

MinIO内部已经实现了GCS、S3、NAS等几个网关,支持的网关列表如下:

1
2
3
4
5
  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网关,可以使用如下命令:

1
minio gateway nas PATH

以上命令中的PATH是一个NAS挂载点路径,当然你也可以使用本地路径。假如我的NAS挂载点路径为/tmp/nas/ ,那么我通过如下命令就可以启动一个NAS网关。

1
 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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这两个命令的提示。

1
2
3
4
5
6
7
8
9
➜  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

1
2
3
4
5
6
7
8
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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
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

1
2
3
4
5
6
// 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子命令也注册好了,那么如果在终端中输入如下命令,程序会怎么运行呢?

1
 minio gateway nas /tmp/nas/

这就需要分析刚刚注册的nas子命令了,我再把注册nas子命令这段代码粘贴出来便于分析。 minio/cmd/gateway/nas/gateway-nas.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
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

1
2
3
4
5
6
7
8
// 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

1
2
3
4
// StartGateway - handler for 'minio gateway <name>'.
func StartGateway(ctx *cli.Context, gw Gateway) {
  //为了分析过程,我先省略这个函数的逻辑
}

StartGateway函数有两个参数,一个ctx是命令行的信息,比如你在终端输入的命令、参数以及Flag等,第二个Gateway就是你要启动哪个网关,这是一个接口: minio/cmd/gateway-interface.go

1
2
3
4
5
6
7
8
9
// 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
// 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// StartGateway - handler for 'minio gateway <name>'.
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对网关架构的优秀设计。

本文为原创文章,转载注明出处,欢迎扫码关注公众号flysnow_org或者网站 https://www.flysnow.org/ ,第一时间看后续精彩文章。觉得好的话,请顺手点个赞吧。

扫码关注