DevOps 12 Min Lesezeit

MinIO Object Storage selbst hosten 2026 – S3-kompatibel auf dem VPS

Was ist MinIO und warum S3-kompatibel selbst hosten 2026?

MinIO ist ein in Go geschriebener, Open-Source-basierter Object Storage Server (Apache-2.0-Lizenz), der die Amazon S3 API vollständig implementiert. Das bedeutet: Jede Anwendung, die mit S3 spricht – sei es Nextcloud, Restic, Borg, Velero, Rclone, GitLab oder eigene Apps über das AWS SDK – funktioniert ohne Änderung auch mit MinIO. Gerade 2026, wo Datenschutz (DSGVO), Kostenkontrolle und Unabhängigkeit von Hyperscalern immer wichtiger werden, ist diese Kompatibilität ein entscheidender strategischer Vorteil.

Im Gegensatz zu klassischen Dateisystemen speichert MinIO Daten als Objekte in flachen Buckets, identisch zu S3. Jedes Objekt erhält einen eindeutigen Schlüssel, Metadaten und – optional – Versioning, Object-Locking und Lifecycle-Regeln. Die Replikation zwischen MinIO-Clustern oder zu AWS S3 ist nativ eingebaut, ebenso Erasure Coding, das Daten selbst bei Ausfall mehrerer Festplatten ohne Datenverlust wiederherstellt.

Für Self-Hoster ist besonders interessant, dass MinIO hardware-agnostisch läuft: Eine einzelne Binary, ein einziger Port (standardmäßig 9000), keine externen Datenbanken, keine komplexen Abhängigkeiten. Selbst auf einem kleinen VPS mit 2 vCPU und 4 GB RAM lassen sich produktive Workloads wie Foto-Backups, Log-Archive oder Nextcloud Primary Storage betreiben. Auf größeren Maschinen skaliert MinIO linear mit der Anzahl der Disks und Nodes.

Die Vorteile gegenüber anderen S3-Alternativen wie Ceph RADOS Gateway oder OpenStack Swift liegen in der Einfachheit: MinIO lässt sich in unter zehn Minuten produktiv deployen, während Ceph ein eigenes Cluster-Setup mit MONs, OSDs und CRUSH-Maps erfordert. Für 90 Prozent der typischen Use-Cases – Backups, statische Inhalte, Container-Registries, KI-Datasets – ist MinIO die pragmatischste Wahl 2026.

Systemvoraussetzungen für MinIO auf einem VPS

Bevor du MinIO installierst, solltest du sicherstellen, dass dein VPS die Mindestanforderungen erfüllt. Für eine Single-Node-Installation reichen bereits 2 vCPU, 4 GB RAM und 50 GB NVMe-Speicher – ideal für Backups und kleinere Anwendungen. Für produktive Workloads mit mehreren Millionen Objekten empfiehlt MinIO mindestens 4 vCPU, 16 GB RAM und dedizierte NVMe-Disks. Die offizielle Empfehlung lautet: Direkt angeschlossener Storage (DAS) statt Netzwerk-Storage, um Latenz zu minimieren.

Als Betriebssystem funktionieren alle gängigen Linux-Distributionen: Ubuntu 22.04/24.04 LTS, Debian 12, Rocky Linux 9 oder AlmaLinux 9. Windows Server wird offiziell nicht für Produktion empfohlen, macOS eignet sich nur als Testplattform. Wichtig ist ein aktueller Kernel (≥ 5.15), damit moderne Storage-Features wie io_uring optimal genutzt werden. Für die Netzwerkanbindung gilt: 1 Gbit/s ausreichend für die meisten Workloads, 10 Gbit/S oder mehr bei großen Datenmengen und Replikation.

Die folgende Tabelle zeigt die empfohlenen Specs je nach Einsatzszenario:

Einsatzszenario CPU RAM Storage Network
Privater Backup-Speicher 2 vCPU 4 GB 500 GB HDD 1 Gbit/s
Kleine Webagentur / CMS 4 vCPU 8 GB 1 TB NVMe 1 Gbit/s
Produktiver Cluster (3 Nodes) 8 vCPU / Node 32 GB / Node 4× 4 TB NVMe / Node 10 Gbit/s
KI / Big-Data Workloads 16+ vCPU 64+ GB 50+ TB NVMe 25 Gbit/s

