Periodo di conservazione

La durata del tempo in cui un oggetto deve essere conservato nel secchio IBM Cloud Object Storage.

Politica di conservazione

Un criterio di conservazione è abilitato a livello di bucket IBM Cloud Object Storage. I periodi di conservazione minimo, massimo e predefinito sono definiti da questa politica e si applicano a tutti gli oggetti nel bucket.

Il periodo di conservazione minimo è la durata minima del periodo di tempo durante il quale un oggetto deve essere mantenuto invariato nel bucket.

Il periodo di conservazione massimo è la durata massima del periodo di tempo durante il quale un oggetto può essere mantenuto invariato nel bucket.

Se un oggetto viene archiviato nel bucket senza specificare un periodo di conservazione personalizzato, viene utilizzato il periodo di conservazione predefinito. Il periodo di conservazione minimo deve essere minore o uguale al periodo di conservazione predefinito, che a sua volta deve essere minore o uguale al periodo di conservazione massimo.

È possibile specificare un periodo di conservazione massimo di 99 anni per gli oggetti.

Per creare una politica di conservazione in un bucket, hai bisogno del ruolo di gestore (Manager). Per ulteriori dettagli, vedi Autorizzazioni bucket.

Conservazione a fini legali

Potrebbe essere necessario impedire che degli specifici oggetti vengano modificati dopo la scadenza di un periodo di conservazione. Un esempio è una revisione legale incompleta, in cui i record potrebbero dover essere accessibili per una durata estesa oltre il periodo di conservazione originariamente impostato. È quindi possibile applicare un indicatore di conservazione a fini legali a livello dell'oggetto.   Le conservazioni a fini legali possono essere applicate agli oggetti durante i caricamenti iniziali o dopo che un oggetto è stato scritto.   Nota: possono essere applicate massimo 100 conservazioni a fini legali per oggetto.

Conservazione indefinita

Consente all'utente di configurare l'oggetto in modo che venga archiviato in modo indefinito fino a quando non viene applicato un nuovo periodo di conservazione. Viene configurata a livello di singolo oggetto.

Un oggetto conservato utilizzando la conservazione indefinita non è completamente immutabile finché la conservazione dell'oggetto non viene convertita da -1 a un valore finito positivo. Sebbene un oggetto scritto con -1 (Indefinite Retention) non possa essere cancellato tramite la richiesta DELETE object o sovrascritta, l'oggetto può comunque avere la retention aggiornata da -1 alla data/ora corrente, il che renderebbe l'oggetto immediatamente cancellabile.

Gli utenti devono tenere conto di questo comportamento quando valutano la fattibilità del sistema per le loro esigenze di archiviazione. Un caso d'uso comune per la conservazione indefinita è descritto in Ritenzione basata sugli eventi. Nel caso in cui si voglia utilizzare la conservazione basata sugli eventi, Immutable Object Storage consente agli utenti di impostare una conservazione indefinita sull'oggetto se non sono sicuri delle esigenze di conservazione quando l'oggetto viene caricato per la prima volta nel sistema. Una volta impostato su indefinito, le applicazioni utente possono modificare la conservazione dell'oggetto in un valore finito quando si verifica un determinato evento.

Esempio Un'azienda ha una politica di conservazione dei documenti dei dipendenti per tre anni dopo che il dipendente ha lasciato l'azienda.

• Quando un dipendente entra a far parte di una società, i dati ad esso associati possono essere conservati a tempo indeterminato.
• E quando lo stesso dipendente lascia l'azienda, la retention a tempo indeterminato viene convertita in un valore finito di tre anni dal momento attuale, definito dalla politica aziendale.

Un'applicazione utente o di terze parti può modificare il periodo di conservazione da indefinito a finito che utilizza un SDK o un'API REST.

I proprietari dei bucket e gli utenti autorizzati possono limitare la nuova conservazione che può essere configurata per un oggetto attualmente conservato con la conservazione indefinita. Ciò avviene utilizzando i valori minimi e massimi consentiti per la ritenzione del secchio. In questo modo, gli utenti possono evitare che un oggetto conservato con una conservazione indefinita venga aggiornato all'ora corrente, in modo da essere immediatamente cancellato.

Conservazione basata sull'evento

Immutable Object Storage consente agli utenti di impostare una conservazione indefinita sull'oggetto se non sono sicuri della durata finale del periodo di conservazione oppure se desiderano utilizzare la conservazione basata sugli eventi. Una volta impostate su indefinite, le applicazioni utente possono quindi cambiare la conservazione dell'oggetto in un valore finito successivamente. Ad esempio, un'azienda ha una politica di conservazione dei record dei dipendenti di tre anni dopo che il dipendente lascia la società. Quando un dipendente si unisce all'azienda, i record associati a tale dipendente possono essere conservati in modo indefinito. Quando il dipendente lascia l'azienda, la conservazione indefinita viene convertita in un valore finito di tre anni dal tempo corrente, come definito dalla politica aziendale. L'oggetto viene poi protetto per tre anni dopo la modifica del periodo di conservazione. Un'applicazione utente o di terze parti può modificare il periodo di conservazione da indefinito a finito che utilizza un SDK o un'API REST.

