Erforderliche Informationen erfassen

• bucketName und newBucketName sind eindeutige und DNS-sichere Zeichenfolgen. Da Bucketnamen im gesamten System eindeutig sind, müssen diese Werte geändert werden, wenn dieses Beispiel mehrfach ausgeführt wird. Beachten Sie, dass die Namen nach ihrer Löschung noch ca. zehn bis fünfzehn Minuten reserviert bleiben.
• apiKey ist der Wert, der in den Dienstanmeldeinformationen als „ apikey “ angegeben ist.
• serviceInstanceId ist der Wert, der in den Dienstanmeldeinformationen als „ resource_instance_id “ angegeben ist.
• endpointUrl ist ein Service-Endpunkt URL, einschließlich des Protokolls „ https:// “. Dies ist nicht der Wert für endpoints, der im Serviceberechtigungsnachweis gefunden wurde. Weitere Informationen zu Endpunkten enthält Endpunkte und Speicherpositionen.
• storageClass ist ein gültiger Bereitstellungscode, der dem Wert von endpoint entspricht. Dieser Wert wird anschließend für die S3-API-Variable LocationConstraint verwendet.
• Für location muss der Standortteil von storageClass festgelegt werden. Für us-south-standard ist dies us-south. Diese Variable wird nur für die Berechnung von HMAC-Signaturenverwendet, ist aber für jeden Client erforderlich (auch in diesem Beispiel), von dem ein IAM-API-Schlüssel verwendet wird.

    package com.cos;
    import java.time.LocalDateTime;
    import java.util.List;
    import com.ibm.cloud.objectstorage.ClientConfiguration;
    import com.ibm.cloud.objectstorage.auth.AWSCredentials;
    import com.ibm.cloud.objectstorage.auth.AWSStaticCredentialsProvider;
    import com.ibm.cloud.objectstorage.client.builder.AwsClientBuilder.EndpointConfiguration;
    import com.ibm.cloud.objectstorage.services.s3.AmazonS3;
    import com.ibm.cloud.objectstorage.services.s3.AmazonS3ClientBuilder;
    import com.ibm.cloud.objectstorage.services.s3.model.Bucket;
    import com.ibm.cloud.objectstorage.services.s3.model.ListObjectsRequest;
    import com.ibm.cloud.objectstorage.services.s3.model.ObjectListing;
    import com.ibm.cloud.objectstorage.services.s3.model.S3ObjectSummary;
    import com.ibm.cloud.objectstorage.oauth.BasicIBMOAuthCredentials;
    public class CosExample
    {
        public static void main(String[] args)
        {
            String bucketName = "<BUCKET_NAME>";  // eg my-unique-bucket-name
            String newBucketName = "<NEW_BUCKET_NAME>"; // eg my-other-unique-bucket-name
            String apiKey = "<API_KEY>"; // eg "W00YiRnLW4k3fTjMB-oiB-2ySfTrFBIQQWanc--P3byk"
            String serviceInstanceId = "<SERVICE_INSTANCE_ID"; // eg "crn:v1:bluemix:public:cloud-object-storage:global:a/3bf0d9003abfb5d29761c3e97696b71c:d6f04d83-6c4f-4a62-a165-696756d63903::"
            String endpointUrl = "https://s3.us-south.cloud-object-storage.appdomain.cloud"; // this could be any service endpoint
            String storageClass = "us-south-standard";
            String location = "us"; // not an endpoint, but used in a custom function below to obtain the correct URL
            System.out.println("Current time: " + LocalDateTime.now());
            AmazonS3 cosClient = createClient(apiKey, serviceInstanceId, endpointUrl, location);
            listObjects(cosClient, bucketName);
            createBucket(cosClient, newBucketName, storageClass);
            listBuckets(cosClient);
        }
        public static AmazonS3 createClient(String apiKey, String serviceInstanceId, String endpointUrl, String location)
        {
            AWSCredentials credentials = new BasicIBMOAuthCredentials(apiKey, serviceInstanceId);
            ClientConfiguration clientConfig = new ClientConfiguration()
                    .withRequestTimeout(5000)
                    .withTcpKeepAlive(true);
            return AmazonS3ClientBuilder
                    .standard()
                    .withCredentials(new AWSStaticCredentialsProvider(credentials))
                    .withEndpointConfiguration(new EndpointConfiguration(endpointUrl, location))
                    .withPathStyleAccessEnabled(true)
                    .withClientConfiguration(clientConfig)
                    .build();
        }
        public static void listObjects(AmazonS3 cosClient, String bucketName)
        {
            System.out.println("Listing objects in bucket " + bucketName);
            ObjectListing objectListing = cosClient.listObjects(new ListObjectsRequest().withBucketName(bucketName));
            for (S3ObjectSummary objectSummary : objectListing.getObjectSummaries()) {
                System.out.println(" - " + objectSummary.getKey() + "  " + "(size = " + objectSummary.getSize() + ")");
            }
            System.out.println();
        }
        public static void createBucket(AmazonS3 cosClient, String bucketName, String storageClass)
        {
            cosClient.createBucket(bucketName, storageClass);
        }
        public static void listBuckets(AmazonS3 cosClient)
        {
            System.out.println("Listing buckets");
            final List<Bucket> bucketList = cosClient.listBuckets();
            for (final Bucket bucket : bucketList) {
                System.out.println(bucket.getName());
            }
            System.out.println();
        }
    }

Konfiguration initialisieren

private static String COS_ENDPOINT = "<endpoint>"; // eg "https://s3.us.cloud-object-storage.appdomain.cloud"
private static String COS_API_KEY_ID = "<api-key>"; // eg "0viPHOY7LbLNa9eLftrtHPpTjoGv6hbLD1QalRXikliJ"
private static String COS_AUTH_ENDPOINT = "https://iam.cloud.ibm.com/identity/token";
private static String COS_SERVICE_CRN = "<resource-instance-id>"; // "crn:v1:bluemix:public:cloud-object-storage:global:a/<CREDENTIAL_ID_AS_GENERATED>:<SERVICE_ID_AS_GENERATED>::"
private static String COS_BUCKET_LOCATION = "<location>"; // eg "us"
public static void main(String[] args)
{
    SDKGlobalConfiguration.IAM_ENDPOINT = COS_AUTH_ENDPOINT;
    try {
        _cos = createClient(COS_API_KEY_ID, COS_SERVICE_CRN, COS_ENDPOINT, COS_BUCKET_LOCATION);
    } catch (SdkClientException sdke) {
        System.out.printf("SDK Error: %s\n", sdke.getMessage());
    } catch (Exception e) {
        System.out.printf("Error: %s\n", e.getMessage());
    }
}
public static AmazonS3 createClient(String api_key, String service_instance_id, String endpoint_url, String location)
{
    AWSCredentials credentials = new BasicIBMOAuthCredentials(api_key, service_instance_id);
    ClientConfiguration clientConfig = new ClientConfiguration().withRequestTimeout(5000);
    clientConfig.setUseTcpKeepAlive(true);
    AmazonS3 cos = AmazonS3ClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(credentials))
            .withEndpointConfiguration(new EndpointConfiguration(endpoint_url, location)).withPathStyleAccessEnabled(true)
            .withClientConfiguration(clientConfig).build();
    return cos;
}

Endpunkt bestimmen

Die folgenden Methoden können verwendet werden, um den Serviceendpunkt basierend auf Bucketstandort, Endpunkttyp (öffentlich oder privat) und einer bestimmten Region (optional) zu bestimmen. Weitere Informationen zu Endpunkten enthält Endpunkte und Speicherpositionen.

/**
* Returns a service endpoint based on the
* storage class location (i.e. us-standard, us-south-standard),
* endpoint type (public or private)
*/
public static String getEndpoint(String location, String endPointType) {
    return getEndpoint(location, "", endPointType);
}
/**
* Returns a service endpoint based on the
* storage class location (i.e. us-standard, us-south-standard),
* specific region if desired (i.e. sanjose, amsterdam) - only use if you want a specific regional endpoint,
* endpoint type (public or private)
*/
public static String getEndpoint(String location, String region, String endpointType) {
    HashMap locationMap = new HashMap<String, String>();
    locationMap.put("us", "s3-api.us-geo");
    locationMap.put("us-dallas", "s3-api.dal-us-geo");
    locationMap.put("us-sanjose", "s3-api.sjc-us-geo");
    locationMap.put("us-washington", "s3-api.wdc-us-geo");
    locationMap.put("us-south", "s3.us-south");
    locationMap.put("us-east", "s3.us-east");
    locationMap.put("eu", "s3.eu-geo");
    locationMap.put("eu-amsterdam", "s3.ams-eu-geo");
    locationMap.put("eu-frankfurt", "s3.fra-eu-geo");
/**    locationMap.put("eu-milan", "s3.mil-eu-geo");*/
    locationMap.put("eu-gb", "s3.eu-gb");
    locationMap.put("eu-germany", "s3.eu-de");
    locationMap.put("ap", "s3.ap-geo");
    locationMap.put("ap-tokyo", "s3.tok-ap-geo");
    locationMap.put("che01", "s3.che01");
    locationMap.put("mel01", "s3.mel01");
    locationMap.put("tor01", "s3.tor01");
    String key = location.substring(0, location.lastIndexOf("-")) + (region != null && !region.isEmpty() ? "-" + region : "");
    String endpoint = locationMap.getOrDefault(key, null).toString();
    if (endpoint != null) {
        if (endpointType.toLowerCase() == "private")
            endpoint += ".objectstorage.service.networklayer.com";
        else
            endpoint += ".objectstorage.s3.us-south.cloud-object-storage.appdomain.cloud.net";
    }
    return endpoint;
}

