This is the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

模块：MINIO

Pigsty 内置了 MinIO 支持，一个本地 S3 对象存储开源替代，可用于 PGSQL 模块冷备份存储。

1: 使用方法
2: 集群配置
3: 参数列表
4: 预置剧本
5: 管理预案
6: 监控告警
7: 指标列表
8: 常见问题

Min.IO 是一个兼容 AWS S3 的多云对象存储软件，使用 AGPLv3 协议开源。

MinIO 可以用来存储文档、图片、视频和备份。Pigsty 原生支持部署各种 MinIO 集群，易于扩展、安全且开箱即用。

1 - 使用方法

快速上手，如何上手使用 MinIO ？如何可靠地接入 MinIO？如何使用 mc / rclone 客户端工具？

当您配置并执行剧本部署 MinIO 集群后，可以参考这里的说明开始使用与接入 MinIO 集群。

部署集群

在 Pigsty 中部署一个开箱即用的单机单盘 MinIO 实例非常简单：首先在配置清单中定义一套 MinIO 集群：

minio: { hosts: { 10.10.10.10: { minio_seq: 1 } }, vars: { minio_cluster: minio } }

然后，针对定义的分组（这里为 minio ）执行 Pigsty 提供的 minio.yml 剧本即可：

./minio.yml -l minio

请注意在 install.yml 中，事先定义好的 MinIO 集群将自动创建，无需手动再次执行 minio.yml 剧本。

如果您计划部署一个生产等级的大规模多节点 MinIO 集群，我们强烈建议您通读 Pigsty MinIO 配置文档与 MinIO 官方文档后再进行。

接入集群

请注意：MinIO 服务必须通过域名与 HTTPS 访问，所以请务必确保： MinIO 服务域名（默认为 sss.pigsty）正确指向 MinIO 服务器节点

您可以在 node_etc_hosts 中添加静态解析记录，或者手工修改 /etc/hosts 文件
您可以在内网的 DNS 服务器上添加一条记录，如果已经有了现成的 DNS 服务
如果您启用了 Infra 节点上的 DNS 服务器，可以在 dns_records 中添加记录

对于生产环境访问 MinIO，通常我们建议使用第一种方式：静态 DNS 解析记录，避免 MinIO 对于 DNS 的额外依赖。

您应当将 MinIO 服务域名指向 MinIO 服务器节点的 IP 地址与服务端口，或者负载均衡器的 IP 地址与服务端口。 Pigsty 默认使用的 MinIO 服务域名是 sss.pigsty，在单机部署时默认指向本机，在 9000 端口提供服务。

在一些例子中，MinIO 集群上还部署了 HAProxy 实例对外暴露服务，在这种情况下，9002 是模板中使用的服务端口。

添加别名

要使用 mcli 客户端访问 minio 服务器集群，首先要配置服务器的别名（alias）：

mcli alias ls  # 列出 minio 别名（默认使用sss）
mcli alias set sss https://sss.pigsty:9000 minioadmin minioadmin              # root 用户
mcli alias set sss https://sss.pigsty:9002 minioadmin minioadmin              # root 用户，使用负载均衡器 9002 端口

mcli alias set pgbackrest https://sss.pigsty:9000 pgbackrest S3User.Backup    # 使用备份用户

在管理节点的管理用户上，已经默认配置了名为 sss 的 MinIO 别名，可以直接使用。

MinIO 客户端工具 mcli 的完整功能参考，请查阅文档： MinIO 客户端。

用户管理

使用 mcli 可以管理 MinIO 中的业务用户，例如这里我们可以使用命令行创建两个业务用户：

mcli admin user list sss     # 列出 sss 上的所有用户
set +o history # 在历史记录中隐藏密码并创建 minio 用户
mcli admin user add sss dba S3User.DBA
mcli admin user add sss pgbackrest S3User.Backup
set -o history

存储桶管理

您可以对MinIO中的存储桶进行增删改查：

mcli ls sss/                         # 列出别名 'sss' 的所有桶
mcli mb --ignore-existing sss/hello  # 创建名为 'hello' 的桶
mcli rb --force sss/hello            # 强制删除 'hello' 桶

对象管理

您也可以对存储桶内的对象进行增删改查，详情请参考官方文档：对象管理