Conservazione permanente

La conservazione permanente garantisce che i dati non possano essere eliminati, mai, da nessuno. Leggere attentamente la documentazione e non utilizzare la conservazione permanente a meno che non vi sia una necessità normativa o di conformità per l'archiviazione dei dati permanente.

La conservazione permanente può essere abilitata solo a livello di bucket IBM Cloud Object Storage con i criteri di conservazione abilitati e gli utenti possono selezionare l'opzione del periodo di conservazione permanente durante il caricamento degli oggetti. Una volta abilitato, questo processo non può essere annullato e gli oggetti caricati che utilizzano un periodo di conservazione permanente non possono essere eliminati. È responsabilità degli utenti convalidare se esiste una necessità legittima di archiviare permanentemente gli oggetti utilizzando i bucket Object Storage con un criterio di conservazione.

Quando utilizzi Immutable Object Storage, devi assicurarti che il tuo account IBM Cloud sia in regola con le politiche e le linee guida di IBM Cloud per tutto il tempo durante il quale i dati saranno soggetti a una politica di conservazione. Per ulteriori informazioni, vedi i termini del servizio di IBM Cloud.

Controllo dell'accesso e delle transazioni

I dati di log di accesso per Immutable Object Storage per esaminare le modifiche ai parametri di conservazione, al periodo di conservazione dell'oggetto e all'applicazione delle conservazioni a fini legali sono disponibili su base di caso per caso aprendo un ticket del servizio clienti.

Aggiungi una politica di conservazione a un bucket esistente

Questa implementazione dell'operazione PUT utilizza il parametro di query protection per impostare i parametri di conservazione per un bucket esistente. Questa operazione ti consente di impostare o modificare il periodo di conservazione minimo, predefinito e massimo. Questa operazione ti consente anche di modificare lo stato di protezione del bucket.

Gli oggetti scritti in un bucket protetto non possono essere eliminati fino a quando il periodo di protezione non è scaduto e tutte le conservazioni a fini legali sull'oggetto non sono stati rimosse. A un oggetto viene dato il valore di conservazione predefinito del bucket, a meno che non venga fornito un valore specifico per l'oggetto quando l'oggetto viene creato. Gli oggetti nei bucket protetti che non sono più sottoposti a conservazione (il periodo di conservazione è scaduto e l'oggetto non ha alcuna conservazione a fini legali), quando vengono sovrascritti sono di nuovo sottoposti a conservazione. Il nuovo periodo di conservazione può essere fornito come parte della richiesta di sovrascrittura dell'oggetto, altrimenti all'oggetto verrà assegnato il tempo di conservazione predefinito del bucket.

I valori minimi e massimi supportati per le impostazioni del periodo di conservazione MinimumRetention, DefaultRetention e MaximumRetention sono un minimo di 0 giorni e un massimo di 36135 giorni (99 anni).

È necessaria un'intestazione Content-MD5 o un'intestazione checksum (comprese x-amz-checksum-crc32, x-amz-checksum-crc32c,x-amz-checksum-crc64nvme, x-amz-checksum-sha1 o x-amz-checksum-sha256). Questa operazione non utilizza parametri di query aggiuntivi.

Per ulteriori informazioni sugli endpoint, vedi Endpoint e ubicazioni di archiviazione

Sintassi

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

Richiesta di esempio

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>

Risposta di esempio

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

Controlla la politica di conservazione su un bucket

Questa implementazione di un'operazione GET recupera i parametri di conservazione per un bucket esistente.

Sintassi

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

Richiesta di esempio

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

Risposta di esempio

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>

Se non ci sono configurazioni di protezione sul bucket, il server risponde invece con lo stato disabilitato.

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

Carica un oggetto in un bucket con la politica di conservazione

Questo miglioramento dell'operazione PUT aggiunge tre nuove intestazioni della richiesta: due per specificare il periodo di conservazione in modi diversi e uno per aggiungere una singola conservazione a fini legali al nuovo oggetto. Vengono definiti nuovi errori per i valori non validi relativi alle nuove intestazioni e se un oggetto è oggetto di conservazione, le sovrascritture avranno esito negativo.