Beachte: MinIO nutzt aggressive Memory-Mapping-Strategien. Bei vielen kleinen Dateien steigt der RAM-Bedarf linear mit der Anzahl paralleler Verbindungen. Eine Faustregel: 1 GB RAM pro 1.000 aktive gleichzeitige PUT/GET-Operationen. Außerdem sollte die Systemzeit via Chrony oder systemd-timesyncd exakt synchron sein – MinIO lehnt Requests mit Zeitabweichung > 15 Minuten ab, um Replay-Attacken zu verhindern.

MinIO Server installieren (Schritt-für-Schritt)

Die Installation von MinIO ist 2026 bewusst einfach gehalten: ein einzelnes statisches Binary, das du einfach herunterlädst und ausführbar machst. Es gibt keine Pakete in den offiziellen Ubuntu- oder Debian-Repositories, weil MinIO seine eigene Update-Pipeline betreibt. Die empfohlene Methode ist der Download direkt von dl.min.io mit Verifikation via SHA256-Hash und GPG-Signatur.

Melde dich als Root oder mit sudo-Rechten am VPS an und führe die folgenden Befehle aus:

# System aktualisieren
sudo apt update && sudo apt upgrade -y

# MinIO-Binary herunterladen (amd64)
wget https://dl.min.io/server/minio/release/linux-amd64/minio

# Ausführbar machen und nach /usr/local/bin verschieben
chmod +x minio
sudo mv minio /usr/local/bin/

# Version verifizieren
minio --version

Nach dem Download erstellst du einen dedizierten Systembenutzer und die notwendigen Verzeichnisse. Niemals MinIO als Root betreiben – das verstößt gegen die Sicherheits-Empfehlung und verhindert später korrekte Permission-Trennung bei Erasure Coding.

# Benutzer und Gruppe anlegen
sudo groupadd -r minio-user
sudo useradd -r -g minio-user -d /var/lib/minio -s /sbin/nologin minio-user

# Storage-Verzeichnis vorbereiten
sudo mkdir -p /var/lib/minio/data
sudo chown -R minio-user:minio-user /var/lib/minio
sudo chmod 750 /var/lib/minio

# Konfigurations-Verzeichnis für TLS etc.
sudo mkdir -p /etc/minio
sudo chown minio-user:minio-user /etc/minio

Optional kannst du das MinIO Client Tool mc installieren – das ist das offizielle CLI-Äquivalent zur AWS CLI und unverzichtbar für die tägliche Administration:

wget https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x mc
sudo mv mc /usr/local/bin/
mc --version

Bei ARM-basierten VPS (z. B. Ampere Altra, AWS Graviton, Oracle ARM) ersetzt du linux-amd64 durch linux-arm64. Für ältere 32-bit-Systeme gibt es entsprechende Builds. Nach der Installation testest du den Server mit einem manuellen Start, bevor du den Systemd-Service einrichtest – so lassen sich Konfigurationsfehler schnell eingrenzen.

MinIO als Systemd-Service einrichten

Ein produktiver MinIO-Server läuft 24/7 als Systemd-Service mit automatischem Neustart, Resource-Limits und Log-Rotation. Systemd ist auf allen aktuellen Linux-Distributionen Standard und ermöglicht sauberes Dependency-Management: MinIO startet erst, wenn Netzwerk und Storage verfügbar sind. Eine eigene Service-Unit sorgt zudem dafür, dass Umgebungsvariablen, Pfade und Limits reproduzierbar gesetzt werden.

Erstelle zunächst die Environment-Datei /etc/default/minio. Diese enthält alle sensiblen Konfigurationsparameter wie Root-User, Passwort, Data-Directory und Listen-Adresse – getrennt vom Service-File, damit Updates die Konfiguration nicht überschreiben:

sudo nano /etc/default/minio

Inhalt der Datei:

# MinIO-Server-Konfiguration
MINIO_ROOT_USER="admin"
MINIO_ROOT_PASSWORD="supersecure-passwort-mindestens-8-zeichen"
MINIO_VOLUMES="/var/lib/minio/data"
MINIO_OPTS="--console-address :9001 --address :9000"
MINIO_SERVER_URL="https://minio.example.com"

Wähle ein starkes Passwort mit mindestens 16 Zeichen, am besten ein zufällig generiertes: openssl rand -base64 24. Die Variable MINIO_SERVER_URL ist wichtig für korrekte Redirects in der Web-Konsole und für signierte URLs. Die Web-Konsole (MinIO Browser UI) läuft standardmäßig auf Port 9001, der API-Endpunkt auf 9000.

Danach erstellst du die Systemd-Unit /etc/systemd/system/minio.service:

[Unit]
Description=MinIO Object Storage
Documentation=https://docs.min.io
Wants=network-online.target
After=network-online.target
AssertFileIsExecutable=/usr/local/bin/minio

