Docker

Diese Seite beschreibt, wie Sie das offizielle RustFS-Image mit Docker betreiben: eine Instanz auf einem Knoten mit persistentem Speicher, Verzeichnisberechtigungen auf dem Host für den Container-Benutzer ohne Root-Rechte, Docker Compose mit optionalen Observability-Diensten, TLS und eine Bereitstellung auf mehreren Knoten. Sie benötigen eine funktionsfähige Docker Engine und die Berechtigung, Container auszuführen.

docker pull rustfs/rustfs:latest

docker volume create rustfs-data

docker run -d \
  --name rustfs \
  --restart unless-stopped \
  -p 9000:9000 \
  -p 9001:9001 \
  -v rustfs-data:/data \
  -e RUSTFS_ACCESS_KEY="<your-access-key>" \
  -e RUSTFS_SECRET_KEY="<your-secret-key>" \
  -e RUSTFS_ADDRESS=":9000" \
  -e RUSTFS_CONSOLE_ADDRESS=":9001" \
  -e RUSTFS_CONSOLE_ENABLE=true \
  -e RUSTFS_OBS_LOGGER_LEVEL=error \
  -e RUSTFS_OBS_LOG_DIRECTORY="/var/log/rustfs/" \
  rustfs/rustfs:latest \
  /data

docker run -d \
  --name rustfs \
  -p 9000:9000 \
  -p 9001:9001 \
  -v rustfs-data:/data \
  rustfs/rustfs:latest \
  --access-key "<your-access-key>" \
  --secret-key "<your-secret-key>" \
  --address :9000 \
  --console-enable \
  /data

chown -R 10001:10001 /path/to/host_directory

docker ps --filter name=rustfs
curl --fail http://localhost:9000/health

Docker ComposeCopy Anchor Link

Das RustFS-Repository enthält eine docker-compose.yml mit den Diensten grafana, prometheus, otel-collector und jaeger, vor allem für Observability. Um RustFS zusammen mit diesen Diensten bereitzustellen, klonen Sie das RustFS-Quellcode-Repository lokal:

git clone https://github.com/rustfs/rustfs.git

Führen Sie den Befehl im Wurzelverzeichnis des Repositorys aus:

docker compose --profile observability up -d

Die Compose-Datei verwendet einen Initialisierungscontainer, der rustfs die richtigen Zugriffsrechte einräumt. Der Dienst rustfs_perms setzt den Eigentümer der eingehängten Volumes auf 10001, bevor rustfs startet. Über depends_on wartet rustfs, bis dieser Dienst abgeschlossen ist. Damit die Logs dauerhaft gespeichert und zugänglich bleiben, wird das Logverzeichnis auf dem Host auf den Pfad /var/log/rustfs/ im Container abgebildet:

  services:
    # grant the necessary permissions to RUSTFS volumes path
    rustfs_perms:
      image: alpine
      user: root
      volumes:
        - /path/to/host_directory/volumes:/fix_path
      command: chown -R 10001:10001 /fix_path

    rustfs:
      image: rustfs/rustfs:latest
      depends_on:
        rustfs_perms:
          condition: service_completed_successfully
      volumes:
        - /path/to_host_directory/volumes/data:/data
        - /path/to_host_directory/volumes/logs:/var/log/rustfs/
      environment:
        - RUSTFS_ADDRESS=":9000"
        - RUSTFS_CONSOLE_ADDRESS=":9001"
        - RUSTFS_CONSOLE_ENABLE=true
        - RUSTFS_OBS_LOGGER_LEVEL=error
        - RUSTFS_OBS_LOG_DIRECTORY="/var/log/rustfs/"

      # ... other configurations

Wenn Sie nur RustFS ohne Grafana, Prometheus und die übrigen Observability-Dienste wollen, starten Sie nur den Dienst rustfs (die Compose-Datei kennzeichnet die Abhängigkeit vom Collector als optional):

docker compose -f docker-compose.yml up -d rustfs

Damit startet nur der Container rustfs-server. Egal, ob Sie nur rustfs-server oder alle Dienste starten: Die S3-API ist unter http://localhost:9000 erreichbar, die RustFS Console unter http://localhost:9001. Öffnen Sie die Console im Browser und melden Sie sich mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüssel an, die Sie oben festgelegt haben. Erzeugen Sie ein starkes Geheimnis, zum Beispiel mit openssl rand -base64 24, und übernehmen Sie die Platzhalterwerte nicht in die Produktion.

Legen Sie für Docker Compose eindeutige Werte für RUSTFS_ACCESS_KEY und RUSTFS_SECRET_KEY in der Umgebung des Dienstes rustfs oder in der Umgebungsdatei für die Variablenersetzung fest. Erstellen Sie den Dienst anschließend mit docker compose up -d rustfs neu.

Bereitstellung auf mehreren KnotenCopy Anchor Link

Das Standard-Bridge-Netzwerk von Docker unterstützt keine Bereitstellungen auf mehreren Knoten. Verwenden Sie --network host, damit jeder Container direkt mit den anderen Knoten kommunizieren kann.

Führen Sie Folgendes auf jedem Knoten aus:

docker run -d \
  --name rustfs \
  --network host \
  -v /mnt/rustfs/data:/data \
  -e RUSTFS_ACCESS_KEY="<your-access-key>" \
  -e RUSTFS_SECRET_KEY="<your-secret-key>" \
  -e RUSTFS_ADDRESS=":9000" \
  -e RUSTFS_CONSOLE_ADDRESS=":9001" \
  -e RUSTFS_CONSOLE_ENABLE=true \
  -e RUSTFS_OBS_LOGGER_LEVEL=error \
  -e RUSTFS_OBS_LOG_DIRECTORY="/var/log/rustfs/" \
  -e RUSTFS_VOLUMES="http://node{1...4}:9000/data/rustfs{0...3}" \
  rustfs/rustfs:latest

Tragen Sie die Einträge auf jedem Knoten in /etc/hosts ein:

192.168.1.1 node1
192.168.1.2 node2
192.168.1.3 node3
192.168.1.4 node4

TLS-KonfigurationCopy Anchor Link

Wenn Sie TLS verwenden, hängen Sie das Zertifikatsverzeichnis ein und verweisen Sie RustFS darauf:

-v /path/to/certs:/certs \
-e RUSTFS_TLS_PATH=/certs \

Vor dem ProduktivbetriebCopy Anchor Link

Arbeiten Sie die Checklisten vor der Installation durch — Hardware, Netzwerk, Software und Sicherheit —, bevor Sie in der Produktion bereitstellen. Verwenden Sie eine Bereitstellung auf mehreren Knoten, aktivieren Sie TLS, konfigurieren Sie die Logrotation und planen Sie regelmäßige Sicherungen.

Nächste SchritteCopy Anchor Link

• RustFS Console
• S3-Client konfigurieren
• TLS-Konfiguration