MinIO installieren - S3-kompatibler Object Storage | Blog

MinIO ist ein hochperformanter, S3-kompatibler Object Storage. Sie können ihn selbst hosten und als Alternative zu Amazon S3 für Backups, Medien und Anwendungsdaten nutzen.

Warum MinIO?

Vorteile

- 100% S3-kompatibel
- Hochperformant (Go-basiert)
- Einfache Installation
- Web-Konsole integriert
- Kubernetes-ready
- Kostenlos (Open Source)

Anwendungsfälle

- Backup-Speicher
- Medien-Storage für Webanwendungen
- Data Lake
- Container Registry Storage
- Nextcloud External Storage
- GitLab/GitLab Artifacts

Installation

Single-Node (Standalone)

# Binary herunterladen
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
mv minio /usr/local/bin/

# Datenverzeichnis erstellen
mkdir -p /data/minio

Mit Docker

docker run -d \
  --name minio \
  -p 9000:9000 \
  -p 9001:9001 \
  -e MINIO_ROOT_USER=admin \
  -e MINIO_ROOT_PASSWORD=sicheres-passwort \
  -v /data/minio:/data \
  minio/minio server /data --console-address ":9001"

Docker Compose

# docker-compose.yml

version: '3.8'

services:
  minio:
    image: minio/minio
    ports:
      - "9000:9000"
      - "9001:9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: sicheres-passwort-min-8-zeichen
    volumes:
      - minio-data:/data
    command: server /data --console-address ":9001"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

volumes:
  minio-data:

docker compose up -d

Systemd-Service

Service-Datei erstellen

# /etc/systemd/system/minio.service

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

[Service]
User=minio-user
Group=minio-user
EnvironmentFile=/etc/minio/minio.env
ExecStart=/usr/local/bin/minio server /data/minio --console-address ":9001"
Restart=always
LimitNOFILE=65536
TimeoutStopSec=infinity
SendSIGKILL=no

[Install]
WantedBy=multi-user.target

Umgebungsvariablen

# /etc/minio/minio.env

MINIO_ROOT_USER=admin
MINIO_ROOT_PASSWORD=sicheres-passwort-min-8-zeichen
MINIO_VOLUMES="/data/minio"
MINIO_OPTS="--console-address :9001"

Benutzer und Berechtigungen

useradd -r minio-user
mkdir -p /data/minio
chown minio-user:minio-user /data/minio
mkdir -p /etc/minio
chmod 600 /etc/minio/minio.env

Service starten

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

Web-Konsole

Zugriff

URL: http://server-ip:9001
Benutzer: admin
Passwort: (aus Konfiguration)

Funktionen

- Buckets erstellen/verwalten
- Dateien hochladen/herunterladen
- Benutzer und Zugriffsrechte
- Monitoring und Metriken

MinIO Client (mc)

Installation

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

Server hinzufügen (Alias)

mc alias set myminio http://localhost:9000 admin sicheres-passwort

Grundlegende Befehle

# Buckets auflisten
mc ls myminio

# Bucket erstellen
mc mb myminio/my-bucket

# Datei hochladen
mc cp myfile.txt myminio/my-bucket/

# Dateien auflisten
mc ls myminio/my-bucket/

# Datei herunterladen
mc cp myminio/my-bucket/myfile.txt ./

# Verzeichnis synchronisieren
mc mirror /local/path myminio/my-bucket

# Datei löschen
mc rm myminio/my-bucket/myfile.txt

# Bucket löschen (muss leer sein)
mc rb myminio/my-bucket

Erweiterte Befehle

# Rekursives Auflisten
mc ls -r myminio/my-bucket

# Statistiken
mc stat myminio/my-bucket/myfile.txt

# Diff zwischen lokal und remote
mc diff /local/path myminio/my-bucket

# Events überwachen
mc watch myminio/my-bucket

Benutzer und Zugriffsrechte

Benutzer erstellen

mc admin user add myminio newuser userpassword

Policy erstellen

// readwrite-policy.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:PutObject",
        "s3:DeleteObject",
        "s3:ListBucket"
      ],
      "Resource": [
        "arn:aws:s3:::my-bucket/*"
      ]
    }
  ]
}

mc admin policy create myminio readwrite-policy readwrite-policy.json

Policy zuweisen

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

Service-Account erstellen

mc admin user svcacct add myminio admin
# Gibt Access Key und Secret Key aus

S3-Integration

AWS CLI

aws configure --profile minio
# Access Key: admin
# Secret Key: sicheres-passwort
# Region: us-east-1

# Endpoint setzen
aws --endpoint-url http://localhost:9000 --profile minio s3 ls

Python (boto3)

import boto3

s3 = boto3.client(
    's3',
    endpoint_url='http://localhost:9000',
    aws_access_key_id='admin',
    aws_secret_access_key='sicheres-passwort',
    region_name='us-east-1'
)

# Bucket erstellen
s3.create_bucket(Bucket='my-bucket')

# Datei hochladen
s3.upload_file('local-file.txt', 'my-bucket', 'remote-file.txt')

# Dateien auflisten
response = s3.list_objects_v2(Bucket='my-bucket')
for obj in response.get('Contents', []):
    print(obj['Key'])