Gli oggetti nei bucket con la politica di conservazione che non sono più oggetto di conservazione (il periodo di conservazione è scaduto e l'oggetto non ha alcuna conservazione a fini legali), quando vengono sovrascritti diventano di nuovo oggetto di conservazione. Il nuovo periodo di conservazione può essere fornito come parte della richiesta di sovrascrittura dell'oggetto, altrimenti all'oggetto verrà assegnato il tempo di conservazione predefinito del bucket.

Un'intestazione Content-MD5 o un'intestazione checksum (incluse x-amz-checksum-crc32, x-amz-checksum-crc32c, x-amz-checksum-crc64nvme, x-amz-checksum-sha1 o x-amz-checksum-sha256) è richiesta come verifica dell'integrità del payload per qualsiasi tipo di richiesta di caricamento di oggetti contro un bucket con un criterio di conservazione.

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

Aggiungi o rimuovi una conservazione a fini legati a/da un oggetto

Questa implementazione dell'operazione POST utilizza il parametro di query legalHold e i parametri di query add e remove per aggiungere o rimuovere una singola conservazione a fini legali da un oggetto protetto in un bucket protetto.

L'oggetto può supportare 100 conservazioni a fini legali:

• Un identificativo di conservazione a fini legali è una stringa di una lunghezza massima di 64 caratteri e una lunghezza minima di un carattere. I caratteri validi sono lettere, numeri, !, _, ., *, (, ), -, e '.
• Se l'aggiunta di una specifica conservazione a fini legali comporta il superamento di un totale di 100 conservazioni a fini legali sull'oggetto, la nuova conservazione a fini legali non viene aggiunta e viene restituito un errore 400.
• Se un identificativo è troppo lungo, non viene aggiunto all'oggetto e viene restituito un errore 400.
• Se un identificativo contiene caratteri non validi, non viene aggiunto all'oggetto e viene restituito un errore 400.
• Se un identificativo è già in uso su un oggetto, la conservazione a fini legali esistente non viene modificata e la risposta indica che l'identificativo era già in uso con un errore 409.
• Se un oggetto non ha metadati del periodo di conservazione, viene restituito un errore 400 e l'aggiunta o la rimozione di una conservazione a fini legali non è consentita.

La presenza di un'intestazione di periodo di conservazione è obbligatoria, altrimenti viene restituito un errore 400.

Sintassi

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

Richiesta di esempio

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

Risposta di esempio

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

Estendi il periodo di conservazione di un oggetto

Questa implementazione dell'operazione POST utilizza il parametro di query extendRetention per estendere il periodo di conservazione di un oggetto protetto in un bucket protetto.

Il periodo di conservazione di un oggetto può solo essere esteso. Non può essere ridotto rispetto al valore attualmente configurato.

Il valore di espansione della conservazione è impostato in uno di tre possibili modi:

• ulteriore tempo dal valore corrente (Additional-Retention-Period o metodo simile)
• nuovo periodo di estensione in secondi (Extend-Retention-From-Current-Time o metodo simile)
• nuova data di scadenza della conservazione dell'oggetto (New-Retention-Expiration-Date o metodo simile)

Il periodo di conservazione attuale memorizzato nei metadati dell'oggetto viene aumentato in misura equivalente al tempo aggiuntivo indicato oppure sostituito con il nuovo valore, a seconda del parametro impostato nella richiesta extendRetention. In tutti i casi, il parametro di estensione della conservazione viene controllato rispetto al periodo di conservazione attuale e il parametro esteso viene accettato solo se il periodo di conservazione aggiornato è più grande del periodo di conservazione attuale.

Il formato ISO 8601 supportato per New-Retention-Expiration-Date è [YYYY]-[MM]-[DD]T[hh]:[mm]:[ss]Z o [YYYY][MM][DD]T[hh][mm][ss]Z (ad esempio, 2020-11-28T03:10:01Z o 20201128T031001Z sono entrambi validi).

Gli oggetti nei bucket protetti che non sono più sottoposti a conservazione (il periodo di conservazione è scaduto e l'oggetto non ha alcuna conservazione a fini legali), quando vengono sovrascritti sono di nuovo sottoposti a conservazione. Il nuovo periodo di conservazione può essere fornito come parte della richiesta di sovrascrittura dell'oggetto, altrimenti all'oggetto verrà assegnato il tempo di conservazione predefinito del bucket.

Sintassi

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

Richiesta di esempio

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

Risposta di esempio

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

Elenca le conservazioni a fini legali su un oggetto

Questa implementazione dell'operazione GET utilizza il parametro di query legalHold per restituire l'elenco delle conservazioni a fini legali su un oggetto e lo stato di conservazione correlato in un corpo della risposta XML.

Questa operazione restituisce:

• La data di creazione dell'oggetto
• Il periodo di conservazione dell'oggetto in secondi
• Data di scadenza della conservazione calcolata sulla base del periodo e della data di creazione
• Elenco delle conservazioni a fini legali
• Identificativo della conservazione a fini legali
• Data/ora di quando è stata applicata la conservazione a fini legali

Se non ci sono conservazioni a fini legali sull'oggetto, viene restituito un LegalHoldSet vuoto. Se non c'è alcun periodo di conservazione specificato sull'oggetto, viene restituito un errore 404.

Sintassi

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

Richiesta di esempio

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

Risposta di esempio

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