Neues Bucket erstellen

public static void createBucket(String bucketName) {
    System.out.printf("Creating new bucket: %s\n", bucketName);
    _cos.createBucket(bucketName);
    System.out.printf("Bucket: %s created!\n", bucketName);
}

Bucket mit anderer Speicherklasse erstellen

Auf eine Liste gültiger Bereitstellungscodes für LocationConstraint kann im Handbuch für Speicherklassen verwiesen werden.

cos.createBucket("sample", "us-vault"); // the name of the bucket, and the storage class (LocationConstraint)

Neue Textdatei erstellen

public static void createTextFile(String bucketName, String itemName, String fileText) {
    System.out.printf("Creating new item: %s\n", itemName);
    byte[] arr = fileText.getBytes(StandardCharsets.UTF_8);
    InputStream newStream = new ByteArrayInputStream(arr);
    ObjectMetadata metadata = new ObjectMetadata();
    metadata.setContentLength(arr.length);
    PutObjectRequest req = new PutObjectRequest(bucketName, itemName, newStream, metadata);
    _cos.putObject(req);
    System.out.printf("Item: %s created!\n", itemName);
}

Beachten Sie, dass beim Hinzufügen von angepassten Metadaten zu einem Objekt das Objekt ObjectMetadata mit dem SDK erstellt werden muss und nicht manuell ein angepasster Header mit x-amz-meta-{key} gesendet werden darf. Die letztere Aktion kann Probleme beim Authentifizieren mithilfe von HMAC-Berechtigungsnachweisen verursachen.

Objekt aus Datei hochladen

Im folgenden Beispiel wird davon ausgegangen, dass das Bucket sample bereits vorhanden ist.

cos.putObject(
    "sample", // the name of the destination bucket
    "myfile", // the object key
    new File("/home/user/test.txt") // the file name and path of the object to be uploaded
);

Objekt per Streaming hochladen

Im folgenden Beispiel wird davon ausgegangen, dass das Bucket sample bereits vorhanden ist.

String obj = "An example"; // the object to be stored
ByteArrayOutputStream theBytes = new ByteArrayOutputStream(); // create a new output stream to store the object data
ObjectOutputStream serializer = new ObjectOutputStream(theBytes); // set the object data to be serialized
serializer.writeObject(obj); // serialize the object data
serializer.flush();
serializer.close();
InputStream stream = new ByteArrayInputStream(theBytes.toByteArray()); // convert the serialized data to a new input stream to store
ObjectMetadata metadata = new ObjectMetadata(); // define the metadata
metadata.setContentType("application/x-java-serialized-object"); // set the metadata
metadata.setContentLength(theBytes.size()); // set metadata for the length of the data stream
cos.putObject(
    "sample", // the name of the bucket to which the object is being written
    "serialized-object", // the name of the object being written
    stream, // the name of the data stream writing the object
    metadata // the metadata for the object being written
);

Alternativ können Sie einen CipherInputStream verwenden, um den Datenstrom einfacher zu verschlüsseln, ohne das vorhandene InputStream-Objekt überlasten zu müssen.

public CipherInputStream encryptStream(InputStream inputStream) {
       // Generate key
       KeyGenerator kgen = KeyGenerator.getInstance("AES");
       kgen.init(128);
       SecretKey aesKey = kgen.generateKey();
       // Encrypt cipher
       Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
       cipher.init(Cipher.ENCRYPT_MODE, aesKey);
       CipherInputStream cis = new CipherInputStream(inputStream, cipher);
       return cis;
}

Objekt in Datei herunterladen

Im folgenden Beispiel wird davon ausgegangen, dass das Bucket sample bereits vorhanden ist.

GetObjectRequest request = new // create a new request to get an object
GetObjectRequest( // request the new object by identifying
    "sample", // the name of the bucket
    "myFile" // the name of the object
);
s3Client.getObject( // write the contents of the object
    request, // using the request that was just created
    new File("retrieved.txt") // to write to a new file
);

Objekt per Streaming herunterladen

Im folgenden Beispiel wird davon ausgegangen, dass das Bucket sample bereits vorhanden ist.

S3Object returned = cos.getObject( // request the object by identifying
    "sample", // the name of the bucket
    "serialized-object" // the name of the serialized object
);
S3ObjectInputStream s3Input = returned.getObjectContent(); // set the object stream

Objekte kopieren

// copy an object within the same Bucket
cos.copyObject( // copy the Object, passing…
    "sample",  // the name of the Bucket in which the Object to be copied is stored,
    "myFile.txt",  // the name of the Object being copied from the source Bucket,
    "sample",  // the name of the Bucket in which the Object to be copied is stored,
    "myFile.txt.backup"    // and the new name of the copy of the Object to be copied
);

// copy an object between two Buckets
cos.copyObject( // copy the Object, passing…
    "sample", // the name of the Bucket from which the Object will be copied,
    "myFile.txt", // the name of the Object being copied from the source Bucket,
    "backup", // the name of the Bucket to which the Object will be copied,
    "myFile.txt" // and the name of the copied Object in the destination Bucket
);

Exception in thread "main" java.lang.NoClassDefFoundError: javax/xml/bind/JAXBException
    at com.ibm.cloud.objectstorage.services.s3.AmazonS3Client.putObject(AmazonS3Client.java:1597)
    at ibmcos.CoSExample.createTextFile(CoSExample.java:174)
    at ibmcos.CoSExample.main(CoSExample.java:65)
Caused by: java.lang.ClassNotFoundException: javax.xml.bind.JAXBException
    at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:582)
    at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:190)
    at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:499)
    ... 3 more

<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.0</version>
</dependency>

Verfügbare Buckets auflisten

public static void getBuckets() {
    System.out.println("Retrieving list of buckets");
    final List<Bucket> bucketList = _cos.listBuckets();
    for (final Bucket bucket : bucketList) {
        System.out.printf("Bucket Name: %s\n", bucket.getName());
    }
}

Elemente in Bucket auflisten (v2)

Das Objekt AmazonS3 enthält eine aktualisierte Methode zum Auflisten der Inhalte (listObjectsV2). Mit dieser Methode können Sie die Anzahl der zurückgegebenen Datensätze begrenzen und die Datensätze stapelweise abrufen. Dies kann beim Paging der Ergebnisse in einer Anwendung nützlich sein und die Leistung verbessern.

public static void getBucketContentsV2(String bucketName, int maxKeys) {
    System.out.printf("Retrieving bucket contents (V2) from: %s\n", bucketName);
    boolean moreResults = true;
    String nextToken = "";
    while (moreResults) {
        ListObjectsV2Request request = new ListObjectsV2Request()
            .withBucketName(bucketName)
            .withMaxKeys(maxKeys)
            .withContinuationToken(nextToken);
        ListObjectsV2Result result = _cos.listObjectsV2(request);
        for(S3ObjectSummary objectSummary : result.getObjectSummaries()) {
            System.out.printf("Item: %s (%s bytes)\n", objectSummary.getKey(), objectSummary.getSize());
        }
        if (result.isTruncated()) {
            nextToken = result.getNextContinuationToken();
            System.out.println("...More results in next batch!\n");
        }
        else {
            nextToken = "";
            moreResults = false;
        }
    }
    System.out.println("...No more results!");
}

Dateiinhalt eines bestimmten Elements abrufen

public static void getItem(String bucketName, String itemName) {
    System.out.printf("Retrieving item from bucket: %s, key: %s\n", bucketName, itemName);
    S3Object item = _cos.getObject(new GetObjectRequest(bucketName, itemName));
    try {
        final int bufferSize = 1024;
        final char[] buffer = new char[bufferSize];
        final StringBuilder out = new StringBuilder();
        InputStreamReader in = new InputStreamReader(item.getObjectContent());
        for (; ; ) {
            int rsz = in.read(buffer, 0, buffer.length);
            if (rsz < 0)
                break;
            out.append(buffer, 0, rsz);
        }
        System.out.println(out.toString());
    } catch (IOException ioe){
        System.out.printf("Error reading file %s: %s\n", name, ioe.getMessage());
    }
}

Element in Bucket löschen

public static void deleteItem(String bucketName, String itemName) {
    System.out.printf("Deleting item: %s\n", itemName);
    _cos.deleteObject(bucketName, itemName);
    System.out.printf("Item: %s deleted!\n", itemName);
}

Mehrere Elemente in Bucket löschen

Eine Löschanforderung kann maximal 1000 Schlüssel enthalten, die gelöscht werden sollen. Dies ist zwar sehr hilfreich, um den Leistungsabfall pro Anfrage zu verringern, doch sollten Sie beim Löschen einer großen Anzahl von Schlüsseln Vorsicht walten lassen. Berücksichtigen Sie auch die Größen der Objekte, um eine geeignete Leistung zu gewährleisten.

