Aufbewahrungszeitraum

Die Zeitdauer, die ein Objekt im Bereich IBM Cloud Object Storage gespeichert sein muss.

Aufbewahrungsrichtlinie

Eine Aufbewahrungsrichtlinie ist auf der Ebene von IBM Cloud Object Storage aktiviert. In dieser Richtlinie werden die mindestens erforderliche, maximal zulässige und standardmäßige Aufbewahrungszeitdauer definiert, die für alle Objekte im Bucket gelten.

Die mindestens erforderliche Aufbewahrungsdauer stellt den Zeitraum dar, für den ein Objekt mindestens unverändert im Bucket aufbewahrt werden muss.

Die maximal zulässige Aufbewahrungsdauer stellt den Zeitraum dar, für den ein Objekt maximal unverändert im Bucket aufbewahrt werden kann.

Wird ein Objekt im Bucket ohne Angabe einer angepassten Aufbewahrungsdauer gespeichert, dann verwendet das System den Standardaufbewahrungszeitraum. Die mindestens erforderliche Aufbewahrungsdauer muss kleiner oder gleich dem Standardaufbewahrungszeitraum sein, der seinerseits kleiner oder gleich der maximal zulässigen Aufbewahrungsdauer sein muss.

Für die Objekte kann eine maximale Aufbewahrungsfrist von 99 Jahren festgelegt werden.

Zum Erstellen einer Aufbewahrungsrichtlinie für ein Bucket benötigen Sie die Rolle 'Manager'. Weitere Einzelheiten hierzu finden Sie im Abschnitt zu den Bucketberechtigungen.

Beweissicherung

Für bestimmte Objekte muss möglicherweise nach Ablauf der Aufbewahrungsdauer eine Änderung verhindert werden. Ein Beispiel ist eine noch nicht abgeschlossene rechtliche Überprüfung, bei der Datensätze für eine längere Zeitdauer zugänglich bleiben müssen, die über die ursprünglich festgelegte Aufbewahrungsdauer hinausgeht. Ein Beweissicherungsvermerk kann auf Objektebene angewendet werden.   Solche Beweissicherungsvermerke können während des ersten Uploads oder nach dem Hinzufügen eines Objekts auf Objekte angewendet werden.   Hinweis: Pro Objekt können maximal 100 Beweissicherungsvermerke angewendet werden.

Unbegrenzte Aufbewahrung

Mit dieser Option kann der Benutzer festlegen, dass das Objekt für unbegrenzte Zeit aufbewahrt werden soll, es sei denn, es wird zu einem späteren Zeitpunkt eine neue Aufbewahrungsdauer definiert. Diese Option wird auf Objektebene festgelegt.

Ein Objekt, das mit unbestimmter Aufbewahrung aufbewahrt wird, ist nicht vollständig unveränderlich, bis die Aufbewahrung des Objekts von -1 in einen positiven endlichen Wert umgewandelt wurde. Während ein Objekt, das mit -1 (Unbegrenzte Aufbewahrung) geschrieben wurde, nicht mit DELETE object gelöscht oder überschrieben werden kann, kann die Aufbewahrung des Objekts von -1 auf das aktuelle Datum/Uhrzeit aktualisiert werden, wodurch das Objekt sofort gelöscht werden kann.

Die Benutzer sollten dieses Verhalten berücksichtigen, wenn sie die Eignung des Systems für ihre Speicheranforderungen beurteilen. Ein häufiger Anwendungsfall für die unbestimmte Aufbewahrung wird in Ereignisbasierte Aufbewahrung beschrieben. Wenn Sie eine ereignisbasierte Aufbewahrung verwenden möchten, können Sie mit Object Storage eine unbegrenzte Aufbewahrung für das Objekt festlegen, wenn Sie sich beim ersten Hochladen des Objekts in das System nicht sicher sind, welche Aufbewahrungszeit erforderlich ist. Einmal auf unbestimmt gesetzt, können Benutzeranwendungen die Objektspeicherung auf einen endlichen Wert ändern, wenn ein bestimmtes Ereignis eingetreten ist.

Beispiel Angenommen, ein Unternehmen hat eine Richtlinie, nach der Mitarbeiterakten drei Jahre nach dem Ausscheiden des Mitarbeiters aufbewahrt werden.

