这是本节的多页打印视图。点击此处打印.

模块：MINIO

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

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

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

MinIO 可以用来存储文档、图片、视频和备份。Pigsty 原生支持部署各种 MinIO 集群，具备原生多节点多磁盘高可用支持，易于扩展、安全且开箱即用，并且有过 10PB+ 级别的大规模生产环境部署用例。

MinIO 是 Pigsty 中的一个 可选模块。您可以将 MinIO 用作 PostgreSQL 备份的可选存储仓库，作为默认本地 POSIX 文件系统仓库的补充。如果使用 MinIO 备份仓库，MINIO 模块应在任何 PGSQL 模块之前安装。MinIO 需要受信任的 CA 证书才能工作，因此它依赖 NODE 模块。

快速开始

以下是一个最简单的 MinIO 单机单盘部署示例：

# 在配置清单中定义 MinIO 集群
minio: { hosts: { 10.10.10.10: { minio_seq: 1 } }, vars: { minio_cluster: minio } }

./minio.yml -l minio    # 在 minio 分组上部署 MinIO 模块

部署完成后，您可以通过以下方式访问 MinIO：

S3 API：https://sss.pigsty:9000（使用域名需要配置 DNS 解析）
Web 控制台：https://<minio-ip>:9001（默认用户名/密码：minioadmin / S3User.MinIO）
命令行：mcli ls sss/（管理节点上已预配置别名）

部署模式

MinIO 支持三种主要部署模式：

模式	说明	适用场景
单机单盘 (SNSD)	单节点，单个数据目录	开发、测试、演示
单机多盘 (SNMD)	单节点，多块磁盘	资源受限的小规模部署
多机多盘 (MNMD)	多节点，每节点多块磁盘	生产环境推荐

此外，您还可以使用多池部署来扩容现有集群，或部署多套集群。

核心特性

S3 兼容：完全兼容 AWS S3 API，可与各种 S3 客户端和工具无缝集成
高可用：原生支持多节点多磁盘部署，容忍节点和磁盘故障
安全：默认启用 HTTPS 加密传输，支持服务端加密
监控：开箱即用的 Grafana 监控面板和 Prometheus 告警规则
易用：预配置的 mcli 客户端别名，一键部署和管理

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 S3User.MinIO            # root 用户
mcli alias set sss https://sss.pigsty:9002 minioadmin S3User.MinIO            # root 用户，使用负载均衡器 9002 端口

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

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

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

注意：请使用您实际配置的密码

上述示例中的密码 S3User.MinIO 是 Pigsty 的默认值。如果您在部署时修改了 minio_secret_key，请使用您实际配置的密码。

用户管理

使用 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 系列系统
apt 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 = S3User.MinIO
endpoint = https://sss.pigsty:9000
EOF

rclone ls sss:/

注意：HTTPS 与证书信任

如果 MinIO 使用 HTTPS（默认配置），您需要确保客户端信任 Pigsty 的 CA 证书（/etc/pki/ca.crt），或者在 rclone 配置中添加 no_check_certificate = true 来跳过证书验证（不建议在生产环境使用）。

配置备份仓库

在 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 将拒绝启动。请确保使用 XFS 格式化的真实磁盘。

例如 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 模块提供了 21 个相关配置参数，用于定制所需的 MinIO 集群。

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

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

参数概览

MINIO 参数组用于 MinIO 集群的部署与配置，包括身份标识、存储路径、端口、认证凭据以及存储桶和用户的置备。

参数	类型	级别	说明
`minio_seq`	`int`	`I`	minio 实例标识符，必填
`minio_cluster`	`string`	`C`	minio 集群名称，默认为 minio
`minio_user`	`username`	`C`	minio 操作系统用户，默认为 `minio`
`minio_https`	`bool`	`G/C`	是否为 MinIO 启用 HTTPS？默认为 true
`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`	根密钥，默认为 `S3User.MinIO`
`minio_extra_vars`	`string`	`C`	minio 服务器的额外环境变量
`minio_provision`	`bool`	`G/C`	是否执行 minio 资源置备任务？默认为 true
`minio_alias`	`string`	`G`	minio 部署的客户端别名
`minio_endpoint`	`string`	`C`	minio 部署的客户端别名对应的端点
`minio_buckets`	`bucket[]`	`C`	待创建的 minio 存储桶列表
`minio_users`	`user[]`	`C`	待创建的 minio 用户列表