[Service]
Type=notify
WorkingDirectory=/usr/lib/minio
User=minio-user
Group=minio-user
EnvironmentFile=/etc/default/minio
ExecStart=/usr/local/bin/minio server $MINIO_OPTS $MINIO_VOLUMES
Restart=always
RestartSec=5
LimitNOFILE=65536
TasksMax=infinity
TimeoutStopSec=infinity
SendSIGKILL=no

[Install]
WantedBy=multi-user.target

Aktiviere und starte den Service:

sudo systemctl daemon-reload
sudo systemctl enable --now minio
sudo systemctl status minio

Mit journalctl -u minio -f verfolgst du die Logs in Echtzeit. Ein erfolgreicher Start zeigt Server listening on :9000 und Console listening on :9001. Sollte der Service nicht starten, prüfe zunächst Permissions, Pfade und das Environment-File. Häufige Fehler sind fehlende Quotes im Passwort oder falsche Pfade in MINIO_VOLUMES.

Buckets erstellen und Benutzer verwalten

Nach dem ersten Start kannst du dich auf der Web-Konsole unter http://deine-vps-ip:9001 mit MINIO_ROOT_USER und MINIO_ROOT_PASSWORD einloggen. Die Konsole ist funktional aufgebaut: links die Navigation (Buckets, Users, Settings), oben ein Drag-and-Drop-Bereich für Uploads, in der Mitte eine Explorer-Ansicht ähnlich dem AWS S3 Console. Der Root-Account hat volle administrative Rechte – im Produktivbetrieb solltest du zeitnah dedizierte Service-User mit minimalen Rechten anlegen.

Über die Web-Konsole legst du Buckets an, vergibst Policies, erstellst Access Keys und verwaltest Lifecycle-Regeln. Alternativ funktioniert alles auch über die CLI mit mc, was für Skripting und Automation deutlich besser geeignet ist. Zuerst konfigurierst du den Alias für deinen Server:

mc alias set myminio https://minio.example.com admin 'supersecure-passwort'

Anschließend erstellst du einen neuen Bucket – z. B. für tägliche Backups:

mc mb myminio/backup-prod
mc anonymous set none myminio/backup-prod
mc version enable myminio/backup-prod

Versioning ist besonders für Backup-Buckets essenziell: Es verhindert Datenverlust durch versehentliches Überschreiben oder Ransomware. Beachte aber, dass Versioning den Storage-Verbrauch deutlich erhöhen kann – plane eine Lifecycle-Policy ein, die alte Versionen nach 30 oder 90 Tagen automatisch löscht.

Für Anwendungen empfiehlt sich das Prinzip der minimalen Rechte. Lege pro Service einen eigenen User mit eigenem Access Key an:

# Benutzer anlegen
mc admin user add myminio backup-user 'BackupService2026!'

# Policy erstellen (nur Zugriff auf backup-prod)
cat > /tmp/backup-policy.json << 'EOF'
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject", "s3:PutObject", "s3:ListBucket", "s3:DeleteObject"],
      "Resource": ["arn:aws:s3:::backup-prod", "arn:aws:s3:::backup-prod/*"]
    }
  ]
}
EOF

mc admin policy attach myminio readwrite-backup --user backup-user

Access Keys für Service-User erzeugst du ebenfalls über die Konsole oder per CLI. Wichtig: MinIO unterscheidet zwischen Root Credentials (volle Admin-Rechte) und Service Accounts (eingeschränkte Rechte, abgeleitet von einem STS-Token). Service Accounts sind sicherer, weil sie kurzlebige Token tragen und feingranular pro Bucket vergeben werden können.

S3-API mit AWS CLI und SDKs testen

Der entscheidende Vorteil von MinIO ist die vollständige S3-Kompatibilität. Du kannst die AWS CLI, boto3 (Python), das AWS SDK for JavaScript oder jeden anderen S3-Client direkt gegen deinen selbst gehosteten MinIO-Server nutzen. Das macht Migrationen zwischen AWS S3 und MinIO trivial: In vielen Fällen reicht es, den Endpoint und die Credentials zu ändern

Docker Compose auf dem VPS: Webserver, Datenbank & Reverse Proxy richtig betreiben
DevOps 02. June 2026 10 Min

Docker Compose auf dem VPS: Webserver, Datenbank & Reverse Proxy richtig betreiben

Praxisnaher Guide für Docker Compose auf dem VPS: Webserver, Datenbank, Reverse Proxy, TLS, Backups, Updates und Sicherheit richtig planen und betreiben.

Weiterlesen →

📖 Ähnliche Artikel