Einführung, Bereitstellungsschritte und Codebeispiele von MinIO, einem leistungsstarken, skalierbaren, verteilten Objektspeichersystem

Ausführliche Einführung

MinIO ist ein beliebtes Open-Source-Objektspeichersystem, das mit der Amazon S3-API kompatibel ist und hauptsächlich in privaten Cloud- und Edge-Computing-Szenarien verwendet wird. Es bietet hohe Leistung, hohe Verfügbarkeit und einfach zu verwaltende Objektspeicherdienste. Im Folgenden finden Sie eine detaillierte Einführung sowie Vor- und Nachteile von MinIO:

1. Architektur und Funktionen:

   • Open Source und plattformübergreifend : MinIO ist Open Source und kostenlos (Apache v2.0-Lizenz) und unterstützt die Bereitstellung auf mehreren Plattformen wie Linux, Windows, macOS usw.
   • Verteilter Speicher : MinIO kann auf verteilte Weise bereitgestellt werden und erreicht Datenredundanz durch Erasure Coding-Technologie (Erasure Coding). Daten können auch dann wiederhergestellt werden, wenn einige Festplatten ausfallen. Normalerweise ist es so konfiguriert, dass der Verlust von N/2 Festplatten möglich ist unter Beibehaltung der Datenverfügbarkeit. Wiederherstellen.
   • Amazon S3-Kompatibilität : Vollständig kompatibel mit den v2- und v4-APIs von Amazon S3, sodass S3-basierte Anwendungen und Dienste nahtlos auf MinIO umsteigen können.
   • Hohe Leistung : Entwickelt für große Arbeitslasten, kann extrem viele gleichzeitige Lese- und Schreibanforderungen verarbeiten und bietet eine gute Leistung auf moderner Hardware.
   • Sicherheit : Bietet eine Vielzahl von Sicherheitsmaßnahmen, einschließlich serverseitiger Verschlüsselung (SSE), clientseitiger Verschlüsselung, Authentifizierung (mit JWT oder benutzerdefinierten Authentifizierungsmechanismen) und Zugriffsrichtlinienkontrollen.

2. Vorteil:

   • Kosteneffizienz : Im Vergleich zu kommerziellen Objektspeicherlösungen erfordert MinIO keine zusätzlichen Lizenzgebühren, wodurch die Speicherkosten gesenkt werden.
   • Einfach und benutzerfreundlich : Die Installation und Konfiguration sind relativ einfach und die Benutzeroberfläche ist benutzerfreundlich. Sie kann über Befehlszeilentools, Web-UI oder SDK verwaltet und bedient werden.
   • Skalierbarkeit : Hervorragende horizontale Skalierbarkeit. Knoten können nach Bedarf hinzugefügt werden, um die Kapazität und Leistung zu erhöhen.
   • Datenschutz : Verwenden Sie Erasure-Coding-Technologie, um die Datenzuverlässigkeit sicherzustellen, und unterstützen Sie Verifizierung und Prüfsumme, um die Datenintegrität sicherzustellen.

3. Vor- und Nachteile in Front-End-Nutzungsszenarien:

   • Vorteil :
     • Bei Projekten, die durch Webpack-Engineering erstellt wurden, können Dateien über die API direkt auf den MinIO-Server hochgeladen werden, da die laufende Umgebung Node.js umfasst.
     • Kompatibel mit dem AWS SDK, ist es für Entwickler bequem, vorhandenen S3-Schnittstellencode für die Entwicklung aufzurufen.
   • Mangel :
     • Es eignet sich nicht für Projekte, die mit reinen Browser-Modulladern wie Vite erstellt wurden, da die nativen Module von Node.j nicht verwendet werden können.
     • Beim Front-End-Direkt-Upload mangelt es an intuitivem Feedback zum Upload-Fortschritt, was zu einer schlechten Benutzererfahrung führt.
     • Wenn Konfigurationsinformationen wie Ports, Kontokennwörter usw. im Frontend fest codiert sind, bestehen Sicherheitsrisiken und es wird schwierig, sie zu pflegen und zu erweitern.