MINIO_REMOVE 参数组控制 MinIO 集群的移除行为，包括防误删保险、数据清理以及软件包卸载。

参数	类型	级别	说明
`minio_safeguard`	`bool`	`G/C/A`	防止意外删除？默认为 false
`minio_rm_data`	`bool`	`G/C/A`	移除时是否删除 minio 数据？默认为 true
`minio_rm_pkg`	`bool`	`G/C/A`	移除时是否卸载 minio 软件包？默认为 false

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

默认参数

MINIO：18 个参数，定义于 roles/minio/defaults/main.yml

#-----------------------------------------------------------------
# MINIO
#-----------------------------------------------------------------
#minio_seq: 1                     # minio 实例标识符，必填
minio_cluster: minio              # minio 集群名称，默认为 minio
minio_user: minio                 # minio 操作系统用户，默认为 `minio`
minio_https: true                 # 是否为 MinIO 启用 HTTPS？默认为 true
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: S3User.MinIO    # 根密钥，默认为 `S3User.MinIO`
minio_extra_vars: ''              # minio 服务器的额外环境变量
minio_provision: true             # 是否执行 minio 资源置备任务？
minio_alias: sss                  # minio 部署的客户端别名
#minio_endpoint: https://sss.pigsty:9000 # minio 别名对应的接入点，如果未指定，则使用拼接生成的默认值
minio_buckets:                    # 待创建的 minio 存储桶列表
  - { name: pgsql }
  - { name: meta ,versioning: true }
  - { name: data }
minio_users:                      # 待创建的 minio 用户列表
  - { access_key: pgbackrest  ,secret_key: S3User.Backup ,policy: pgsql }
  - { access_key: s3user_meta ,secret_key: S3User.Meta   ,policy: meta  }
  - { access_key: s3user_data ,secret_key: S3User.Data   ,policy: data  }

MINIO_REMOVE：3 个参数，定义于 roles/minio_remove/defaults/main.yml

#-----------------------------------------------------------------
# MINIO_REMOVE
#-----------------------------------------------------------------
minio_safeguard: false            # 防止意外删除？默认为 false
minio_rm_data: true               # 移除时是否删除 minio 数据？默认为 true
minio_rm_pkg: false               # 移除时是否卸载 minio 软件包？默认为 false

`minio_seq`

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

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

通常的最佳实践是，从 1 开始分配，依次加 1，并永远不使用已经分配的序列号。序列号与集群名称 minio_cluster 一起，唯一标识每一个 MinIO 实例（例如：minio-1）。

在多节点部署中，序列号还会用于生成节点名称，写入 /etc/hosts 文件中进行静态解析。

`minio_cluster`

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

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

集群名称与序列号 minio_seq 一起，唯一标识每一个 MinIO 实例。例如，当集群名为 minio，序列号为 1 时，实例名称为 minio-1。

请注意，Pigsty 默认一套部署中只有一个 MinIO 集群。如果您需要部署多个 MinIO 集群，需要显式设置 minio_alias、minio_domain、minio_endpoint 等参数以避免命名冲突。

`minio_user`

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

MinIO 操作系统用户名，默认为 minio。

MinIO 服务将以此用户身份运行，该用户的家目录（默认为 /home/minio）中将存储 MinIO 使用的 SSL 证书（位于 ~/.minio/certs/ 目录下）。

`minio_https`

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

是否为 MinIO 服务启用 HTTPS？默认为 true，即使用 HTTPS。

请注意，pgBackREST 需要 MinIO 启用 HTTPS 才能正常工作。但如果您不使用 MinIO 进行 PostgreSQL 备份，且不需要使用 HTTPS，可以将此参数设置为 false。

启用 HTTPS 后，Pigsty 会自动为 MinIO 服务器签发 SSL 证书，证书包含 minio_domain 指定的域名以及各个节点的 IP 地址。

