Zuletzt aktualisiert: 11. September

Dateien mit Java aus MinIO importieren

Kevin van Zonneveld

Mitgründer · Amsterdam, Niederlande ·

MinIO ist ein leistungsstarkes, verteiltes Objektspeichersystem, das mit den Amazon-S3-APIs kompatibel ist. Seine Einfachheit, Skalierbarkeit und Kompatibilität machen es zu einer beliebten Wahl für Entwickler, die robuste Speicherlösungen in ihre Java-Anwendungen integrieren möchten.

In diesem Leitfaden zeigen wir, wie Sie Dateien mithilfe des MinIO Java SDK effizient mit Java aus MinIO importieren. Wir behandeln Einrichtung, Integration, praktische Beispiele, bewährte Sicherheitsverfahren und Optimierungstipps.

Einführung in MinIO und die S3-Kompatibilität

MinIO bietet eine verteilte Open-Source-Objektspeicherlösung, die auf hohe Leistung und Skalierbarkeit ausgelegt ist. Dank der Kompatibilität mit den Amazon-S3-APIs können Entwickler sie mühelos in bestehende Workflows und Anwendungen integrieren, die bereits S3 nutzen.

Ihre Java-Umgebung einrichten

Bevor Sie beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:

Eine Installation von Java 8 oder höher.
Eine laufende MinIO-Serverinstanz.
Zugangsdaten (accessKey und secretKey) für Ihren MinIO-Server.

Das MinIO Java SDK integrieren

Um das MinIO Java SDK zu integrieren, fügen Sie Ihrem Projekt die folgende Abhängigkeit hinzu:

Maven:

<dependency>
  <groupId>io.minio</groupId>
  <artifactId>minio</artifactId>
  <version>8.5.17</version>
</dependency>

Gradle:

implementation 'io.minio:minio:8.5.17'

Dateien aus MinIO importieren: eine Schritt-für-Schritt-Anleitung

Hier ein praktisches Beispiel, das zeigt, wie Sie eine Datei aus MinIO importieren:

import io.minio.MinioClient;
import io.minio.GetObjectArgs;
import io.minio.errors.MinioException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

public class MinIOFileImporter {
  public static void main(String[] args) {
    // Initialize and close the client for this command-line operation.
    try (MinioClient minioClient = MinioClient.builder()
        .endpoint("https://play.min.io")
        .credentials(System.getenv("MINIO_ACCESS_KEY"), System.getenv("MINIO_SECRET_KEY"))
        .build()) {

      // Download file from MinIO
      try (InputStream stream = minioClient.getObject(
          GetObjectArgs.builder()
            .bucket("my-bucket")
            .object("path/to/file.txt")
            .build())) {

        Files.copy(stream, Paths.get("downloaded-file.txt"));
        System.out.println("File imported successfully.");
      }
    } catch (MinioException e) {
      System.err.println("MinIO request failed: " + e.getClass().getSimpleName());
    } catch (IOException e) {
      System.err.println("File operation error: " + e);
    } catch (NoSuchAlgorithmException | InvalidKeyException e) {
      System.err.println("Authentication error: " + e);
    } catch (Exception e) {
      System.err.println("Client setup or cleanup failed: " + e.getClass().getSimpleName());
    }
  }
}

Ersetzen Sie den Demo-Endpunkt, den Bucket-Namen und den Objektpfad durch Ihre MinIO-Daten und setzen Sie MINIO_ACCESS_KEY und MINIO_SECRET_KEY in der Umgebung. Der Demo-Endpunkt verwendet HTTPS auf Port 443. Files.copy überschreibt keine vorhandene lokale Datei; ein fehlgeschlagener Stream kann eine unvollständige neue Datei hinterlassen, die Sie vor einem erneuten Versuch entfernen oder isolieren sollten.

Häufige Exceptions behandeln

Bei der Arbeit mit MinIO können verschiedene Arten von Exceptions auftreten:

