Neuerungen in v2

Das IBM Cloud Object Storage SDK für Java v2 ist eine modernisierte Version, die auf der AWS SDK v2 Architektur aufbaut und erhebliche Verbesserungen mit sich bringt:

• Unveränderliche Builder: Alle Anfrage- und Antwortobjekte verwenden unveränderliche Builder-Muster für eine bessere Thread-Sicherheit
• Moderne Paketstruktur: Neuer Namespace com.ibm.cos.v2.* mit sauberer Organisation
• Verbesserte Async-Unterstützung: Einführung von S3AsyncClient für nicht blockierende Operationen
• Verbessertes Streaming: Verbesserte Streaming-APIs mit RequestBody und ResponseTransformer
• Automatische IAM-Token-Verwaltung: SDK verwaltet die Aktualisierung von IAM-Tokens automatisch
• Typsicherheit: Verbesserte Kompilierzeit-Typüberprüfung mit Buildern
• Moderner HTTP Stack: Unterstützung für Apache HTTP Client und Netty für asynchrone Operationen

Für Entwickler, die von v1 migrieren, siehe die Migrationsanleitung.

SDK abrufen

Am einfachsten lässt sich das IBM Cloud Object Storage Java-SDK v2 mit Maven zur Verwaltung der Abhängigkeiten nutzen. Wenn Sie mit Maven noch nicht vertraut sind, können Sie mit dem Leitfaden Maven in 5 Minuten den Einstieg finden.

Maven verwendet eine Datei mit dem Namen pom.xml, um die Bibliotheken (und deren Versionen) anzugeben, die für ein Java-Projekt erforderlich sind. Hier finden Sie eine pom.xml Beispieldatei zur Verwendung des IBM Cloud Object Storage Java-SDK v2 zur Verbindung mit Object Storage.

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.cos</groupId>
    <artifactId>docs</artifactId>
    <packaging>jar</packaging>
    <version>2.0-SNAPSHOT</version>
    <name>docs</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>com.ibm.cos.v2</groupId>
            <artifactId>cos-java-sdk</artifactId>
            <version>1.0.1</version>
        </dependency>
    </dependencies>
</project>

SDK-Referenzen

Client erstellen und Berechtigungsnachweise ableiten

Im folgenden Beispiel wird der Client cos erstellt und durch Bereitstellen der Berechtigungsnachweisinformationen (API-Schlüssel und Serviceinstanz-ID) konfiguriert. Diese Werte können auch automatisch aus einer Berechtigungsnachweisdatei oder aus Umgebungsvariablen abgeleitet werden.

Nach dem Generieren eines Serviceberechtigungsnachweises kann das daraus resultierende JSON-Dokument unter ~/.bluemix/cos_credentials gespeichert werden. Vom SDK wird diese Datei automatisch als Quelle für die Berechtigungsnachweise verwendet, sofern während der Clienterstellung nicht explizit andere Berechtigungsnachweise festgelegt werden. Wenn die Datei cos_credentials HMAC-Schlüssel enthält, wird die Authentifizierung vom Client mithilfe einer Signatur durchgeführt; andernfalls wird vom Client für die Authentifizierung der bereitgestellte API-Schlüssel mit einem Bearer-Token verwendet.

Falls Sie eine Migration von AWS S3 durchführen, können Sie die Daten für die Berechtigungsnachweise aus ~/.aws/credentials im folgenden Format verwenden:

[default]
aws_access_key_id = {API_KEY}
aws_secret_access_key = {SERVICE_INSTANCE_ID}

Wenn sowohl ~/.bluemix/cos_credentials als auch ~/.aws/credentials vorhanden ist, genießt cos_credentials Vorrang.

Weitere Details zur Client-Konstruktion finden Sie in der Java API-Referenzdokumentation.

Codebeispiele

Beginnen wir mit einer vollständigen Beispielklasse, die einige grundlegende Funktionen durchläuft. Diese Klasse CosExample listet Objekte in einem vorhandenen Bucket auf, erstellt einen neuen Bucket und listet anschließend alle Buckets in der Service-Instanz auf.

package com.cos;
import java.net.URI;
import java.util.List;
import com.ibm.cos.v2.auth.credentials.AwsCredentials;
import com.ibm.cos.v2.auth.credentials.StaticCredentialsProvider;
import com.ibm.cos.v2.auth.credentials.ibmOAuth.BasicIBMOAuthCredentials;
import com.ibm.cos.v2.regions.Region;
import com.ibm.cos.v2.services.s3.S3Client;
import com.ibm.cos.v2.services.s3.model.*;
public class CosExample {
    private static String COS_ENDPOINT = "<endpoint>";
    private static String COS_API_KEY_ID = "<api-key>";
    private static String COS_SERVICE_INSTANCE_ID = "<service-instance-id>";
    private static String COS_LOCATION = "<location>";
    public static void main(String[] args) {
        System.out.println("Current time: " + new java.util.Date());
        // Create IBM COS credentials using API key
        AwsCredentials credentials = new BasicIBMOAuthCredentials(COS_API_KEY_ID, COS_SERVICE_INSTANCE_ID);
        // Create the S3 client
        S3Client cosClient = S3Client.builder()
                .endpointOverride(URI.create(COS_ENDPOINT))
                .credentialsProvider(StaticCredentialsProvider.create(credentials))
                .region(Region.of(COS_LOCATION))
                .build();
        listObjects("my-bucket", cosClient);
        createBucket("my-new-bucket", cosClient);
        listBuckets(cosClient);
        cosClient.close();
    }
    public static void listObjects(String bucketName, S3Client cosClient) {
        System.out.println("Listing objects in bucket: " + bucketName);
        ListObjectsV2Request request = ListObjectsV2Request.builder()
                .bucket(bucketName)
                .build();
        ListObjectsV2Response response = cosClient.listObjectsV2(request);
        List<S3Object> objects = response.contents();
        for (S3Object object : objects) {
            System.out.println("Item: " + object.key() + " (" + object.size() + " bytes)");
        }
    }
    public static void createBucket(String bucketName, S3Client cosClient) {
        System.out.println("Creating bucket: " + bucketName);
        CreateBucketRequest request = CreateBucketRequest.builder()
                .bucket(bucketName)
                .build();
        cosClient.createBucket(request);
        System.out.println("Bucket created: " + bucketName);
    }
    public static void listBuckets(S3Client cosClient) {
        System.out.println("Listing buckets:");
        ListBucketsResponse response = cosClient.listBuckets();
        List<Bucket> buckets = response.buckets();
        for (Bucket bucket : buckets) {
            System.out.println("Bucket Name: " + bucket.name());
        }
    }
}

public static void createBucket(String bucketName, S3Client cosClient) {
    System.out.println("Creating new bucket: " + bucketName);
    CreateBucketRequest request = CreateBucketRequest.builder()
            .bucket(bucketName)
            .build();
    cosClient.createBucket(request);
    System.out.println("Bucket: " + bucketName + " created!");
}

Bucket mit anderer Speicherklasse erstellen