`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 证书的 SAN（Subject Alternative Name）字段中。

建议在 node_etc_hosts 中添加静态解析记录，将此域名指向 MinIO 服务器节点的 IP 地址（单机部署），或负载均衡器的 VIP 地址（多节点部署）。

`minio_port`

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

MinIO 服务端口，默认为 9000。

这是 MinIO S3 API 的监听端口，客户端通过此端口访问对象存储服务。在多节点部署中，此端口也用于节点间通信。

`minio_admin_port`

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

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

这是 MinIO 内置 Web 管理控制台的监听端口。您可以通过 https://<minio-ip>:9001 访问 MinIO 的图形化管理界面。

如果希望通过 Nginx 对外暴露 MinIO 控制台，可以将其添加到 infra_portal 中。请注意，MinIO 控制台需要使用 HTTPS 和 WebSocket。

`minio_access_key`

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

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

这是 MinIO 的超级管理员用户名，拥有对所有存储桶和对象的完全访问权限。建议在生产环境中修改此默认值。

`minio_secret_key`

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

根访问密钥（secret key），默认为 S3User.MinIO。

这是 MinIO 超级管理员的密码，与 minio_access_key 配合使用。

安全警告：请务必修改默认密码！

使用默认密码是高危行为！请务必在您的生产环境部署中修改此密码。

提示：执行 ./configure 或 ./configure -g 时，会自动修改配置文件模板中的这些默认密码。

`minio_extra_vars`

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

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

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

minio_extra_vars: |
  MINIO_BROWSER_REDIRECT_URL=https://minio.example.com
  MINIO_SERVER_URL=https://s3.example.com

`minio_provision`

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

是否执行 MinIO 资源置备任务？默认为 true。

当启用时，Pigsty 将自动创建 minio_buckets 和 minio_users 中定义的存储桶和用户。如果您不需要自动置备这些资源，可以将此参数设置为 false。

`minio_alias`

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

本地 MinIO 集群的 MinIO 客户端别名，默认值：sss。

此别名将被写入管理节点上管理员用户的 MinIO 客户端配置文件中（~/.mcli/config.json），使您可以直接使用 mcli <alias> 命令访问 MinIO 集群，例如 mcli ls sss/。

如果部署多个 MinIO 集群，需要为每个集群指定不同的别名以避免冲突。

`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: meta ,versioning: true }
  - { name: data }

默认创建三个存储桶，各有不同的用途和策略：

pgsql 存储桶：默认用于 PostgreSQL 的 pgBackREST 备份存储。
meta 存储桶：开放式存储桶，启用了版本控制（versioning），适合存储需要版本管理的重要元数据。
data 存储桶：开放式存储桶，用于其他用途，例如 Supabase 模板可能使用此存储桶存储业务数据。

每个存储桶都会创建一个同名的访问策略，例如 pgsql 策略拥有对 pgsql 存储桶的所有权限，以此类推。

您还可以在存储桶定义中添加 lock 标志，启用对象锁定功能，防止存储桶中的对象被意外删除。

`minio_users`

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

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

minio_users:
  - { access_key: pgbackrest  ,secret_key: S3User.Backup ,policy: pgsql }
  - { access_key: s3user_meta ,secret_key: S3User.Meta   ,policy: meta  }
  - { access_key: s3user_data ,secret_key: S3User.Data   ,policy: data  }

默认配置会创建三个用户，分别对应三个默认存储桶：

pgbackrest：用于 PostgreSQL pgBackREST 备份，拥有 pgsql 存储桶的访问权限。
s3user_meta：用于访问 meta 存储桶。
s3user_data：用于访问 data 存储桶。

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

提示：./configure -g 会默认修改配置文件模板中的这些密码，如果这些默认密码出现在模版文件中。

`minio_safeguard`

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

防止意外删除的保险开关，默认值为 false。

如果启用此参数，minio-rm.yml 剧本将中止并拒绝移除 MinIO 集群，从而提供防止意外删除的保护。

建议在生产环境中启用此保险开关，防止误操作导致数据丢失：

minio_safeguard: true   # 启用后，minio-rm.yml 将拒绝执行

`minio_rm_data`

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

移除时是否删除 MinIO 数据？默认值为 true。

当启用时，minio-rm.yml 剧本将在集群移除过程中删除 MinIO 数据目录和配置文件。

`minio_rm_pkg`

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

移除时是否卸载 MinIO 软件包？默认值为 false。