MinioException: Basis-Exception für alle MinIO-bezogenen Fehler.
- ErrorResponseException: Weist auf Probleme wie falsche Bucket-Namen oder Berechtigungen hin.
- InsufficientDataException: Tritt auf, wenn der Datenstrom vorzeitig endet.
- InternalException: Steht für interne SDK-Fehler.
IOException: Fehler im Zusammenhang mit dem Dateisystem.
NoSuchAlgorithmException oder InvalidKeyException: Fehler im Zusammenhang mit der Authentifizierung.

Behandeln Sie Exceptions stets sauber und protokollieren Sie aussagekräftige Fehlermeldungen, um das Debugging zu vereinfachen.

Bewährte Verfahren für die Sicherheit

Wenn Sie MinIO in der Produktion einsetzen, befolgen Sie diese bewährten Sicherheitsverfahren:

Umgebungsvariablen verwenden

Speichern Sie Zugangsdaten in Umgebungsvariablen, statt sie fest im Code zu hinterlegen:

String accessKey = System.getenv("MINIO_ACCESS_KEY");
String secretKey = System.getenv("MINIO_SECRET_KEY");

MinioClient minioClient = MinioClient.builder()
  .endpoint("https://your-minio-server.com")
  .credentials(accessKey, secretKey)
  .build();

TLS aktivieren

Verwenden Sie in der Produktion immer HTTPS:

MinioClient minioClient = MinioClient.builder()
  .endpoint("your-minio-server.com", 443, true) // true enables HTTPS
  .credentials(accessKey, secretKey)
  .build();

Fehlerbehandlung und Logging richtig implementieren

Protokollieren Sie den Exception-Typ und den Vorgang, ohne HTTP-Traces oder Zugangsdaten auszugeben. Zum Beispiel innerhalb des Blocks catch (MinioException e) im Hauptbeispiel:

System.err.println("MinIO download failed: " + e.getClass().getSimpleName());

Verbindungsverwaltung und Optimierung

Um MinIO-Vorgänge zu optimieren, ziehen Sie diese Techniken in Betracht:

Connection Pooling

Verwenden Sie die Instanz von MinioClient in Ihrer gesamten Anwendung wieder:

Halten Sie sie für die Lebensdauer der Anwendung offen und schließen Sie sie beim Herunterfahren.

import io.minio.MinioClient;

// Create a singleton MinioClient
public class MinioClientFactory {
  private static MinioClient instance;

  public static synchronized MinioClient getClient() {
    if (instance == null) {
      instance = MinioClient.builder()
        .endpoint("https://your-minio-server.com")
        .credentials(System.getenv("MINIO_ACCESS_KEY"), System.getenv("MINIO_SECRET_KEY"))
        .build();
    }
    return instance;
  }
}

Timeouts konfigurieren

Legen Sie passende Timeouts für die Verbindung sowie für Lese- und Schreibvorgänge fest:

import io.minio.MinioClient;
import okhttp3.OkHttpClient;
import java.util.concurrent.TimeUnit;

OkHttpClient httpClient = new OkHttpClient.Builder()
  .connectTimeout(30, TimeUnit.SECONDS)
  .writeTimeout(60, TimeUnit.SECONDS)
  .readTimeout(60, TimeUnit.SECONDS)
  .build();

MinioClient minioClient = MinioClient.builder()
  .endpoint("https://your-minio-server.com")
  .credentials(System.getenv("MINIO_ACCESS_KEY"), System.getenv("MINIO_SECRET_KEY"))
  .httpClient(httpClient)
  .build();

Retry-Mechanismen implementieren

Diese Methode wiederholt vorübergehend fehlschlagende Versuche beim Öffnen eines Downloads und nutzt dafür ein begrenztes exponentielles Backoff. Sie setzt ein Feld MinioClient minioClient in der umgebenden Klasse voraus. Importieren Sie die unten gezeigten Typen am Anfang dieser Datei. Die aufrufende Seite muss den zurückgegebenen Stream schließen und Fehler beim Lesen seines Inhalts separat behandeln:

import io.minio.GetObjectArgs;
import io.minio.errors.ErrorResponseException;
import io.minio.errors.MinioException;
import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

