TL;DR — Kurzzusammenfassung

Vollständiger MinIO-Leitfaden: Architektur, verteilter Modus, Erasure Coding, IAM, Verschlüsselung, Benachrichtigungen und Docker Compose Produktionsdeployment.

MinIO ist ein hochperformantes, Kubernetes-natives Objektspeichersystem, das die vollständige AWS S3 API implementiert. Dieser Leitfaden behandelt die verteilte Architektur mit Erasure Coding, integriertes IAM, serverseitige Verschlüsselung, Bucket-Benachrichtigungen, Site-Replikation und einen produktionsbereiten Docker Compose Stack mit nginx. Jedes S3-kompatible Tool — boto3, rclone, Terraform, aws CLI — funktioniert mit MinIO, indem nur die Endpoint-URL geändert wird.

Voraussetzungen

  • Linux-Server (Ubuntu 22.04+ oder RHEL 9+) oder Docker 24+.
  • Mindestens 8 GB RAM und dedizierte Laufwerke (nicht das OS-Laufwerk) in der Produktion.
  • Ports 9000 (API) und 9001 (Konsole) erreichbar.
  • Für den verteilten Modus: identische Hardware auf allen Knoten, DNS zur Auflösung jedes Knotennamens und synchronisierte Uhren (NTP).

Architektur: Erasure Coding und Bitrot-Schutz

MinIO speichert Objekte mithilfe von Erasure Coding (Reed-Solomon). Beim Schreiben eines Objekts wird es in N Datenfragmente und M Paritätsfragmente aufgeteilt — zusammen als Erasure Set bezeichnet. Ein 16-Laufwerk-Erasure-Set mit EC:8 liefert 8 Daten + 8 Parität: MinIO kann den gleichzeitigen Verlust von 8 Laufwerken ohne Datenverlust überstehen.

  • Erasure Set — Redundanzeinheit, typischerweise 4–16 Laufwerke.
  • Server-Pool — Gruppe von Knoten, die einen einzigen Namespace bilden. Pools können online hinzugefügt werden, um die Kapazität zu erweitern.
  • Bitrot-Schutz — jedes Fragment hat eine Prüfsumme (HighwayHash); korrupte Fragmente werden automatisch aus der Parität repariert.
  • Inline-Datenverschlüsselung — Objekte werden auf Fragment-Ebene verschlüsselt, bevor sie auf den Datenträger geschrieben werden.

Installationsmethoden

Methode 1: Binary + systemd

wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio && sudo mv minio /usr/local/bin/
sudo useradd -r minio-user -s /sbin/nologin
sudo mkdir -p /data/minio
sudo chown minio-user:minio-user /data/minio

Datei /etc/default/minio:

MINIO_ROOT_USER=minioadmin
MINIO_ROOT_PASSWORD=StarkesPasswort123!
MINIO_VOLUMES="/data/minio"
MINIO_OPTS="--console-address :9001"
sudo systemctl daemon-reload && sudo systemctl enable --now minio

Methode 2: Docker

docker run -d --name minio \
  -p 9000:9000 -p 9001:9001 \
  -e MINIO_ROOT_USER=minioadmin \
  -e MINIO_ROOT_PASSWORD=StarkesPasswort123! \
  -v /data/minio:/data \
  quay.io/minio/minio server /data --console-address ":9001"

Verteilter Modus: Multi-Node Multi-Drive

export MINIO_ROOT_USER=minioadmin
export MINIO_ROOT_PASSWORD=StarkesPasswort123!

minio server \
  http://minio-knoten{1...4}/data/{1...4} \
  --console-address ":9001"

Führen Sie denselben Befehl auf allen Knoten gleichzeitig aus. Die Klammerexpansion {1...4} generiert automatisch die Knoten-/Laufwerksnamen.

mc CLI: Befehlsreferenz

mc alias set myminio https://minio.beispiel.com minioadmin StarkesPasswort123!
Befehl Beschreibung
mc mb myminio/sicherungen Bucket erstellen
mc cp datei.tar.gz myminio/sicherungen/ Datei hochladen
mc mirror /lokales/verz myminio/sicherungen/verz/ Verzeichnis synchronisieren
mc ls myminio/sicherungen Objekte auflisten
mc version enable myminio/sicherungen Versionierung aktivieren
mc ilm add --expiry-days 30 myminio/sicherungen Ablaufregel
mc admin info myminio Cluster-Status
mc admin prometheus generate myminio Prometheus-Konfiguration

Bucket-Verwaltung: Versionierung, Lifecycle und Object Locking

# Versionierung aktivieren
mc version enable myminio/mein-bucket

# Nicht aktuelle Versionen nach 30 Tagen ablaufen lassen
mc ilm add --noncurrentversion-expiration-days 30 myminio/mein-bucket

# WORM-Sperrung (kann nach Aktivierung nicht deaktiviert werden)
mc mb --with-lock myminio/compliance-bucket
mc retention set --default COMPLIANCE "7y" myminio/compliance-bucket