• Wenn ein Arbeitnehmer in ein Unternehmen eintritt, können die mit diesem Arbeitnehmer verbundenen Unterlagen auf unbestimmte Zeit aufbewahrt werden.
• Und wenn derselbe Mitarbeiter das Unternehmen verlässt, wird die unbefristete Weiterbeschäftigung in einen endlichen Wert von drei Jahren ab dem aktuellen Zeitpunkt umgewandelt, der durch die Unternehmenspolitik festgelegt ist.

Eine Benutzer- oder Drittanbieteranwendung kann die Aufbewahrungsdauer mit einem SDK oder einer REST-API von unbegrenzt in begrenzt ändern.

Bucket-Besitzer und zugelassene Benutzer können die neue Aufbewahrung begrenzen, die für ein Objekt konfiguriert werden kann, das derzeit mit unbegrenzter Aufbewahrung aufbewahrt wird. Dazu werden die zulässigen Mindest- und Höchstwerte für die Eimerspeicherung verwendet. Auf diese Weise können die Benutzer verhindern, dass die Aufbewahrungszeit eines Objekts, das auf unbestimmte Zeit aufbewahrt wird, auf den aktuellen Zeitpunkt aktualisiert wird, so dass es sofort löschbar ist.

Ereignisgesteuerte Aufbewahrung

Immutable Object Storage (IOS) ermöglicht Benutzern das Festlegen einer unbegrenzten Aufbewahrungsdauer für Objekte, wenn die endgültige Zeitdauer der Aufbewahrung noch nicht feststeht oder wenn die ereignisgesteuerte Aufbewahrung verwendet werden soll. Nachdem eine unbegrenzte Aufbewahrungsdauer festgelegt wurde, kann in Benutzeranwendungen die Aufbewahrungsdauer eines Objekts zu einem späteren Zeitpunkt geändert und eine begrenzte Aufbewahrungsdauer angegeben werden. Beispiel: Ein Unternehmen verfügt über eine Richtlinie zur Aufbewahrung von Mitarbeiterdaten, in der eine Aufbewahrungsdauer von drei Jahren nach Ausscheiden des Mitarbeiters aus dem Unternehmen vorgegeben ist. Wenn ein Mitarbeiter ins Unternehmen eintritt, dann wird angegeben, dass die Datensätze des Mitarbeiters unbeschränkt aufbewahrt werden sollen. Verlässt der betreffende Mitarbeiter das Unternehmen, dann wird die unbeschränkte Aufbewahrungsdauer in eine beschränkte Aufbewahrungsdauer von drei Jahren ab dem aktuellen Zeitpunkt umgewandelt, was den Angaben in der Unternehmensrichtlinie entspricht. Das Objekt wird dann nach Änderung der Aufbewahrungsdauer für drei Jahre geschützt. Eine Benutzer- oder Drittanbieteranwendung kann die Aufbewahrungsdauer mit einem SDK oder einer REST-API von unbegrenzt in begrenzt ändern.

Dauerhafte Aufbewahrung

Die permanente Aufbewahrung stellt sicher, dass Daten nicht von jedermann gelöscht werden können. Lesen Sie die Dokumentation sorgfältig und verwenden Sie keine permanente Aufbewahrung, es sei denn, es besteht ein zwingender Bedarf an gesetzlichen Bestimmungen oder Compliance für permanente Datenspeicherung.

Die permanente Aufbewahrung kann nur auf IBM Cloud Object Storage Bucket-Ebene aktiviert werden, wenn die Aufbewahrungsrichtlinie aktiviert ist und die Benutzer beim Hochladen von Objekten die Option für die permanente Aufbewahrungsdauer auswählen können. Nach seiner Aktivierung kann dieser Prozess nicht umgekehrt werden und Objekte, die unter Verwendung einer dauerhaften Aufbewahrung hochgeladen wurden, können nicht gelöscht werden. Es liegt in der Verantwortung der Benutzer, auf ihrer Seite zu überprüfen, ob es einen legitimen Bedarf für die dauerhafte Speicherung von Objekten gibt, indem sie Object Storage Buckets mit einer Aufbewahrungsrichtlinie verwenden.

Bei Verwendung von Immutable Object Storage sind Sie für die Einhaltung der IBM Cloud-Richtlinien und -Leitlinien für Ihr IBM Cloud-Konto verantwortlich, solange Ihre Daten einer Aufbewahrungsrichtlinie unterliegen. Weitere Informationen hierzu finden Sie im Abschnitt zu den IBM Cloud Service-Bedingungen.

Zugriff und Transaktionen protokollieren