public static void createBucketWithStorageClass(String bucketName, String storageClass, String location, S3Client cosClient) {
    System.out.println("Creating bucket: " + bucketName + " with storage class: " + storageClass);
    CreateBucketRequest request = CreateBucketRequest.builder()
            .bucket(bucketName)
            .ibmServiceInstanceId(COS_SERVICE_INSTANCE_ID)
            .build();
    cosClient.createBucket(request);
    System.out.println("Bucket: " + bucketName + " created with " + storageClass + " class storage!");
}

Die Optionen der Speicherklasse umfassen:

• us-south-standard / us-east-standard / eu-gb-standard- Standardspeicher
• us-south-vault / us-east-vault / eu-gb-vault- Tresorraum
• us-south-cold / us-east-cold / eu-gb-cold- Lagerung im Kühlturm
• us-south-flex / us-east-flex / eu-gb-flex- Flex-Storage

Neue Textdatei erstellen

public static void createTextFile(String bucketName, String itemName, String fileText, S3Client cosClient) {
    System.out.println("Creating new item: " + itemName);
    PutObjectRequest request = PutObjectRequest.builder()
            .bucket(bucketName)
            .key(itemName)
            .build();
    cosClient.putObject(request, RequestBody.fromString(fileText));
    System.out.println("Item: " + itemName + " created!");
}

Objekt aus Datei hochladen

public static void putObject(String bucketName, String itemName, String filePath, S3Client cosClient) {
    System.out.println("Creating new item: " + itemName);
    PutObjectRequest request = PutObjectRequest.builder()
            .bucket(bucketName)
            .key(itemName)
            .build();
    cosClient.putObject(request, RequestBody.fromFile(new File(filePath)));
    System.out.println("Item: " + itemName + " created!");
}

Objekt per Streaming hochladen

public static void putObjectStream(String bucketName, String itemName, InputStream inputStream, long contentLength, S3Client cosClient) {
    System.out.println("Creating new item: " + itemName + " from input stream");
    PutObjectRequest request = PutObjectRequest.builder()
            .bucket(bucketName)
            .key(itemName)
            .contentLength(contentLength)
            .build();
    cosClient.putObject(request, RequestBody.fromInputStream(inputStream, contentLength));
    System.out.println("Item: " + itemName + " created!");
}

Objekt in Datei herunterladen

public static void getObject(String bucketName, String itemName, String filePath, S3Client cosClient) {
    System.out.println("Retrieving item: " + itemName);
    GetObjectRequest request = GetObjectRequest.builder()
            .bucket(bucketName)
            .key(itemName)
            .build();
    cosClient.getObject(request, ResponseTransformer.toFile(new File(filePath)));
    System.out.println("Item: " + itemName + " downloaded to: " + filePath);
}

Objekt per Streaming herunterladen

public static void getObjectStream(String bucketName, String itemName, S3Client cosClient) {
    System.out.println("Retrieving item: " + itemName + " as stream");
    GetObjectRequest request = GetObjectRequest.builder()
            .bucket(bucketName)
            .key(itemName)
            .build();
    ResponseInputStream<GetObjectResponse> response = cosClient.getObject(request);
    try (InputStream inputStream = response) {
        // Process the input stream
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = inputStream.read(buffer)) != -1) {
            // Process bytes
            System.out.write(buffer, 0, bytesRead);
        }
    } catch (IOException e) {
        System.err.println("Error reading object: " + e.getMessage());
    }
    System.out.println("\nItem: " + itemName + " retrieved!");
}

Objekte kopieren

public static void copyObject(String sourceBucketName, String sourceKey, String destinationBucketName, String destinationKey, S3Client cosClient) {
    System.out.println("Copying item: " + sourceKey + " from bucket: " + sourceBucketName +
                       " to: " + destinationKey + " in bucket: " + destinationBucketName);
    CopyObjectRequest request = CopyObjectRequest.builder()
            .sourceBucket(sourceBucketName)
            .sourceKey(sourceKey)
            .destinationBucket(destinationBucketName)
            .destinationKey(destinationKey)
            .build();
    cosClient.copyObject(request);
    System.out.println("Item: " + sourceKey + " copied!");
}

Verfügbare Buckets auflisten

public static void listBuckets(S3Client cosClient) {
    System.out.println("Listing buckets:");
    ListBucketsResponse response = cosClient.listBuckets();
    List<Bucket> buckets = response.buckets();
    for (Bucket bucket : buckets) {
        System.out.println("Bucket Name: " + bucket.name());
    }
}

Dateiinhalt eines bestimmten Elements abrufen

public static void getItem(String bucketName, String itemName, S3Client cosClient) {
    System.out.println("Retrieving item: " + itemName);
    GetObjectRequest request = GetObjectRequest.builder()
            .bucket(bucketName)
            .key(itemName)
            .build();
    ResponseInputStream<GetObjectResponse> response = cosClient.getObject(request);
    try {
        String content = new String(response.readAllBytes(), StandardCharsets.UTF_8);
        System.out.println("File Contents:\n" + content);
    } catch (IOException e) {
        System.err.println("Error reading object: " + e.getMessage());
    }
}

Element in Bucket löschen

public static void deleteItem(String bucketName, String itemName, S3Client cosClient) {
    System.out.println("Deleting item: " + itemName);
    DeleteObjectRequest request = DeleteObjectRequest.builder()
            .bucket(bucketName)
            .key(itemName)
            .build();
    cosClient.deleteObject(request);
    System.out.println("Item: " + itemName + " deleted!");
}

Mehrere Elemente in Bucket löschen

public static void deleteMultipleItems(String bucketName, List<String> itemNames, S3Client cosClient) {
    System.out.println("Deleting multiple items from bucket: " + bucketName);
    List<ObjectIdentifier> objectsToDelete = itemNames.stream()
            .map(key -> ObjectIdentifier.builder().key(key).build())
            .collect(Collectors.toList());
    Delete delete = Delete.builder()
            .objects(objectsToDelete)
            .build();
    DeleteObjectsRequest request = DeleteObjectsRequest.builder()
            .bucket(bucketName)
            .delete(delete)
            .build();
    DeleteObjectsResponse response = cosClient.deleteObjects(request);
    System.out.println("Deleted " + response.deleted().size() + " items!");
}

Bucket löschen

Der Eimer muss leer sein, bevor er gelöscht werden kann.

public static void deleteBucket(String bucketName, S3Client cosClient) {
    System.out.println("Deleting bucket: " + bucketName);
    DeleteBucketRequest request = DeleteBucketRequest.builder()
            .bucket(bucketName)
            .build();
    cosClient.deleteBucket(request);
    System.out.println("Bucket: " + bucketName + " deleted!");
}

Öffentliche Lesbarkeit eines Objekts überprüfen

public static boolean isObjectPubliclyReadable(String bucketName, String objectKey, S3Client cosClient) {
    System.out.println("Checking if object is publicly readable: " + objectKey);
    try {
        GetObjectAclRequest request = GetObjectAclRequest.builder()
                .bucket(bucketName)
                .key(objectKey)
                .build();
        GetObjectAclResponse response = cosClient.getObjectAcl(request);
        for (Grant grant : response.grants()) {
            if (grant.grantee().type() == Type.GROUP &&
                grant.grantee().uri() != null &&
                grant.grantee().uri().contains("AllUsers") &&
                grant.permission() == Permission.READ) {
                System.out.println("Object is publicly readable");
                return true;
            }
        }
        System.out.println("Object is not publicly readable");
        return false;
    } catch (S3Exception e) {
        System.err.println("Error checking object ACL: " + e.getMessage());
        return false;
    }
}