public InputStream getObjectWithRetry(String bucket, String object, int maxRetries) {
  if (maxRetries < 1) throw new IllegalArgumentException("maxRetries must be at least 1");
  int attempts = 0;
  while (attempts < maxRetries) {
    try {
      return minioClient.getObject(
        GetObjectArgs.builder()
          .bucket(bucket)
          .object(object)
          .build());
    } catch (MinioException | IOException e) {
      if (e instanceof ErrorResponseException) {
        int status = ((ErrorResponseException) e).response().code();
        if (status != 408 && status != 429 && status < 500) {
          throw new RuntimeException("Non-retryable storage response", e);
        }
      } else if (!(e instanceof IOException) && !(e instanceof io.minio.errors.ServerException)) {
        throw new RuntimeException("Non-retryable MinIO failure", e);
      }
      attempts++;
      if (attempts >= maxRetries) throw new RuntimeException("Failed after " + maxRetries + " attempts", e);
      try {
        Thread.sleep(1000L << Math.min(attempts - 1, 5)); // 1s, 2s, 4s, capped at 32s
      } catch (InterruptedException ie) {
        Thread.currentThread().interrupt();
        throw new RuntimeException("Interrupted during retry", ie);
      }
    } catch (NoSuchAlgorithmException | InvalidKeyException e) {
      throw new RuntimeException("Cryptographic configuration error", e);
    }
  }
  throw new RuntimeException("Should not reach here");
}

Anwendungsfälle aus der Praxis

MinIO wird häufig eingesetzt für:

Das Speichern und Abrufen großer Datensätze für Datenanalysen.
Backup- und Archivierungslösungen.
Die Auslieferung statischer Assets für Webanwendungen.
Medienspeicherung und Streaming.
Das Speichern und Abrufen von KI-/ML-Modellen.

Beispiel: Objekte auflisten

import io.minio.ListObjectsArgs;
import io.minio.Result;
import io.minio.messages.Item;

try {
  Iterable<Result<Item>> results = minioClient.listObjects(
    ListObjectsArgs.builder().bucket("my-bucket").prefix("documents/").build());

  for (Result<Item> result : results) {
    Item item = result.get();
    System.out.println(item.objectName());
  }
} catch (Exception e) {
  System.err.println("Error listing objects: " + e.getMessage());
}

Fehlerbehebung

Verbindung abgelehnt

Wenn Verbindungsprobleme auftreten:

Prüfen Sie, ob der MinIO-Server läuft.
Überprüfen Sie die Firewall-Einstellungen.
Stellen Sie sicher, dass Endpunkt-URL und Port korrekt sind.
Prüfen Sie die Netzwerkverbindung.

Zugriff verweigert

Bei Berechtigungsproblemen:

Überprüfen Sie Ihren Zugriffsschlüssel und Ihren geheimen Schlüssel.
Prüfen Sie die Bucket-Richtlinien und Berechtigungen.
Stellen Sie sicher, dass der Bucket existiert.
Prüfen Sie, ob der Objektpfad korrekt ist.

Fazit

Die Integration von MinIO mit Java bietet eine leistungsstarke und effiziente Möglichkeit, Dateien in Ihren Anwendungen zu verwalten. Das MinIO Java SDK stellt eine robuste API für die Interaktion mit MinIO-Servern bereit, inklusive Funktionen wie Connection Pooling, Retry-Mechanismen und umfassender Fehlerbehandlung. Wenn Sie die in diesem Leitfaden beschriebenen bewährten Verfahren befolgen, können Sie sichere, skalierbare und leistungsstarke Anwendungen entwickeln, die die Stärken von MinIO nutzen.

Weiterführende Informationen finden Sie in der offiziellen Dokumentation des MinIO Java SDK.

Auch Transloadit setzt auf MinIO. Unser 🤖 MinIO Import Robot ermöglicht es Ihnen, ganze Verzeichnisse mühelos aus Ihren MinIO-Buckets zu importieren, und unser 🔧 Java SDK vereinfacht die Integration mit den Dateiverarbeitungsfunktionen von Transloadit.