Die Immutable Object Storage-Protokolldaten können verwendet werden, um Änderungen der Aufbewahrungsparameter, der Aufbewahrungsdauer für Objekte sowie die Anwendung von Beweissicherungsvermerken auf Fallbasis zu überprüfen. Hierzu kann ein Kundenservice-Ticket geöffnet werden.

Aufbewahrungsrichtlinie 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, es sei denn, bei der Erstellung des Objekts wird ein objektspezifischer Wert angegeben. 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 Aufbewahrungsfrist MinimumRetention, DefaultRetention und MaximumRetention betragen mindestens 0 Tage und höchstens 36135 Tage (99 Jahre).

Eine Content-MD5 Kopfzeile oder eine checksum Kopfzeile (einschließlich x-amz-checksum-crc32, x-amz-checksum-crc32c,x-amz-checksum-crc64nvme, x-amz-checksum-sha1, oder x-amz-checksum-sha256) ist erforderlich. Diese Operation verwendet keine zusätzlichen Abfrageparameter.

Weitere Informationen zu Endpunkten finden Sie in Endpunkte und Speicherpositionen.

Syntax

PUT https://{endpoint}/{bucket-name}?protection= # path style
PUT https://{bucket-name}.{endpoint}?protection= # virtual host style

Beispielanforderung

PUT /example-bucket?protection= HTTP/1.1
Authorization: {authorization-string}
x-amz-date: 20181011T190354Z
x-amz-content-sha256: 2938f51643d63c864fdbea618fe71b13579570a86f39da2837c922bae68d72df
Content-MD5: GQmpTNpruOyK6YrxHnpj7g==
Content-Type: text/plain
Host: 67.228.254.193
Content-Length: 299
<ProtectionConfiguration>
  <Status>Retention</Status>
  <MinimumRetention>
    <Days>100</Days>
  </MinimumRetention>
  <MaximumRetention>
    <Days>10000</Days>
  </MaximumRetention>
  <DefaultRetention>
    <Days>2555</Days>
  </DefaultRetention>
</ProtectionConfiguration>

Beispielantwort

HTTP/1.1 200 OK
Date: Wed, 5 Oct 2018 15:39:38 GMT
X-Clv-Request-Id: 7afca6d8-e209-4519-8f2c-1af3f1540b42
Accept-Ranges: bytes
Server: Cleversafe/3.14.1
X-Clv-S3-Version: 2.5
x-amz-request-id: 7afca6d8-e209-4519-8f2c-1af3f1540b42
Content-Length: 0

def add_protection_configuration_to_bucket(bucket_name):
    try:
        new_protection_config = {
            "Status": "Retention",
            "MinimumRetention": {"Days": 10},
            "DefaultRetention": {"Days": 100},
            "MaximumRetention": {"Days": 1000}
        }

        cos.put_bucket_protection_configuration(Bucket=bucket_name, ProtectionConfiguration=new_protection_config)

        print("Protection added to bucket {0}\n".format(bucket_name))
    except ClientError as be:
        print("CLIENT ERROR: {0}\n".format(be))
    except Exception as e:
        print("Unable to set bucket protection config: {0}".format(e))