Mehrteiligen Upload ausführen

Beim Arbeiten mit größeren Objekten werden Operationen mit mehrteiligen Uploads empfohlen, um Objekte in IBM Cloud Object Storage zu schreiben. Der Upload eines einzelnen Objekts kann als Gruppe einzelner Teile ausgeführt werden. Diese Teile können unabhängig voneinander in beliebiger Reihenfolge und auch parallel hochgeladen werden. Nach Abschluss des Uploads stellt IBM Cloud Object Storage alle Teile als ein einziges Objekt dar.

Mehrteilige Uploads sind nur für Objekte mit einer Größe von mehr als 5 MB verfügbar. Bei Objekten, die kleiner als 50 GB sind, wird eine Größe der einzelnen Teile zwischen 20 MB und 100 MB empfohlen, um eine optimale Leistung zu erzielen. Bei größeren Objekten kann die Größe der Teile vergrößert werden, ohne dass hierdurch die Leistung wesentlich beeinträchtigt wird.

public static void multipartUpload(String bucketName, String itemName, String filePath, S3Client cosClient) {
    System.out.println("Starting multipart upload for: " + itemName);
    // Step 1: Initiate multipart upload
    CreateMultipartUploadRequest initiateRequest = CreateMultipartUploadRequest.builder()
            .bucket(bucketName)
            .key(itemName)
            .build();
    CreateMultipartUploadResponse initiateResponse = cosClient.createMultipartUpload(initiateRequest);
    String uploadId = initiateResponse.uploadId();
    System.out.println("Upload ID: " + uploadId);
    // Step 2: Upload parts
    int partNumber = 1;
    List<CompletedPart> completedParts = new ArrayList<>();
    ByteBuffer buffer = ByteBuffer.allocate(5 * 1024 * 1024); // 5 MB parts
    try (RandomAccessFile file = new RandomAccessFile(filePath, "r")) {
        long fileSize = file.length();
        long position = 0;
        while (position < fileSize) {
            file.seek(position);
            long bytesRead = file.getChannel().read(buffer);
            buffer.flip();
            UploadPartRequest uploadPartRequest = UploadPartRequest.builder()
                    .bucket(bucketName)
                    .key(itemName)
                    .uploadId(uploadId)
                    .partNumber(partNumber)
                    .build();
            UploadPartResponse partResponse = cosClient.uploadPart(
                    uploadPartRequest,
                    RequestBody.fromByteBuffer(buffer)
            );
            CompletedPart part = CompletedPart.builder()
                    .partNumber(partNumber)
                    .eTag(partResponse.eTag())
                    .build();
            completedParts.add(part);
            System.out.println("Uploaded part " + partNumber);
            buffer.clear();
            position += bytesRead;
            partNumber++;
        }
    } catch (IOException e) {
        System.err.println("Error during multipart upload: " + e.getMessage());
        // Abort the multipart upload on error
        AbortMultipartUploadRequest abortRequest = AbortMultipartUploadRequest.builder()
                .bucket(bucketName)
                .key(itemName)
                .uploadId(uploadId)
                .build();
        cosClient.abortMultipartUpload(abortRequest);
        return;
    }
    // Step 3: Complete multipart upload
    CompletedMultipartUpload completedUpload = CompletedMultipartUpload.builder()
            .parts(completedParts)
            .build();
    CompleteMultipartUploadRequest completeRequest = CompleteMultipartUploadRequest.builder()
            .bucket(bucketName)
            .key(itemName)
            .uploadId(uploadId)
            .multipartUpload(completedUpload)
            .build();
    cosClient.completeMultipartUpload(completeRequest);
    System.out.println("Multipart upload completed for: " + itemName);
}

Immutable Object Storage (IOS) verwenden

Benutzer können Buckets mit der Richtlinie Unveränderlich Object Storage konfigurieren, um zu verhindern, dass Objekte für einen bestimmten Zeitraum geändert oder gelöscht werden. Die Aufbewahrungsfrist kann für jedes Objekt einzeln festgelegt werden, oder die Objekte können eine für den Bereich festgelegte Standardaufbewahrungsfrist übernehmen.

Hinzufügen einer Schutzkonfiguration zu einem Bucket

Bei dieser Implementierung der PUT-Operation wird der Abfrageparameter protection verwendet, um die Aufbewahrungsparameter für ein vorhandenes Bucket festzulegen. Diese Operation ermöglicht Ihnen das Festlegen der Werte für die mindestens erforderliche, maximal zulässige und standardmäßige Aufbewahrungsdauer. Mit dieser Operation können Sie auch den Schutzstatus des Buckets ändern.

Objekte, die in ein geschütztes Bucket geschrieben wurden, können erst gelöscht werden, nachdem die Schutzfrist abgelaufen ist und alle Beweissicherungsvermerke für das Objekt entfernt wurden. Einem Objekt wird der Standardaufbewahrungswert des Buckets zugewiesen, es sei denn, bei der Erstellung des Objekts wird ein objektspezifischer Wert angegeben. Objekte in geschützten Buckets, die nicht mehr der Aufbewahrungspflicht unterliegen (die Aufbewahrungsfrist ist abgelaufen und für das Objekt besteht keine rechtliche Aufbewahrungspflicht mehr), unterliegen bei Überschreibung erneut der Aufbewahrungspflicht. Die neue Aufbewahrungsdauer kann als Teil der Objektüberschreibungsanforderung angegeben werden oder dem Objekt wird der Standardaufbewahrungszeitraum des Buckets zugeordnet.

Die unterstützten Mindest- und Höchstwerte für die Einstellungen der Aufbewahrungsdauer MinimumRetention, DefaultRetention, und liegen MaximumRetention bei mindestens 0 Tagen und höchstens 365.243 Tagen (1.000 Jahre).

public static void addProtectionConfigurationToBucket(String bucketName, S3Client cosClient) {
    System.out.println("Adding protection configuration to bucket: " + bucketName);
    BucketProtectionConfiguration protectionConfig = BucketProtectionConfiguration.builder()
            .status(BucketProtectionStatus.RETENTION)
            .minimumRetention(BucketProtectionMinimumRetention.builder()
                    .days(10)
                    .build())
            .defaultRetention(BucketProtectionDefaultRetention.builder()
                    .days(100)
                    .build())
            .maximumRetention(BucketProtectionMaximumRetention.builder()
                    .days(1000)
                    .build())
            .build();
    PutBucketProtectionConfigurationRequest request = PutBucketProtectionConfigurationRequest.builder()
            .bucket(bucketName)
            .protectionConfiguration(protectionConfig)
            .build();
    cosClient.putBucketProtectionConfiguration(request);
    System.out.println("Protection configuration added!");
}

Abrufen der Schutzkonfiguration eines Eimers

