MinIO Deployment & Automation Scripts: Standalone & Distributed Setup Guide

MinIO is an open-source object storage service compatible with the Amazon S3 API, providing lightweight private cloud storage that runs as a single binary on Linux, macOS, and Windows. It supports massive file storage (images, videos, logs, backups) and integrates with middleware like Kafka and Spark for both development and production archiving.

Core Concepts

Key MinIO concepts mapped to familiar analogies:

Bucket – basic storage unit for categorizing files, similar to a folder with finer permission control.

Object – actual file stored in MinIO, including content, name, and metadata (size, format).

Access Key – like a username for verifying access permissions.

Secret Key – like a password paired with Access Key for secure access.

MinIO Server – core service handling upload, download, delete requests.

MinIO Client – tool for operating the server via CLI, Web UI, or API.

Deployment Preparation

MinIO requires no Java dependency (Go-based). Minimum requirements:

OS: CentOS 7.x/RHEL 7.x, Ubuntu 18.04+, macOS 10.15+ (Windows via Linux commands).

Memory: ≥1 GB (2 GB recommended).

Disk: ≥10 GB free (more for production).

Ports: 9000 (service) and 9001 (Web console) must be free.

Environment Check Script

A Bash script check-minio-env.sh validates OS, memory, ports, and disk space on Linux/macOS. It uses colored logging (INFO/SUCCESS/WARNING/ERROR), detects OS type (macOS via OSTYPE, Linux via /etc/os-release), checks memory with free -g (Linux) or sysctl hw.memsize (macOS), verifies ports 9000/9001 with ss (Linux) or lsof (macOS), and reports disk availability via df. The script exits on any failure.

#!/bin/bash
# check-minio-env.sh - Minio deployment environment quick check (Linux/macOS)
echo "Minio 部署环境检查"
echo "========================"
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'
log_info() { echo -e "${BLUE}[INFO]${NC}$1"; }
log_success() { echo -e "${GREEN}[SUCCESS]${NC}$1"; }
log_warn() { echo -e "${YELLOW}[WARNING]${NC}$1"; }
log_error() { echo -e "${RED}[ERROR]${NC}$1"; }
# 1. OS detection
OS="Unknown"
if [[ "$OSTYPE" == "darwin"* ]]; then
  OS="macOS"
  VER=$(sw_vers -productVersion)
elif [ -f /etc/redhat-release ]; then
  OS="CentOS"
  VER=$(grep -o '[0-9]\.[0-9]' /etc/redhat-release | head -1)
elif [ -f /etc/debian_version ]; then
  OS="Ubuntu"
  VER=$(cat /etc/debian_version)
elif [ -f /etc/os-release ]; then
  OS=$(grep "^NAME=" /etc/os-release | cut -d'"' -f2)
  VER=$(grep "^VERSION_ID=" /etc/os-release | cut -d'"' -f2)
fi
log_info "系统: $OS$VER"
# 2. Memory check
MEM_GB=0
if [[ "$OS" == "macOS" ]]; then
  MEM_GB=$((($(sysctl hw.memsize | awk '{print $2}') / 1024 / 1024 / 1024)))
else
  if command -v free &>/dev/null; then
    MEM_GB=$(free -g | awk '/^Mem:/{print $2}')
  else
    log_error "free命令未找到，无法检查内存"
    exit 1
  fi
fi
if [ -n "$MEM_GB" ] && [ "$MEM_GB" -ge 2 ]; then
  log_success "内存: ${MEM_GB}GB (优秀，推荐)"
elif [ -n "$MEM_GB" ] && [ "$MEM_GB" -ge 1 ]; then
  log_success "内存: ${MEM_GB}GB (够用，测试环境可用)"
else
  log_error "内存不足（至少需要1GB），无法部署"
  exit 1
