Zuletzt aktualisiert: 11. September

Dateien aus Amazon S3 in Java importieren

Kevin van Zonneveld

Mitgründer · Amsterdam, Niederlande ·

Die Integration von Amazon S3 in Java-Anwendungen ist eine häufige Anforderung für Entwicklerinnen und Entwickler, die mit Cloud-Storage arbeiten. Das AWS SDK v2 bietet eine robuste und effiziente Möglichkeit, den Dateiimport abzuwickeln. In diesem DevTip zeigen wir Ihnen, wie Sie das AWS SDK v2 einrichten, Zugangsdaten sicher konfigurieren, Dateien aus S3 importieren, Ausnahmen behandeln und die Performance optimieren.

Einführung in Amazon S3 und Java

Amazon S3 (Simple Storage Service) ist eine skalierbare Cloud-Storage-Lösung zum Speichern und Abrufen von Daten. Java-Entwickler greifen häufig auf S3 zu, um Dateien zu importieren. Das AWS SDK v2 bietet eine schlanke API für diese Vorgänge.

AWS SDK v2 einrichten

Fügen Sie die Abhängigkeiten des AWS SDK v2 zu Ihrem Projekt hinzu. Für Maven in pom.xml:

<dependency>
  <groupId>software.amazon.awssdk</groupId>
  <artifactId>s3</artifactId>
  <version>2.30.38</version>
</dependency>
<dependency>
  <groupId>software.amazon.awssdk</groupId>
  <artifactId>s3-transfer-manager</artifactId>
  <version>2.30.38</version>
</dependency>
<dependency>
  <groupId>software.amazon.awssdk.crt</groupId>
  <artifactId>aws-crt</artifactId>
  <version>0.34.1</version>
</dependency>

Für Gradle in build.gradle:

implementation 'software.amazon.awssdk:s3:2.30.38'
implementation 'software.amazon.awssdk:s3-transfer-manager:2.30.38'
implementation 'software.amazon.awssdk.crt:aws-crt:0.34.1'

Die Abhängigkeiten transfer-manager und CRT werden für die späteren Beispiele benötigt. Die oben genannten Versionen entsprechen der CRT-Abhängigkeit von AWS SDK 2.30.38. Java-Snippets ohne Klassendeklaration sind Auszüge aus Methodenrümpfen; platzieren Sie deren Importe am Anfang Ihrer Java-Datei.

AWS-Zugangsdaten konfigurieren

Das AWS SDK v2 unterstützt mehrere Möglichkeiten, Zugangsdaten zu konfigurieren. Empfohlen wird die Verwendung von Umgebungsvariablen oder AWS-Zugangsdaten-Dateien.

Mit Umgebungsvariablen:

export AWS_ACCESS_KEY_ID=your_access_key
export AWS_SECRET_ACCESS_KEY=your_secret_key

Alternativ speichern Sie die Zugangsdaten in ~/.aws/credentials:

[default]
aws_access_key_id = your_access_key
aws_secret_access_key = your_secret_key

Die AWS-Region konfigurieren

Die Angabe der richtigen AWS-Region ist entscheidend. So konfigurieren Sie sie:

import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;

// Configure the S3 client with a specific region
Region region = Region.US_EAST_1; // Choose your region
try (S3Client s3 = S3Client.builder()
    .region(region)
    .build()) {
  // Perform S3 operations here while the client is open.
}

Dateien aus S3 importieren

Hier ein Beispiel für den Import einer Datei aus Amazon S3:

import software.amazon.awssdk.core.sync.ResponseTransformer;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.S3Exception;

import java.nio.file.Paths;

public class S3FileImporter {

  public static void main(String[] args) {
    String bucketName = "your-bucket-name";
    String key = "path/to/your/file.txt";
    String downloadPath = "downloaded-file.txt";

    Region region = Region.US_EAST_1; // Choose your region

    try (S3Client s3 = S3Client.builder()
        .region(region)
        .build()) {

      GetObjectRequest request = GetObjectRequest.builder()
          .bucket(bucketName)
          .key(key)
          .build();

      s3.getObject(request, ResponseTransformer.toFile(Paths.get(downloadPath)));
      System.out.println("File downloaded successfully to " + downloadPath);
    } catch (S3Exception e) {
      System.err.println("S3 error: " + e.getMessage());
    } catch (Exception e) {
      System.err.println("Unexpected error: " + e.getMessage());
    }
  }
}

Ausnahmen behandeln

Ersetzen Sie im oben gezeigten Block mit geöffnetem Client (try) den Aufruf von getObject durch diesen Handler. Er verwendet s3, request, downloadPath sowie die Importe aus jenem Beispiel weiter:

try {
  s3.getObject(request, ResponseTransformer.toFile(Paths.get(downloadPath)));
  System.out.println("File downloaded successfully.");
} catch (software.amazon.awssdk.services.s3.model.NoSuchKeyException e) {
  System.err.println("File not found: " + e.getMessage());
} catch (software.amazon.awssdk.services.s3.model.NoSuchBucketException e) {
  System.err.println("Bucket not found: " + e.getMessage());
} catch (software.amazon.awssdk.services.s3.model.S3Exception e) {
  System.err.println("S3 error: " + e.getMessage());
} catch (Exception e) {
  System.err.println("Unexpected error: " + e.getMessage());
}

S3-Client-Typen

Das AWS SDK für Java v2 bietet verschiedene Client-Typen:

Synchroner Client (S3Client)

Der Standard-Client für die meisten Anwendungen. Vorgänge blockieren, bis sie abgeschlossen sind.

Asynchroner Client (S3AsyncClient)

Ideal für nicht blockierende Vorgänge; liefert Objekte vom Typ CompletableFuture:

import software.amazon.awssdk.core.async.AsyncResponseTransformer;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;
import java.nio.file.Paths;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;

try (S3AsyncClient asyncClient = S3AsyncClient.builder().region(Region.US_EAST_1).build()) {
  GetObjectRequest request = GetObjectRequest.builder()
      .bucket("your-bucket-name").key("path/to/your/file.txt").build();
  CompletableFuture<GetObjectResponse> futureResponse = asyncClient.getObject(
      request, AsyncResponseTransformer.toFile(Paths.get("downloaded-file.txt")));
  // Other work can run here. Await completion before closing the client or exiting.
  futureResponse.join();
  System.out.println("File downloaded successfully.");
} catch (CompletionException e) {
  System.err.println("Asynchronous download failed: " + e.getCause().getClass().getSimpleName());
}

Client mit erhöhter Leistung (AWS CRT)

Für hohen Durchsatz, unter Verwendung der AWS Common Runtime (CRT):

import software.amazon.awssdk.core.async.AsyncResponseTransformer;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import java.nio.file.Paths;

try (S3AsyncClient crtClient = S3AsyncClient.crtBuilder()
    .region(Region.US_EAST_1).build()) {
  GetObjectRequest request = GetObjectRequest.builder()
      .bucket("your-bucket-name").key("path/to/your/file.txt").build();
  crtClient.getObject(request, AsyncResponseTransformer.toFile(Paths.get("crt-download.txt")))
      .join();
}

Performance optimieren

Für große Dateien bieten sich diese Techniken an:

Streaming auf die Festplatte

Streamen Sie ein Objekt an ein neues lokales Ziel, solange der synchrone Client geöffnet bleibt:

s3.getObject(request, ResponseTransformer.toFile(Paths.get("large-file.txt")));

So wird die Datei auf die Festplatte gestreamt und der Speicherverbrauch minimiert.

Multipart-Downloads

Bei Dateien, die größer als einige Hundert MB sind, verwenden Sie Multipart-Downloads:

import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.transfer.s3.S3TransferManager;
import software.amazon.awssdk.transfer.s3.model.DownloadFileRequest;
import java.nio.file.Paths;

try (S3AsyncClient s3AsyncClient = S3AsyncClient.crtBuilder().region(Region.US_EAST_1).build();
     S3TransferManager transferManager = S3TransferManager.builder()
         .s3Client(s3AsyncClient).build()) {
  GetObjectRequest request = GetObjectRequest.builder()
      .bucket("your-bucket-name").key("path/to/your/video.mp4").build();
  DownloadFileRequest downloadFileRequest = DownloadFileRequest.builder()
      .getObjectRequest(request)
      .destination(Paths.get("very-large-file.mp4"))
      .build();

  transferManager.downloadFile(downloadFileRequest).completionFuture().join();
}

IAM-Berechtigungen

Stellen Sie sicher, dass Ihr IAM-Benutzer bzw. Ihre IAM-Rolle über die mindestens erforderlichen Berechtigungen verfügt:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject", "s3:ListBucket"],
      "Resource": ["arn:aws:s3:::your-bucket-name/*", "arn:aws:s3:::your-bucket-name"]
    }
  ]
}

Bewährte Verfahren

Sichern Sie Ihre AWS-Zugangsdaten.
Verwenden Sie IAM-Rollen mit minimalen Berechtigungen.
Streamen Sie große Dateien auf die Festplatte.
Implementieren Sie eine robuste Fehlerbehandlung.
Wählen Sie den passenden S3-Client-Typ.
Nutzen Sie den S3TransferManager für große Dateien.
Setzen Sie angemessene Timeouts.

Transloadit bietet eine verwaltete Lösung für den Dateiimport, auch aus S3. Sehen Sie sich unseren S3 Import Robot und unser Java SDK an.