public static void getProtectionConfigurationOnBucket(String bucketName, S3Client cosClient) {
    System.out.println("Retrieving protection configuration for bucket: " + bucketName);
    GetBucketProtectionConfigurationRequest request = GetBucketProtectionConfigurationRequest.builder()
            .bucket(bucketName)
            .build();
    GetBucketProtectionConfigurationResponse response = cosClient.getBucketProtectionConfiguration(request);
    System.out.println("Status: " + response.status());
    System.out.println("Minimum Retention (days): " + response.minimumRetention().days());
    System.out.println("Default Retention (days): " + response.defaultRetention().days());
    System.out.println("Maximum Retention (days): " + response.maximumRetention().days());
}

Hochladen eines geschützten Objekts mit Speicherung

Objekte in geschützten Buckets, die nicht mehr der Aufbewahrungspflicht unterliegen (die Aufbewahrungsfrist ist abgelaufen und für das Objekt besteht keine rechtliche Aufbewahrungspflicht mehr), unterliegen bei Überschreibung erneut der Aufbewahrungspflicht. Die neue Aufbewahrungsdauer kann als Teil der Objektüberschreibungsanforderung angegeben werden oder dem Objekt wird der Standardaufbewahrungszeitraum des Buckets zugeordnet.

Sie können beim Hochladen von Objekten in geschützte Buckets mithilfe von benutzerdefinierten Kopfzeilen Parameter für die Aufbewahrung angeben:

public static void uploadProtectedObject(String bucketName, String objectKey, String filePath, S3Client cosClient) {
    System.out.println("Uploading protected object with retention: " + objectKey);
    // Option 1: Upload with retention period (in seconds)
    PutObjectRequest requestWithPeriod = PutObjectRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .retentionPeriod(2592000L)  // 30 days in seconds
            .build();
    cosClient.putObject(requestWithPeriod, RequestBody.fromFile(new File(filePath)));
    System.out.println("Object uploaded with 30-day retention period");
}
public static void uploadProtectedObjectWithExpirationDate(String bucketName, String objectKey, String filePath, S3Client cosClient) {
    System.out.println("Uploading protected object with expiration date: " + objectKey);
    // Option 2: Upload with retention expiration date
    Instant expirationDate = Instant.now().plus(90, ChronoUnit.DAYS);
    PutObjectRequest requestWithDate = PutObjectRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .retentionExpirationDate(expirationDate)
            .build();
    cosClient.putObject(requestWithDate, RequestBody.fromFile(new File(filePath)));
    System.out.println("Object uploaded with expiration date: " + expirationDate);
}
public static void uploadProtectedObjectWithLegalHold(String bucketName, String objectKey, String filePath, String legalHoldId, S3Client cosClient) {
    System.out.println("Uploading protected object with legal hold: " + objectKey);
    // Option 3: Upload with legal hold
    PutObjectRequest requestWithLegalHold = PutObjectRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .retentionLegalHoldId(legalHoldId)
            .build();
    cosClient.putObject(requestWithLegalHold, RequestBody.fromFile(new File(filePath)));
    System.out.println("Object uploaded with legal hold: " + legalHoldId);
}
public static void uploadProtectedObjectWithMultipleRetentionOptions(String bucketName, String objectKey, String filePath, String legalHoldId, S3Client cosClient) {
    System.out.println("Uploading protected object with retention period and legal hold: " + objectKey);
    // Option 4: Combine retention period with legal hold
    PutObjectRequest request = PutObjectRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .retentionPeriod(2592000L)  // 30 days
            .retentionLegalHoldId(legalHoldId)
            .build();
    cosClient.putObject(request, RequestBody.fromFile(new File(filePath)));
    System.out.println("Object uploaded with retention and legal hold");
}

Wichtige Hinweise:

• Sie können nicht sowohl Retention-Period als auch Retention-Expiration-Date in derselben Anfrage angeben.
• Wenn keiner der beiden Aufbewahrungsparameter angegeben ist, wird die Standardaufbewahrungszeit des Bereichs angewendet.
• Gesetzliche Sperrfristen können mit Aufbewahrungsfristen kombiniert werden.
• Objekte, für die eine Aufbewahrungsfrist gilt oder die mit einer rechtlichen Sperre versehen sind, können nicht gelöscht oder überschrieben werden, bevor die Aufbewahrungsfrist abgelaufen ist und alle rechtlichen Sperren aufgehoben wurden.

Hinzufügen eines legalen Zugriffs auf ein geschütztes Objekt

Das Objekt kann bis zu 100 Beweissicherungsvermerke unterstützen:

Eine Kennung für die Aufbewahrungspflicht ist eine Zeichenfolge mit einer maximalen Länge von 64 Zeichen und einer minimalen Länge von 1 Zeichen. Zulässige Zeichen sind Buchstaben, Zahlen, !, _, ., *, (, ), -, und '. Wenn durch das Hinzufügen des angegebenen Beweissicherungsvermerks der Grenzwert von insgesamt 100 Beweissicherungsvermerken für das Objekt überschritten wird, dann wird der neue Beweissicherungsvermerk nicht hinzugefügt und das System gibt den Fehler 400 aus. Ist eine Kennung zu lang, wird sie dem Objekt nicht hinzugefügt, und es wird ein Fehler 400 zurückgegeben. Wenn eine Kennung ungültige Zeichen enthält, dann wird sie nicht zum Objekt hinzugefügt und das System gibt den Fehler 400 zurück. Wenn eine Kennung für ein Objekt bereits verwendet wird, dann wird der vorhandene Beweissicherungsvermerk nicht geändert und in der Antwort wird angegeben, dass die Kennung bereits belegt ist (Fehler 409). Wenn ein Objekt keine Metadaten für die Aufbewahrungsdauer aufweist, wird der Fehler 400 zurückgegeben und das Hinzufügen oder Entfernen eines Beweissicherungsvermerks ist nicht zulässig. Das Vorhandensein eines Headers für die Aufbewahrungsdauer ist erforderlich, da andernfalls der Fehler 400 zurückgegeben wird.

Der Benutzer, der einen Beweissicherungsvermerk hinzufügt oder entfernt, muss über die Berechtigungen für Manager für dieses Bucket verfügen.

public static void addLegalHoldToObject(String bucketName, String objectKey, String legalHoldId, S3Client cosClient) {
    System.out.println("Adding legal hold to object: " + objectKey);
    AddLegalHoldRequest request = AddLegalHoldRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .legalHoldId(legalHoldId)
            .build();
    cosClient.addLegalHold(request);
    System.out.println("Legal hold added!");
}

Verlängerung der Aufbewahrungsfrist eines geschützten Objekts

Die Aufbewahrungsdauer eines Objekts kann nur verlängert werden. Sie kann gegenüber dem momentan konfigurierten Wert nicht verkürzt werden.

Der Wert für die Verlängerung der Aufbewahrungsdauer kann auf die folgenden drei Arten festgelegt werden:

• Zusätzliche Zeit ausgehend vom aktuellen Wert (additionalRetentionPeriod oder eine ähnliche Methode)
• Neue Verlängerungsdauer in Sekunden (extendRetentionFromCurrentTime oder eine ähnliche Methode)
• Neues Ablaufdatum für die Aufbewahrungsdauer des Objekts (newRetentionExpirationDate oder eine ähnliche Methode)