fi
# 3. Port check
check_port() {
  local port=$1
  local port_name=$2
  if [[ "$OS" == "macOS" ]]; then
    if ! lsof -i :$port -P -n | grep LISTEN > /dev/null 2>&1; then
      log_success "端口 $port ($port_name): 可用"
    else
      log_error "端口 $port ($port_name): 被占用"
      PID=$(lsof -ti:$port | head -1)
      if [ ! -z "$PID" ]; then
        echo "      占用进程PID: $PID"
        echo "      进程名: $(ps -p $PID -o comm= 2>/dev/null || echo '未知')"
        echo "      建议关闭进程后重新部署，关闭命令: kill -9 $PID"
      fi
      exit 1
    fi
  else
    if ! ss -tln | grep ":$port " > /dev/null; then
      log_success "端口 $port ($port_name): 可用"
    else
      log_error "端口 $port ($port_name): 被占用"
      PID=$(lsof -ti:$port 2>/dev/null | head -1)
      if [ ! -z "$PID" ]; then
        echo "      占用进程PID: $PID"
        echo "      进程名: $(ps -p $PID -o comm= 2>/dev/null || echo '未知')"
        echo "      建议关闭进程后重新部署，关闭命令: kill -9 $PID"
      fi
      exit 1
    fi
  fi
}
log_info "端口检查:"
check_port 9000 "Minio服务端口"
check_port 9001 "Minio Web管理端口"
# 4. Disk space
DISK_NEED=10
DISK_FREE=0
if [[ "$OS" == "macOS" ]]; then
  DISK_FREE=$(df -g / | awk 'NR==2{print $4}')
else
  DISK_FREE=$(df -BG / | awk 'NR==2{print $4}' | sed 's/G//')
fi
if [ -n "$DISK_FREE" ] && [ "$DISK_FREE" -ge "$DISK_NEED" ]; then
  log_success "磁盘: ${DISK_FREE}GB 可用 (足够)"
else
  log_warn "磁盘: ${DISK_FREE}GB 可用 (建议清理空间，至少保留10GB)"
fi
echo "========================"
log_success "环境检查通过，可使用本地已下载的Minio包进行部署！"

Binary Download

Two download modes:

Offline (air-gapped) : Download on a machine with internet, then transfer via scp, sftp, or USB. Official URLs: https://dl.min.io/server/minio/release/linux-amd64/minio, linux-arm64, darwin-amd64, darwin-arm64. Use curl -L -o minio <url> and chmod +x minio.

Online : Directly on target server. Check architecture with uname -m, then curl the matching binary. For slow downloads, replace dl.min.io with dl.minio.org.cn.

Standalone Deployment

Single-node setup for dev/test/small production:

Create install directory ( /usr/local/minio Linux, ~/Applications/minio macOS).

Place binary and chmod +x.

Create storage directory ( /data/minio or ~/Applications/minio/data) with chmod 777.

Set credentials via environment variables: export MINIO_ROOT_USER=admin, export MINIO_ROOT_PASSWORD=12345678 (min 8 chars).

Start in background:

nohup /usr/local/minio/minio server /data/minio --console-address ":9001" &

(Linux) or equivalent on macOS.

Verify: ps -ef | grep minio, tail -f nohup.out, or open Web UI at http://<IP>:9001.

Permanent Configuration (Recommended)

Persist credentials and enable auto-start:

Linux : Append exports to /etc/profile, source /etc/profile. Create systemd unit /etc/systemd/system/minio.service with

ExecStart=/usr/local/minio/minio server /data/minio --console-address ":9001"

, then

systemctl daemon-reload && systemctl enable minio && systemctl start minio

.

macOS : Append exports to ~/.bash_profile, source ~/.bash_profile. Add login item via System Preferences → Users & Groups → Login Items pointing to a startup script.

Automation Script: deploy-minio.sh

A comprehensive Bash script supporting both standalone and distributed modes, using local binaries (no internet required). Key features:

Command-line arguments: -m standalone|distributed, -d install_dir, -b binary_path, -u access_key, -p secret_key, -P service_port, -c console_port, -s storage_dir, -n nodes_csv (distributed), -f force, -y auto-confirm.

OS detection (Linux/macOS) and distro identification.

Checks for required commands ( ps, grep, awk, mkdir, chmod, ln plus ss, systemctl, lsof on Linux; lsof, sysctl on macOS).

Validates local binary existence and executable permission.

Port availability check for service and console ports.

Standalone flow : configures storage dir, writes credentials to /etc/profile (Linux) or ~/.bash_profile (macOS), generates systemd unit (Linux) or background nohup (macOS), starts service, verifies active status.