Identitäts- und Zugriffsverwaltung (IAM)

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": ["s3:GetObject", "s3:ListBucket"],
    "Resource": ["arn:aws:s3:::sicherungen", "arn:aws:s3:::sicherungen/*"]
  }]
}
mc admin policy create myminio nur-lesen richtlinie.json
mc admin user add myminio appuser geheimschluessel123
mc admin policy attach myminio nur-lesen --user appuser
mc admin user svcacct add myminio appuser

LDAP-Integration:

export MINIO_IDENTITY_LDAP_SERVER_ADDR="ldap.corp.beispiel.com:389"
export MINIO_IDENTITY_LDAP_USER_DN_SEARCH_FILTER="(uid=%s)"

Serverseitige Verschlüsselung

# SSE-S3: interner Schlüssel
export MINIO_KMS_SECRET_KEY="mein-minio-schluessel:bXltaW5pb2tleXBhc3N3b3JkMTIzNDU2Nzg="
mc encrypt set sse-s3 myminio/mein-bucket

# SSE-KMS mit HashiCorp Vault (über KES)
export MINIO_KMS_KES_ENDPOINT="https://kes.beispiel.com:7373"
export MINIO_KMS_KES_KEY_NAME="minio-hauptschluessel"
mc encrypt set sse-kms minio-hauptschluessel myminio/sensitiver-bucket

Bucket-Benachrichtigungen

# Webhook-Ziel konfigurieren
mc admin config set myminio notify_webhook:1 \
  endpoint="https://hooks.beispiel.com/minio" \
  auth_token="Bearer meintoken"
mc admin service restart myminio
mc event add myminio/mein-bucket arn:minio:sqs::1:webhook --event put,delete

# Kafka-Ziel
mc admin config set myminio notify_kafka:1 \
  brokers="kafka1.beispiel.com:9092" topic="minio-ereignisse"

Site-Replikation und Bucket-Replikation

# Aktiv-Aktiv-Replikation zwischen zwei Clustern
mc admin replicate add site-a site-b

# Bucket-Replikation für Disaster Recovery
mc version enable site-a/wichtiger-bucket
mc replicate add site-a/wichtiger-bucket \
  --remote-bucket https://adminB:passB@minio-b.beispiel.com/bucket-replik \
  --replicate "delete,delete-marker,existing-objects"

Monitoring mit Prometheus und Grafana

mc admin prometheus generate myminio > /etc/prometheus/minio.yml
Metrik Beschreibung
minio_cluster_capacity_usable_free_bytes Nutzbarer freier Speicher
minio_cluster_nodes_online_total Online-Knoten
minio_cluster_drive_offline_total Offline-Laufwerke
minio_s3_requests_total Anfragerate

Importieren Sie das Grafana-Dashboard mit ID 13502.

MinIO vs. Alternativen

Merkmal MinIO Ceph RGW SeaweedFS AWS S3
Vollständige S3 API Ja Ja Teilweise Ja (kanonisch)
Erasure Coding Ja Ja Ja Verwaltet
Installationskomplexität Niedrig Sehr hoch Niedrig Keine
Kubernetes-nativ Ja Teilweise Teilweise N/A
Object Locking (WORM) Ja Ja Nein Ja
Bucket-Benachrichtigungen Ja Begrenzt Nein Ja (SNS)
IAM / OIDC Ja Ja Nein Ja (volles IAM)

Produktions-Docker-Compose mit nginx

services:
  minio:
    image: quay.io/minio/minio:latest
    restart: unless-stopped
    command: server /data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: "${MINIO_ROOT_USER}"
      MINIO_ROOT_PASSWORD: "${MINIO_ROOT_PASSWORD}"
      MINIO_KMS_SECRET_KEY: "${MINIO_KMS_SECRET_KEY}"
    volumes:
      - minio_data:/data
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 30s
    networks:
      - minio_net

  nginx:
    image: nginx:alpine
    ports:
      - "443:443"
      - "9001:9001"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./certs:/etc/nginx/certs:ro
    depends_on:
      minio:
        condition: service_healthy
    networks:
      - minio_net

volumes:
  minio_data:
networks:
  minio_net:

Zusammenfassung

  • MinIO bietet einen vollständigen S3-kompatiblen Objektspeicher-Stack selbst gehostet — Erasure Coding, IAM, SSE, Benachrichtigungen und Replikation.
  • Einzelknoten für Entwicklung; verteilter Modus mit Server-Pools für die Produktion.
  • SSE-KMS + KES für regulierte Workloads, die externe Schlüsselverwaltung erfordern.
  • Object Locking (WORM) im COMPLIANCE-Modus erfüllt SEC 17a-4, FINRA und ähnliche Vorschriften.
  • Monitoring mit Prometheus + Grafana-Dashboard 13502.

Verwandte Artikel