Die in den Objektmetadaten momentan gespeicherte Aufbewahrungsdauer wird entweder um die angegebene zusätzliche Zeitdauer verlängert oder durch den neuen Wert ersetzt. Welche Methode verwendet wird, hängt von dem Parameter ab, der in der Anforderung für extendRetention festgelegt wird. In allen Fällen wird der Parameter für die verlängerte Aufbewahrungsfrist mit der aktuellen Aufbewahrungsfrist abgeglichen, und der Parameter für die Verlängerung wird nur akzeptiert, wenn die aktualisierte Aufbewahrungsfrist länger ist als die aktuelle Aufbewahrungsfrist.

Objekte in geschützten Buckets, die nicht mehr der Aufbewahrungspflicht unterliegen (die Aufbewahrungsfrist ist abgelaufen und für das Objekt besteht keine rechtliche Aufbewahrungspflicht mehr), unterliegen bei Überschreibung erneut der Aufbewahrungspflicht. Die neue Aufbewahrungsdauer kann als Teil der Objektüberschreibungsanforderung angegeben werden oder dem Objekt wird der Standardaufbewahrungszeitraum des Buckets zugeordnet.

public static void extendRetentionPeriodOnObject(String bucketName, String objectName, Long additionalSeconds, S3Client cosClient) {
    System.out.printf("Extending the retention period on %s in bucket %s by %s seconds.%n", objectName, bucketName, additionalSeconds);
    ExtendObjectRetentionRequest request = ExtendObjectRetentionRequest.builder()
            .bucket(bucketName)
            .key(objectName)
            .additionalRetentionPeriod(additionalSeconds)
            .build();
    cosClient.extendObjectRetention(request);
    System.out.printf("Retention period extended on %s by %s seconds%n", objectName, additionalSeconds);
}

Auflistung von Aufbewahrungspflichten für ein geschütztes Objekt

Nach dem Ausführen dieser Operation wird Folgendes zurückgegeben:

• Objekterstellungsdatum
• Aufbewahrungsdauer des Objekts in Sekunden
• Berechnetes Ablaufdatum der Aufbewahrungsfrist basierend auf der Dauer und dem Erstellungsdatum
• Liste der Beweissicherungsvermerke
  • Kennung des Beweissicherungsvermerks
  • Zeitmarke für Anwendung des Beweissicherungsvermerks

Wichtige Hinweise:

• Wenn für das Objekt keine rechtlichen Aufbewahrungspflichten bestehen, wird LegalHoldSet ein leerer Wert zurückgegeben
• Wenn für das Objekt keine Aufbewahrungsfrist angegeben ist, wird ein Fehler 404 zurückgegeben

public static void listLegalHoldsOnObject(String bucketName, String objectKey, S3Client cosClient) {
    System.out.println("Listing legal holds for object: " + objectKey);
    ListLegalHoldsRequest request = ListLegalHoldsRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .build();
    ListLegalHoldsResponse response = cosClient.listLegalHolds(request);
    for (LegalHold hold : response.legalHolds()) {
        System.out.println("Legal Hold ID: " + hold.id());
        System.out.println("Date: " + hold.date());
    }
}

Löschen eines rechtlichen Zugriffs auf ein geschütztes Objekt

public static void deleteLegalHoldFromObject(String bucketName, String objectKey, String legalHoldId, S3Client cosClient) {
    System.out.println("Deleting legal hold from object: " + objectKey);
    DeleteLegalHoldRequest request = DeleteLegalHoldRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .legalHoldId(legalHoldId)
            .build();
    cosClient.deleteLegalHold(request);
    System.out.println("Legal hold deleted!");
}

Key Protect verwenden

Key Protect kann zu einem Speicherbucket hinzugefügt werden, um sensible ruhende Daten in der Cloud zu verschlüsseln.

public static void createBucketWithKeyProtect(String bucketName, String kpRootKeyCrn, S3Client cosClient) {
    System.out.println("Creating bucket with Key Protect: " + bucketName);
    CreateBucketRequest request = CreateBucketRequest.builder()
            .bucket(bucketName)
            .ibmSSEKPEncryptionAlgorithm("AES256")
            .ibmSSEKPCustomerRootKeyCrn(kpRootKeyCrn)
            .build();
    cosClient.createBucket(request);
    System.out.println("Bucket created with Key Protect encryption!");
}

public static void putObjectToKPBucket(String bucketName, String objectKey, String filePath, S3Client cosClient) {
    System.out.println("Uploading object to Key Protect enabled bucket");
    PutObjectRequest request = PutObjectRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .build();
    cosClient.putObject(request, RequestBody.fromFile(new File(filePath)));
    System.out.println("Object uploaded with Key Protect encryption!");
}

Größere Objekte mit einem Übertragungsmanager hochladen

Der Transfer Manager bietet eine einfache API zum Hoch- und Herunterladen von Objekten auf und von IBM Cloud Object Storage.

import com.ibm.cos.v2.transfer.s3.S3TransferManager;
import com.ibm.cos.v2.transfer.s3.model.*;
public static void uploadWithTransferManager(String bucketName, String objectKey, String filePath, S3Client cosClient) {
    System.out.println("Uploading with Transfer Manager: " + objectKey);
    // Create Transfer Manager
    S3TransferManager transferManager = S3TransferManager.builder()
            .s3Client(cosClient)
            .build();
    try {
        // Upload file
        UploadFileRequest uploadRequest = UploadFileRequest.builder()
                .putObjectRequest(req -> req.bucket(bucketName).key(objectKey))
                .source(Paths.get(filePath))
                .build();
        FileUpload upload = transferManager.uploadFile(uploadRequest);
        // Wait for upload to complete
        CompletedFileUpload completedUpload = upload.completionFuture().join();
        System.out.println("Upload completed: " + completedUpload.response().eTag());
    } finally {
        transferManager.close();
    }
}

Metadaten aktualisieren

public static void updateObjectMetadata(String bucketName, String objectKey, S3Client cosClient) {
    System.out.println("Updating metadata for object: " + objectKey);
    // Create new metadata
    Map<String, String> newMetadata = new HashMap<>();
    newMetadata.put("updated-by", "admin");
    newMetadata.put("update-date", LocalDate.now().toString());
    // Copy object to itself with new metadata
    CopyObjectRequest request = CopyObjectRequest.builder()
            .sourceBucket(bucketName)
            .sourceKey(objectKey)
            .destinationBucket(bucketName)
            .destinationKey(objectKey)
            .metadata(newMetadata)
            .metadataDirective(MetadataDirective.REPLACE)
            .build();
    cosClient.copyObject(request);
    System.out.println("Metadata updated!");
}

Aspera-Hochgeschwindigkeitsübertragung verwenden

Die Integration der Aspera-Hochgeschwindigkeitsübertragung ist über das IBM Aspera SDK verfügbar. Einzelheiten zur Integration mit IBM Cloud Object Storage finden Sie in der Aspera-Dokumentation.

Für Java Anwendungen können Sie Aspera Transfer SDK zusammen mit dem IBM Cloud Object Storage SDK v2 für Hochgeschwindigkeitsübertragungen von großen Dateien verwenden.

Objektsperre verwenden