Distributed flow : requires ≥4 nodes (comma-separated IPs). Creates two storage subdirectories per node ( storage_dir/{1,2}), builds node storage URLs (

http://<node><storage_dir>/1 http://<node><storage_dir>/2

), configures systemd with the combined node list, starts service, and instructs to run same script on all nodes.

#!/bin/bash
# Minio 一键自动化部署脚本（支持单机/分布式，兼容Linux/macOS，内网适配）
set -e
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'
log_info() { echo -e "${BLUE}[INFO]${NC}$1"; }
log_success() { echo -e "${GREEN}[SUCCESS]${NC}$1"; }
log_warn() { echo -e "${YELLOW}[WARNING]${NC}$1"; }
log_error() { echo -e "${RED}[ERROR]${NC}$1"; }
show_help() { cat << EOF
Minio 一键自动化部署脚本（支持单机/分布式，内网本地包版）
使用方法: $0 [选项]
核心选项（必选）:
  -m, --mode MODE           指定部署模式（standalone=单机，distributed=分布式）
  -d, --directory PATH      指定Minio安装目录（必填，需提前将Minio包上传至此目录）
  -b, --binary PATH         指定Minio本地二进制包路径（必填，内网适配）
可选选项:
  -u, --user USER           指定访问密钥（默认: admin）
  -p, --password PASSWORD   指定秘密密钥（默认: 12345678，至少8位）
  -P, --port PORT           指定服务端口（默认: 9000）
  -c, --console-port PORT   指定Web控制台端口（默认: 9001）
  -s, --storage PATH        指定存储目录（默认: 安装目录/data）
  -n, --nodes NODES         分布式集群节点（格式：IP1,IP2,IP3,IP4，仅分布式模式需要）
  -f, --force               强制重新安装（覆盖现有文件）
  -y, --yes                 自动确认所有提示
  -h, --help                显示此帮助信息
示例:
  # 单机部署（推荐新手/测试环境，内网本地包）
  $0 -m standalone -d /usr/local/minio -b /usr/local/minio/minio -u admin -p 12345678
  # 单机部署（快速测试，默认密钥，内网本地包）
  $0 -m standalone -d ~/minio-test -b ~/minio-test/minio -y
  # 分布式部署（生产环境，4节点集群，内网本地包）
  $0 -m distributed -d /usr/local/minio -b /usr/local/minio/minio -n 192.168.1.10,192.168.1.11,192.168.1.12,192.168.1.13 -y
注意:
  1. 分布式模式至少需要4个节点，节点之间需能互相通信（关闭防火墙）；
  2. 秘密密钥至少8位，生产环境建议使用复杂密码（字母+数字+符号）；
  3. 自动配置Systemd开机自启（Linux专属），Mac系统需手动设置登录项；
  4. 脚本会自动检查环境、校验本地包是否存在，无需手动操作，适配内网；
  5. 需提前将Minio二进制包上传至服务器，通过-b选项指定包路径。
EOF
  exit 0
}
detect_os() {
  OS="$(uname -s)"
  case "$OS" in
    Linux*) OS_TYPE="Linux" ;;
    Darwin*) OS_TYPE="macOS" ;;
    *) OS_TYPE="UNKNOWN" ;;
  esac
  if [ -f /etc/os-release ]; then
    . /etc/os-release
    DISTRO="$ID"
    DISTRO_VERSION="$VERSION_ID"
  elif [ -f /etc/redhat-release ]; then
    DISTRO="rhel"
    DISTRO_VERSION=$(cat /etc/redhat-release | sed -E 's/.*release ([0-9]+).*/\1/')
  elif [ -f /etc/debian_version ]; then
    DISTRO="debian"
    DISTRO_VERSION=$(cat /etc/debian_version)
  else
    DISTRO="unknown"
    DISTRO_VERSION="unknown"
  fi
  log_info "操作系统: $OS_TYPE, 发行版: $DISTRO$DISTRO_VERSION"
  if [ "$OS_TYPE" = "UNKNOWN" ]; then
    log_error "不支持当前操作系统，仅支持Linux和macOS"
    exit 1
  fi
}
check_local_binary() {
  local binary_path=$1
  log_info "检查本地Minio二进制包: $binary_path"
  if [ ! -f "$binary_path" ]; then
    log_error "本地Minio包不存在，请确认路径正确，或先将包上传至对应目录"
    exit 1
  fi
  if [ ! -x "$binary_path" ]; then
    log_info "本地Minio包无执行权限，正在添加..."
    chmod +x "$binary_path"
    log_success "本地Minio包执行权限添加完成"
  fi
  log_success "本地Minio包检查通过"
}
check_basic_commands() {
  log_info "检查系统基础命令..."
  local missing_cmds=()
  for cmd in "ps" "grep" "awk" "mkdir" "chmod" "ln"; do
    if ! command -v $cmd &>/dev/null; then
      missing_cmds+=("$cmd")
      log_error "$cmd 命令未找到！"
    fi
  done
  if [ "$OS_TYPE" = "Linux" ]; then
    for cmd in "ss" "systemctl" "lsof"; do
      if ! command -v $cmd &>/dev/null; then
        missing_cmds+=("$cmd")
        log_error "$cmd 命令未找到！"
      fi
    done
  fi
  if [ "$OS_TYPE" = "macOS" ]; then
    for cmd in "lsof" "sysctl"; do
      if ! command -v $cmd &>/dev/null; then
        missing_cmds+=("$cmd")
        log_error "$cmd 命令未找到！"
      fi
    done
  fi
  if [ ${#missing_cmds[@]} -gt 0 ]; then
    log_error "缺少必要的系统命令: ${missing_cmds[*]}，请手动安装后重新运行脚本"
    exit 1
  fi
  log_success "系统基础命令检查通过"
}
check_port() {
  local port=$1
  local port_name=$2
  log_info "检查端口 $port ($port_name) 是否可用..."
  if [ "$OS_TYPE" = "Linux" ]; then
    if ss -tuln 2>/dev/null | grep -q ":${port} "; then
      log_error "端口 $port ($port_name) 已被占用，无法部署"
      PID=$(lsof -ti:$port 2>/dev/null | head -1)
      if [ ! -z "$PID" ]; then
        echo "      占用进程PID: $PID"
        echo "      进程名: $(ps -p $PID -o comm= 2>/dev/null || echo '未知')"
      fi
      exit 1
    fi
  elif [ "$OS_TYPE" = "macOS" ]; then
    if lsof -Pi :$port -sTCP:LISTEN -t >/dev/null 2>&1; then
      log_error "端口 $port ($port_name) 已被占用，无法部署"
      PID=$(lsof -ti:$port | head -1)
      if [ ! -z "$PID" ]; then
        echo "      占用进程PID: $PID"
        echo "      进程名: $(ps -p $PID -o comm= 2>/dev/null || echo '未知')"
      fi
      exit 1
    fi
  fi
  log_success "端口 $port ($port_name) 可用"
}
deploy_standalone() {
  local install_dir=$1 binary_path=$2 access_key=$3 secret_key=$4 service_port=$5 console_port=$6 storage_dir=$7
  log_info "开始Minio单机部署，部署目录: $install_dir，本地包路径: $binary_path"
  check_local_binary "$binary_path"
  if [ -z "$storage_dir" ]; then storage_dir="$install_dir/data"; fi
  mkdir -p "$storage_dir"
  chmod 777 "$storage_dir"
  log_info "存储目录配置完成: $storage_dir"
  if [ "$OS_TYPE" = "Linux" ]; then
    if ! grep -q "MINIO_ROOT_USER=$access_key" /etc/profile; then
      sudo echo "export MINIO_ROOT_USER=$access_key" >> /etc/profile
    fi
    if ! grep -q "MINIO_ROOT_PASSWORD=$secret_key" /etc/profile; then
      sudo echo "export MINIO_ROOT_PASSWORD=$secret_key" >> /etc/profile
    fi
    source /etc/profile
  elif [ "$OS_TYPE" = "macOS" ]; then
    if ! grep -q "MINIO_ROOT_USER=$access_key" ~/.bash_profile; then
      echo "export MINIO_ROOT_USER=$access_key" >> ~/.bash_profile
    fi
    if ! grep -q "MINIO_ROOT_PASSWORD=$secret_key" ~/.bash_profile; then
      echo "export MINIO_ROOT_PASSWORD=$secret_key" >> ~/.bash_profile
    fi
    source ~/.bash_profile
  fi
  log_success "永久密钥配置完成，访问密钥: $access_key"
  if [ "$OS_TYPE" = "Linux" ]; then
    sudo tee /etc/systemd/system/minio.service > /dev/null << EOF
[Unit]
Description=MinIO Server
Documentation=https://min.io/docs/minio/linux/index.html
After=network.target
[Service]
User=root
Group=root
Environment="MINIO_ROOT_USER=$access_key"
Environment="MINIO_ROOT_PASSWORD=$secret_key"
ExecStart=$binary_path server $storage_dir --console-address ":$console_port"
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
EOF
    sudo systemctl daemon-reload
    sudo systemctl enable minio
    sudo systemctl start minio
    sleep 3
    if sudo systemctl is-active --quiet minio; then
      log_success "Minio服务启动成功，已设置开机自启"
    else
      log_error "Minio服务启动失败，请查看日志: sudo journalctl -u minio"
      exit 1
    fi
  elif [ "$OS_TYPE" = "macOS" ]; then
    nohup $binary_path server $storage_dir --console-address ":$console_port" &
    sleep 3
    if ps -ef | grep "$binary_path" | grep -v grep &>/dev/null; then
      log_success "Minio服务启动成功（Mac后台启动）"
    else
      log_error "Minio服务启动失败，请查看nohup.out日志"
      exit 1
    fi
  fi
  log_success "Minio单机部署完成（内网本地包版）！"
  log_info "服务端口: $service_port，Web控制台端口: $console_port"
  log_info "登录账号: $access_key，登录密码: $secret_key"
  log_info "Web访问地址: http://$(hostname -I | awk '{print $1}'):$console_port（Linux）"
  log_info "Web访问地址: http://localhost:$console_port（Mac）"
}
deploy_distributed() {
  local install_dir=$1 binary_path=$2 access_key=$3 secret_key=$4 service_port=$5 console_port=$6 storage_dir=$7 nodes=$8
  IFS=',' read -r -a nodes_arr <<< "$nodes"
  if [ ${#nodes_arr[@]} -lt 4 ]; then
    log_error "分布式集群至少需要4个节点，当前节点数: ${#nodes_arr[@]}"
    exit 1
  fi
  log_info "开始Minio分布式部署，节点数: ${#nodes_arr[@]}，本地包路径: $binary_path"
  check_local_binary "$binary_path"
  if [ -z "$storage_dir" ]; then storage_dir="$install_dir/data"; fi
  mkdir -p "$storage_dir/{1,2}"
  chmod 777 "$storage_dir" -R
  log_info "存储目录配置完成: $storage_dir/{1,2}"
  sudo echo "export MINIO_ROOT_USER=$access_key" >> /etc/profile
  sudo echo "export MINIO_ROOT_PASSWORD=$secret_key" >> /etc/profile
  source /etc/profile
  log_success "永久密钥配置完成，访问密钥: $access_key"
  local node_storage_paths=""
  for node in "${nodes_arr[@]}"; do
    node_storage_paths+="http://$node$storage_dir/1 http://$node$storage_dir/2 "
  done
  sudo tee /etc/systemd/system/minio.service > /dev/null << EOF
[Unit]
Description=MinIO Server
Documentation=https://min.io/docs/minio/linux/index.html
After=network.target
[Service]
User=root
Group=root
Environment="MINIO_ROOT_USER=$access_key"
Environment="MINIO_ROOT_PASSWORD=$secret_key"
ExecStart=$binary_path server $node_storage_paths --console-address ":$console_port"
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
EOF
  sudo systemctl daemon-reload
  sudo systemctl enable minio
  sudo systemctl start minio
  sleep 5
  if sudo systemctl is-active --quiet minio; then
    log_success "Minio集群节点启动成功，已设置开机自启"
  else
    log_error "Minio集群节点启动失败，请查看日志: sudo journalctl -u minio"
    exit 1
  fi
  log_success "Minio分布式节点部署完成（内网本地包版）！"
  log_info "当前节点IP: $(hostname -I | awk '{print $1}')"
  log_info "Web控制台端口: $console_port，访问地址: http://$(hostname -I | awk '{print $1}'):$console_port"
  log_info "请在其他所有节点执行相同脚本，完成集群部署"
  log_info "集群验证：所有节点启动后，访问任意节点Web界面，查看集群状态"
}
parse_args() {
  MODE=""
  INSTALL_DIR=""
  BINARY_PATH=""
  ACCESS_KEY="admin"
  SECRET_KEY="12345678"
  SERVICE_PORT="9000"
  CONSOLE_PORT="9001"
  STORAGE_DIR=""
  NODES=""
  FORCE=false
  AUTO_CONFIRM=false
  while [[ $# -gt 0 ]]; do
    case "$1" in
      -m|--mode) MODE="$2"; shift 2 ;;
      -d|--directory) INSTALL_DIR="$2"; shift 2 ;;
      -b|--binary) BINARY_PATH="$2"; shift 2 ;;
      -u|--user) ACCESS_KEY="$2"; shift 2 ;;
      -p|--password) SECRET_KEY="$2"; shift 2 ;;
      -P|--port) SERVICE_PORT="$2"; shift 2 ;;
      -c|--console-port) CONSOLE_PORT="$2"; shift 2 ;;
      -s|--storage) STORAGE_DIR="$2"; shift 2 ;;
      -n|--nodes) NODES="$2"; shift 2 ;;
      -f|--force) FORCE=true; shift 1 ;;
      -y|--yes) AUTO_CONFIRM=true; shift 1 ;;
      -h|--help) show_help ;;
      *) log_error "未知选项: $1"; show_help ;;
    esac
  done
  if [ -z "$MODE" ] || [ -z "$INSTALL_DIR" ] || [ -z "$BINARY_PATH" ]; then
    log_error "缺少必选参数！部署模式、安装目录、本地包路径为必填项"
    show_help
  fi
  if [ "$MODE" != "standalone" ] && [ "$MODE" != "distributed" ]; then
    log_error "部署模式错误！仅支持standalone（单机）和distributed（分布式）"
    exit 1
  fi
  if [ "$MODE" = "distributed" ] && [ -z "$NODES" ]; then
    log_error "分布式模式需指定节点列表（-n/--nodes），格式：IP1,IP2,IP3,IP4"
    exit 1
  fi
  if [ ${#SECRET_KEY} -lt 8 ]; then
    log_error "秘密密钥至少8位，请重新指定"
    exit 1
  fi
}
main() {
  echo -e "${BLUE}===================================================${NC}"
  echo -e "${BLUE}Minio 一键自动化部署脚本（内网本地包版）${NC}"
  echo -e "${BLUE}===================================================${NC}"
  echo
  parse_args "$@"
  detect_os
  check_basic_commands
  check_port "$SERVICE_PORT" "Minio服务端口"
  check_port "$CONSOLE_PORT" "Minio Web控制台端口"
  if [ "$MODE" = "standalone" ]; then
    deploy_standalone "$INSTALL_DIR" "$BINARY_PATH" "$ACCESS_KEY" "$SECRET_KEY" "$SERVICE_PORT" "$CONSOLE_PORT" "$STORAGE_DIR"
  elif [ "$MODE" = "distributed" ]; then
    deploy_distributed "$INSTALL_DIR" "$BINARY_PATH" "$ACCESS_KEY" "$SECRET_KEY" "$SERVICE_PORT" "$CONSOLE_PORT" "$STORAGE_DIR" "$NODES"
  fi
}
main "$@"

Kafka Interview Q&A (Appendix)

The article concludes with a review of Kafka fundamentals:

What is Kafka? A distributed streaming platform for high-throughput real-time data pipelines and streaming apps. Three core capabilities: pub/sub messaging, fault-tolerant storage, real-time stream processing.

Deployment conditions? Requires Java (JDK 8/11). Pre-2.8 needs ZooKeeper; 2.8+ supports KRaft mode (metadata managed by Kafka itself, simpler architecture). Hardware: ≥4 GB RAM (8 GB+ recommended), SSD, multi-core CPU.

Components? Topic, Producer, Consumer, Broker. Additional deep-dive: Partitions enable horizontal scaling and parallelism (consumer group max parallelism = partition count); Consumer Groups provide load balancing and horizontal scaling; Replicas (Leader/Follower) ensure high availability with automatic failover in seconds.