mcli cp /www/pigsty/* sss/infra/     # 将本地软件源的内容上传到 MinIO 的 infra 桶中 
mcli cp sss/infra/plugins.tgz /tmp/  # 从 minio 下载文件到本地
mcli ls sss/infra                    # 列出 infra 桶中的所有文件
mcli rm sss/infra/plugins.tgz        # 删除 infra 桶中的特定文件  
mcli cat sss/infra/repo_complete     # 查看 infra 桶中的文件内容

使用rclone

Pigsty 仓库中提供了 rclone，一个方便的多云对象存储客户端，您可以使用它来访问 MinIO 服务。

yum install rclone; # el compatible
dnf install rclone; # debian/ubuntu

mkdir -p ~/.config/rclone/;
tee ~/.config/rclone/rclone.conf > /dev/null <<EOF
[sss]
type = s3
access_key_id = minioadmin
secret_access_key = minioadmin
endpoint = sss.pigsty:9000
EOF

rclone ls sss:/

配置备份仓库

在 Pigsty 中，MinIO 默认的用例是作为 pgBackRest 的备份存储仓库。当您修改 pgbackrest_method 为 minio 时，PGSQL 模块会自动将备份存储仓库切换到 MinIO 上。

pgbackrest_method: local          # pgbackrest repo method: local,minio,[user-defined...]
pgbackrest_repo:                  # pgbackrest repo: https://pgbackrest.org/configuration.html#section-repository
  local:                          # default pgbackrest repo with local posix fs
    path: /pg/backup              # local backup directory, `/pg/backup` by default
    retention_full_type: count    # retention full backups by count
    retention_full: 2             # keep 2, at most 3 full backup when using local fs repo
  minio:                          # optional minio repo for pgbackrest
    type: s3                      # minio is s3-compatible, so s3 is used
    s3_endpoint: sss.pigsty       # minio endpoint domain name, `sss.pigsty` by default
    s3_region: us-east-1          # minio region, us-east-1 by default, useless for minio
    s3_bucket: pgsql              # minio bucket name, `pgsql` by default
    s3_key: pgbackrest            # minio user access key for pgbackrest
    s3_key_secret: S3User.Backup  # minio user secret key for pgbackrest
    s3_uri_style: path            # use path style uri for minio rather than host style
    path: /pgbackrest             # minio backup path, default is `/pgbackrest`
    storage_port: 9000            # minio port, 9000 by default
    storage_ca_file: /pg/cert/ca.crt  # minio ca file path, `/pg/cert/ca.crt` by default
    bundle: y                     # bundle small files into a single file
    cipher_type: aes-256-cbc      # enable AES encryption for remote backup repo
    cipher_pass: pgBackRest       # AES encryption password, default is 'pgBackRest'
    retention_full_type: time     # retention full backup by time on minio repo
    retention_full: 14            # keep full backup for last 14 days

请注意，如果您使用了多节点部署的 MinIO 集群，并通过负载均衡器对外提供服务，您需要相应地修改这里的 s3_endpoint 与 storage_port 参数。

2 - 集群配置

根据需求场景选择合适的 MinIO 部署类型，并对外提供可靠的接入。

在部署 MinIO 之前，你需要在配置清单中定义一个 MinIO 集群，MinIO 有三种经典部署模式：

单机单盘：SNSD：单机单盘模式，可以使用任意目录作为数据盘，仅作为开发、测试、演示使用。
单机多盘：SNMD：折中模式，在单台服务器上使用多块磁盘 (>=2)，仅当资源极为有限时使用。
多机多盘：MNMD：多机多盘模式，标准生产环境部署，具有最好的可靠性，但需要多台服务器。

通常我们建议使用 SNSD 与 MNMD 这两种模式，前者用于开发测试，后者用于生产部署，SNMD 仅在资源有限（只有一台服务器）的情况下使用。

此外，还可以使用多池部署来实现现有 MinIO 集群的扩容，或者直接部署多套集群。

使用多节点 MinIO 集群时，访问任意节点都可以获取服务，因此最佳实践是在 MinIO 集群前使用负载均衡与高可用服务接入机制。

核心参数

MinIO 部署中，MINIO_VOLUMES 是一个核心配置参数，用于指定 MinIO 的部署模式。 Pigsty 提供了一些便捷的参数用于自动根据配置清单，生成 MINIO_VOLUMES 与其他配置参数的值，但您也可以直接指定它们。

单机单盘： MINIO_VOLUMES 指向本机上的一个普通目录，默认由 minio_data 指定，默认位置为 /data/minio。
单机多盘： MINIO_VOLUMES 指向本机上的序列挂载点，同样是由 minio_data 指定，单需要用特殊语法显式覆盖指定，例如 /data{1...4}。
多机多盘： MINIO_VOLUMES 指向多台服务器上的序列挂载点，由以下两部分自动组合生成：
- 首先要使用 minio_data 指定集群每个成员的磁盘挂载点序列 /data{1...4}，
- 还需要使用 minio_node 指定节点的命名模式 ${minio_cluster}-${minio_seq}.pigsty
多池部署：您需要显式指定 minio_volumes 参数来分配每个存储池的节点，从而实现集群扩容

单机单盘

SNSD 模式，部署参考教程：MinIO 单机单盘部署

在 Pigsty 中，定义一个单例 MinIO 实例非常简单：

# 1 节点 1 驱动器（默认）
minio: { hosts: { 10.10.10.10: { minio_seq: 1 } }, vars: { minio_cluster: minio } }

单机模式下，唯一必要的参数是 minio_seq 和 minio_cluster，它们会唯一标识每一个 MinIO 实例。

单节点单磁盘模式仅用于开发目的，因此您可以使用一个普通的目录作为数据目录，该目录由参数 minio_data 默认为 /data/minio。

在您使用 MinIO 时，强烈建议您通过静态解析的域名记录访问 MinIO，例如，假设 minio_domain 设置的内部服务域名使用了默认的 sss.pigsty，那么您可以在所有节点上添加一个静态解析，便于其他节点访问此服务。

node_etc_hosts: ["10.10.10.10 sss.pigsty"] # domain name to access minio from all nodes (required)

SNSD 仅适用于开发测试

单节点模式应当仅用于开发，测试，演示目的，因为它无法容忍硬件故障，也无法带来多磁盘的性能改善。

单机多盘

SNMD 模式，部署参考教程：MinIO 单机多盘部署

要在单节点上使用多块磁盘，所需的操作与单机单盘基本一致，但用户需要以 {{ prefix }}{x...y} 的特定格式指定 minio_data，该格式定义了序列磁盘挂载点。

minio:
  hosts: { 10.10.10.10: { minio_seq: 1 } }
  vars:
    minio_cluster: minio         # minio 集群名称，默认为 minio
    minio_data: '/data{1...4}'   # minio 数据目录，使用 {x...y} 记号来指定多块磁盘

请使用真实磁盘挂载点

请注意，SNMD 模式不支持使用普通目录作为数据目录，如果您使用 SNMD 模式拉起 MinIO，但数据目录不是有效的磁盘挂载点，MinIO 将拒绝启动。

例如 Vagrant MinIO 沙箱定义了一个带有4块磁盘的单节点 MinIO 集群：/data1、/data2、/data3 和 /data4。启动 MinIO 之前，你需要正确地挂载它们（请务必使用 xfs 格式化磁盘）：

mkfs.xfs /dev/vdb; mkdir /data1; mount -t xfs /dev/sdb /data1;   # 挂载第1块盘……
mkfs.xfs /dev/vdc; mkdir /data2; mount -t xfs /dev/sdb /data2;   # 挂载第2块盘……
mkfs.xfs /dev/vdd; mkdir /data3; mount -t xfs /dev/sdb /data3;   # 挂载第3块盘……
mkfs.xfs /dev/vde; mkdir /data4; mount -t xfs /dev/sdb /data4;   # 挂载第4块盘……

挂载磁盘属于服务器置备的部分，超出 Pigsty 的处理范畴。挂载的磁盘应该同时写入 /etc/fstab 以便在服务器重启后可以自动挂载。

/dev/vdb /data1 xfs defaults,noatime,nodiratime 0 0
/dev/vdc /data2 xfs defaults,noatime,nodiratime 0 0
/dev/vdd /data3 xfs defaults,noatime,nodiratime 0 0
/dev/vde /data4 xfs defaults,noatime,nodiratime 0 0

SNMD 模式可以利用单机上的多块磁盘，提供更高的性能和容量，并且容忍部分磁盘故障。但单节点模式无法容忍整个节点的故障，而且您无法在运行时添加新的节点，因此如果没有特殊原因，我们不建议在生产环境中使用 SNMD 模式。

多机多盘

MNMD 模式，部署参考教程：MinIO 多机多盘部署

除了需要单机多盘模式中的 minio_data 指定磁盘驱动器，使用MinIO 多节点部署需要使用一个额外的 minio_node 参数。

例如，以下配置定义了一个 MinIO 集群，其中有四个节点，每个节点有四块磁盘：

minio:
  hosts:
    10.10.10.10: { minio_seq: 1 }  # 实际节点名： minio-1.pigsty
    10.10.10.11: { minio_seq: 2 }  # 实际节点名： minio-2.pigsty
    10.10.10.12: { minio_seq: 3 }  # 实际节点名： minio-3.pigsty
    10.10.10.13: { minio_seq: 4 }  # 实际节点名： minio-4.pigsty
  vars:
    minio_cluster: minio
    minio_data: '/data{1...4}'                         # 每个节点使用四块磁盘
    minio_node: '${minio_cluster}-${minio_seq}.pigsty' # minio 节点名称规则

minio_node 参数指定了 MinIO 节点名称的模式，用于生成每个节点的唯一名称。默认情况下，节点名称是 ${minio_cluster}-${minio_seq}.pigsty，其中 ${minio_cluster} 是集群名称，${minio_seq} 是节点序号。 MinIO 实例的名称非常重要，会自动写入到 MinIO 节点的 /etc/hosts 中进行静态解析。MinIO 依靠这些名称来识别并访问集群中的其他节点。

在这种情况下，MINIO_VOLUMES 将被设置为 https://minio-{1...4}.pigsty/data{1...4} ，以标识四个节点上的四块盘。您可以直接在 MinIO 集群中指定 minio_volumes 参数，来覆盖自动根据规则生成的值。但通常不需要这样做，因为 Pigsty 会自动根据配置清单生成它。

多池部署

MinIO 的架构允许通过添加新的存储池来扩容。在 Pigsty 中，您可以通过显式指定 minio_volumes 参数来分配每个存储池的节点，从而实现集群扩容。

例如，假设您已经创建了多机多盘样例中定义的 MinIO 集群，现在您想要添加一个新的存储池，同样由四个节点构成。

那么，你需要直接覆盖指定 minio_volumes 参数：

minio:
  hosts:
    10.10.10.10: { minio_seq: 1 }
    10.10.10.11: { minio_seq: 2 }
    10.10.10.12: { minio_seq: 3 }
    10.10.10.13: { minio_seq: 4 }
    
    10.10.10.14: { minio_seq: 5 }
    10.10.10.15: { minio_seq: 6 }
    10.10.10.16: { minio_seq: 7 }
    10.10.10.17: { minio_seq: 8 }
  vars:
    minio_cluster: minio
    minio_data: "/data{1...4}"
    minio_node: '${minio_cluster}-${minio_seq}.pigsty' # minio 节点名称规则
    minio_volumes: 'https://minio-{1...4}.pigsty:9000/data{1...4} https://minio-{5...8}.pigsty:9000/data{1...4}'

在这里，空格分割的两个参数分别代表两个存储池，每个存储池有四个节点，每个节点有四块磁盘。更多关于存储池的信息请参考管理预案：MinIO集群扩容

多套集群

您可以将新的 MinIO 节点部署为一个全新的 MinIO 集群，使用不同的集群名称定义一个新的分组即可，以下配置声明了两个独立的 MinIO 集群：

minio1:
  hosts:
    10.10.10.10: { minio_seq: 1 }
    10.10.10.11: { minio_seq: 2 }
    10.10.10.12: { minio_seq: 3 }
    10.10.10.13: { minio_seq: 4 }
  vars:
    minio_cluster: minio2
    minio_data: "/data{1...4}"

minio2:
  hosts:    
    10.10.10.14: { minio_seq: 5 }
    10.10.10.15: { minio_seq: 6 }
    10.10.10.16: { minio_seq: 7 }
    10.10.10.17: { minio_seq: 8 }
  vars:
    minio_cluster: minio2
    minio_data: "/data{1...4}"
    minio_alias: sss2
    minio_domain: sss2.pigsty
    minio_endpoint: sss2.pigsty:9000

请注意，Pigsty 默认一套部署中只有一个 MinIO 集群，如果您需要部署多个 MinIO 集群，那么一些带有默认值的参数需要显式设置，无法省略，否则会出现命名冲突，如上所示。

服务接入

MinIO 默认使用 9000 端口提供服务。多节点 MinIO 集群可以通过访问 任意一个节点 来访问其服务。

服务接入属于 NODE 模块的功能范畴，这里仅做基本介绍。

多节点 MinIO 集群的高可用接入可以使用 L2 VIP 或 HAProxy 实现。例如，您可以选择使用 keepalived 在 MinIO 集群上绑定一个 L2 VIP，或者使用由 NODE 模块的提供的 haproxy 组件，通过负载均衡器对外暴露 MinIO 服务。

# minio cluster with 4 nodes and 4 drivers per node
minio:
  hosts:
    10.10.10.10: { minio_seq: 1 , nodename: minio-1 }
    10.10.10.11: { minio_seq: 2 , nodename: minio-2 }
    10.10.10.12: { minio_seq: 3 , nodename: minio-3 }
    10.10.10.13: { minio_seq: 4 , nodename: minio-4 }
  vars:
    minio_cluster: minio
    minio_data: '/data{1...4}'
    minio_buckets: [ { name: pgsql }, { name: infra }, { name: redis } ]
    minio_users:
      - { access_key: dba , secret_key: S3User.DBA, policy: consoleAdmin }
      - { access_key: pgbackrest , secret_key: S3User.SomeNewPassWord , policy: readwrite }

    # bind a node l2 vip (10.10.10.9) to minio cluster (optional)
    node_cluster: minio
    vip_enabled: true
    vip_vrid: 128
    vip_address: 10.10.10.9
    vip_interface: eth1

    # expose minio service with haproxy on all nodes
    haproxy_services:
      - name: minio                    # [REQUIRED] service name, unique
        port: 9002                     # [REQUIRED] service port, unique
        balance: leastconn             # [OPTIONAL] load balancer algorithm
        options:                       # [OPTIONAL] minio health check
          - option httpchk
          - option http-keep-alive
          - http-check send meth OPTIONS uri /minio/health/live
          - http-check expect status 200
        servers:
          - { name: minio-1 ,ip: 10.10.10.10 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
          - { name: minio-2 ,ip: 10.10.10.11 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
          - { name: minio-3 ,ip: 10.10.10.12 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
          - { name: minio-4 ,ip: 10.10.10.13 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }

例如，上面的配置块为 MinIO 集群的所有节点上启用了 HAProxy ，在 9002 端口上暴露 MinIO 服务，同时为集群绑定了一个二层 VIP。当使用时，用户应当将 sss.pigsty 域名解析指向 VIP 地址 10.10.10.9，并使用 9002 端口访问 MinIO 服务。这样当任意一个节点发生故障时，VIP 会自动切换到另一个节点，保证服务的高可用性。

在这种情况下，您通常还需要在全局修改域名解析的目的地，以及 minio_endpoint 参数，修改写入管理节点 MinIO Alias 对应的端点地址：

minio_endpoint: https://sss.pigsty:9002   # 覆盖默认值： https://sss.pigsty:9000
node_etc_hosts: ["10.10.10.9 sss.pigsty"] # 其他节点将使用 sss.pigsty 域名来访问 MinIO

专用负载均衡

Pigsty 允许用户使用专用的负载均衡服务器组，而不是集群本身来运行 VIP 与 HAProxy。例如 prod 模板中就使用了这种方式。

proxy:
  hosts:
    10.10.10.18 : { nodename: proxy1 ,node_cluster: proxy ,vip_interface: eth1 ,vip_role: master }
    10.10.10.19 : { nodename: proxy2 ,node_cluster: proxy ,vip_interface: eth1 ,vip_role: backup }
  vars:
    vip_enabled: true
    vip_address: 10.10.10.20
    vip_vrid: 20
    
    haproxy_services:      # expose minio service : sss.pigsty:9000
      - name: minio        # [REQUIRED] service name, unique
        port: 9000         # [REQUIRED] service port, unique
        balance: leastconn # Use leastconn algorithm and minio health check
        options: [ "option httpchk", "option http-keep-alive", "http-check send meth OPTIONS uri /minio/health/live", "http-check expect status 200" ]
        servers:           # reload service with ./node.yml -t haproxy_config,haproxy_reload
          - { name: minio-1 ,ip: 10.10.10.21 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
          - { name: minio-2 ,ip: 10.10.10.22 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
          - { name: minio-3 ,ip: 10.10.10.23 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
          - { name: minio-4 ,ip: 10.10.10.24 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
          - { name: minio-5 ,ip: 10.10.10.25 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }

在这种情况下，您通常还需要在全局修改 MinIO 域名的解析，将 sss.pigsty 指向负载均衡器的地址，并修改 minio_endpoint 参数，修改写入管理节点 MinIO Alias 对应的端点地址：

minio_endpoint: https://sss.pigsty:9002    # overwrite the defaults: https://sss.pigsty:9000
node_etc_hosts: ["10.10.10.20 sss.pigsty"] # domain name to access minio from all nodes (required)

访问服务

如果您想要访问上面通过 HAProxy 暴露的 MinIO，以 PGSQL 备份配置为例，可以修改 pgbackrest_repo 中的配置，添加新的备份仓库定义：

# 这是新添加的 HA MinIO Repo 定义，使用此配置代替之前的单机 MinIO 配置
minio_ha:
  type: s3
  s3_endpoint: minio-1.pigsty   # s3_endpoint 可以是任何一个负载均衡器：10.10.10.1{0,1,2}，或指向任意 3 个节点的域名
  s3_region: us-east-1          # 你可以使用外部域名：sss.pigsty，该域名指向任一成员（`minio_domain`）
  s3_bucket: pgsql              # 你可使用实例名和节点名：minio-1.pigsty minio-1.pigsty minio-1.pigsty minio-1 minio-2 minio-3
  s3_key: pgbackrest            # 最好为 MinIO 的 pgbackrest 用户使用专门的密码
  s3_key_secret: S3User.SomeNewPassWord
  s3_uri_style: path
  path: /pgbackrest
  storage_port: 9002            # 使用负载均衡器的端口 9002 代替默认的 9000（直接访问）
  storage_ca_file: /etc/pki/ca.crt
  bundle: y
  cipher_type: aes-256-cbc      # 在您的生产环境中最好使用新的加密密码，这里可以使用集群名作为密码的一部分。
  cipher_pass: pgBackRest.With.Some.Extra.PassWord.And.Salt.${pg_cluster}
  retention_full_type: time
  retention_full: 14

暴露管控

MinIO 默认通过 9001 端口（由 minio_admin_port 参数指定）提供Web管控界面。

将后台管理界面暴露给外部可能存在安全隐患。如果你希望这样做，请将 MinIO 添加到 infra_portal 并刷新 Nginx 配置。

# ./infra.yml -t nginx
infra_portal:
  home         : { domain: h.pigsty }
  grafana      : { domain: g.pigsty ,endpoint: "${admin_ip}:3000" , websocket: true }
  prometheus   : { domain: p.pigsty ,endpoint: "${admin_ip}:9090" }
  alertmanager : { domain: a.pigsty ,endpoint: "${admin_ip}:9093" }
  blackbox     : { endpoint: "${admin_ip}:9115" }
  loki         : { endpoint: "${admin_ip}:3100" }

  # MinIO 管理页面需要 HTTPS / Websocket 才能工作
  minio        : { domain: m.pigsty     ,endpoint: "10.10.10.10:9001" ,scheme: https ,websocket: true }
  minio10      : { domain: m10.pigsty   ,endpoint: "10.10.10.10:9001" ,scheme: https ,websocket: true }
  minio11      : { domain: m11.pigsty   ,endpoint: "10.10.10.11:9001" ,scheme: https ,websocket: true }
  minio12      : { domain: m12.pigsty   ,endpoint: "10.10.10.12:9001" ,scheme: https ,websocket: true }
  minio13      : { domain: m13.pigsty   ,endpoint: "10.10.10.13:9001" ,scheme: https ,websocket: true }

请注意，MinIO 管控页面需要使用 HTTPS，请不要在生产环境中暴露未加密的 MinIO 管控页面。

这意味着，您通常需要在您的 DNS 服务器，或者本机 /etc/hosts 中添加 m.pigsty 的解析记录，以便访问 MinIO 管控页面。

与此同时，如果您使用的是 Pigsty 自签名的 CA 而不是一个正规的公共 CA ，通常您还需要手工信任该 CA 或证书，才能跳过浏览器中的 “不安全” 提示信息。

3 - 参数列表

MinIO 模块提供了 15 个相关配置参数，用于定制所需的 Minio 集群。

MinIO 是一个与 S3 兼容的对象存储服务，它被用作 PostgreSQL 的可选的集中式备份存储库。

但用户也可以将其用于其他目的，如存储文件、文档、图片和视频，作为数据湖。

参数列表

MinIO 模块有 15 个相关参数：

参数	类型	层次	中文说明
`minio_seq`	int	I	minio 实例标识符，必填
`minio_cluster`	string	C	minio 集群名称，默认为 minio
`minio_clean`	bool	G/C/A	初始化时清除 minio？默认为 false
`minio_user`	username	C	minio 操作系统用户，默认为 `minio`
`minio_node`	string	C	minio 节点名模式
`minio_data`	path	C	minio 数据目录，使用 `{x...y}` 指定多个磁盘
`minio_volumes`	string	C	minio 核心参数，指定成员节点与磁盘，默认不指定
`minio_domain`	string	G	minio 外部域名，默认为 `sss.pigsty`
`minio_port`	port	C	minio 服务端口，默认为 9000
`minio_admin_port`	port	C	minio 控制台端口，默认为 9001
`minio_access_key`	username	C	根访问密钥，默认为 `minioadmin`
`minio_secret_key`	password	C	根密钥，默认为 `minioadmin`
`minio_extra_vars`	string	C	minio 服务器的额外环境变量
`minio_alias`	string	C	minio 部署的客户端别名
`minio_endpoint`	string	C	minio 部署的客户端别名对应的端点
`minio_buckets`	bucket[]	C	待创建的 minio 存储桶列表
`minio_users`	user[]	C	待创建的 minio 用户列表

其中，minio_volumes 与 minio_endpoint 为自动生成的参数，但您可以显式覆盖指定这两个参数。

默认参数

MinIO 模块的默认参数为：

#-----------------------------------------------------------------
# MINIO
#-----------------------------------------------------------------
#minio_seq: 1                     # minio 实例标识符，必填
minio_cluster: minio              # minio 集群名称，默认为 minio
minio_clean: false                # 初始化时清除 minio？默认为 false
minio_user: minio                 # minio 操作系统用户，默认为 `minio`
minio_node: '${minio_cluster}-${minio_seq}.pigsty' # minio 节点名模式
minio_data: '/data/minio'         # minio 数据目录，使用 `{x...y}` 指定多个磁盘
#minio_volumes:                   # minio 核心参数，如果未指定，则使用拼接生成的默认值 
minio_domain: sss.pigsty          # minio 外部域名，默认为 `sss.pigsty`
minio_port: 9000                  # minio 服务端口，默认为 9000
minio_admin_port: 9001            # minio 控制台端口，默认为 9001
minio_access_key: minioadmin      # 根访问密钥，默认为 `minioadmin`
minio_secret_key: minioadmin      # 根密钥，默认为 `minioadmin`
minio_extra_vars: ''              # minio 服务器的额外环境变量
minio_alias: sss                  # minio 部署的客户端别名
#minio_endpoint: https://sss.pigsty:9000 # minio 别名对应的接入点，如果未指定，则使用拼接生成的默认值
minio_buckets: [ { name: pgsql }, { name: infra },  { name: redis } ] # 待创建的 minio 存储桶列表
minio_users:                      # 待创建的 minio 用户列表
  - { access_key: dba , secret_key: S3User.DBA, policy: consoleAdmin }
  - { access_key: pgbackrest , secret_key: S3User.Backup, policy: readwrite }

`minio_seq`

参数名称： minio_seq，类型： int，层次：I

MinIO 实例标识符，必需的身份参数。没有默认值，您必须手动分配这些序列号。

通常的最佳实践是，从1开始分配，依次加1，并永远不使用已经分配的序列号。

`minio_cluster`

参数名称： minio_cluster，类型： string，层次：C

MinIO 集群名称，默认为 minio。当部署多个MinIO集群时，可以使用此参数进行区分。

`minio_clean`

参数名称： minio_clean，类型： bool，层次：G/C/A

是否在初始化时清理 MinIO ？默认为 false，即不清理现有数据。

如果您想在移除，或者在安装过程中清理 MinIO 数据目录，可以将此参数设置为 true，这是一个危险的操作，因为它会删除所有MinIO数据！

`minio_user`

参数名称： minio_user，类型： username，层次：C

MinIO 操作系统用户名，默认为 minio，MinIO 的家目录中将存储 MinIO 使用的证书。

`minio_node`

参数名称： minio_node，类型： string，层次：C

MinIO 节点名称模式，用于多节点部署。

默认值为：${minio_cluster}-${minio_seq}.pigsty，即以实例名 + .pigsty 后缀作为默认的节点名。

在这里指定的域名模式将用于生成节点名，节点名将写入所有 MinIO 节点的 /etc/hosts 文件中。

`minio_data`

参数名称： minio_data，类型： path，层次：C

MinIO 数据目录（们），默认值：/data/minio，这是单节点部署的常见目录。

对于多机多盘与 单机多盘 部署，您可以使用 {x...y} 的记法来指定多个磁盘。

`minio_volumes`

参数名称： minio_volumes，类型： string，层次：C

MinIO 核心参数，默认不指定留空，留空情况下，该参数会自动使用以下规则拼接生成：

minio_volumes: "{% if minio_cluster_size|int > 1 %}https://{{ minio_node|replace('${minio_cluster}', minio_cluster)|replace('${minio_seq}',minio_seq_range) }}:{{ minio_port|default(9000) }}{% endif %}{{ minio_data }}"

在单机部署（无论是单盘还是多盘）模式下，minio_volumes 直接使用 minio_data 的值，进行单机部署。
在多机部署模式下，minio_volumes 会使用 minio_node, minio_port, minio_data 参数的值生成多节点的地址，用于多机部署。
在多池部署模式下，通常需要您直接指定并覆盖 minio_volumes 的值，以指定多个节点池的地址。

指定本参数时，您需要确保使用的参数与 minio_node, minio_port, minio_data 三者匹配。

`minio_domain`

参数名称： minio_domain，类型： string，层次：G

MinIO 服务域名，默认为sss.pigsty。

客户端可以通过此域名访问 MinIO S3 服务。此名称将注册到本地 DNSMASQ，并包含在 SSL 证书字段中。

`minio_port`

参数名称： minio_port，类型： port，层次：C

MinIO 服务端口，默认为9000。

`minio_admin_port`

参数名称： minio_admin_port，类型： port，层次：C

MinIO 控制台端口，默认为9001。

`minio_access_key`

参数名称： minio_access_key，类型： username，层次：C

根访问用户名（access key），默认为minioadmin。

`minio_secret_key`

参数名称： minio_secret_key，类型： password，层次：C

根访问密钥（secret key），默认为minioadmin。

使用默认根密码是高危行为！请务必在生产部署中更改此参数！

`minio_extra_vars`

参数名称： minio_extra_vars，类型： string，层次：C

MinIO 服务器的额外环境变量。查看 MinIO Server 文档以获取完整列表。

默认值为空字符串，您可以使用多行字符串来传递多个环境变量。

`minio_alias`

参数名称： minio_alias，类型： string，层次：C

本地 MinIO 集群的 MinIO 别名，默认值：sss，它将被写入基础设施节点/管理员用户的客户端别名配置文件中。

`minio_endpoint`

参数名称：minio_endpoint，类型： string，层次：C

部署的客户端别名对应的端点，如果指定，这里的 minio_endpoint （例如： https://sss.pigsty:9002）将会替代默认值，作为写入管理节点 MinIO Alias 的目标端点。

mcli alias set {{ minio_alias }} {% if minio_endpoint is defined and minio_endpoint != '' %}{{ minio_endpoint }}{% else %}https://{{ minio_domain }}:{{ minio_port }}{% endif %} {{ minio_access_key }} {{ minio_secret_key }}

以上 MinIO Alias 会在管理节点上以默认管理用户执行。

`minio_buckets`

参数名称： minio_buckets，类型： bucket[]，层次：C

默认创建的minio存储桶列表：

minio_buckets: [ { name: pgsql }, { name: infra },  { name: redis } ]

为模块 PGSQL、INFRA和REDIS 创建了三个默认的存储桶

目前这三个桶中，仅 pgsql 默认用于 pgbackrest 备份存储。

`minio_users`

参数名称： minio_users，类型： user[]，层次：C

要创建的minio用户列表，默认值：

minio_users:
  - { access_key: dba , secret_key: S3User.DBA, policy: consoleAdmin }
  - { access_key: pgbackrest , secret_key: S3User.Backup, policy: readwrite }

默认配置会为 PostgreSQL DBA 和 pgBackREST 创建两个默认用户：dba，pgbackrest。

使用默认密码是高危行为！请务必在您的部署中调整这些凭证！

4 - 预置剧本

如何使用预置的 ansible 剧本来管理 MinIO 集群，常用管理命令速查。

MinIO 模块提供了一个默认的剧本 minio.yml ，用于安装 MinIO 集群。

`minio.yml`

剧本 minio.yml 用于在节点上安装 MinIO 模块。

minio-id : 生成/校验 minio 身份参数
minio_install : 安装 minio
- minio_os_user : 创建操作系统用户 minio
- minio_pkg : 安装 minio/mcli 软件包
- minio_clean : 移除 minio 数据目录 (默认不移除)
- minio_dir : 创建 minio 目录
minio_config : 生成 minio 配置
- minio_conf : minio 主配置文件
- minio_cert : minio SSL证书签发
- minio_dns : minio DNS记录插入
minio_launch : minio 服务启动
minio_register : minio 纳入监控
minio_provision : 创建 minio 别名/存储桶/业务用户
- minio_alias : 创建 minio 客户端别名（管理节点上）
- minio_bucket : 创建 minio 存储桶
- minio_user : 创建 minio 业务用户

在执行剧本前，请先在配置清单中，完成 MinIO 集群的配置。

命令速查

MINIO 剧本与快捷方式：

./minio.yml -l <cls>                      # 在 <cls> 分组上安装 MINIO 模块
./minio.yml -l minio -e minio_clean=true  # 安装 MINIO 模块，安装时清理现有数据目录（危险！）
./minio.yml -l minio -e minio_clean=true  -t minio_clean # 停止 MinIO 并抹除 MinIO 数据目录（危险！）
./minio.yml -l minio -t minio_instal      # 在节点上安装 MinIO 服务，准备数据目录，但不启动
./minio.yml -l minio -t minio_config      # 重新配置 MinIO 集群
./minio.yml -l minio -t minio_launch      # 重启 MinIO 集群

保护机制

出于防止误删的目的，Pigsty 的 MINIO 模块提供了防误删保险，由以下参数控制：

minio_clean 默认为 false，即，默认不清理现有实例。

如果您希望在初始化时清理现有实例，请修改配置文件，显式关闭此保险，或者在执行时使用命令行参数 -e minio_clean=true 进行覆盖。

如果您单纯希望清理现有实例，而不安装新实例，直接执行 minio_clean 子任务即可：

./minio.yml -l <cls> -e minio_clean=true -t minio_clean

执行演示

5 - 管理预案

MinIO 集群管理 SOP：创建，销毁，扩容，缩容，节点故障与磁盘故障的处理。

创建集群

要创建一个集群，在配置清单中定义好后，执行 minio.yml 剧本即可。

minio: { hosts: { 10.10.10.10: { minio_seq: 1 } }, vars: { minio_cluster: minio } }

例如，上面的配置定义了一个 SNSD 单机单盘 MinIO 集群，使用以下命令即可创建该 MinIO 集群：

./minio.yml -l minio  # 在 minio 分组上安装 MinIO 模块

销毁集群

要销毁一个集群，执行 minio.yml 剧本的 minio_clean 子任务即可

./minio.yml -l minio -t minio_clean -e minio_clean=true   # 停止并清理 MinIO 数据目录

如果您希望将 MinIO 从 Prometheus 监控系统中移除，可以执行：

ansible infra -b -a 'rm -rf /etc/prometheus/targets/minio/minio-1.yml'  # 删除 MinIO 监控目标 minio-1

集群扩容

集群扩容教程

MinIO 无法在节点/磁盘级别上扩容，但可以在存储池（多个节点）层次上进行扩容。

现在假设您有这样一个四节点的 MinIO 集群，希望扩容一倍，新增一个四节点的存储池。

minio:
  hosts:
    10.10.10.10: { minio_seq: 1 , nodename: minio-1 }
    10.10.10.11: { minio_seq: 2 , nodename: minio-2 }
    10.10.10.12: { minio_seq: 3 , nodename: minio-3 }
    10.10.10.13: { minio_seq: 4 , nodename: minio-4 }
  vars:
    minio_cluster: minio
    minio_data: '/data{1...4}'
    minio_buckets: [ { name: pgsql }, { name: infra }, { name: redis } ]
    minio_users:
      - { access_key: dba , secret_key: S3User.DBA, policy: consoleAdmin }
      - { access_key: pgbackrest , secret_key: S3User.SomeNewPassWord , policy: readwrite }

    # bind a node l2 vip (10.10.10.9) to minio cluster (optional)
    node_cluster: minio
    vip_enabled: true
    vip_vrid: 128
    vip_address: 10.10.10.9
    vip_interface: eth1

    # expose minio service with haproxy on all nodes
    haproxy_services:
      - name: minio                    # [REQUIRED] service name, unique
        port: 9002                     # [REQUIRED] service port, unique
        balance: leastconn             # [OPTIONAL] load balancer algorithm
        options:                       # [OPTIONAL] minio health check
          - option httpchk
          - option http-keep-alive
          - http-check send meth OPTIONS uri /minio/health/live
          - http-check expect status 200
        servers:
          - { name: minio-1 ,ip: 10.10.10.10 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
          - { name: minio-2 ,ip: 10.10.10.11 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
          - { name: minio-3 ,ip: 10.10.10.12 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
          - { name: minio-4 ,ip: 10.10.10.13 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }

首先，修改 MinIO 集群定义，新增四台节点，按顺序分配序列号 5 到 8。这里的关键一步是修改 minio_volumes 参数，将新的四个节点指定为一个新的 存储池。

minio:
  hosts:
    10.10.10.10: { minio_seq: 1 , nodename: minio-1 }
    10.10.10.11: { minio_seq: 2 , nodename: minio-2 }
    10.10.10.12: { minio_seq: 3 , nodename: minio-3 }
    10.10.10.13: { minio_seq: 4 , nodename: minio-4 }
    # 新增的四个节点
    10.10.10.14: { minio_seq: 5 , nodename: minio-5 }
    10.10.10.15: { minio_seq: 6 , nodename: minio-6 }
    10.10.10.16: { minio_seq: 7 , nodename: minio-7 }
    10.10.10.17: { minio_seq: 8 , nodename: minio-8 }

  vars:
    minio_cluster: minio
    minio_data: '/data{1...4}'
    minio_volumes: 'https://minio-{1...4}.pigsty:9000/data{1...4} https://minio-{5...8}.pigsty:9000/data{1...4}'  # 新增的集群配置
    # …… 省略其他配置

第二步，将这些节点交由 Pigsty 纳管：

./node.yml -l 10.10.10.14,10.10.10.15,10.10.10.16,10.10.10.17

第三步，在新节点上，使用 Ansible 剧本安装并准备 MinIO 软件：

./minio.yml -l 10.10.10.14,10.10.10.15,10.10.10.16,10.10.10.17 -t minio_install

第四步，在 整个集群 上，使用 Ansible 剧本重新配置 MinIO 集群：

./minio.yml -l minio -t minio_config

这一步会更新现有四个节点的 MINIO_VOLUMES 配置

第五步，一次性重启整个 MinIO 集群（请注意，不要滚动重启！）：

./minio.yml -l minio -t minio_launch -f 10   # 8并发数，确保同时重启

第六步（可选）：如果您使用了负载均衡，那么请确保负载均衡器的配置也已经更新。例如，将新的四个节点加入到负载均衡器的配置中：

# expose minio service with haproxy on all nodes
haproxy_services:
  - name: minio                    # [REQUIRED] service name, unique
    port: 9002                     # [REQUIRED] service port, unique
    balance: leastconn             # [OPTIONAL] load balancer algorithm
    options:                       # [OPTIONAL] minio health check
      - option httpchk
      - option http-keep-alive
      - http-check send meth OPTIONS uri /minio/health/live
      - http-check expect status 200
    servers:
      - { name: minio-1 ,ip: 10.10.10.10 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
      - { name: minio-2 ,ip: 10.10.10.11 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
      - { name: minio-3 ,ip: 10.10.10.12 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
      - { name: minio-4 ,ip: 10.10.10.13 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }

      - { name: minio-5 ,ip: 10.10.10.14 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
      - { name: minio-6 ,ip: 10.10.10.15 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
      - { name: minio-7 ,ip: 10.10.10.16 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }
      - { name: minio-8 ,ip: 10.10.10.17 ,port: 9000 ,options: 'check-ssl ca-file /etc/pki/ca.crt check port 9000' }

然后，执行 node.yml 剧本的 haproxy 子任务，更新负载均衡器配置：

./node.yml -l minio -t haproxy_config,haproxy_reload   # 更新负载均衡器配置并在线加载

如果您使用 L2 VIP 来确保可靠的负载均衡器接入，那么还需要将新的节点（如果有）加入到现有 NODE VIP 分组中：

./node.yml -l minio -t node_vip  # 刷新集群 L2 VIP 配置

集群缩容

MinIO 无法在节点/磁盘级别上缩容，但可以在存储池（多个节点）层次上进行退役 —— 新增一个新存储池，将旧存储池排干迁移到新存储池，然后将旧存储池退役。

集群缩容教程

集群升级

集群升级教程

首先，将新版本的 MinIO 软件包下载至 INFRA 节点的本地软件仓库，然后重建软件仓库索引：

minio:
- amd64: https://dl.min.io/server/minio/release/linux-amd64/
- arm64: https://dl.min.io/server/minio/release/linux-arm64/
mcli:
- amd64: https://dl.min.io/client/mc/release/linux-amd64/
- arm64: https://dl.min.io/client/mc/release/linux-arm64/

./infra.yml -t repo_create

其次，使用 Ansible 批量升级 MinIO 软件包版本：

ansible minio -m package -b -a 'name=minio state=latest'  # 升级 MinIO 服务器软件版本
ansible minio -m package -b -a 'name=mcli state=latest'   # 升级 MinIO 客户端软件版本

最后，使用 mc 命令行工具通知 MinIO 集群重启：

mc admin service restart sss

替换故障节点

节点故障教程

# 1. 从集群中下线故障节点
bin/node-rm <your_old_node_ip>

# 2. 替换故障节点，使用原来的节点名称（如果IP变化，您需要修改 MinIO 集群定义）
bin/node-add <your_new_node_ip>

# 3. 在新节点上安装配置 MinIO
./minio.yml -l <your_new_node_ip>

# 4. 指示 MinIO 执行恢复动作
mc admin heal

替换故障磁盘

磁盘故障教程

# 1. 从集群中删除故障磁盘
umount /dev/<your_disk_device>

# 2. 替换故障磁盘，使用xfs格盘
mkfs.xfs /dev/sdb -L DRIVE1

# 3. 不要忘记设置开机自动挂载
vi /etc/fstab
# LABEL=DRIVE1     /mnt/drive1    xfs     defaults,noatime  0       2

# 4. 重新挂载
mount -a

# 5. 指示 MinIO 执行恢复动作
mc admin heal

6 - 监控告警

如何在 Pigsty 中监控 MinIO？如何使用 MinIO 本身的管控面板？有哪些告警规则值得关注？

内置控制台

MinIO 内置了一个相当不错的管控界面，默认您可以通过任意 MinIO 实例的管控端口（minio_admin_port ，默认为 9001），使用 HTTPS 访问此界面。

在大多数提供 MinIO 服务的配置模板中，MinIO 都会以 m.pigsty 的自定义服务对外暴露。在配置域名解析后，您可以通过 https://m.pigsty 访问 MinIO 管控界面。

Pigsty监控

Pigsty 提供了两个与 MINIO 模块有关的监控面板：

MinIO Overview 展示了 MinIO 集群的整体监控指标。

MinIO Instance 展示了单个 MinIO 实例的监控指标详情

Pigsty告警

Pigsty 针对 MinIO 提供了以下三条告警规则，分别是：

MinIO 宕机
MinIO 节点离线
MinIO 磁盘离线

#==============================================================#
#                         Aliveness                            #
#==============================================================#
# MinIO server instance down
- alert: MinioServerDown
  expr: minio_up < 1
  for: 1m
  labels: { level: 0, severity: CRIT, category: minio }
  annotations:
    summary: "CRIT MinioServerDown {{ $labels.ins }}@{{ $labels.instance }}"
    description: |
      minio_up[ins={{ $labels.ins }}, instance={{ $labels.instance }}] = {{ $value }} < 1
      http://g.pigsty/d/minio-overview      

#==============================================================#
#                         Error                                #
#==============================================================#
# MinIO node offline triggers a p1 alert
- alert: MinioNodeOffline
  expr: avg_over_time(minio_cluster_nodes_offline_total{job="minio"}[5m]) > 0
  for: 3m
  labels: { level: 1, severity: WARN, category: minio }
  annotations:
    summary: "WARN MinioNodeOffline: {{ $labels.cls }} {{ $value }}"
    description: |
      minio_cluster_nodes_offline_total[cls={{ $labels.cls }}] = {{ $value }} > 0
      http://g.pigsty/d/minio-overview?from=now-5m&to=now&var-cls={{$labels.cls}}      

# MinIO disk offline triggers a p1 alert
- alert: MinioDiskOffline
  expr: avg_over_time(minio_cluster_disk_offline_total{job="minio"}[5m]) > 0
  for: 3m
  labels: { level: 1, severity: WARN, category: minio }
  annotations:
    summary: "WARN MinioDiskOffline: {{ $labels.cls }} {{ $value }}"
    description: |
      minio_cluster_disk_offline_total[cls={{ $labels.cls }}] = {{ $value }} > 0
      http://g.pigsty/d/minio-overview?from=now-5m&to=now&var-cls={{$labels.cls}}

7 - 指标列表

Pigsty MINIO 模块提供的完整监控指标列表与释义

MINIO 模块包含有 79 类可用监控指标。

Metric Name	Type	Labels	Description
minio_audit_failed_messages	counter	`ip`, `job`, `target_id`, `cls`, `instance`, `server`, `ins`	Total number of messages that failed to send since start
minio_audit_target_queue_length	gauge	`ip`, `job`, `target_id`, `cls`, `instance`, `server`, `ins`	Number of unsent messages in queue for target
minio_audit_total_messages	counter	`ip`, `job`, `target_id`, `cls`, `instance`, `server`, `ins`	Total number of messages sent since start
minio_cluster_bucket_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of buckets in the cluster
minio_cluster_capacity_raw_free_bytes	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total free capacity online in the cluster
minio_cluster_capacity_raw_total_bytes	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total capacity online in the cluster
minio_cluster_capacity_usable_free_bytes	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total free usable capacity online in the cluster
minio_cluster_capacity_usable_total_bytes	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total usable capacity online in the cluster
minio_cluster_drive_offline_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total drives offline in this cluster
minio_cluster_drive_online_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total drives online in this cluster
minio_cluster_drive_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total drives in this cluster
minio_cluster_health_erasure_set_healing_drives	gauge	`pool`, `ip`, `job`, `cls`, `set`, `instance`, `server`, `ins`	Get the count of healing drives of this erasure set
minio_cluster_health_erasure_set_online_drives	gauge	`pool`, `ip`, `job`, `cls`, `set`, `instance`, `server`, `ins`	Get the count of the online drives in this erasure set
minio_cluster_health_erasure_set_read_quorum	gauge	`pool`, `ip`, `job`, `cls`, `set`, `instance`, `server`, `ins`	Get the read quorum for this erasure set
minio_cluster_health_erasure_set_status	gauge	`pool`, `ip`, `job`, `cls`, `set`, `instance`, `server`, `ins`	Get current health status for this erasure set
minio_cluster_health_erasure_set_write_quorum	gauge	`pool`, `ip`, `job`, `cls`, `set`, `instance`, `server`, `ins`	Get the write quorum for this erasure set
minio_cluster_health_status	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Get current cluster health status
minio_cluster_nodes_offline_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of MinIO nodes offline
minio_cluster_nodes_online_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of MinIO nodes online
minio_cluster_objects_size_distribution	gauge	`ip`, `range`, `job`, `cls`, `instance`, `server`, `ins`	Distribution of object sizes across a cluster
minio_cluster_objects_version_distribution	gauge	`ip`, `range`, `job`, `cls`, `instance`, `server`, `ins`	Distribution of object versions across a cluster
minio_cluster_usage_deletemarker_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of delete markers in a cluster
minio_cluster_usage_object_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of objects in a cluster
minio_cluster_usage_total_bytes	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total cluster usage in bytes
minio_cluster_usage_version_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of versions (includes delete marker) in a cluster
minio_cluster_webhook_failed_messages	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Number of messages that failed to send
minio_cluster_webhook_online	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Is the webhook online?
minio_cluster_webhook_queue_length	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Webhook queue length
minio_cluster_webhook_total_messages	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of messages sent to this target
minio_cluster_write_quorum	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Maximum write quorum across all pools and sets
minio_node_file_descriptor_limit_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Limit on total number of open file descriptors for the MinIO Server process
minio_node_file_descriptor_open_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of open file descriptors by the MinIO Server process
minio_node_go_routine_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of go routines running
minio_node_ilm_expiry_pending_tasks	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Number of pending ILM expiry tasks in the queue
minio_node_ilm_transition_active_tasks	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Number of active ILM transition tasks
minio_node_ilm_transition_missed_immediate_tasks	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Number of missed immediate ILM transition tasks
minio_node_ilm_transition_pending_tasks	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Number of pending ILM transition tasks in the queue
minio_node_ilm_versions_scanned	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of object versions checked for ilm actions since server start
minio_node_io_rchar_bytes	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total bytes read by the process from the underlying storage system including cache, /proc/[pid]/io rchar
minio_node_io_read_bytes	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total bytes read by the process from the underlying storage system, /proc/[pid]/io read_bytes
minio_node_io_wchar_bytes	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total bytes written by the process to the underlying storage system including page cache, /proc/[pid]/io wchar
minio_node_io_write_bytes	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total bytes written by the process to the underlying storage system, /proc/[pid]/io write_bytes
minio_node_process_cpu_total_seconds	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total user and system CPU time spent in seconds
minio_node_process_resident_memory_bytes	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Resident memory size in bytes
minio_node_process_starttime_seconds	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Start time for MinIO process per node, time in seconds since Unix epoc
minio_node_process_uptime_seconds	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Uptime for MinIO process per node in seconds
minio_node_scanner_bucket_scans_finished	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of bucket scans finished since server start
minio_node_scanner_bucket_scans_started	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of bucket scans started since server start
minio_node_scanner_directories_scanned	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of directories scanned since server start
minio_node_scanner_objects_scanned	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of unique objects scanned since server start
minio_node_scanner_versions_scanned	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of object versions scanned since server start
minio_node_syscall_read_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total read SysCalls to the kernel. /proc/[pid]/io syscr
minio_node_syscall_write_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total write SysCalls to the kernel. /proc/[pid]/io syscw
minio_notify_current_send_in_progress	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Number of concurrent async Send calls active to all targets (deprecated, please use ‘minio_notify_target_current_send_in_progress’ instead)
minio_notify_events_errors_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Events that were failed to be sent to the targets (deprecated, please use ‘minio_notify_target_failed_events’ instead)
minio_notify_events_sent_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of events sent to the targets (deprecated, please use ‘minio_notify_target_total_events’ instead)
minio_notify_events_skipped_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Events that were skipped to be sent to the targets due to the in-memory queue being full
minio_s3_requests_4xx_errors_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`, `api`	Total number of S3 requests with (4xx) errors
minio_s3_requests_errors_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`, `api`	Total number of S3 requests with (4xx and 5xx) errors
minio_s3_requests_incoming_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of incoming S3 requests
minio_s3_requests_inflight_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`, `api`	Total number of S3 requests currently in flight
minio_s3_requests_rejected_auth_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of S3 requests rejected for auth failure
minio_s3_requests_rejected_header_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of S3 requests rejected for invalid header
minio_s3_requests_rejected_invalid_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of invalid S3 requests
minio_s3_requests_rejected_timestamp_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of S3 requests rejected for invalid timestamp
minio_s3_requests_total	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`, `api`	Total number of S3 requests
minio_s3_requests_ttfb_seconds_distribution	gauge	`ip`, `job`, `cls`, `le`, `instance`, `server`, `ins`, `api`	Distribution of time to first byte across API calls
minio_s3_requests_waiting_total	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of S3 requests in the waiting queue
minio_s3_traffic_received_bytes	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of s3 bytes received
minio_s3_traffic_sent_bytes	counter	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Total number of s3 bytes sent
minio_software_commit_info	gauge	`ip`, `job`, `cls`, `instance`, `commit`, `server`, `ins`	Git commit hash for the MinIO release
minio_software_version_info	gauge	`ip`, `job`, `cls`, `instance`, `version`, `server`, `ins`	MinIO Release tag for the server
minio_up	Unknown	`ip`, `job`, `cls`, `instance`, `ins`	N/A
minio_usage_last_activity_nano_seconds	gauge	`ip`, `job`, `cls`, `instance`, `server`, `ins`	Time elapsed (in nano seconds) since last scan activity.
scrape_duration_seconds	Unknown	`ip`, `job`, `cls`, `instance`, `ins`	N/A
scrape_samples_post_metric_relabeling	Unknown	`ip`, `job`, `cls`, `instance`, `ins`	N/A
scrape_samples_scraped	Unknown	`ip`, `job`, `cls`, `instance`, `ins`	N/A
scrape_series_added	Unknown	`ip`, `job`, `cls`, `instance`, `ins`	N/A
up	Unknown	`ip`, `job`, `cls`, `instance`, `ins`	N/A

8 - 常见问题

Pigsty MINIO 对象存储模块常见问题答疑

启动多节点/多盘MinIO集群失败怎么办？

在单机多盘或多机多盘模式下，如果数据目录不是有效的磁盘挂载点，MinIO会拒绝启动。

请使用已挂载的磁盘作为MinIO的数据目录，而不是普通目录。您只能在单机单盘模式下使用普通目录作为 MinIO 的数据目录，作为开发测试之用。

如何向已有的MinIO集群中添加新的成员？

在部署之前，您最好规划MinIO集群容量，因为新增成员需要全局重启。

您可以通过向现有集群中添加新的服务器节点，打造一个新的存储池的方式，实现 MinIO 扩容。

请注意，MinIO 一旦部署，你无法修改现有集群的节点数量与磁盘数量！

请参考这里：扩展MinIO部署