Mit der Objektsperre können Sie Objekte nach dem WORM-Modell (write-once-read-many) speichern. Mit der Objektsperre können Sie verhindern, dass Objekte für eine bestimmte Zeit oder auf unbestimmte Zeit gelöscht oder überschrieben werden.

public static void createBucketWithObjectLock(String bucketName, S3Client cosClient) {
    System.out.println("Creating bucket with Object Lock: " + bucketName);
    CreateBucketRequest request = CreateBucketRequest.builder()
            .bucket(bucketName)
            .objectLockEnabledForBucket(true)
            .build();
    cosClient.createBucket(request);
    System.out.println("Bucket created with Object Lock enabled!");
}

public static void putObjectRetention(String bucketName, String objectKey, S3Client cosClient) {
    System.out.println("Setting object retention for: " + objectKey);
    // Create retention period of 90 days
    Instant retainUntil = Instant.now().plus(90, ChronoUnit.DAYS);
    // Create object lock retention with COMPLIANCE mode
    ObjectLockRetention retention = ObjectLockRetention.builder()
            .mode(ObjectLockRetentionMode.COMPLIANCE)
            .retainUntilDate(retainUntil)
            .build();
    // Apply retention to object
    PutObjectRetentionRequest request = PutObjectRetentionRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .retention(retention)
            .build();
    cosClient.putObjectRetention(request);
    System.out.println("Object retention set until: " + retainUntil);
}

public static void getObjectRetention(String bucketName, String objectKey, S3Client cosClient) {
    System.out.println("Getting object retention for: " + objectKey);
    GetObjectRetentionRequest request = GetObjectRetentionRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .build();
    GetObjectRetentionResponse response = cosClient.getObjectRetention(request);
    System.out.println("Retention Mode: " + response.retention().mode());
    System.out.println("Retain Until: " + response.retention().retainUntilDate());
}

public static void putObjectLegalHold(String bucketName, String objectKey, S3Client cosClient) {
    System.out.println("Setting legal hold on: " + objectKey);
    ObjectLockLegalHold legalHold = ObjectLockLegalHold.builder()
            .status(ObjectLockLegalHoldStatus.ON)
            .build();
    PutObjectLegalHoldRequest request = PutObjectLegalHoldRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .legalHold(legalHold)
            .build();
    cosClient.putObjectLegalHold(request);
    System.out.println("Legal hold applied!");
}

public static void getObjectLegalHold(String bucketName, String objectKey, S3Client cosClient) {
    System.out.println("Getting legal hold status for: " + objectKey);
    GetObjectLegalHoldRequest request = GetObjectLegalHoldRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .build();
    GetObjectLegalHoldResponse response = cosClient.getObjectLegalHold(request);
    System.out.println("Legal Hold Status: " + response.legalHold().status());
}

Eimer-Lebenszyklus-Konfiguration verwenden

Die Lebenszykluskonfiguration ermöglicht es Ihnen, Aktionen zu definieren, die IBM Cloud Object Storage auf eine Gruppe von Objekten anwendet. Sie können Lebenszyklusrichtlinien verwenden, um Objekte in verschiedene Speicherklassen zu überführen oder Objekte nach einer bestimmten Zeitspanne auslaufen zu lassen.

public static void putBucketLifecycle(String bucketName, S3Client cosClient) {
    System.out.println("Setting lifecycle configuration on bucket: " + bucketName);
    // Create a transition to move objects to GLACIER after 30 days
    Transition transition = Transition.builder()
            .days(30)
            .storageClass(StorageClass.GLACIER)
            .build();
    // Create lifecycle rule filter
    LifecycleRuleFilter ruleFilter = LifecycleRuleFilter.builder()
            .prefix("archive/")  // Apply to objects with this prefix
            .build();
    // Create lifecycle rule
    LifecycleRule rule = LifecycleRule.builder()
            .id("archive-old-objects")
            .filter(ruleFilter)
            .transitions(transition)
            .status(ExpirationStatus.ENABLED)
            .build();
    // Create lifecycle configuration
    BucketLifecycleConfiguration lifecycleConfig = BucketLifecycleConfiguration.builder()
            .rules(rule)
            .build();
    // Apply lifecycle configuration to bucket
    PutBucketLifecycleConfigurationRequest request = PutBucketLifecycleConfigurationRequest.builder()
            .bucket(bucketName)
            .lifecycleConfiguration(lifecycleConfig)
            .build();
    cosClient.putBucketLifecycleConfiguration(request);
    System.out.println("Lifecycle configuration applied!");
}

public static void getBucketLifecycle(String bucketName, S3Client cosClient) {
    System.out.println("Getting lifecycle configuration for bucket: " + bucketName);
    GetBucketLifecycleConfigurationRequest request = GetBucketLifecycleConfigurationRequest.builder()
            .bucket(bucketName)
            .build();
    GetBucketLifecycleConfigurationResponse response = cosClient.getBucketLifecycleConfiguration(request);
    System.out.println("Found " + response.rules().size() + " lifecycle rules:");
    for (LifecycleRule rule : response.rules()) {
        System.out.println("  Rule ID: " + rule.id());
        System.out.println("  Status: " + rule.status());
        if (rule.hasTransitions()) {
            for (Transition t : rule.transitions()) {
                System.out.println("  Transition after " + t.days() + " days to " + t.storageClass());
            }
        }
    }
}

public static void deleteBucketLifecycle(String bucketName, S3Client cosClient) {
    System.out.println("Deleting lifecycle configuration from bucket: " + bucketName);
    DeleteBucketLifecycleRequest request = DeleteBucketLifecycleRequest.builder()
            .bucket(bucketName)
            .build();
    cosClient.deleteBucketLifecycle(request);
    System.out.println("Lifecycle configuration deleted!");
}

Versionierung von Eimern verwenden

Die Versionierung ermöglicht es Ihnen, mehrere Versionen eines Objekts im selben Bucket zu speichern. Dies kann Ihnen helfen, unbeabsichtigte Benutzeraktionen und Anwendungsfehler zu beheben.

public static void enableBucketVersioning(String bucketName, S3Client cosClient) {
    System.out.println("Enabling versioning on bucket: " + bucketName);
    VersioningConfiguration versioningConfig = VersioningConfiguration.builder()
            .status(BucketVersioningStatus.ENABLED)
            .build();
    PutBucketVersioningRequest request = PutBucketVersioningRequest.builder()
            .bucket(bucketName)
            .versioningConfiguration(versioningConfig)
            .build();
    cosClient.putBucketVersioning(request);
    System.out.println("Versioning enabled!");
}

public static void getBucketVersioning(String bucketName, S3Client cosClient) {
    System.out.println("Getting versioning status for bucket: " + bucketName);
    GetBucketVersioningRequest request = GetBucketVersioningRequest.builder()
            .bucket(bucketName)
            .build();
    GetBucketVersioningResponse response = cosClient.getBucketVersioning(request);
    System.out.println("Versioning Status: " + response.status());
}

public static void listObjectVersions(String bucketName, S3Client cosClient) {
    System.out.println("Listing object versions in bucket: " + bucketName);
    ListObjectVersionsRequest request = ListObjectVersionsRequest.builder()
            .bucket(bucketName)
            .build();
    ListObjectVersionsResponse response = cosClient.listObjectVersions(request);
    System.out.println("Versions:");
    for (ObjectVersion version : response.versions()) {
        System.out.println("  Key: " + version.key());
        System.out.println("  Version ID: " + version.versionId());
        System.out.println("  Is Latest: " + version.isLatest());
        System.out.println("  Last Modified: " + version.lastModified());
        System.out.println();
    }
}