4. Allgemeine Vor- und Nachteile:

   • Vorteil :
     • Hohe Leistung, hohe Zuverlässigkeit und einfache Skalierbarkeit
     • Gute Kompatibilität und niedrige Migrationskosten für Organisationen, die bereits das AWS S3-Ökosystem nutzen
     • Die Open-Source-Community ist aktiv und wird ständig aktualisiert und verbessert.
   • Mangel :
     • Im Vergleich zu größeren Speicherlösungen der Enterprise-Klasse fehlen möglicherweise einige erweiterte Funktionen und professioneller Support
     • In einigen spezifischen Anwendungsszenarien (z. B. den oben erwähnten Sicherheits- und Erfahrungsproblemen bei direkter Anbindung des Frontends) sind zusätzliche Entwicklungsarbeiten zur Verbesserung der Lösung erforderlich.
     • Für Teams, die mit der S3-API nicht vertraut sind, kann es zu einer Lernkurve kommen.

MinIO ist eine leistungsstarke, ideale Speicherlösung für Cloud-native Anwendungen, insbesondere für Unternehmen, die kostengünstige, hochverfügbare und flexibel skalierbare private Cloud-Speicher benötigen. Bei der tatsächlichen Nutzung sollte jedoch darauf geachtet werden, die Vor- und Nachteile abzuwägen, und geeignete Strategien und technische Mittel sollten entsprechend den spezifischen Geschäftsszenarien übernommen werden, um potenzielle Herausforderungen zu bewältigen.

Quelle: MinIO | Leistungsstarker, nativer Kubernetes-Objektspeicher

MinIO-Bereitstellungsschritte

Es gibt einige Unterschiede in der Art und Weise, wie MinIO auf verschiedenen Systemen und Umgebungen bereitgestellt wird, aber das Grundkonzept ist ähnlich, nämlich die Ausführung eines S3-API-kompatiblen Objektspeicherdienstes durch Containerisierung oder direkte Installation. Im Folgenden wird kurz vorgestellt, wie die Serverseite von MinIO auf Kubernetes, Docker, CentOS, Windows, macOS und anderen Systemen bereitgestellt wird, und einige grundlegende Anleitungen zur Clientverbindung bereitgestellt.

Kubernetes (k8s) stellt MinIO Server bereit

1. Erstellen Sie ein MinIO StatefulSet oder Deployment:

   Yaml

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: minio-deployment
   spec:
     replicas: 4 # 根据需求设置副本数量以实现高可用性
     selector:
       matchLabels:
         app: minio
     template:
       metadata:
         labels:
           app: minio
       spec:
         containers:
         - name: minio
           image: minio/minio:latest
           args: ["server", "/data"]
           ports:
           - containerPort: 9000
           env:
           - name: MINIO_ACCESS_KEY
             value: "your-access-key"
           - name: MINIO_SECRET_KEY
             value: "your-secret-key"
           volumeMounts:
           - mountPath: /data
             name: minio-data
         volumes:
         - name: minio-data
           persistentVolumeClaim:
             claimName: minio-pvc # 需要预先创建并绑定到实际PV

2. Verwenden Sie kubectl applyden Befehl, um eine YAML-Konfigurationsdatei anzuwenden, um eine StatefulSet- oder Deployment-Ressource zu erstellen. Die Konfigurationsdatei gibt normalerweise das Image, das persistente Volume (PV) und den persistenten Volume-Anspruch (PVC), die Portzuordnung und die erforderlichen Umgebungsvariablen an.

3. Konfigurieren Sie Dienstressourcen:  Erstellen Sie eine Dienstressource, um den MinIO-Dienst verfügbar zu machen und externen Zugriff über ClusterIP, NodePort oder LoadBalancer bereitzustellen.

4. Initialisieren Sie den MinIO-Cluster (falls erforderlich):  Wenn Sie planen, verteiltes MinIO bereitzustellen, müssen Sie sicherstellen, dass die Startparameter und Umgebungsvariablen korrekt konfiguriert sind, damit sich jeder Pod gegenseitig erkennen und einen Cluster bilden kann.

Docker stellt MinIO Server bereit

1. Ziehen Sie das Bild :

   docker pull minio/minio