当启用时，minio-rm.yml 剧本将在集群移除过程中卸载 MinIO 软件包。默认禁用此选项，以便保留 MinIO 安装供将来可能的使用。

4 - 预置剧本

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

MinIO 模块提供了两个内置剧本用于集群管理：

minio.yml：用于安装 MinIO 集群
minio-rm.yml：用于移除 MinIO 集群

`minio.yml`

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

minio-id : 生成/校验 minio 身份参数
minio_install : 安装 minio
- minio_os_user : 创建操作系统用户 minio
- minio_pkg : 安装 minio/mcli 软件包
- 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 集群的配置。

架构变更：Pigsty v3.6+

从 Pigsty v3.6 开始，minio.yml 剧本专注于集群安装。所有移除操作已迁移至专用的 minio-rm.yml 剧本，使用 minio_remove 角色执行。

`minio-rm.yml`

剧本 minio-rm.yml 用于移除 MinIO 集群。

minio-id : 生成 minio 身份参数用于移除操作
minio_safeguard : 安全检查，防止意外删除（默认：false）
minio_pause : 暂停 3 秒，允许用户中止操作
minio_deregister : 从 Victoria/Prometheus 监控中移除目标
minio_svc : 停止并禁用 minio systemd 服务
minio_data : 移除 minio 数据目录（可通过 minio_rm_data=false 禁用）
minio_pkg : 卸载 minio 软件包（可通过 minio_rm_pkg=true 启用）

移除剧本使用 minio_remove 角色，支持以下可配置参数：

minio_safeguard：设置为 true 时阻止意外删除
minio_rm_data：控制是否删除 MinIO 数据（默认 true）
minio_rm_pkg：控制是否卸载 MinIO 软件包（默认 false）

命令速查

MINIO 剧本常用命令：

./minio.yml -l <cls>                      # 在 <cls> 分组上安装 MINIO 模块
./minio.yml -l minio -t minio_install     # 在节点上安装 MinIO 服务，准备数据目录，但不配置启动
./minio.yml -l minio -t minio_config      # 重新配置 MinIO 集群
./minio.yml -l minio -t minio_launch      # 重启 MinIO 集群
./minio.yml -l minio -t minio_provision   # 重新执行资源置备（创建存储桶和用户）

./minio-rm.yml -l minio                   # 移除 MinIO 集群（使用专用移除剧本）
./minio-rm.yml -l minio -e minio_rm_data=false  # 移除集群但保留数据
./minio-rm.yml -l minio -e minio_rm_pkg=true    # 移除集群并卸载软件包

保护机制

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

默认情况下，minio_safeguard 为 false，允许执行移除操作。如果您希望保护 MinIO 集群不被意外删除，可以在配置清单中启用此保险：

minio_safeguard: true   # 启用后，minio-rm.yml 将拒绝执行

如果您确实需要移除受保护的集群，可以在执行时使用命令行参数覆盖：

./minio-rm.yml -l minio -e minio_safeguard=false

执行演示

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-rm.yml 剧本即可：

./minio-rm.yml -l minio                   # 移除 MinIO 集群
./minio-rm.yml -l minio -e minio_rm_data=false  # 移除集群但保留数据
./minio-rm.yml -l minio -e minio_rm_pkg=true    # 移除集群并卸载软件包

架构变更：Pigsty v3.6+

从 Pigsty v3.6 开始，集群移除操作已从 minio.yml 剧本迁移至专用的 minio-rm.yml 剧本。旧的 minio_clean 任务已被弃用。

移除剧本会自动完成以下操作：

从 Victoria/Prometheus 监控系统中注销 MinIO 目标
从 INFRA 节点的 DNS 服务中移除记录
停止并禁用 MinIO systemd 服务
删除 MinIO 数据目录和配置文件（可选）
卸载 MinIO 软件包（可选）

集群扩容

集群扩容教程

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 节点的本地软件仓库，然后重建软件仓库索引：

./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 管控界面。

使用 minio_access_key 和 minio_secret_key 配置的管理员凭证登录（默认为 minioadmin / S3User.MinIO）。

注意：HTTPS 与证书信任

MinIO 控制台需要 HTTPS 访问。如果您使用 Pigsty 自签名 CA，需要在浏览器中信任该 CA 证书，或者手动接受安全警告。