public static void deleteObjectVersion(String bucketName, String objectKey, String versionId, S3Client cosClient) {
    System.out.println("Deleting version " + versionId + " of object: " + objectKey);
    DeleteObjectRequest request = DeleteObjectRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .versionId(versionId)
            .build();
    cosClient.deleteObject(request);
    System.out.println("Object version deleted!");
}

Erweitertes Bucket Listing verwenden

IBM Cloud Object Storage bietet eine erweiterte Auflistungs-API, die zusätzliche Metadaten über Buckets zurückgibt, einschließlich Informationen zu Standort und Speicherklasse.

public static void listBucketsExtended(S3Client cosClient) {
    System.out.println("Listing buckets with extended information:");
    ListBucketsExtendedRequest request = ListBucketsExtendedRequest.builder().build();
    ListBucketsExtendedResponse response = cosClient.listBucketsExtended(request);
    for (Bucket bucket : response.buckets()) {
        System.out.println("Bucket Name: " + bucket.name());
        System.out.println("  Creation Date: " + bucket.creationDate());
        // Extended metadata (IBM-specific)
        if (bucket.locationConstraint() != null) {
            System.out.println("  Location: " + bucket.locationConstraint());
        }
    }
}

Verwendung von Archive Tier und Object Restoration

IBM Cloud Object Storage bietet Archivspeicherklassen (Glacier) für die langfristige Datenspeicherung zu geringeren Kosten. Objekte im Archivspeicher müssen wiederhergestellt werden, bevor auf sie zugegriffen werden kann.

public static void setArchiveRule(String bucketName, S3Client cosClient) {
    System.out.println("Setting archive rule on bucket: " + bucketName);
    // Create transition to Glacier after 30 days
    Transition transition = Transition.builder()
            .days(30)
            .storageClass(StorageClass.GLACIER)
            .build();
    // Create lifecycle rule
    LifecycleRuleFilter filter = LifecycleRuleFilter.builder()
            .prefix("archive/")
            .build();
    LifecycleRule rule = LifecycleRule.builder()
            .id("archive-rule")
            .filter(filter)
            .transitions(transition)
            .status(ExpirationStatus.ENABLED)
            .build();
    // Apply lifecycle configuration
    BucketLifecycleConfiguration config = BucketLifecycleConfiguration.builder()
            .rules(rule)
            .build();
    PutBucketLifecycleConfigurationRequest request = PutBucketLifecycleConfigurationRequest.builder()
            .bucket(bucketName)
            .lifecycleConfiguration(config)
            .build();
    cosClient.putBucketLifecycleConfiguration(request);
    System.out.println("Archive rule configured!");
}

public static void restoreArchivedObject(String bucketName, String objectKey, int days, S3Client cosClient) {
    System.out.println("Restoring archived object: " + objectKey);
    // Create restore request with duration
    RestoreRequest restoreRequest = RestoreRequest.builder()
            .days(days)
            .glacierJobParameters(GlacierJobParameters.builder()
                    .tier(Tier.STANDARD)  // Options: STANDARD (12 hours), EXPEDITED (2 hours), BULK (5-12 hours)
                    .build())
            .build();
    RestoreObjectRequest request = RestoreObjectRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .restoreRequest(restoreRequest)
            .build();
    cosClient.restoreObject(request);
    System.out.println("Restore initiated. Object will be available for " + days + " days once restored.");
}

public static void checkRestoreStatus(String bucketName, String objectKey, S3Client cosClient) {
    System.out.println("Checking restore status for: " + objectKey);
    HeadObjectRequest request = HeadObjectRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .build();
    HeadObjectResponse response = cosClient.headObject(request);
    if (response.restore() != null) {
        System.out.println("Restore Status: " + response.restore());
        // Parse restore status
        String restoreStatus = response.restore();
        if (restoreStatus.contains("ongoing-request=\"true\"")) {
            System.out.println("Restoration in progress...");
        } else if (restoreStatus.contains("ongoing-request=\"false\"")) {
            System.out.println("Object has been restored and is available for download");
        }
    } else {
        System.out.println("Object is not archived or no restore in progress");
    }
}

public static void restoreWithExpeditedRetrieval(String bucketName, String objectKey, S3Client cosClient) {
    System.out.println("Restoring with expedited retrieval: " + objectKey);
    RestoreRequest restoreRequest = RestoreRequest.builder()
            .days(1)
            .glacierJobParameters(GlacierJobParameters.builder()
                    .tier(Tier.EXPEDITED)  // 2-hour retrieval
                    .build())
            .build();
    RestoreObjectRequest request = RestoreObjectRequest.builder()
            .bucket(bucketName)
            .key(objectKey)
            .restoreRequest(restoreRequest)
            .build();
    cosClient.restoreObject(request);
    System.out.println("Expedited restore initiated (2-hour retrieval)");
}

Verwendung von CORS (Cross-Origin Resource Sharing)

CORS konfiguration ermöglicht es Webanwendungen, die in einer Domäne laufen, auf Ressourcen in IBM Cloud Object Storage aus einer anderen Domäne zuzugreifen.

public static void setCorsConfiguration(String bucketName, S3Client cosClient) {
    System.out.println("Setting CORS configuration on bucket: " + bucketName);
    // Create CORS rule
    CORSRule corsRule = CORSRule.builder()
            .allowedMethods("GET", "PUT", "POST", "DELETE")
            .allowedOrigins("https://example.com")
            .allowedHeaders("*")
            .maxAgeSeconds(3000)
            .exposeHeaders("ETag", "x-amz-request-id")
            .build();
    // Create CORS configuration
    CORSConfiguration corsConfig = CORSConfiguration.builder()
            .corsRules(corsRule)
            .build();
    PutBucketCorsRequest request = PutBucketCorsRequest.builder()
            .bucket(bucketName)
            .corsConfiguration(corsConfig)
            .build();
    cosClient.putBucketCors(request);
    System.out.println("CORS configuration applied!");
}

public static void getCorsConfiguration(String bucketName, S3Client cosClient) {
    System.out.println("Getting CORS configuration for bucket: " + bucketName);
    GetBucketCorsRequest request = GetBucketCorsRequest.builder()
            .bucket(bucketName)
            .build();
    GetBucketCorsResponse response = cosClient.getBucketCors(request);
    System.out.println("CORS Rules:");
    for (CORSRule rule : response.corsRules()) {
        System.out.println("  Allowed Methods: " + rule.allowedMethods());
        System.out.println("  Allowed Origins: " + rule.allowedOrigins());
        System.out.println("  Allowed Headers: " + rule.allowedHeaders());
        System.out.println("  Max Age: " + rule.maxAgeSeconds());
    }
}

public static void deleteCorsConfiguration(String bucketName, S3Client cosClient) {
    System.out.println("Deleting CORS configuration from bucket: " + bucketName);
    DeleteBucketCorsRequest request = DeleteBucketCorsRequest.builder()
            .bucket(bucketName)
            .build();
    cosClient.deleteBucketCors(request);
    System.out.println("CORS configuration deleted!");
}