2. Ausführen des Containers : Einzelknoteninstanz:

   docker run -p 9000:9000 -p 9001:9001 --name minio \
   -e "MINIO_ACCESS_KEY=youraccesskey" \
   -e "MINIO_SECRET_KEY=yoursecretkey" \
   -v /path/to/data:/data \          #新版目录已经更改为/mnt/data
   minio/minio server /data

   Im verteilten Modus sind zusätzliche Umgebungsvariablen erforderlich, um den Clustermodus und andere Clustermitglieder zu definieren.

docker-compose.yaml

version: '3.9'  # 使用最新的Docker Compose版本以利用新特性

services:
  minio:
    image: minio/minio:RELEASE.2024-01-05T22-17-24Z.fips  # 使用最新稳定版镜像（或指定特定版本）
    container_name: minio
    ports:
      - "19000:9000"  # 根据实际需求决定是否暴露9001端口，用于HTTPS访问时需要
      - "19001:9001"  # 根据实际需求决定是否暴露9001端口，用于HTTPS访问时需要
    environment:
      MINIO_ROOT_USER: youradminaccount
      MINIO_ROOT_PASSWORD: youradminpassword
      #MINIO_BROWSER: off  # （可选）关闭Web浏览器界面，如果只通过API访问
      #MINIO_OPTS: server --address ":9000"  # （可选）自定义启动参数，比如启用多节点集群模式等
    volumes:
      - /your pathto/minio_data:/data  # 确保宿主机目录存在并有合适的权限
    command: server /data --console-address ":9001"  --address ":9000" # 指定控制台监听的静态端口为9001

Untermann

podman run -p 9000:9000 -p 9001:9001 minio/minio server /data --console-address ":9001"

podman run --name my-mc --hostname my-mc -it --entrypoint /bin/bash --rm minio/mc
[root@my-mc /]# mc alias set myminio/ https://my-minio-service MY-USER MY-PASSWORD
[root@my-mc /]# mc ls myminio/mybucket

Installieren Sie MinIO Server direkt auf CentOS

1. Abhängigkeiten installieren :

   sudo yum install -y epel-release
   sudo yum install -y mc httpd-tools

2. Laden Sie das MinIO-Binärpaket herunter und dekomprimieren Sie es : Laden Sie die neueste Version des MinIO-Binärpakets herunter, dekomprimieren Sie es und verschieben Sie es in  /usr/local/bin ein Verzeichnis oder ein von Ihnen angegebenes Verzeichnis. Beim Anpassen des Verzeichnisses wird empfohlen, das Verzeichnis zum PATH der Systemumgebung hinzuzufügen .

3. Ausführen von MinIO : Ähnlich wie beim Mounten von Datenvolumes in Docker müssen Sie ein lokales Verzeichnis als Speicherpfad angeben:

   mkdir -p /mnt/minio/data
   nohup minio server /mnt/minio/data &

Bereitstellen des MinIO-Servers unter Windows

Vorsichtsmaßnahmen:

1. Schritt 1: Laden Sie den MinIO-Server herunter

   Besuchen Sie die offizielle Download-Seite von MinIO, um die ausführbare Datei für das Windows-Betriebssystem zu erhalten: Download-Adresse: MinIO | Code und Downloads zum Erstellen eines leistungsstarken Objektspeichers

2. Schritt 2: Entpacken und installieren

3. Nachdem der Download abgeschlossen ist, entpacken Sie die Datei an den Speicherort, an dem Sie das MinIO-Dienstprogramm speichern möchten, z. B.  C:\develop\minio.