Pigsty监控

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

MinIO Overview：展示 MinIO 集群的整体监控指标，包括集群状态、存储使用量、请求速率等。
MinIO Instance：展示单个 MinIO 实例的监控指标详情，包括 CPU、内存、网络、磁盘等。

MinIO 监控指标通过 MinIO 原生的 Prometheus 端点（/minio/v2/metrics/cluster）采集，默认由 Victoria Metrics 抓取并存储。

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 对象存储模块常见问题答疑

Pigsty 使用的 MinIO 是什么版本？

MinIO 于 2025-12-03 宣布进入 维护模式，不再发布新的功能版本，只会发布安全补丁与维护版本，并且在 2025-10-15 停止发布二进制 RPM/DEB。所以 Pigsty fork 了自己的 MinIO，并使用 minio/pkger 制作了最新的 2025-12-03 版本。

这一版本修复了 MinIO CVE-2025-62506 安全漏洞，确保 Pigsty 用户的 MinIO 部署安全可靠。您可以在 Pigsty Infra 仓库中找到 RPM/DEB 包以及构建使用的脚本。

为什么 MinIO 强制要求 HTTPS？

当 pgbackrest 使用对象存储作为备份仓库时，强制要求使用 HTTPS，以确保数据传输的安全性。如果您的 MinIO 并非用于 pgbackrest 备份，您仍然可以选择使用 HTTP 协议。可以通过修改参数 minio_https 来关闭 HTTPS。

从容器中访问 MinIO 提示证书无效？

除非您使用真正的企业 CA 颁发的证书，否则 MinIO 默认使用自签名证书，这会导致容器内的客户端工具（如 mc / rclone / awscli 等）无法验证 MinIO 服务器的身份，从而提示证书无效。

例如，对于 Node.js 应用程序，可以 MinIO 服务器的 CA 证书挂载到容器内，并通过环境变量 NODE_EXTRA_CA_CERTS 指定 CA 证书路径：

    environment:
      NODE_EXTRA_CA_CERTS: /etc/pki/ca.crt
    volumes:
      - /etc/pki/ca.crt:/etc/pki/ca.crt:ro

当然，如果您的 MinIO 没有用作 pgbackrest 备份仓库的话，您也可以选择关闭 MinIO 的 HTTPS 支持，改用 HTTP 协议访问。

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

在 单机多盘 或 多机多盘 模式下，如果数据目录不是有效的磁盘挂载点，MinIO 会拒绝启动。请使用已挂载的磁盘作为 MinIO 的数据目录，而不是普通目录。您只能在 单机单盘 模式下使用普通目录作为 MinIO 的数据目录，仅可用于开发测试或非关键场合。

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

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

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

请注意，MinIO 一旦部署，你无法修改现有集群的节点数量与磁盘数量！只能通过添加新的存储池来扩容。

详细步骤请参考 Pigsty 文档：集群扩容，以及 MinIO 官方文档：扩展 MinIO 部署

如何移除 MinIO 集群？

从 Pigsty v3.6 开始，移除 MinIO 集群需要使用专用的 minio-rm.yml 剧本：

./minio-rm.yml -l minio                   # 移除 MinIO 集群
./minio-rm.yml -l minio -e minio_rm_data=false  # 移除集群但保留数据

如果您启用了 minio_safeguard 保护，需要显式覆盖才能执行移除：

./minio-rm.yml -l minio -e minio_safeguard=false

mcli 命令与 mc 命令有什么区别？

mcli 是 MinIO 官方客户端 mc 的重命名版本。在 Pigsty 中，我们使用 mcli 而不是 mc，以避免与 Midnight Commander（一个常见的文件管理器，也使用 mc 命令）产生冲突。

两者功能完全相同，只是命令名称不同。您可以在 MinIO 客户端文档中找到完整的命令参考。

如何监控 MinIO 集群状态？

Pigsty 为 MinIO 提供了开箱即用的监控能力：

Grafana 面板：MinIO Overview 和 MinIO Instance
告警规则：包括 MinIO 宕机、节点离线、磁盘离线等告警
MinIO 内置控制台：通过 https://<minio-ip>:9001 访问

详情请参阅监控告警文档