public static void deleteItems(String bucketName) {
    DeleteObjectsRequest req = new DeleteObjectsRequest(bucketName);
    req.withKeys(
        "deletetest/testfile1.txt",
        "deletetest/testfile2.txt",
        "deletetest/testfile3.txt",
        "deletetest/testfile4.txt",
        "deletetest/testfile5.txt"
    );
    DeleteObjectsResult res = _cos.deleteObjects(req);
    System.out.printf("Deleted items for %s\n", bucketName);
    List<DeleteObjectsResult.DeletedObject> deletedItems = res.getDeletedObjects();
    for(DeleteObjectsResult.DeletedObject deletedItem : deletedItems) {
        System.out.printf("Deleted item: %s\n", deletedItem.getKey());
    }
}

Bucket löschen

public static void deleteBucket(String bucketName) {
    System.out.printf("Deleting bucket: %s\n", bucketName);
    _cos.deleteBucket(bucketName);
    System.out.printf("Bucket: %s deleted!\n", bucketName);
}

Öffentliche Lesbarkeit eines Objekts überprüfen

public static void getItemACL(String bucketName, String itemName) {
    System.out.printf("Retrieving ACL for %s from bucket: %s\n", itemName, bucketName);
    AccessControlList acl = _cos.getObjectAcl(bucketName, itemName);
    List<Grant> grants = acl.getGrantsAsList();
    for (Grant grant : grants) {
        System.out.printf("User: %s (%s)\n", grant.getGrantee().getIdentifier(), grant.getPermission().toString());
    }
}

Mehrteiligen Upload ausführen

public static void multiPartUpload(String bucketName, String itemName, String filePath) {
    File file = new File(filePath);
    if (!file.isFile()) {
        System.out.printf("The file '%s' does not exist or is not accessible.\n", filePath);
        return;
    }
    System.out.printf("Starting multi-part upload for %s to bucket: %s\n", itemName, bucketName);
    InitiateMultipartUploadResult mpResult = _cos.initiateMultipartUpload(new InitiateMultipartUploadRequest(bucketName, itemName));
    String uploadID = mpResult.getUploadId();
    //begin uploading the parts
    //min 5MB part size
    long partSize = 1024 * 1024 * 5;
    long fileSize = file.length();
    long partCount = ((long)Math.ceil(fileSize / partSize)) + 1;
    List<PartETag> dataPacks = new ArrayList<PartETag>();
    try {
        long position = 0;
        for (int partNum = 1; position < fileSize; partNum++) {
            partSize = Math.min(partSize, (fileSize - position));
            System.out.printf("Uploading to %s (part %s of %s)\n", name, partNum, partCount);
            UploadPartRequest upRequest = new UploadPartRequest()
                    .withBucketName(bucketName)
                    .withKey(itemName)
                    .withUploadId(uploadID)
                    .withPartNumber(partNum)
                    .withFileOffset(position)
                    .withFile(file)
                    .withPartSize(partSize);
            UploadPartResult upResult = _cos.uploadPart(upRequest);
            dataPacks.add(upResult.getPartETag());
            position += partSize;
        }
        //complete upload
        _cos.completeMultipartUpload(new CompleteMultipartUploadRequest(bucketName, itemName, uploadID, dataPacks));
        System.out.printf("Upload for %s Complete!\n", itemName);
    } catch (SdkClientException sdke) {
        System.out.printf("Multi-part upload aborted for %s\n", itemName);
        System.out.printf("Upload Error: %s\n", sdke.getMessage());
        _cos.abortMultipartUpload(new AbortMultipartUploadRequest(bucketName, itemName, uploadID));
    }
}

Erstellen einer Sicherungsrichtlinie