function addProtectionConfigurationToBucket(bucketName) {
    console.log(`Adding protection to bucket ${bucketName}`);
    return cos.putBucketProtectionConfiguration({
        Bucket: bucketName,
        ProtectionConfiguration: {
            'Status': 'Retention',
            'MinimumRetention': {'Days': 10},
            'DefaultRetention': {'Days': 100},
            'MaximumRetention': {'Days': 1000}
        }
    }).promise()
    .then(() => {
        console.log(`Protection added to bucket ${bucketName}!`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

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);
}

Aufbewahrungsrichtlinie eines Buckets prüfen

Bei dieser Implementierung der GET-Operation werden die Aufbewahrungsparameter eines vorhandenen Buckets abgerufen.

Syntax

GET https://{endpoint}/{bucket-name}?protection= # path style
GET https://{bucket-name}.{endpoint}?protection= # virtual host style

Beispielanforderung

GET /example-bucket?protection= HTTP/1.1
Authorization: {authorization-string}
x-amz-date: 20181011T190354Z
Content-Type: text/plain
Host: 67.228.254.193

Beispielantwort

HTTP/1.1 200 OK
Date: Wed, 5 Oct 2018 15:39:38 GMT
X-Clv-Request-Id: 7afca6d8-e209-4519-8f2c-1af3f1540b42
Accept-Ranges: bytes
Server: Cleversafe/3.13.1
X-Clv-S3-Version: 2.5
x-amz-request-id: 7afca6d8-e209-4519-8f2c-1af3f1540b42
Content-Length: 299
<ProtectionConfiguration>
  <Status>Retention</Status>
  <MinimumRetention>
    <Days>100</Days>
  </MinimumRetention>
  <MaximumRetention>
    <Days>10000</Days>
  </MaximumRetention>
  <DefaultRetention>
    <Days>2555</Days>
  </DefaultRetention>
</ProtectionConfiguration>

Wenn für ein Bucket keine Schutzkonfiguration festgelegt wurde, dann gibt der Server den Status 'Inaktiviert' aus.

<ProtectionConfiguration>
  <Status>Disabled</Status>
</ProtectionConfiguration>

def get_protection_configuration_on_bucket(bucket_name):
    try:
        response = cos.get_bucket_protection_configuration(Bucket=bucket_name)
        protection_config = response.get("ProtectionConfiguration")

        print("Bucket protection config for {0}\n".format(bucket_name))
        print(protection_config)
        print("\n")
    except ClientError as be:
        print("CLIENT ERROR: {0}\n".format(be))
    except Exception as e:
        print("Unable to get bucket protection config: {0}".format(e))

function getProtectionConfigurationOnBucket(bucketName) {
    console.log(`Retrieve the protection on bucket ${bucketName}`);
    return cos.getBucketProtectionConfiguration({
        Bucket: bucketName
    }).promise()
    .then((data) => {
        console.log(`Configuration on bucket ${bucketName}:`);
        console.log(data);
    }
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

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());
    }
}

Objekt mit Aufbewahrungsrichtlinie in Bucket hochladen

Diese Erweiterung der PUT-Operation fügt drei neue Anforderungsheader hinzu: Zwei zur Angabe der Aufbewahrungsdauer auf unterschiedliche Weise und einen zum Hinzufügen eines einzelnen Beweissicherungsvermerks zu dem neuen Objekt. Für unzulässige Werte bei neuen Headern werden neue Fehler definiert. Wenn für ein Objekt eine Aufbewahrungsdauer angegeben ist, dann schlagen Überschreibungen fehl.

Objekte in Buckets mit Aufbewahrungsrichtlinie, 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.

Ein Content-MD5-Header oder ein checksum-Header (einschließlich x-amz-checksum-crc32, x-amz-checksum-crc32c, x-amz-checksum-crc64nvme, x-amz-checksum-sha1 oder x-amz-checksum-sha256) ist als Integritätsprüfung für die Nutzlast für jede Art von Objekt-Upload-Anforderung für einen Bereich mit einer Aufbewahrungsrichtlinie erforderlich.

def put_object_add_legal_hold(bucket_name, object_name, file_text, legal_hold_id):
    print("Add legal hold {0} to {1} in bucket {2} with a putObject operation.\n".format(legal_hold_id, object_name, bucket_name))

    cos.put_object(
        Bucket=bucket_name,
        Key=object_name,
        Body=file_text,
        RetentionLegalHoldId=legal_hold_id)

    print("Legal hold {0} added to object {1} in bucket {2}\n".format(legal_hold_id, object_name, bucket_name))

def copy_protected_object(source_bucket_name, source_object_name, destination_bucket_name, new_object_name):
    print("Copy protected object {0} from bucket {1} to {2}/{3}.\n".format(source_object_name, source_bucket_name, destination_bucket_name, new_object_name))

    copy_source = {
        "Bucket": source_bucket_name,
        "Key": source_object_name
    }

    cos.copy_object(
        Bucket=destination_bucket_name,
        Key=new_object_name,
        CopySource=copy_source,
        RetentionDirective="Copy"
    )

    print("Protected object copied from {0}/{1} to {2}/{3}\n".format(source_bucket_name, source_object_name, destination_bucket_name, new_object_name));

def complete_multipart_upload_with_retention(bucket_name, object_name, upload_id, retention_period):
    print("Completing multi-part upload for object {0} in bucket {1}\n".format(object_name, bucket_name))

    cos.complete_multipart_upload(
        Bucket=bucket_name,
        Key=object_name,
        MultipartUpload={
            "Parts":[{
                "ETag": part["ETag"],
                "PartNumber": 1
            }]
        },
        UploadId=upload_id,
        RetentionPeriod=retention_period
    )

    print("Multi-part upload completed for object {0} in bucket {1}\n".format(object_name, bucket_name))

def upload_file_with_retention(bucket_name, object_name, path_to_file, retention_period):
    print("Uploading file {0} to object {1} in bucket {2}\n".format(path_to_file, object_name, bucket_name))

    args = {
        "RetentionPeriod": retention_period
    }

    cos.upload_file(
        Filename=path_to_file,
        Bucket=bucket_name,
        Key=object_name,
        ExtraArgs=args
    )

    print("File upload complete to object {0} in bucket {1}\n".format(object_name, bucket_name))

function putObjectAddLegalHold(bucketName, objectName, legalHoldId) {
    console.log(`Add legal hold ${legalHoldId} to ${objectName} in bucket ${bucketName} with a putObject operation.`);
    return cos.putObject({
        Bucket: bucketName,
        Key: objectName,
        Body: 'body',
        RetentionLegalHoldId: legalHoldId
    }).promise()
    .then((data) => {
        console.log(`Legal hold ${legalHoldId} added to object ${objectName} in bucket ${bucketName}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

function copyProtectedObject(sourceBucketName, sourceObjectName, destinationBucketName, newObjectName, ) {
    console.log(`Copy protected object ${sourceObjectName} from bucket ${sourceBucketName} to ${destinationBucketName}/${newObjectName}.`);
    return cos.copyObject({
        Bucket: destinationBucketName,
        Key: newObjectName,
        CopySource: sourceBucketName + '/' + sourceObjectName,
        RetentionDirective: 'Copy'
    }).promise()
    .then((data) => {
        console.log(`Protected object copied from ${sourceBucketName}/${sourceObjectName} to ${destinationBucketName}/${newObjectName}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

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 Objekt hinzufügen oder für Objekt entfernen

Bei dieser Implementierung der POST-Operation werden die Abfrageparameter legalHold sowie add und remove verwendet, um einen einzelnen Beweissicherungsvermerk zu einem geschützten Objekt in einem geschützten Bucket hinzuzufügen oder für ein solches Objekt zu 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 (1) Zeichen. Gültige 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.

Syntax

POST https://{endpoint}/{bucket-name}/{object-name}?legalHold # path style
POST https://{bucket-name}.{endpoint}/{object-name}?legalHold= # virtual host style

Beispielanforderung

POST /BucketName/ObjectName?legalHold&add=legalHoldID HTTP/1.1
Host: myBucket.mydsNet.corp.com
Date: Fri, 8 Dec 2018 17:50:00 GMT
Authorization: authorization string
Content-Type: text/plain

Beispielantwort

HTTP/1.1 200 OK
Date: Fri, 8 Dec 2018 17:51:00 GMT
Connection: close

def add_legal_hold_to_object(bucket_name, object_name, legal_hold_id):
    print("Adding legal hold {0} to object {1} in bucket {2}\n".format(legal_hold_id, object_name, bucket_name))

    cos.add_legal_hold(
        Bucket=bucket_name,
        Key=object_name,
        RetentionLegalHoldId=legal_hold_id
    )

    print("Legal hold {0} added to object {1} in bucket {2}!\n".format(legal_hold_id, object_name, bucket_name))

def delete_legal_hold_from_object(bucket_name, object_name, legal_hold_id):
    print("Deleting legal hold {0} from object {1} in bucket {2}\n".format(legal_hold_id, object_name, bucket_name))

    cos.delete_legal_hold(
        Bucket=bucket_name,
        Key=object_name,
        RetentionLegalHoldId=legal_hold_id
    )

    print("Legal hold {0} deleted from object {1} in bucket {2}!\n".format(legal_hold_id, object_name, bucket_name))

function addLegalHoldToObject(bucketName, objectName, legalHoldId) {
    console.log(`Adding legal hold ${legalHoldId} to object ${objectName} in bucket ${bucketName}`);
    return cos.client.addLegalHold({
        Bucket: bucketName,
        Key: objectId,
        RetentionLegalHoldId: legalHoldId
    }).promise()
    .then(() => {
        console.log(`Legal hold ${legalHoldId} added to object ${objectName} in bucket ${bucketName}!`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

function deleteLegalHoldFromObject(bucketName, objectName, legalHoldId) {
    console.log(`Deleting legal hold ${legalHoldId} from object ${objectName} in bucket ${bucketName}`);
    return cos.client.deleteLegalHold({
        Bucket: bucketName,
        Key: objectId,
        RetentionLegalHoldId: legalHoldId
    }).promise()
    .then(() => {
        console.log(`Legal hold ${legalHoldId} deleted from object ${objectName} in bucket ${bucketName}!`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

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 Objekts verlängern

Bei dieser Implementierung der POST-Operation wird der Abfrageparameter extendRetention verwendet, um die Aufbewahrungsdauer eines geschützten Objekts in einem geschützten Bucket zu verlängern.

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.

Das unterstützte ISO 8601-Format für New-Retention-Expiration-Date ist [YYYY]-[MM]-[DD]T[hh]:[mm]:[ss]Z oder [YYYY][MM][DD]T[hh][mm][ss]Z (beispielsweise sind 2020-11-28T03:10:01Z oder 20201128T031001Z beide gültig).

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.

Syntax

POST https://{endpoint}/{bucket-name}/{object-name}?extendRetention= # path style
POST https://{bucket-name}.{endpoint}/{object-name}?extendRetention= # virtual host style

Beispielanforderung

POST /BucketName/ObjectName?extendRetention HTTP/1.1
Host: myBucket.mydsNet.corp.com
Date: Fri, 8 Dec 2018 17:50:00GMT
Authorization: authorization string
Content-Type: text/plain
Additional-Retention-Period: 31470552

Beispielantwort

HTTP/1.1 200 OK
Date: Fri, 8 Dec 2018 17:50:00GMT
Connection: close

def extend_retention_period_on_object(bucket_name, object_name, additional_seconds):
    print("Extend the retention period on {0} in bucket {1} by {2} seconds.\n".format(object_name, bucket_name, additional_seconds))

    cos.extend_object_retention(
        Bucket=bucket_ame,
        Key=object_name,
        AdditionalRetentionPeriod=additional_seconds
    )

    print("New retention period on {0} is {1}\n".format(object_name, additional_seconds))

function extendRetentionPeriodOnObject(bucketName, objectName, additionalSeconds) {
    console.log(`Extend the retention period on ${objectName} in bucket ${bucketName} by ${additionalSeconds} seconds.`);
    return cos.extendObjectRetention({
        Bucket: bucketName,
        Key: objectName,
        AdditionalRetentionPeriod: additionalSeconds
    }).promise()
    .then((data) => {
        console.log(`New retention period on ${objectName} is ${data.RetentionPeriod}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

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 eines Objekts auflisten

Bei dieser Implementierung der GET-Operation wird der Abfrageparameter legalHold verwendet, um die Liste der Beweissicherungsvermerke für ein Objekt und den zugehörigen Aufbewahrungsstatus in einem XML-Antworthauptteil zurückzugeben.

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.

Syntax

GET https://{endpoint}/{bucket-name}/{object-name}?legalHold= # path style
GET https://{bucket-name}.{endpoint}/{object-name}?legalHold= # virtual host style

Beispielanforderung

GET /BucketName/ObjectName?legalHold HTTP/1.1
Host: myBucket.mydsNet.corp.com
Date: Fri, 8 Dec 2018 17:50:00 GMT
Authorization: {authorization-string}
Content-Type: text/plain

Beispielantwort

HTTP/1.1 200 OK
Date: Fri, 8 Dec 2018 17:51:00 GMT
Connection: close
<?xml version="1.0" encoding="UTF-8"?>
<RetentionState>
  <CreateTime>Fri, 8 Sep 2018 21:33:08 GMT</CreateTime>
  <RetentionPeriod>220752000</RetentionPeriod>
  <RetentionPeriodExpirationDate>Fri, 1 Sep 2023 21:33:08
GMT</RetentionPeriodExpirationDate>
  <LegalHoldSet>
    <LegalHold>
      <ID>SomeLegalHoldID</ID>
      <Date>Fri, 8 Sep 2018 23:13:18 GMT</Date>
    </LegalHold>
    <LegalHold>
    ...
    </LegalHold>
  </LegalHoldSet>
</RetentionState>

def list_legal_holds_on_object(bucket_name, object_name):
    print("List all legal holds on object {0} in bucket {1}\n".format(object_name, bucket_name));

    response = cos.list_legal_holds(
        Bucket=bucket_name,
        Key=object_name
    )

    print("Legal holds on bucket {0}: {1}\n".format(bucket_name, response))

function listLegalHoldsOnObject(bucketName, objectName) {
    console.log(`List all legal holds on object ${objectName} in bucket ${bucketName}`);
    return cos.listLegalHolds({
        Bucket: bucketName,
        Key: objectId
    }).promise()
    .then((data) => {
        console.log(`Legal holds on bucket ${bucketName}: ${data}`);
    })
    .catch((e) => {
        console.log(`ERROR: ${e.code} - ${e.message}\n`);
    });
}

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);
    }
}