Node.js

const { S3Client, PutObjectCommand } = require("@aws-sdk/client-s3");

const s3Client = new S3Client({
  endpoint: "http://localhost:9000",
  region: "us-east-1",
  credentials: {
    accessKeyId: "admin",
    secretAccessKey: "sicheres-passwort",
  },
  forcePathStyle: true,
});

async function uploadFile() {
  const command = new PutObjectCommand({
    Bucket: "my-bucket",
    Key: "test.txt",
    Body: "Hello World",
  });
  await s3Client.send(command);
}

Nginx Reverse Proxy

Mit SSL

# /etc/nginx/sites-available/minio

upstream minio_s3 {
    server 127.0.0.1:9000;
}

upstream minio_console {
    server 127.0.0.1:9001;
}

server {
    listen 443 ssl http2;
    server_name s3.example.com;

    ssl_certificate /etc/letsencrypt/live/s3.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/s3.example.com/privkey.pem;

    # S3 API
    location / {
        proxy_pass http://minio_s3;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Für große Uploads
        client_max_body_size 0;
        proxy_buffering off;
    }
}

server {
    listen 443 ssl http2;
    server_name console.s3.example.com;

    ssl_certificate /etc/letsencrypt/live/s3.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/s3.example.com/privkey.pem;

    # Konsole
    location / {
        proxy_pass http://minio_console;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # WebSocket
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Backup-Lösung

Backup-Script mit mc

#!/bin/bash
# /usr/local/bin/backup-to-minio.sh

SOURCE="/var/www"
BUCKET="backups"
DATE=$(date +%Y%m%d)

# Archiv erstellen
tar -czf /tmp/backup-$DATE.tar.gz $SOURCE

# Zu MinIO hochladen
mc cp /tmp/backup-$DATE.tar.gz myminio/$BUCKET/

# Lokal löschen
rm /tmp/backup-$DATE.tar.gz

# Alte Backups löschen (älter als 30 Tage)
mc rm --older-than 30d myminio/$BUCKET/

Lifecycle-Regeln

// lifecycle.json
{
  "Rules": [
    {
      "ID": "expire-old-backups",
      "Status": "Enabled",
      "Filter": {
        "Prefix": "backups/"
      },
      "Expiration": {
        "Days": 30
      }
    }
  ]
}

mc ilm import myminio/my-bucket < lifecycle.json

Monitoring

Prometheus-Metriken

# Metriken aktivieren
mc admin prometheus generate myminio

# Ergebnis zu prometheus.yml hinzufügen

Healthcheck

curl http://localhost:9000/minio/health/live
curl http://localhost:9000/minio/health/ready

Distributed Mode (Cluster)

4-Node-Cluster

# Auf jedem Node
minio server http://node{1...4}.example.com/data{1...4}

Docker Compose Cluster

version: '3.8'

services:
  minio1:
    image: minio/minio
    command: server http://minio{1...4}/data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: sicheres-passwort
    volumes:
      - minio1-data:/data

  minio2:
    image: minio/minio
    command: server http://minio{1...4}/data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: sicheres-passwort
    volumes:
      - minio2-data:/data

  # minio3, minio4 analog...

volumes:
  minio1-data:
  minio2-data:

Zusammenfassung

| Befehl | Funktion | |--------|----------| | mc alias set | Server hinzufügen | | mc mb | Bucket erstellen | | mc cp | Kopieren | | mc ls | Auflisten | | mc rm | Löschen | | mc mirror | Synchronisieren | | mc admin user add | Benutzer erstellen |

Fazit

MinIO ist die perfekte Self-Hosted-Alternative zu Amazon S3. Die Installation ist einfach, die Performance hervorragend, und die S3-Kompatibilität ermöglicht die Nutzung mit bestehenden Tools und Bibliotheken. Für Produktivumgebungen empfiehlt sich ein Cluster-Setup mit mehreren Nodes für Ausfallsicherheit.

Warum MinIO?

Vorteile

Anwendungsfälle

Installation

Single-Node (Standalone)

Mit Docker

Docker Compose

Systemd-Service

Service-Datei erstellen

Umgebungsvariablen

Benutzer und Berechtigungen

Service starten

Web-Konsole

Zugriff

Funktionen

MinIO Client (mc)

Installation

Server hinzufügen (Alias)

Grundlegende Befehle

Erweiterte Befehle

Benutzer und Zugriffsrechte

Benutzer erstellen

Policy erstellen

Policy zuweisen

Service-Account erstellen

S3-Integration

AWS CLI

Python (boto3)

Node.js

Nginx Reverse Proxy

Mit SSL

Backup-Lösung

Backup-Script mit mc

Lifecycle-Regeln

Monitoring

Prometheus-Metriken

Healthcheck

Distributed Mode (Cluster)

4-Node-Cluster

Docker Compose Cluster

Zusammenfassung

Fazit

Das könnte dich auch interessieren

MinIO - S3-kompatibler Object Storage

Duplicati - Cloud-Backups mit Verschlüsselung

Btrfs - Copy-on-Write Dateisystem für Linux