4. Schritt 3: Erstellen Sie ein Datenspeicherverzeichnis

   Um Daten dauerhaft zu speichern, muss auf der lokalen Festplatte ein Verzeichnis zum Speichern hochgeladener Dateien erstellt werden. Zum Beispiel  D:\minio-data das Erstellen eines Speicherverzeichnisses.

   Schritt 4: Starten Sie den MinIO-Server

   Öffnen Sie ein Eingabeaufforderungsfenster (CMD), führen Sie es als Administrator aus und wechseln Sie in das Verzeichnis, in dem sich die ausführbare MinIO-Datei befindet:

   cd C:\develop\minio

   Starten Sie dann den MinIO-Server mit dem folgenden Befehl, ersetzen Sie  <MINIO_ACCESS_KEY>, <MINIO_SECRET_KEY> durch Ihren benutzerdefinierten Zugriffsschlüssel und privaten Schlüssel und geben Sie das Verzeichnis an, in dem die Daten gespeichert werden:

   .\minio.exe server D:\minio-data --address ":9000" --access-key <MINIO_ACCESS_KEY> --secret-key <MINIO_SECRET_KEY>

   Schritt 5: Umgebungskonfiguration (optional)

   Wenn Sie einen Domänennamen oder andere erweiterte Optionen festlegen müssen, können Sie diese mithilfe von Umgebungsvariablen konfigurieren. Legen Sie beispielsweise die Umgebungsvariable MINIO_DOMAIN fest:

   set MINIO_DOMAIN=my-minio-server.local

   Starten Sie dann den MinIO-Dienst, indem Sie Umgebungsvariablen einbinden.

   Schritt 6: Verifizierung und Zugriff

5. Der MinIO-Server überwacht standardmäßig Port 9000, sodass Sie über einen Browser auf die Webverwaltungsoberfläche zugreifen können  http://localhost:9000 .
6. Melden Sie sich mit dem zuvor festgelegten Zugriffsschlüssel und privaten Schlüssel an (die anfänglichen Standardeinstellungen sind  minioadmin und  minioadmin).
7. Bitte stellen Sie sicher, dass die Firewall- oder Sicherheitsgruppenregeln den Zugriff auf Port 9000 zulassen. Stellen Sie in einer Produktionsumgebung sicher, dass Sie die Standardzugriffsschlüssel und privaten Schlüssel ändern, um die Systemsicherheit zu gewährleisten. Wenn Sie MinIO im verteilten Modus bereitstellen müssen, lesen Sie bitte die offizielle Dokumentation für spezifische Schritte zur Cluster-Bereitstellung. Für Bereitstellungen mit mehreren Knoten sind zusätzliche Konfigurationsparameter erforderlich, um Informationen wie Clustermitgliedschaft und Erasure Coding zu definieren.

Powershell-Weg:

## 安装minio，先直接拉取exe
Invoke-WebRequest -Uri "https://dl.min.io/server/minio/release/windows-amd64/minio.exe" -OutFile "C:\minio.exe"
setx MINIO_ROOT_USER admin
setx MINIO_ROOT_PASSWORD password
C:\minio.exe server F:\Data --console-address ":9001"


## client
Invoke-WebRequest -Uri "https://dl.minio.io/client/mc/release/windows-amd64/mc.exe" -OutFile "C:\mc.exe"
C:\mc.exe alias set myminio/ http://MINIO-SERVER MYUSER MYPASSWORD

Bereitstellen von MinIO Server unter macOS

1. Homebrew installieren (falls noch nicht installiert):

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Installieren Sie MinIO mit Homebrew :

   brew install minio/stable/minio

3. MinIO ausführen : Führen Sie den MinIO-Server in einem Terminal aus, das auf ein lokales Verzeichnis zeigt:

   mkdir -p ~/minio-storage
   minio server ~/minio-storage

Client-Anbindung und Nutzung:

Für Clientverbindungen können Sie unabhängig von der Umgebung, in der der MinIO-Server bereitgestellt wird, die folgenden Schritte zum Herstellen einer Verbindung verwenden:

1. Umgebungsvariablen festlegen (optional, um Befehlszeilenvorgänge zu vereinfachen):

   export MINIO_ENDPOINT=http://localhost:9000
   export MINIO_ACCESS_KEY=youraccesskey
   export MINIO_SECRET_KEY=yoursecretkey

2. Mit dem MinIO-Client-Tool mc : Installieren Sie mc( minio/mc) und stellen Sie dann mit dem folgenden Befehl eine Verbindung zum MinIO-Server her:

   mc alias set myminio $MINIO_ENDPOINT $MINIO_ACCESS_KEY $MINIO_SECRET_KEY

3. Verbindung überprüfen : Führen Sie diese  mc ls myminio Option aus, um die Bucket-Liste anzuzeigen. Wenn alles in Ordnung ist, sollten Sie die Bucket-Informationen auf dem Server sehen können.