Verwendung von Bucket Policies

Bereichsrichtlinien ermöglichen die Verwaltung der Zugriffskontrolle für Bereiche und Objekte. Sie sind in JSON geschrieben und können Benutzern und Diensten Berechtigungen erteilen oder verweigern.

public static void setBucketPolicy(String bucketName, S3Client cosClient) {
    System.out.println("Setting bucket policy on: " + bucketName);
    // Create policy document (JSON format)
    String policyText = "{"
            + "\"Version\": \"2012-10-17\","
            + "\"Statement\": [{"
            + "  \"Effect\": \"Allow\","
            + "  \"Principal\": {\"AWS\": \"*\"},"
            + "  \"Action\": \"s3:GetObject\","
            + "  \"Resource\": \"arn:aws:s3:::" + bucketName + "/*\""
            + "}]"
            + "}";
    PutBucketPolicyRequest request = PutBucketPolicyRequest.builder()
            .bucket(bucketName)
            .policy(policyText)
            .build();
    cosClient.putBucketPolicy(request);
    System.out.println("Bucket policy applied!");
}

public static void getBucketPolicy(String bucketName, S3Client cosClient) {
    System.out.println("Getting bucket policy for: " + bucketName);
    GetBucketPolicyRequest request = GetBucketPolicyRequest.builder()
            .bucket(bucketName)
            .build();
    GetBucketPolicyResponse response = cosClient.getBucketPolicy(request);
    System.out.println("Policy: " + response.policy());
}

public static void deleteBucketPolicy(String bucketName, S3Client cosClient) {
    System.out.println("Deleting bucket policy from: " + bucketName);
    DeleteBucketPolicyRequest request = DeleteBucketPolicyRequest.builder()
            .bucket(bucketName)
            .build();
    cosClient.deleteBucketPolicy(request);
    System.out.println("Bucket policy deleted!");
}

Erstellen einer gehosteten statischen Website

IBM Cloud Object Storage unterstützt das Hosting statischer Websites direkt aus Buckets. Sie können einen Bucket für die Bereitstellung statischer Inhalte konfigurieren, indem Sie ein Indexdokument und ein Fehlerdokument angeben.

Dieser Vorgang erfordert die folgende Importanweisung:

import com.ibm.cos.v2.services.s3.model.BucketWebsiteConfiguration;

public static void setBucketWebsiteConfiguration(String bucketName, S3Client cosClient) {
    System.out.println("Setting website configuration for bucket: " + bucketName);
    // Create website configuration with index and error documents
    IndexDocument indexDocument = IndexDocument.builder()
            .suffix("index.html")
            .build();
    ErrorDocument errorDocument = ErrorDocument.builder()
            .key("error.html")
            .build();
    WebsiteConfiguration websiteConfig = WebsiteConfiguration.builder()
            .indexDocument(indexDocument)
            .errorDocument(errorDocument)
            .build();
    PutBucketWebsiteRequest request = PutBucketWebsiteRequest.builder()
            .bucket(bucketName)
            .websiteConfiguration(websiteConfig)
            .build();
    cosClient.putBucketWebsite(request);
    System.out.println("Website configuration set successfully!");
}

public static void getBucketWebsiteConfiguration(String bucketName, S3Client cosClient) {
    System.out.println("Getting website configuration for bucket: " + bucketName);
    GetBucketWebsiteRequest request = GetBucketWebsiteRequest.builder()
            .bucket(bucketName)
            .build();
    GetBucketWebsiteResponse response = cosClient.getBucketWebsite(request);
    System.out.println("Index Document: " + response.indexDocument().suffix());
    System.out.println("Error Document: " + response.errorDocument().key());
}

public static void deleteBucketWebsiteConfiguration(String bucketName, S3Client cosClient) {
    System.out.println("Deleting website configuration from bucket: " + bucketName);
    DeleteBucketWebsiteRequest request = DeleteBucketWebsiteRequest.builder()
            .bucket(bucketName)
            .build();
    cosClient.deleteBucketWebsite(request);
    System.out.println("Website configuration deleted!");
}

Fehlerbehandlung und bewährte Praktiken

import com.ibm.cos.v2.services.s3.model.S3Exception;
import com.ibm.cos.v2.services.s3.model.NoSuchBucketException;
import com.ibm.cos.v2.services.s3.model.NoSuchKeyException;
public static void handleExceptions(String bucketName, String objectKey, S3Client cosClient) {
    try {
        GetObjectRequest request = GetObjectRequest.builder()
                .bucket(bucketName)
                .key(objectKey)
                .build();
        cosClient.getObject(request, ResponseTransformer.toBytes());
    } catch (NoSuchBucketException e) {
        System.err.println("Bucket does not exist: " + bucketName);
        System.err.println("Error Code: " + e.awsErrorDetails().errorCode());
    } catch (NoSuchKeyException e) {
        System.err.println("Object does not exist: " + objectKey);
        System.err.println("Error Code: " + e.awsErrorDetails().errorCode());
    } catch (S3Exception e) {
        System.err.println("S3 Error: " + e.awsErrorDetails().errorMessage());
        System.err.println("Error Code: " + e.awsErrorDetails().errorCode());
        System.err.println("Status Code: " + e.statusCode());
    } catch (Exception e) {
        System.err.println("Unexpected error: " + e.getMessage());
    }
}

// Good: Create once, reuse
S3Client client = S3Client.builder()
        .endpointOverride(URI.create(endpoint))
        .credentialsProvider(StaticCredentialsProvider.create(credentials))
        .region(Region.of(region))
        .build();
// Use client for multiple operations
client.listBuckets();
client.putObject(...);
client.getObject(...);
// Close when done
client.close();

try (S3Client client = S3Client.builder()
        .endpointOverride(URI.create(endpoint))
        .credentialsProvider(StaticCredentialsProvider.create(credentials))
        .region(Region.of(region))
        .build()) {
    // Perform operations
    client.listBuckets();
} // Client automatically closed

S3Client client = S3Client.builder()
        .endpointOverride(URI.create(endpoint))
        .credentialsProvider(StaticCredentialsProvider.create(credentials))
        .region(Region.of(region))
        .overrideConfiguration(ClientOverrideConfiguration.builder()
                .apiCallTimeout(Duration.ofMinutes(5))
                .apiCallAttemptTimeout(Duration.ofMinutes(2))
                .build())
        .build();

Zusätzliche Ressourcen

• Java API-Referenz(v2)
• GitHub-Repository
• Endpunkte und Speicherpositionen

Hilfe anfordern

• Stellen Sie Fragen auf Stack Overflow mit den Tags ibm und object-storage
• Eröffnen Sie ein Support-Ticket bei IBM Cloud Support
• Berichten Sie Fehler oder beantragen Sie Funktionen auf GitHub Issues

Diese Dokumentation enthält die Struktur und SDK-Referenzen für IBM Cloud Object Storage Java SDK v2. Vollständige, funktionierende Code-Beispiele für alle Vorgänge finden Sie im Verzeichnis examples und im Migration Guide im Repository GitHub.