public static void main(String[] args) {
        try {
            // Initialize authenticator
            IamAuthenticator authenticator = new IamAuthenticator.Builder()
                    .apikey(API_KEY)
                    .build();
            // Initialize ResourceConfiguration client
            ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
            // Generate unique backup vault name
            String backupVaultName = "vault-" + UUID.randomUUID().toString();
            // Create backup policy
            CreateBackupPolicyOptions backupPolicyOptions = new CreateBackupPolicyOptions.Builder()
                    .bucket(SOURCE_BUCKET_NAME)
                    .initialRetention(new DeleteAfterDays.Builder().deleteAfterDays(1).build())
                    .policyName(BACKUP_POLICY_NAME)
                    .targetBackupVaultCrn(BACKUP_VAULT_CRN)
                    .backupType("continuous").build();
            Response<BackupPolicy> createResult = rcClient.createBackupPolicy(backupPolicyOptions).execute();
            System.out.println("Policy Name:");
            System.out.println(createResult.getResult().getPolicyName());
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }

Auflistung einer Sicherungsrichtlinie

    public static void main(String[] args) {
            try {
                // Initialize IAM authenticator and Resource Configuration client
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
                // List all backup policies
                ListBackupPoliciesOptions listOptions = new ListBackupPoliciesOptions.Builder()
                        .bucket(SOURCE_BUCKET_NAME)
                        .build();
                Response<BackupPolicyCollection> listResponse = rcClient.listBackupPolicies(listOptions).execute();
                System.out.println("\nList of backup policies:");
                List<?> policies = listResponse.getResult().getBackupPolicies();
                for (Object policy : policies) {
                    System.out.println(policy);
                }
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }

Erstellen Sie eine Backup-Richtlinie

    public static void main(String[] args) {
            try {
                // Setup IAM Authenticator
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                // Initialize Resource Configuration client
                ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
                // Generate unique policy name
                String policyName = "policy_name_" + UUID.randomUUID().toString();
                // Fetch backup policy using policy ID
                GetBackupPolicyOptions getOptions = new GetBackupPolicyOptions.Builder()
                        .bucket(SOURCE_BUCKET_NAME)
                        .policyId(POLICY_ID)
                        .build();
                Response<BackupPolicy> getResponse = rcClient.getBackupPolicy(getOptions).execute();
                BackupPolicy fetchedPolicy = getResponse.getResult();
                System.out.println("\nFetched Backup Policy Details:");
                System.out.println(fetchedPolicy);
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }

Löschen einer Sicherungsrichtlinie

    public static void main(String[] args) {
            try {
                // Setup IAM Authenticator
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                // Initialize Resource Configuration client
                ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
                // Delete the created backup policy
                DeleteBackupPolicyOptions deleteOptions = new DeleteBackupPolicyOptions.Builder()
                        .bucket(SOURCE_BUCKET_NAME)
                        .policyId(POLICY_ID)
                        .build();
                rcClient.deleteBackupPolicy(deleteOptions).execute();
                System.out.printf("Backup policy '%s' deleted successfully.%n", POLICY_ID);
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }

Erstellen eines Backup Tresors

    public static void main(String[] args) {
            try {
                // Setup IAM Authenticator
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                // Initialize Resource Configuration client
                ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
                // Generate unique backup vault name
                String backupVaultName = "backup-vault-" + UUID.randomUUID();
                // Create backup vault
                CreateBackupVaultOptions createOptions = new CreateBackupVaultOptions.Builder()
                        .serviceInstanceId(SERVICE_INSTANCE_ID)
                        .backupVaultName(BACKUP_VAULT_NAME)
                        .region(REGION)
                        .build();
                Response<BackupVault> response = rcClient.createBackupVault(createOptions).execute();
                BackupVault vault = response.getResult();
                System.out.println("Backup vault created:");
                System.out.println(vault);
            } catch (Exception e) {
                System.err.println("Error creating backup vault: " + e.getMessage());
                e.printStackTrace();
            }
        }

Auflistung von Backup-Tresoren

    public static void main(String[] args) {
            try {
                // Setup IAM Authenticator
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                // Initialize Resource Configuration client
                ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
                // List backup vaults
                ListBackupVaultsOptions listBackupVaultsOptions = new ListBackupVaultsOptions.Builder().
                        serviceInstanceId(SERVICE_INSTANCE_ID).build();
                Response<BackupVaultCollection> backupVaults = rcClient.listBackupVaults(listBackupVaultsOptions).execute();
                System.out.println("\nList of backup vaults:");
                if ( backupVaults.getResult().getBackupVaults() != null) {
                    for (String vault :  backupVaults.getResult().getBackupVaults()) {
                        System.out.println(vault);
                    }
                } else {
                    System.out.println("No backup vaults found.");
                }
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }

Backup-Tresore erhalten

    public static void main(String[] args) {
            try {
                // Initialize IAM Authenticator
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                // Create Resource Configuration client
                ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
                // Generate unique backup vault name
                String backupVaultName = "backup-vault-" + UUID.randomUUID();
                // Get backup vault details
                GetBackupVaultOptions getOptions = new GetBackupVaultOptions.Builder()
                        .backupVaultName(BACKUP_VAULT_NAME)
                        .build();
                Response<BackupVault> getResponse = rcClient.getBackupVault(getOptions).execute();
                BackupVault vaultDetails = getResponse.getResult();
                System.out.println("Backup vault details:");
                System.out.println(vaultDetails);
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }

Backup-Tresore aktualisieren

    public static void main(String[] args) {
            try {
                // Setup IAM Authenticator
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                // Initialize Resource Configuration client
                ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
                // Update vault: disable activity tracking and metrics monitoring
                BackupVaultPatch backupVaultPatch = new BackupVaultPatch.Builder()
                        .activityTracking(new BackupVaultActivityTracking.Builder().managementEvents(Boolean.FALSE).build())
                        .metricsMonitoring(new BackupVaultMetricsMonitoring.Builder().usageMetricsEnabled(Boolean.FALSE).build())
                        .build();
                UpdateBackupVaultOptions updateBackupVaultOptions = new UpdateBackupVaultOptions.Builder()
                        .backupVaultName(backupVaultName)
                        .backupVaultPatch(backupVaultPatch.asPatch()).build();
                Response<BackupVault> backupVaultResponse2 = rcClient.updateBackupVault(updateBackupVaultOptions).execute();
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }

Löschen eines Sicherungsdepots

    public static void main(String[] args) {
            try {
                // Set up the authenticator
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                // Initialize Resource Configuration client
                ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
                // Delete backup vault
                DeleteBackupVaultOptions deleteOptions = new DeleteBackupVaultOptions.Builder()
                        .backupVaultName(BACKUP_VAULT_NAME)
                        .build();
                Response<Void> deleteResponse = rcClient.deleteBackupVault(deleteOptions).execute();
                System.out.println("Failed to delete backup vault '" + BACKUP_VAULT_NAME + "'.");
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }

Auflistung der Verwertungsspannen

    public static void main(String[] args) {
            try {
                // Setup authenticator
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                // Initialize Resource Configuration client
                ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
                // List recovery ranges
                ListRecoveryRangesOptions recoveryRangesOptions = new ListRecoveryRangesOptions.Builder()
                        .backupVaultName(BACKUP_VAULT_NAME)
                        .build();
                Response<RecoveryRangeCollection> recoveryRangesResponse = rcClient.listRecoveryRanges(recoveryRangesOptions).execute();
                System.out.println("Recovery Ranges:");
                System.out.println(recoveryRangesResponse.getResult());
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }

Erholungsbereich erhalten

    public static void main(String[] args) {
            try {
                // Setup authenticator
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                // Initialize Resource Configuration client
                ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
                // Fetch details of the recovery range
                GetSourceResourceRecoveryRangeOptions recoveryRangeOptions = new GetSourceResourceRecoveryRangeOptions.Builder()
                        .backupVaultName(BACKUP_VAULT_NAME)
                        .recoveryRangeId(RECOVERY_RANGE_ID)
                        .build();
                Response<RecoveryRange> getRecoveryRangeResponse = rcClient.getSourceResourceRecoveryRange(recoveryRangeOptions).execute();
                System.out.println("Recovery Range Details:");
                System.out.println(getRecoveryRangeResponse.getResult());
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }

Wiederherstellungsbereich aktualisieren

    public static void main(String[] args) {
            try {
                // Setup authenticator
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                // Initialize Resource Configuration client
                ResourceConfiguration rcClient = new ResourceConfiguration("resource-configuration", authenticator);
                // Patch the recovery range (update retention to 99 days)
                PatchSourceResourceRecoveryRangeOptions patchOptions = new PatchSourceResourceRecoveryRangeOptions.Builder()
                        .backupVaultName(BACKUP_VAULT_NAME)
                        .recoveryRangeId(RECOVERY_RANGE_ID)
                        .recoveryRangePatch(
                                new RecoveryRangePatch.Builder()
                                        .retention(new DeleteAfterDays.Builder().deleteAfterDays(99).build())
                                        .build()
                        )
                        .build();
                Response<RecoveryRange> patchResponse = rcClient.patchSourceResourceRecoveryRange(patchOptions).execute();
                System.out.println("Recovery Range successfully patched:");
                System.out.println(patchResponse.getResult());
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }

Initiieren einer Wiederherstellung

    public static void main(String[] args) {
            try {
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                ResourceConfiguration RC_CLIENT = new ResourceConfiguration("resource-configuration", authenticator);
                 CreateRestoreOptions  createRestoreOptions = new CreateRestoreOptions.Builder()
                         .backupVaultName(BACKUP_VAULT_NAME)
                         .recoveryRangeId(recoveryRangeId)
                         .restoreType("in_place")
                         .targetResourceCrn(TARGET_BUCKET_CRN)
                         .restorePointInTime(RESTORE_TIME)
                         .build();
                 Response<Restore> createRestoreCall = RC_CLIENT.createRestore(createRestoreOptions).execute();
                 String restoreId = createRestoreCall.getResult().getRestoreId();
                 GetRestoreOptions getRestoreOptions = new GetRestoreOptions.Builder().restoreId(restoreId).backupVaultName(backupVaultName).build();
                 Response<Restore> restoreResult = RC_CLIENT.getRestore(getRestoreOptions).execute();
                 System.out.println("Restore successfully:");
                 System.out.println(restoreResult);
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }

Auflistung Wiederherstellen

    public static void main(String[] args) {
            try {
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                ResourceConfiguration RC_CLIENT = new ResourceConfiguration("resource-configuration", authenticator);
                ListRestoresOptions listRestoreOptions = new ListRestoresOptions.Builder()
                        .backupVaultName(BACKUP_VAULT_NAME)
                        .build();
                Response<RestoreList> listRestoreResponse = rcClient.listRestores(listRestoreOptions).execute();
                System.out.println("Restore operations: " + listRestoreResponse.getResult());
           } catch (Exception e) {
               System.err.println("Error: " + e.getMessage());
               e.printStackTrace();
           }
        }

Details zur Wiederherstellung abrufen

    public static void main(String[] args) {
            try {
                IamAuthenticator authenticator = new IamAuthenticator.Builder()
                        .apikey(API_KEY)
                        .build();
                ResourceConfiguration RC_CLIENT = new ResourceConfiguration("resource-configuration", authenticator);
                Response<Restore> getRestoreOptions =
                        GetRestoreOptions.Builder()
                        .restoreId(restoreId)
                        .backupVaultName(BACKUP_VAULT_NAME)
                        .build();
                Response<Restore> restoreResult = RC_CLIENT.getRestore(getRestoreOptions).execute();
                System.out.println("Get Restore: " + restoreResult);
           } catch (Exception e) {
               System.err.println("Error: " + e.getMessage());
               e.printStackTrace();
           }
        }

Erstellen Sie einen neuen Cos-Bucket mit aktivierter Objektsperre

    public static void createBucket(String bucketName, AmazonS3 _cosClient)
        {
            _cosClient.createBucket(bucketName);
            System.out.printf("Bucket: %s created!\n", bucketName);
        }

Objektsperrenkonfiguration mit Compliance-Modus auf COS-Bucket setzen

    public static void putObjectLockConfiguration(String bucketName, AmazonS3 _cosClient)
        {
            DefaultRetention defRet = new DefaultRetention()
                    .withMode(ObjectLockRetentionMode.COMPLIANCE)
                    .withDays(1);
            ObjectLockRule objRule = new ObjectLockRule()
                            .withDefaultRetention(defRet);
            ObjectLockConfiguration objConfig = new ObjectLockConfiguration()
                            .withObjectLockEnabled(ObjectLockEnabled.ENABLED)
                            .withRule(objRule);
            SetObjectLockConfigurationRequest objSet = new SetObjectLockConfigurationRequest()
                            .withBucketName(BUCKET_NAME)
                            .withObjectLockConfiguration(objConfig);
            _cosClient.setObjectLockConfiguration(objSet);
            System.out.printf("Successfully added object lock cofiguration on : %s\n", bucketName);
        }

Objektsperrenkonfiguration mit Governance-Modus auf COS-Bucket setzen

    public static void putObjectLockConfigurationWithGovernanceMode(String bucketName, AmazonS3 _cosClient)
        {
            DefaultRetention defRet = new DefaultRetention()
                    .withMode(ObjectLockRetentionMode.GOVERNANCE)
                    .withDays(1);
            ObjectLockRule objRule = new ObjectLockRule()
                            .withDefaultRetention(defRet);
            ObjectLockConfiguration objConfig = new ObjectLockConfiguration()
                            .withObjectLockEnabled(ObjectLockEnabled.ENABLED)
                            .withRule(objRule);
            SetObjectLockConfigurationRequest objSet = new SetObjectLockConfigurationRequest()
                            .withBucketName(BUCKET_NAME)
                            .withObjectLockConfiguration(objConfig);
            _cosClient.setObjectLockConfiguration(objSet);
            System.out.printf("Successfully added object lock cofiguration on : %s\n", bucketName);
        }

Objektsperrkonfiguration für COS-Bucket abrufen

    public static void getObjectLockConfigurationWithGovernanceMode(String bucketName, AmazonS3 _cosClient)
        {
            GetObjectLockConfigurationRequest objReq = new GetObjectLockConfigurationRequest().withBucketName(BUCKET_NAME);
            GetObjectLockConfigurationResult objRes = _cosClient.getObjectLockConfiguration(objReq);
            ObjectLockConfiguration objLckConfig = objRes.getObjectLockConfiguration();
            ObjectLockRule objGetRule = objLckConfig.getRule();
            System.out.printf("ObjectLock Configuration : %s\n", objGetRule);
        }

Laden Sie ein Objekt mit Governance-Modus in den COS-Bucket hoch

    public static void uploadFileWithGovernanceMode(String bucketName, String itemName, String fileText) {
            System.out.printf("Creating new item: %s\n", itemName);
            LocalDate date = LocalDate.of(2025, 11, 11);
            InputStream newStream = new ByteArrayInputStream(fileText.getBytes(Charset.forName("UTF-8")));
            ObjectMetadata metadata = new ObjectMetadata();
            metadata.setContentLength(fileText.length());
            PutObjectRequest req = new PutObjectRequest(bucketName, itemName, newStream, metadata)
                                .withObjectLockMode("GOVERNANCE")
                                .withObjectLockRetainUntilDate(date);
            _cosClient.putObject(req);
            System.out.printf("Item: %s created!\n", itemName);
        }

Objektsperre mit Compliance-Modus auf das Objekt anwenden

    public static void putObjectLockRetention(String bucketName,String itemName, AmazonS3 _cosClient)
        {
            LocalDate date = LocalDate.of(2025, 11, 11);
            ObjectLockRetention objRet = new ObjectLockRetention()
                        .withMode("COMPLIANCE")
                        .withRetainUntilDate(date);
            SetObjectRetentionRequest objSet = new SetObjectRetentionRequest()
                        .withBucketName(BUCKET_NAME)
                        .withitemName(itemName)
                        .withRetention(objRet);
                        .withBypassGovernanceRetention(true);
            _cosClient.setObjectRetention(objSet);
            System.out.printf("Successfully added object retention on : %s\n", itemName);
        }

Objektsperre mit Governance-Modus auf das Objekt anwenden

    public static void putObjectLockRetentionWithGovernanceMode(String bucketName,String itemName, AmazonS3 _cosClient)
        {
            LocalDate date = LocalDate.of(2025, 11, 11);
            ObjectLockRetention objRet = new ObjectLockRetention()
                        .withMode("GOVERNANCE")
                        .withRetainUntilDate(date);
            SetObjectRetentionRequest objSet = new SetObjectRetentionRequest()
                        .withBucketName(BUCKET_NAME)
                        .withitemName(itemName)
                        .withRetention(objRet);
                        .withBypassGovernanceRetention(true);
            _cosClient.setObjectRetention(objSet);
            System.out.printf("Successfully added object retention on : %s\n", itemName);
        }

Objektsperre beibehalten

    public static void getObjectLockRetentionWithGovernanceMode(String bucketName,String itemName, AmazonS3 _cosClient)
        {
            GetObjectRetentionRequest objReq = new GetObjectRetentionRequest()
                .withBucketName(BUCKET_NAME)
                .withitemName(itemName);
            GetObjectRetentionResult objRes1 = _cosClient.getObjectRetention(objReq);
            ObjectLockRetention objRet1 = objRes1.getRetention();
            System.out.printf("Retention : %s\n", objRet1);
        }

Objekt sperren – Legal Hold

   public static void putObjectLockLegalHold(String bucketName,string itemName, AmazonS3 _cosClient)
   {
      ObjectLockLegalHold objLegalHold = new ObjectLockLegalHold()
            .withStatus("ON");
        SetObjectLegalHoldRequest objSetLegalHold = new SetObjectLegalHoldRequest()
            .withBucketName(bucketName)
            .withKey(itemName)
            .withLegalHold(objLegalHold);
        _cosClient.setObjectLegalHold(objSetLegalHold);
       System.out.printf("Successfully added object lock legal hold on : %s\n", itemName);
       GetObjectLegalHoldRequest objReqLegal = new GetObjectLegalHoldRequest()
            .withBucketName(bucketName)
            .withKey(itemName);
    	GetObjectLegalHoldResult objResLegal = _cosClient.getObjectLegalHold(objReqLegal);
       System.out.printf("ObjectLock Legal Hold  : %s\n", objResLegal.getLegalHold());
   }

Objektsperre „Legal Hold“ setzen

   public static void getObjectLockLegalHold(String bucketName,string itemName, AmazonS3 _cosClient)
   {
       GetObjectLegalHoldRequest objReqLegal = new GetObjectLegalHoldRequest()
            .withBucketName(bucketName)
            .withKey(itemName);
    	GetObjectLegalHoldResult objResLegal = _cosClient.getObjectLegalHold(objReqLegal);
       System.out.printf("ObjectLock Legal Hold  : %s\n", objResLegal.getLegalHold());
   }

Löschen eines Objekts mit Objektsperr-Governance-Modus unter Verwendung der Bypass-Governance

    public static void deleteObjectWithBypassGovernance(String bucketName, String itemName) {
            System.out.printf("Deleting item: %s\n", itemName);
            DeleteObjectRequest deleteRequest = new DeleteObjectRequest(BUCKET_NAME, Key)
                .withBypassGovernanceRetention(true);
            _cosClient.deleteObject(deleteRequest);
            System.out.printf("Item: %s deleted!\n", itemName);
        }

SDK-Referenzen

Klassen

• TransferManager
• TransferManagerBuilder
• Hochladen

Methoden

• shutdownNow
• Upload
• waitForCompletion

Vorbereitende Schritte

Damit Sie ein Bucket erstellen können, während Key Protect aktiviert ist, müssen die folgenden Voraussetzungen erfüllt sein:

• Ein Key Protect-Service wird bereitgestellt
• Ein Stammschlüssel ist verfügbar (entweder generiert oder importiert)

Cloudressourcenname für Stammschlüssel abrufen

1. Rufen Sie die Instanz-ID für den Key Protect-Service ab.
2. Verwenden Sie die Key Protect-API, um alle verfügbaren Schlüssel abzurufen.
   • Sie können entweder curl-Befehle oder einen API-REST-Client wie zum Beispiel Postman für den Zugriff auf die Key Protect-API verwenden.
3. Rufen Sie den Cloudressourcennamen des Stammschlüssels ab, mit dem Sie Key Protect für das Bucket aktivieren. Der Cloudressourcenname ähnelt der folgenden Zeichenfolge:

crn:v1:bluemix:public:kms:us-south:a/3d624cd74a0dea86ed8efe3101341742:90b6a1db-0fe1-4fe9-b91e-962c327df531:key:0bg3e33e-a866-50f2-b715-5cba2bc93234

Bucket während Aktivierung von Key Protect erstellen

private static String COS_KP_ALGORITHM = "<algorithm>";
private static String COS_KP_ROOTKEY_CRN = "<root-key-crn>";
public static void createBucketKP(String bucketName) {
    System.out.printf("Creating new encrypted bucket: %s\n", bucketName);
    EncryptionType encType = new EncryptionType();
    encType.setKmsEncryptionAlgorithm(COS_KP_ALGORITHM);
    encType.setIBMSSEKMSCustomerRootKeyCrn(COS_KP_ROOTKEY_CRN);
    CreateBucketRequest req = new CreateBucketRequest(bucketName).withEncryptionType(encType);
    _cos.createBucket(req);
    System.out.printf("Bucket: %s created!", bucketName);
}

Neue Header für Key Protect

Die zusätzlichen Header wurden in der Klasse Headers definiert:

public static final String IBM_SSE_KP_ENCRYPTION_ALGORITHM = "ibm-sse-kp-encryption-algorithm";
public static final String IBM_SSE_KP_CUSTOMER_ROOT_KEY_CRN = "ibm-sse-kp-customer-root-key-crn";

In demselben Abschnitt der Implementierung z um Erstellen von Buckets, in der bereits IAM-Serviceinstanzheader hinzugefügt werden, werden zwei neue Verschlüsselungsheader hinzugefügt:

//Add IBM Service Instance Id & Encryption to headers
if ((null != this.awsCredentialsProvider ) && (this.awsCredentialsProvider.getCredentials() instanceof IBMOAuthCredentials)) {
    IBMOAuthCredentials oAuthCreds = (IBMOAuthCredentials)this.awsCredentialsProvider.getCredentials();
    if (oAuthCreds.getServiceInstanceId() != null) {
        request.addHeader(Headers.IBM_SERVICE_INSTANCE_ID, oAuthCreds.getServiceInstanceId());
        request.addHeader(Headers.IBM_SSE_KP_ENCRYPTION_ALGORITHM, createBucketRequest.getEncryptionType().getKpEncryptionAlgorithm());
        request.addHeader(Headers.IBM_SSE_KP_CUSTOMER_ROOT_KEY_CRN, createBucketRequest.getEncryptionType().getIBMSSEKPCustomerRootKeyCrn());
    }
}

Die Objekte „ ObjectListing “ und „ HeadBucketResult “ wurden aktualisiert und enthalten nun boolesche Variablen vom Typ „ IBMSSEKPEnabled “ sowie String-Variablen vom Typ „ IBMSSEKPCustomerRootKeyCrn “ mit Getter- und Setter-Methoden. Auf diese Art werden die Werte der neuen Header gespeichert.

public ObjectListing listObjects(String bucketName)
public ObjectListing listObjects(String bucketName, String prefix)
public ObjectListing listObjects(ListObjectsRequest listObjectsRequest)

ObjectListing listing = s3client.listObjects(listObjectsRequest)
String KPEnabled = listing.getIBMSSEKPEnabled();
String crkId = listing.getIBMSSEKPCrkId();

Headers.java
public static final string IBM_SSE_KP_ENABLED = "ibm-sse-kp-enabled";
public static final String IBM_SSE_KP_CUSTOMER_ROOT_KEY_CRN = "ibm-sse-kp-customer-root-key-crn";

if (result instanceof ObjectListing) {
    if (!StringUtils.isNullOrEmpty(responseHeaders.get(Headers.IBM_SSE_KP_ENABLED)){
            ((ObjectListing) result).setIBMSSEKPEnabled(Boolean.parseBoolean(responseHeaders.get(Headers.IBM_SSE_KP_ENABLED)));
        }
    if (!StringUtils.isNullOrEmpty(responseHeaders.get(Headers.IBM_SSE_KP_CUSTOMER_ROOT_KEY_CRN))) {
            ((ObjectListing) result).setIBMSSEKPCrk(responseHeaders.get(Headers.IBM_SSE_KP_CUSTOMER_ROOT_KEY_CRN));
        }
}

Headers.java
public static final String IBM_SSE_KP_ENABLED = "ibm-sse-kp-enabled";
public static final String IBM_SSE_KP_CUSTOMER_ROOT_KEY_CRN = "ibm-sse-kp-customer-root-key-crn";

HeadBucketResultHandler
result.setIBMSSEKPEnabled(response.getHeaders().get(Headers.IBM_SSE_KP_ENABLED));
result.setIBMSSEKPCrk(response.getHeaders().get(Headers. IBM_SSE_KP_CUSTOMER_ROOT_KEY_CRN));
Head Bucket Example
HeadBucketResult result = s3client.headBucket(headBucketRequest)
boolean KPEnabled = result.getIBMSSEKPEnabled();
String crn = result.getIBMSSEKPCUSTOMERROOTKEYCRN();

AsperaTransferManager initialisieren

Stellen Sie vor der Initialisierung von AsperaTransferManager sicher, dass Sie mit den Objekten s3Client und tokenManager arbeiten.

Es wird empfohlen, TokenManager tokenManager = new DefaultTokenManager(new DelegateTokenProvider(apiKey)); zu verwenden und .withTokenManager(tokenManager) zu vermeiden, wenn AsperaTransferManager mit AsperaTransferManagerBuilder erstellt wird.

Der Vorteil ist im Vergleich zu einer einzelnen Sitzung der Aspera-Hochgeschwindigkeitsübertragung ist nicht groß, wenn Sie nicht erwarten, dass erhebliche Störgrößen und Paketverluste im Netz auftreten. Daher muss AsperaTransferManager für die Verwendung mehrerer Sitzungen mithilfe der Klasse AsperaConfig eingerichtet werden. Dadurch wird die Übertragung in eine Anzahl paralleler Sitzungen aufgeteilt, in denen Datenblöcke gesendet werden, deren Größe durch den Wert für Schwellenwert definiert ist.

Eine typische Konfiguration für die Verwendung von Mehrfachsitzungen muss folgende Merkmale aufweisen:

• 2.500 MB/s Zielrate
• 100 MB Schwellenwert (dies ist der empfohlene Wert für die meisten Anwendungen)

AsperaTransferManagerConfig transferConfig = new AsperaTransferManagerConfig()
    .withMultiSession(true);
AsperaConfig asperaConfig = new AsperaConfig()
    .withTargetRateMbps(2500L)
    .withMultiSessionThresholdMb(100);
TokenManager tokenManager = new DefaultTokenManager(new DelegateTokenProvider(API_KEY));
AsperaTransferManager asperaTransferMgr = new AsperaTransferManagerBuilder(API_KEY, s3Client)
    .withAsperaTransferManagerConfig(transferConfig)
    .withAsperaConfig(asperaConfig)
    .build();

Im obigen Beispiel werden vom SDK ausreichend Sitzungen zum Erreichen der Zielrate von 2.500 MB/s generiert.

Alternativ dazu kann das Sitzungsmanagement im SDK explizit konfiguriert werden. Dies ist in den Fällen nützlich, in denen eine genauere Kontrolle über die Netzauslastung gewünscht wird.

Eine typische Konfiguration für die Verwendung expliziter Mehrfachsitzungen muss folgende Merkmale aufweisen:

• 2 oder 10 Sitzungen
• 100 MB Schwellenwert (dies ist der empfohlene Wert für die meisten Anwendungen)

AsperaConfig asperaConfig = new AsperaConfig()
    .withMultiSession(2)
    .withMultiSessionThresholdMb(100);
TokenManager tokenManager = new DefaultTokenManager(new DelegateTokenProvider(API_KEY));
AsperaTransferManager asperaTransferMgr = new AsperaTransferManagerBuilder(API_KEY, s3Client)
    .withAsperaConfig(asperaConfig)
    .build();

Um in den meisten Szenarien eine optimale Leistung zu erzielen, sollten Sie stets mehrere Sitzungen nutzen, um den mit der Instanziierung eines „ Aspera “-Hochgeschwindigkeitstransfers verbundenen Rechenaufwand zu minimieren. Falls die Netzkapazität mindestens 1 Gb/s beträgt, sollten Sie 10 Sitzungen verwenden. In Netzen mit niedrigerer Bandbreite sollten zwei Sitzungen verwendet werden.

Dateiupload

String filePath = "<absolute-path-to-source-data>";
String bucketName = "<bucket-name>";
String itemName = "<item-name>";
// Load file
File inputFile = new File(filePath);
// Create AsperaTransferManager for FASP upload
AsperaTransferManager asperaTransferMgr = new AsperaTransferManagerBuilder(API_KEY, s3Client).build();
// Upload test file and report progress
Future<AsperaTransaction> asperaTransactionFuture = asperaTransferMgr.upload(bucketName, itemName, inputFile);
AsperaTransaction asperaTransaction = asperaTransactionFuture.get();

Dateidownload

String bucketName = "<bucket-name>";
String outputPath = "<absolute-path-to-file>";
String itemName = "<item-name>";
// Create local file
File outputFile = new File(outputPath);
outputFile.createNewFile();
// Create AsperaTransferManager for FASP download
AsperaTransferManager asperaTransferMgr = new AsperaTransferManagerBuilder(COS_API_KEY_ID, s3Client)
    .withTokenManager(tokenManager)
    .withAsperaConfig(asperaConfig)
    .build();
// Download file
Future<AsperaTransaction> asperaTransactionFuture = asperaTransferMgr.download(bucketName, itemName, outputPath);
AsperaTransaction asperaTransaction = asperaTransactionFuture.get();

Verzeichnisupload

String bucketName = "<bucket-name>";
String directoryPath = "<absolute-path-to-directory-for-new-file>";
String directoryPrefix = "<virtual-directory-prefix>";
boolean includeSubDirectories = true;
// Load Directory
File inputDirectory = new File(directoryPath);
// Create AsperaTransferManager for FASP upload
AsperaTransferManager asperaTransferMgr = new AsperaTransferManagerBuilder(COS_API_KEY_ID, s3Client)
    .withTokenManager(tokenManager)
    .withAsperaConfig(asperaConfig)
    .build();
// Upload test directory
Future<AsperaTransaction> asperaTransactionFuture  = asperaTransferMgr.uploadDirectory(bucketName, directoryPrefix, inputDirectory, includeSubDirectories);
AsperaTransaction asperaTransaction = asperaTransactionFuture.get();

Verzeichnisdownload

String bucketName = "<bucket-name>";
String directoryPath = "<absolute-path-to-directory>";
String directoryPrefix = "<virtual-directory-prefix>";
boolean includeSubDirectories = true;
// Load Directory
File outputDirectory = new File(directoryPath);
// Create AsperaTransferManager for FASP download
AsperaTransferManager asperaTransferMgr = new AsperaTransferManagerBuilder(COS_API_KEY_ID, s3Client)
    .withTokenManager(tokenManager)
    .withAsperaConfig(asperaConfig)
    .build();
// Download test directory
Future<AsperaTransaction> asperaTransactionFuture   = asperaTransferMgr.downloadDirectory(bucketName, directoryPrefix, outputDirectory, includeSubDirectories);
AsperaTransaction asperaTransaction = asperaTransactionFuture.get();

Sitzungskonfiguration abhängig von Übertragung überschreiben

Sie können die Werte für die Mehrfachsitzungskonfiguration je nach Übertragung überschreiben; übergeben Sie hierzu eine Instanz von AsperaConfig für die überladenen Methoden für Upload und Download. Mit AsperaConfig können Sie die Anzahl der Sitzungen und den Schwellenwert für die Mindestdateigröße pro Sitzung angeben.

String bucketName = "<bucket-name>";
String filePath = "<absolute-path-to-file>";
String itemName = "<item-name>";
// Load file
File inputFile = new File(filePath);
// Create AsperaTransferManager for FASP upload
AsperaTransferManager asperaTransferMgr = new AsperaTransferManagerBuilder(API_KEY, s3Client)
.withTokenManager(TOKEN_MANAGER)
.withAsperaConfig(asperaConfig)
.build();
// Create AsperaConfig to set number of sessions
// and file threshold per session.
AsperaConfig asperaConfig = new AsperaConfig().
withMultiSession(10).
withMultiSessionThresholdMb(100);
// Upload test file and report progress
Future<AsperaTransaction> asperaTransactionFuture  = asperaTransferMgr.upload(bucketName, itemName, inputFile, asperaConfig, null);
AsperaTransaction asperaTransaction = asperaTransactionFuture.get();

Übertragungsfortschritt überwachen

Die einfachste Möglichkeit, den Fortschritt der Datei- bzw. Verzeichnisübertragungen zu überwachen ist die Verwendung der Eigenschaft isDone(), von der true zurückgegeben wird, wenn die Übertragung abgeschlossen ist.

Future<AsperaTransaction> asperaTransactionFuture  = asperaTransferMgr.downloadDirectory(bucketName, directoryPrefix, outputDirectory, includeSubDirectories);
AsperaTransaction asperaTransaction = asperaTransactionFuture.get();
while (!asperaTransaction.isDone()) {
    System.out.println("Directory download is in progress");
    //pause for 3 seconds
    Thread.sleep(1000 * 3);
}

Sie können auch prüfen, ob eine Übertragung zur Verarbeitung in die Warteschlange gestellt wird, indem Sie die Methode onQueue für AsperaTransaction aufrufen. onQueue gibt einen booleschen Wert mit true zurück, der angibt, dass die Übertragung in die Warteschlange gestellt wurde.

Future<AsperaTransaction> asperaTransactionFuture  = asperaTransferMgr.downloadDirectory(bucketName, directoryPrefix, outputDirectory, includeSubDirectories);
AsperaTransaction asperaTransaction = asperaTransactionFuture.get();
while (!asperaTransaction.isDone()) {
    System.out.println("Directory download is in queueing: " + asperaTransaction.onQueue());
    //pause for 3 seconds
    Thread.sleep(1000 * 3);
}

Wenn Sie überprüfen möchten, ob eine Übertragung in Bearbeitung ist, rufen Sie die Fortschrittsmethode in AsperaTransactionauf.

Future<AsperaTransaction> asperaTransactionFuture  = asperaTransferMgr.downloadDirectory(bucketName, directoryPrefix, outputDirectory, includeSubDirectories);
AsperaTransaction asperaTransaction = asperaTransactionFuture.get();
while (!asperaTransaction.isDone()) {
    System.out.println("Directory download is in progress: " + asperaTransaction.progress());
    //pause for 3 seconds
    Thread.sleep(1000 * 3);
}

Jeder Übertragung ist standardmäßig ein Wert für TransferProgress zugeordnet. Von TransferProgress wird die Anzahl der übertragenen Byte und der Prozentsatz der übertragenen Byte im Vergleich zur Gesamtsumme der zu übertragenden Byte angegeben. Wenn Sie auf die Angaben von TransferProgress einer Übertragung zugreifen möchten, verwenden Sie die Methode getProgress in AsperaTransaction.

Future<AsperaTransaction> asperaTransactionFuture  = asperaTransferMgr.downloadDirectory(bucketName, directoryPrefix, outputDirectory, includeSubDirectories);
AsperaTransaction asperaTransaction = asperaTransactionFuture.get();
while (!asperaTransaction.isDone()) {
    TransferProgress transferProgress = asperaTransaction.getProgress();
    //pause for 3 seconds
    Thread.sleep(1000 * 3);
}

Wenn Sie die Anzahl der übertragenen Byte auflisten möchten, rufen Sie die Methode getBytesTransferred für TransferProgress auf. Wenn Sie den Prozentsatz der übertragenen Byte im Vergleich zur Gesamtsumme der zu übertragenen Byte auflisten möchten, rufen Sie die Methode getPercentTransferred für TransferProgress auf.

Future<AsperaTransaction> asperaTransactionFuture  = asperaTransferMgr.downloadDirectory(bucketName, directoryPrefix, outputDirectory, includeSubDirectories);
AsperaTransaction asperaTransaction = asperaTransactionFuture.get();
while (!asperaTransaction.isDone()) {
    TransferProgress transferProgress = asperaTransaction.getProgress();
    System.out.println("Bytes transferred: " + transferProgress.getBytesTransferred());
    System.out.println("Percent transferred: " + transferProgress.getPercentTransferred());
    //pause for 3 seconds
    Thread.sleep(1000 * 3);
}

Anhalten/Wiederaufnehmen/Abbrechen

Das SDK bietet die Möglichkeit, den Fortschritt der Datei- bzw. Verzeichnisübertragungen über die folgenden Methoden des Objekts AsperaTransfer zu verwalten:

• pause()
• resume()
• cancel()

Das Aufrufen der oben dargestellten Methoden verursacht keine Nebeneffekte. Vom SDK wird die ordnungsgemäße Bereinigung und Verwaltung gewährleistet.

Am folgenden Beispiel wird eine mögliche Verwendung dieser Methoden veranschaulicht:

String bucketName = "<bucket-name>";
String directoryPath = "<absolute-path-to-directory>";
String directoryPrefix = "<virtual-directory-prefix>";
boolean includeSubDirectories = true;
AsperaTransferManager asperaTransferMgr = new AsperaTransferManagerBuilder(COS_API_KEY_ID, _cos)
    .withTokenManager(TOKEN_MANAGER)
    .build();
File outputDirectory = new File(directoryName);
System.out.println("Starting directory download...");
//download the directory from cloud storage
Future<AsperaTransaction> asperaTransactionFuture  = asperaTransferMgr.downloadDirectory(bucketName, directoryPrefix, outputDirectory, includeSubDirectories);
AsperaTransaction asperaTransaction = asperaTransactionFuture.get();
int pauseCount = 0;
while (!asperaTransaction.isDone()) {
    System.out.println("Directory download in progress...");
    //pause the transfer
    asperaTransfer.pause();
    //resume the transfer
    asperaTransfer.resume();
    //cancel the transfer
    asperaTransfer.cancel();
}
System.out.println("Directory download complete!");

Fehlerbehebung bei Aspera-Problemen

Problem: Wenn Entwickler das Oracle-JDK unter Linux oder Mac OS X verwenden, können bei Übertragungen unerwartete Abstürze und Abstürze im Hintergrund auftreten.

Ursache: Für den nativen Code sind die eigenen Signalhandler erforderlich, was dazu führen kann, dass die Signalhandler der JVM überschrieben werden. Es kann erforderlich sein, die Funktion für die Signalverkettung der JVM zu verwenden.

IBM® JDK-Benutzer oder Benutzer von „ Microsoft® Windows “ sind davon nicht betroffen.

Lösung: Stellen Sie eine Verbindung zur Bibliothek für die JVM-Signalverkettung her und laden Sie sie.

• Suchen Sie unter Linux die gemeinsam genutzte Bibliothek libjsig.so und legen Sie die folgenden Umgebungsvariable fest:

  • LD_PRELOAD=<PATH_TO_SHARED_LIB>/libjsig.so

• Suchen Sie unter Mac OS die gemeinsam genutzte Bibliothek libjsig.dylib und legen Sie die folgenden Umgebungsvariablen fest:

  • DYLD_INSERT_LIBRARIES=<PATH_TO_SHARED_LIB>/libjsig.dylib
  • DYLD_FORCE_FLAT_NAMESPACE=0

Weitere Informationen zur Signalverkettung finden Sie auf der Website „ Oracle® JDK-Dokumentation “.

Problem:UnsatisfiedLinkError unter Linux

Ursache: Vom System können abhängige Bibliotheken nicht geladen werden. In den Anwendungsprotokollen werden Fehler wie die folgenden aufgeführt:

libfaspmanager2.so: libawt.so: cannot open shared object file: No such file or directory

Lösung: Legen Sie die folgende Umgebungsvariable fest:

LD_LIBRARY_PATH=<JAVA_HOME>/jre/lib/amd64/server:<JAVA_HOME>/jre/lib/amd64

PUT zum Aktualisieren der Metadaten verwenden

Die Anfrage „ PUT “ überschreibt den bestehenden Inhalt des Objekts; daher muss dieses zunächst heruntergeladen und anschließend mit den neuen Metadaten erneut hochgeladen werden.

public static void updateMetadataPut(String bucketName, String itemName, String key, String value) throws IOException {
    System.out.printf("Updating metadata for item: %s\n", itemName);
    //retrieve the existing item to reload the contents
    S3Object item = _cos.getObject(new GetObjectRequest(bucketName, itemName));
    S3ObjectInputStream itemContents = item.getObjectContent();
    //read the contents of the item in order to set the content length and create a copy
    ByteArrayOutputStream output = new ByteArrayOutputStream();
    int b;
    while ((b = itemContents.read()) != -1) {
        output.write(b);
    }
    int contentLength = output.size();
    InputStream itemCopy = new ByteArrayInputStream(output.toByteArray());
    //set the new metadata
    HashMap<String, String> userMetadata = new HashMap<String, String>();
    userMetadata.put(key, value);
    ObjectMetadata metadata = new ObjectMetadata();
    metadata.setContentLength(contentLength);
    metadata.setUserMetadata(userMetadata);
    PutObjectRequest req = new PutObjectRequest(bucketName, itemName, itemCopy, metadata);
    _cos.putObject(req);
    System.out.printf("Updated metadata for item %s from bucket %s\n", itemName, bucketName);
}

COPY zum Aktualisieren der Metadaten verwenden

public static void updateMetadataCopy(String bucketName, String itemName, String key, String value) {
    System.out.printf("Updating metadata for item: %s\n", itemName);
    //set the new metadata
    HashMap<String, String> userMetadata = new HashMap<String, String>();
    userMetadata.put(key, value);
    ObjectMetadata metadata = new ObjectMetadata();
    metadata.setUserMetadata(userMetadata);
    //set the copy source to itself
    CopyObjectRequest req = new CopyObjectRequest(bucketName, itemName, bucketName, itemName);
    req.setNewObjectMetadata(metadata);
    _cos.copyObject(req);
    System.out.printf("Updated metadata for item %s from bucket %s\n", itemName, bucketName);
}

Schutzkonfiguration für vorhandenes Bucket hinzufügen

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, sofern für das Objekt bei seiner Erstellung nicht ein objektspezifischer Wert angegeben wurde. Objekte in geschützten Buckets, die nicht mehr aufbewahrt werden müssen (Aufbewahrungszeitraum ist abgelaufen und für das Objekt wurden keine Beweissicherungsvermerke angegeben), werden im Falle einer Überschreibung erneut mit einer Aufbewahrungsdauer versehen. 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 Aufbewahrungsfristen „ MinimumRetention “, „ DefaultRetention “ und „ MaximumRetention “ liegen zwischen mindestens 0 Tagen und höchstens 365.243 Tagen (1.000 Jahre).

public static void addProtectionConfigurationToBucket(String bucketName) {
    System.out.printf("Adding protection to bucket: %s\n", bucketName);
    BucketProtectionConfiguration newConfig = new BucketProtectionConfiguration()
        .withStatus(BucketProtectionStatus.Retention)
        .withMinimumRetentionInDays(10)
        .withDefaultRetentionInDays(100)
        .withMaximumRetentionInDays(1000);
    cos.setBucketProtection(bucketName, newConfig);
    System.out.printf("Protection added to bucket %s\n", bucketName);
}
public static void addProtectionConfigurationToBucketWithRequest(String bucketName) {
    System.out.printf("Adding protection to bucket: %s\n", bucketName);
    BucketProtectionConfiguration newConfig = new BucketProtectionConfiguration()
        .withStatus(BucketProtectionStatus.Retention)
        .withMinimumRetentionInDays(10)
        .withDefaultRetentionInDays(100)
        .withMaximumRetentionInDays(1000);
    SetBucketProtectionConfigurationRequest newRequest = new SetBucketProtectionConfigurationRequest()
        .withBucketName(bucketName)
        .withProtectionConfiguration(newConfig);
    cos.setBucketProtectionConfiguration(newRequest);
    System.out.printf("Protection added to bucket %s\n", bucketName);
}

Schutz für Bucket überprüfen

public static void getProtectionConfigurationOnBucket(String bucketName) {
    System.out.printf("Retrieving protection configuration from bucket: %s\n", bucketName;
    BucketProtectionConfiguration config = cos.getBucketProtection(bucketName);
    String status = config.getStatus();
    System.out.printf("Status: %s\n", status);
    if (!status.toUpperCase().equals("DISABLED")) {
        System.out.printf("Minimum Retention (Days): %s\n", config.getMinimumRetentionInDays());
        System.out.printf("Default Retention (Days): %s\n", config.getDefaultRetentionInDays());
        System.out.printf("Maximum Retention (Days): %s\n", config.getMaximumRetentionInDays());
    }
}

Geschütztes Objekt hochladen

Objekte in geschützten Buckets, die nicht mehr aufbewahrt werden müssen (Aufbewahrungszeitraum ist abgelaufen und für das Objekt wurden keine Beweissicherungsvermerke angegeben), werden im Falle einer Überschreibung erneut mit einer Aufbewahrungsdauer versehen. Die neue Aufbewahrungsdauer kann als Teil der Objektüberschreibungsanforderung angegeben werden oder dem Objekt wird der Standardaufbewahrungszeitraum des Buckets zugeordnet.

public static void putObjectAddLegalHold(String bucketName, String objectName, String fileText, String legalHoldId) {
    System.out.printf("Add legal hold %s to %s in bucket %s with a putObject operation.\n", legalHoldId, objectName, bucketName);
    InputStream newStream = new ByteArrayInputStream(fileText.getBytes(StandardCharsets.UTF_8));
    ObjectMetadata metadata = new ObjectMetadata();
    metadata.setContentLength(fileText.length());
    PutObjectRequest req = new PutObjectRequest(
        bucketName,
        objectName,
        newStream,
        metadata
    );
    req.setRetentionLegalHoldId(legalHoldId);
    cos.putObject(req);
    System.out.printf("Legal hold %s added to object %s in bucket %s\n", legalHoldId, objectName, bucketName);
}
public static void copyProtectedObject(String sourceBucketName, String sourceObjectName, String destinationBucketName, String newObjectName) {
    System.out.printf("Copy protected object %s from bucket %s to %s/%s.\n", sourceObjectName, sourceBucketName, destinationBucketName, newObjectName);
    CopyObjectRequest req = new CopyObjectRequest(
        sourceBucketName,
        sourceObjectName,
        destinationBucketName,
        newObjectName
    );
    req.setRetentionDirective(RetentionDirective.COPY);
    cos.copyObject(req);
    System.out.printf("Protected object copied from %s/%s to %s/%s\n", sourceObjectName, sourceBucketName, destinationBucketName, newObjectName);
}

Beweissicherungsvermerk zu geschütztem Objekt hinzufügen oder aus geschütztem Objekt entfernen

Das Objekt kann bis zu 100 Beweissicherungsvermerke unterstützen:

• Die Kennung eines Beweissicherungsvermerks besteht aus einer Zeichenfolge mit maximal 64 Zeichen Länge und einer Mindestlänge von einem 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.
• Wenn eine Kennung zu lang ist, dann wird sie nicht zum Objekt hinzugefügt und das System gibt den Fehler 400 zurück.
• 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 objectName, String legalHoldId) {
    System.out.printf("Adding legal hold %s to object %s in bucket %s\n", legalHoldId, objectName, bucketName);
    cos.addLegalHold(
        bucketName,
        objectName,
        legalHoldId
    );
    System.out.printf("Legal hold %s added to object %s in bucket %s!\n", legalHoldId, objectName, bucketName);
}
public static void deleteLegalHoldFromObject(String bucketName, String objectName, String legalHoldId) {
    System.out.printf("Deleting legal hold %s from object %s in bucket %s\n", legalHoldId, objectName, bucketName);
    cos.deleteLegalHold(
        bucketName,
        objectName,
        legalHoldId
    );
    System.out.printf("Legal hold %s deleted from object %s in bucket %s!\n", legalHoldId, objectName, bucketName);
}

Aufbewahrungsdauer eines geschützten Objekts erweitern

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:

• Hinzufügen zusätzlicher Zeit zum aktuellen Wert (Additional-Retention-Period oder ähnliche Methode)
• Definieren einer neuen Verlängerungszeitdauer in Sekunden (Extend-Retention-From-Current-Time oder ähnliche Methode)
• Definieren eines neuen Ablaufdatums für die Aufbewahrung des Objekts (New-Retention-Expiration-Date oder ä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ängerung des Aufbewahrungszeitraums mit den Angaben für den aktuellen Aufbewahrungszeitraum verglichen; der erweiterte Parameter wird nur akzeptiert, wenn der aktualisierte Aufbewahrungszeitraum größer ist als der aktuelle Aufbewahrungszeitraum.

Objekte in geschützten Buckets, die nicht mehr aufbewahrt werden müssen (Aufbewahrungszeitraum ist abgelaufen und für das Objekt wurden keine Beweissicherungsvermerke angegeben), werden im Falle einer Überschreibung erneut mit einer Aufbewahrungsdauer versehen. 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) {
    System.out.printf("Extend the retention period on %s in bucket %s by %s seconds.\n", objectName, bucketName, additionalSeconds);
    ExtendObjectRetentionRequest req = new ExtendObjectRetentionRequest(
        bucketName,
        objectName)
        .withAdditionalRetentionPeriod(additionalSeconds);
    cos.extendObjectRetention(req);
    System.out.printf("New retention period on %s is %s\n", objectName, additionalSeconds);
}

Beweissicherungsvermerke für geschütztes Objekt auflisten

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

• Objekterstellungsdatum
• Aufbewahrungsdauer des Objekts in Sekunden
• Berechnetes Ablaufdatum der Aufbewahrung auf Basis der Aufbewahrungsdauer und des Erstellungsdatums
• Liste der Beweissicherungsvermerke
• Kennung des Beweissicherungsvermerks
• Zeitmarke für Anwendung des Beweissicherungsvermerks

Wenn für das Objekt keine Beweissicherungsvermerke definiert wurden, dann gibt das System ein leeres Element LegalHoldSet zurück. Wurde keine Aufbewahrungsdauer für das Objekt angegeben, dann wird der Fehler 404 zurückgegeben.

public static void listLegalHoldsOnObject(String bucketName, String objectName) {
    System.out.printf("List all legal holds on object %s in bucket %s\n", objectName, bucketName);
    ListLegalHoldsResult result = cos.listLegalHolds(
        bucketName,
        objectName
    );
    System.out.printf("Legal holds on bucket %s: \n", bucketName);
    List<LegalHold> holds = result.getLegalHolds();
    for (LegalHold hold : holds) {
        System.out.printf("Legal Hold: %s", hold);
    }
}

Erstellen einer gehosteten statischen Website

Für diese Operation muss eine Importanweisung hinzugefügt werden:

import com.ibm.cloud.objectstorage.services.s3.model.model.BucketWebsiteConfiguration;

Diese Operation bietet bei der Konfiguration Folgendes und erfordert einen ordnungsgemäß konfigurierten Client:

• Bucketkonfiguration für Suffix (Indexdokument)
• Bucketkonfiguration für Schlüssel (Fehlerdokument)

cosClient.setBucketWebsiteConfiguration("<bucket_name>", new BucketWebsiteConfiguration("index.html", "error.html"));