Bitte beachten Sie, dass Sie in einer Produktionsumgebung unbedingt „youraccesskey“ und „yoursecretkey“ im obigen Beispiel durch Ihren tatsächlichen Zugriffsschlüssel und privaten Schlüssel ersetzen und die Netzwerkkonfiguration und die Persistenzspeichereinstellungen entsprechend der tatsächlichen Situation anpassen müssen. Befolgen Sie gleichzeitig unbedingt die besten Sicherheitspraktiken, wie z. B. die Einschränkung des Zugriffs auf öffentliche Netzwerke, die Aktivierung der SSL-Verschlüsselung usw.

 Browserzugriff:

Greifen Sie auf MinIO-Server zu und verwalten Sie sie

Nach dem Starten des MinIO-Servers können Sie über einen Browser oder über die S3-API auf den MinIO-Server zugreifen und ihn verwalten.

Python-Beispielcode:

Im Folgenden finden Sie einen in Python geschriebenen Beispielcode, der zeigt, wie Sie mithilfe des Python SDK von MinIO mit dem MinIO-Server interagieren.

import boto3

# 创建MinIO客户端
s3 = boto3.client('s3',
                  endpoint_url='http://localhost:9000',
                  aws_access_key_id='YOUR_ACCESS_KEY',
                  aws_secret_access_key='YOUR_SECRET_KEY')

# 列出所有桶
response = s3.list_buckets()
for bucket in response['Buckets']:
    print(bucket['Name'])

# 创建一个桶
s3.create_bucket(Bucket='mybucket')

# 上传文件
s3.upload_file('myfile.txt', 'mybucket', 'myfile.txt')

# 下载文件
s3.download_file('mybucket', 'myfile.txt', 'downloaded_file.txt')

# 删除文件
s3.delete_object(Bucket='mybucket', Key='myfile.txt')

# 删除桶
s3.delete_bucket(Bucket='mybucket')

Der obige Code verwendet die boto3-Bibliothek, um mit dem MinIO-Server zu interagieren. Beachten Sie, dass endpoint_urldie Parameter auf die richtige MinIO-Serveradresse verweisen aws_access_key_idund aws_secret_access_keyauf die richtigen Zugriffsschlüssel eingestellt sein sollten.

nodejs-Beispiel:

Installieren Sie das MinIO Node.js SDK

Installieren Sie zunächst das MinIO SDK in Ihrem Node.js-Projekt:

npm install minio

Beispielcode

1. Initialisieren Sie den MinIO-Client

const Minio = require('minio');

// 创建一个MinIO客户端实例
var minioClient = new Minio.Client({
    endPoint: 'your-minio-server-endpoint',
    port: 9000, // 默认端口为9000，如果自定义了端口，请修改
    useSSL: false, // 如果是https连接，则设置为true
    accessKey: 'your-access-key',
    secretKey: 'your-secret-key'
});

// 检查连接
minioClient.ping((err) => {
  if (err) throw err;
  console.log('Connected to MinIO server successfully.');
});

2. Erstellen Sie einen Bucket

minioClient.makeBucket('my-bucket', 'us-west-1', function(err) {
  if (err) return console.log(err);
  console.log('Bucket created successfully');
});

3. Laden Sie eine Datei in den Bucket hoch

// 读取本地文件
const fs = require('fs');
fs.readFile('local-file.txt', (err, data) => {
  if (err) throw err;

  // 上传文件到MinIO
  minioClient.putObject('my-bucket', 'remote-file.txt', data, data.length, 'application/text', function(err, etag) {
    if (err) return console.log(err);
    console.log("File uploaded successfully.");
  });
});

4. Listen Sie alle Objekte im Bucket auf

minioClient.listObjectsV2('my-bucket', '', true, function(err, objects) {
  if (err) return console.log(err);
  
  for (let obj of objects) {
    console.log(obj.name);
  }
});

your-minio-server-endpointBitte stellen Sie sicher, dass Sie , your-access-keyund im obigen Code your-secret-keydurch Ihre tatsächliche MinIO-Serveradresse, Ihren Zugriffsschlüssel und Ihren privaten Schlüssel ersetzen. Passen Sie außerdem den Bucket-Namen, den lokalen Dateipfad und den Namen des Remote-Objekts nach Bedarf an.