Suppression des données périmées à l'aide de règles d'expiration

Une règle d'expiration supprime les objets au terme d'une période définie (à partir de la date de création de l'objet).

Vous pouvez définir le cycle de vie des objets à l'aide de la console Web, de l'API REST et des outils tiers qui sont intégrés à IBM Cloud Object Storage.

  • Une règle d'expiration peut être ajoutée à un compartiment nouveau ou existant.

  • Une règle d'expiration existante peut être modifiée ou désactivée.

  • Une règle d'expiration récemment ajoutée ou modifiée s'applique à tous les objets nouveaux et existants dans le compartiment.

  • Les opérations d'ajout ou de modification de règles de cycle de vie requièrent le rôle Writer.

  • Jusqu'à 1 000 règles de cycle de vie (archivage + expiration) peuvent être définies par compartiment.

  • Prévoyez jusqu'à 24 heures avant que les modifications apportées aux règles d'expiration prennent effet.

  • La portée de chaque règle d'expiration peut être limitée en définissant un filtre de préfixe facultatif à appliquer uniquement à un sous-ensemble d'objets dont les noms correspondent au préfixe.

  • Une règle d'expiration sans filtre de préfixe s'applique à tous les objets du compartiment.

  • Le délai d'expiration d'un objet, spécifié en nombre de jours, est calculé à partir du moment où l'objet a été créé et est arrondi au jour suivant à minuit (UTC). Par exemple, si la règle d'expiration d'un compartiment prévoit qu'un ensemble d'objets arrive à échéance dix jours après la date de création, un objet qui a été créé le 15 avril 2019 à 5 heures 10 (UTC) expirera le 26 avril 2019 à minuit (UTC).

  • Les règles d'expiration de chaque compartiment sont évaluées une fois toutes les 24 heures. Tout objet admissible à l'expiration (d'après la date d'expiration qui lui est associée) sera mis en file d'attente pour suppression. La suppression des objets arrivés à expiration commence le jour suivant et prend généralement moins de 24 heures. Une fois que des objets sont supprimés, vous cessez d'être facturé pour le stockage qui leur est associé.

  • Dans les compartiments activés ou suspendus pour la gestion des versions, un La règle conserve la version en cours et crée un marqueur de suppression plutôt que de supprimer définitivement les données. Pour nettoyer un seau à version, vous pouvez définir deux règles d'expiration. Ajoutez une première règle qui définit une expiration pour la version actuelle et la version non actuelle. Comme la gestion des versions est activée, cette règle crée un marqueur de suppression pour la version. Ajoutez une deuxième règle avec la sélection "Nettoyer les marqueurs de suppression d'objets expirés" pour supprimer les données. Si le versioning est suspendu, vous ne verrez pas l'option de nettoyage des marqueurs de suppression expirés dans la page de configuration de la règle d'expiration. C'est pourquoi il faut d'abord activer la gestion des versions. Ajoutez ensuite une première règle qui fixe une date d'expiration pour la version actuelle et la version non actuelle. Comme la gestion des versions est activée, cette règle crée un marqueur de suppression pour la version. Ajoutez une deuxième règle avec la sélection "Nettoyer les marqueurs de suppression d'objets expirés" pour supprimer les données.

  • L'heure d'expiration des versions non courantes est déterminée par l'heure de la dernière modification de son successeur, arrondie au jour suivant à minuit UTC.

  • Si des versions sont supprimées manuellement d'un objet dont les versions sont censées expirer le jour suivant, ces expirations peuvent ne pas se produire.

Les règles spécifiant une date dans le passé peuvent prendre jusqu'à quelques jours.

Sans précaution, les données risquent d'être définitivement perdues lors de l'utilisation de règles d'expiration sur un compartiment versionné. Dans les cas où la gestion des versions est suspendue et qu'une version null est présente pour l'objet arrivé à expiration, les données peuvent être définitivement perdues. Dans ce cas, un marqueur de suppression null est remplacé, ce qui supprime définitivement l'objet.

Les actions d'expiration des objets soumis à une règle de conservation Immutable Object Storage pour un compartiment sont retardées jusqu'à ce que la règle de conservation ne soit plus appliquée.

Attributs des règles d'expiration

Chaque règle d'expiration comporte les attributs suivants :

ID

L'ID d'une règle doit être unique dans la configuration de cycle de vie du compartiment.

Expiration

Le bloc d'expiration contient les détails qui régissent la suppression automatique des objets. Il peut s'agir d'une date spécifique située dans le futur ou d'une période au terme de laquelle de nouveaux objets sont écrits.

NoncurrentVersionExpiration

Nombre de jours après lequel les versions non actuelles des objets sont automatiquement supprimées.

Préfixe

Chaîne facultative qui sera mise en correspondance avec le préfixe du nom de l'objet dans le compartiment. Une règle avec un préfixe ne s'applique qu'aux objets concordants. Vous pouvez utiliser plusieurs règles pour différentes actions d'expiration et pour différents préfixes dans le même compartiment. Par exemple, dans une même configuration de cycle de vie, une règle peut supprimer tous les objets commençant par logs/ au terme d'une période de 30 jours et une seconde règle peut supprimer les objets commençant par video/ au terme d'une période de 365 jours.

Balise

Option de filtre permettant d'appliquer les règles d'expiration aux objets contenant une balise correspondante. Le filtre de balises est fourni sous la forme d'un conteneur qui spécifie une chaîne de clés et une chaîne de valeurs. La chaîne de clés doit comporter moins de 128 caractères. La chaîne de valeur doit comporter moins de 256 caractères.

ObjectSizeLessThan

Filtre qui limite les actions du cycle de vie aux objets d'une taille inférieure à un certain seuil. Il doit s'agir d'une valeur entière supérieure à 0.

ObjectSizeGreaterThan

Filtre qui limite les actions du cycle de vie aux objets d'une taille supérieure à un certain seuil. Il doit s'agir d'une valeur entière supérieure à 0.

Et

Utilisez le paramètre AND pour appliquer plusieurs filtres à des objets qui doivent répondre à toutes les conditions spécifiées.

Statut

Une règle peut être activée ou désactivée. Une règle est active uniquement lorsqu'elle est activée.

Exemples de configuration de cycle de vie

Avec la configuration suivante, tous les nouveaux objets arrivent à expiration au bout de 30 jours :

<LifecycleConfiguration>
	<Rule>
		<ID>delete-after-30-days</ID>
		<Filter />
		<Status>Enabled</Status>
		<Expiration>
			<Days>30</Days>
		</Expiration>
	</Rule>
</LifecycleConfiguration>

Avec la configuration suivante, tous les objets dotés du préfixe foo/ arrivent à expiration le 1er juin 1020 :

<LifecycleConfiguration>
	<Rule>
        <ID>delete-on-a-date</ID>
    <Filter>
        <Prefix>foo/</Prefix>
    </Filter>
        <Status>Enabled</Status>
        <Expiration>
            <Date>2020-06-01T00:00:00.000Z</Date>
        </Expiration>
	</Rule>
</LifecycleConfiguration>

Cette configuration fait expirer toutes les versions non actuelles des objets au bout de 100 jours.

<LifecycleConfiguration>
  <Rule>
    <ID>DeleteAfterBecomingNonCurrent</ID>
    <Filter/>
    <Status>Enabled</Status>
    <NoncurrentVersionExpiration>
      <NoncurrentDays>100</NoncurrentDays>
    </NoncurrentVersionExpiration>
  </Rule>
</LifecycleConfiguration>

Vous pouvez également combiner des règles de transition et d'expiration. Avec la configuration suivante, tous les objets sont archivés 90 jours après leur création et tous les objets comportant le préfixe foo/ sont supprimés au bout de 180 jours :

<LifecycleConfiguration>
    <Rule>
        <ID>archive-first</ID>
        <Filter />
        <Status>Enabled</Status>
    <Transition>
        <Days>90</Days>
        <StorageClass>GLACIER</StorageClass>
    </Transition>
    </Rule>
    <Rule>
        <ID>then-delete</ID>
    <Filter>
        <Prefix>foo/</Prefix>
    </Filter>
        <Status>Enabled</Status>
        <Expiration>
            <Days>180</Days>
        </Expiration>
    </Rule>
</LifecycleConfiguration>

Cette configuration expire tout objet dont la valeur de la clé de marquage est environment:production.

<LifecycleConfiguration>
    <Rule>
        <ID>DeleteWithTagsFilter</ID>
    <Filter>
        <TagSet>
            <Tag>
                <Key>environment</Key>
                <Value>production</Value>
            </Tag>
        </TagSet>
    </Filter>
        <Status>Enabled</Status>
        <Expiration>
            <Days>180</Days>
        </Expiration>
    </Rule>
</LifecycleConfiguration>

Cette configuration exclut tout objet dont la taille est inférieure à 2kb.

<LifecycleConfiguration>
    <Rule>
        <ID>DeleteWithObjectSizeLessThanFilter</ID>
    <Filter>
        <ObjectSizeLessThan>2048</ObjectSizeLessThan>
    </Filter>
        <Status>Enabled</Status>
        <Expiration>
            <Days>180</Days>
        </Expiration>
    </Rule>
</LifecycleConfiguration>

Cette configuration exclut tout objet dont la taille est supérieure à 1kb.

<LifecycleConfiguration>
    <Rule>
        <ID>DeleteWithObjectSizeGreaterThanFilter</ID>
    <Filter>
        <ObjectSizeGreaterThan>1024</ObjectSizeGreaterThan>
    </Filter>
        <Status>Enabled</Status>
        <Expiration>
            <Days>180</Days>
        </Expiration>
    </Rule>
</LifecycleConfiguration>

Cette configuration expire tout objet supérieur à 10mb dont la tag key value est égale à environnment:production et la tag key value est égale à environment:development.

<LifecycleConfiguration>
    <Rule>
        <ID>DeleteWithMultipleFilter</ID>
    <Filter>
        <And>
        <TagSet>
            <Tag>
                <Key>environment</Key>
                <Value>production</Value>
            </Tag>
            <Tag>
                <Key>environment</Key>
                <Value>development</Value>
            </Tag>
        </TagSet>
        <ObjectSizeGreaterThan>10485760</ObjectSizeGreaterThan>
        </And>
    </Filter>
        <Status>Enabled</Status>
        <Expiration>
            <Days>180</Days>
        </Expiration>
    </Rule>
</LifecycleConfiguration>

Utilisation de la console

Lorsque vous créez un nouveau compartiment, cochez la case Ajouter une règle d'expiration. Cliquez ensuite sur Ajouter une règle pour créer la nouvelle règle d'expiration. Vous pouvez ajouter jusqu'à cinq règles lors de la création d'un compartiment, et des règles supplémentaires peuvent être ajoutées ultérieurement.

Pour un seau existant, sélectionnez Configuration dans le menu de navigation et cliquez sur Ajouter une règle dans la section Règle d'expiration.

Utilisation de l'API et des SDK

Vous pouvez gérer des règles d'expiration à l'aide d'un programme à l'aide de l'API REST ou des SDK IBM COS. Sélectionnez le format des exemples en sélectionnant une catégorie dans le sélecteur de contexte.

Ajout d'une règle d'expiration à la configuration de cycle de vie d'un compartiment

Référence de l'interface de programme d'application REST

Cette implémentation de l'opération PUT utilise le paramètre de requête lifecycle pour définir les paramètres de cycle de vie du compartiment. Cette opération permet de créer une définition de règle de cycle de vie unique pour un compartiment. La règle est définie comme un ensemble de règles composé des paramètres suivants : ID, Status, Filter et Expiration.

Les utilisateurs de Cloud IAM doivent avoir le rôle Writer pour ajouter une politique de cycle de vie à partir d'un panier.

Infrastructure classique Les utilisateurs doivent avoir les droits Owner sur le seau pour ajouter une politique de cycle de vie à partir d'un seau.

En-têtes facultatifs
En-tête Type Description
Content-MD5 Chaîne MD5 Le hachage base64 codé sur 128 bits de la charge utile, qui est utilisé comme contrôle d'intégrité pour garantir que la charge utile n'a pas été modifiée en cours de route.
x-amz-checksum-crc32 Chaîne Cet en-tête est la somme de contrôle Base64 encodée, 32 bits CRC32 de l'objet.
x-amz-checksum-crc32c Chaîne Cet en-tête est la somme de contrôle Base64 encodée, 32 bits CRC32C de l'objet.
x-amz-checksum-crc64nvme Chaîne Cet en-tête est la somme de contrôle Base64 encodée, 64 bits CRC64NVME de l'objet. La somme de contrôle de CRC64NVME est toujours une somme de contrôle d'objet complet.
x-amz-checksum-sha1 Chaîne SHA1 Cet en-tête est le condensé de 160 bits de l'objet, codé sur Base64.
x-amz-checksum-sha256 Chaîne Cet en-tête est le code Base64, 256-bit SHA256 digest de l'objet.
x-amz-sdk-checksum-algorithm Chaîne Indique l'algorithme utilisé pour créer la somme de contrôle de l'objet lors de l'utilisation du SDK.

Un en-tête Content-MD5 ou un en-tête checksum (y compris x-amz-checksum-crc32, x-amz-checksum-crc32c, x-amz-checksum-crc64nvme, x-amz-checksum-sha1 ou x-amz-checksum-sha256) est nécessaire pour vérifier l'intégrité de la charge utile.

Le corps de la demande doit contenir un bloc XML avec le schéma suivant :

Elément Type Enfants Ancêtre Contrainte
LifecycleConfiguration Conteneur Rule Aucun Limite 1.
Rule Conteneur ID, Status, Filter, Expiration LifecycleConfiguration Limite 1000.
ID Chaîne Aucun Rule Doit se composer de (a-z,A-Z,0-9) et des symboles suivants: ! _ . * ' ( ) -
Filter Chaîne Prefix Rule Doit contenir un élément Prefix.
Expiration Container Days ou Date Rule Limite 1.
Days Entier non négatif Aucun Expiration Doit être une valeur supérieure à 0.
Date Date Aucun Expiration Doit être au format ISO 8601.
NoncurrentVersionExpiration Date NoncurrentDays Rule Limite 1.
NoncurrentDays Entier non négatif Aucun NoncurrentVersionExpiration Doit être une valeur supérieure à 0.
ObjectSizeGreaterThan Entier non négatif Aucun Filter,And Doit être une valeur supérieure à 0.
ObjectSizeLessThan Entier non négatif Aucun Filter,And Doit être une valeur supérieure à 0.
Prefix Chaîne Aucun Filter,And Doit être utilisé avec deux filtres ou plus.
And Conteneur Prefix,ObjectSizeGreaterThan, ObjectSizeLessThan, Tag Filter Peut contenir un ou plusieurs éléments Tag.
Tag Conteneur Key, Value Filter,And Doit définir à la fois une clé et un filtre.
Key Chaîne Aucun Tag La chaîne doit comporter moins de 128 caractères.
Value Chaîne Aucun Tag La chaîne doit comporter moins de 256 caractères.

Le corps de la demande doit contenir un bloc XML avec le schéma présenté dans le tableau (voir l'exemple 1).

<LifecycleConfiguration>
	<Rule>
		<ID>id1</ID>
		<Filter />
		<Status>Enabled</Status>
		<Expiration>
			<Days>60</Days>
		</Expiration>
	</Rule>
</LifecycleConfiguration>

Syntaxe

PUT https://{endpoint}/{bucket}?lifecycle # path style
PUT https://{bucket}.{endpoint}?lifecycle # virtual host style

Exemple de demande

PUT /images?lifecycle HTTP/1.1
Host: s3.us.cloud-object-storage.appdomain.cloud
Date: Wed, 7 Feb 2018 17:50:00 GMT
Authorization: authorization string
Content-Type: text/plain
Content-MD5: M625BaNwd/OytcM7O5gIaQ==
Content-Length: 305

<LifecycleConfiguration>
	<Rule>
		<ID>id1</ID>
		<Filter />
		<Status>Enabled</Status>
		<Expiration>
			<Days>60</Days>
		</Expiration>
	</Rule>
</LifecycleConfiguration>

Exemple de code à utiliser avec le SDK COS NodeJS

L'utilisation des SDK IBM Cloud® Object Storage nécessite uniquement d'appeler les fonctions appropriées avec les paramètres corrects et la configuration adéquate.

var aws = require('ibm-cos-sdk');
var ep = new aws.Endpoint('s3.us-south.cloud-object-storage.appdomain.cloud');
var config = {
    endpoint: ep,
    apiKeyId: 'ZRZDoNoUseOLL7bRO8SAMPLEHPUzUL_-fsampleyYE',
    ibmAuthEndpoint: 'https://iam.cloud.ibm.com/identity/token',
    serviceInstanceId: 'crn:v1:bluemix:public:cloud-object-storage:global:a/<CREDENTIAL_ID_AS_GENERATED>:<SERVICE_ID_AS_GENERATED>::',
};
var s3 = new aws.S3(config);
var date = new Date('June 16, 2019 00:00:00');

var params = {
  Bucket: 'STRING_VALUE', /* required */
  LifecycleConfiguration: {
    Rules: [ /* required */
      {
        Status: 'Enabled', /* required */
        ID: 'OPTIONAL_STRING_VALUE',
        Filter: {}, /* required */
        Expiration:
        {
          Date: date
        }
      },
    ]
  }
};

s3.putBucketLifecycleConfiguration(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

Exemple de code à utiliser avec le SDK COS Python

L'utilisation des SDK IBM Cloud® Object Storage nécessite uniquement d'appeler les fonctions appropriées avec les paramètres corrects et la configuration adéquate.

import sys
import ibm_boto3
from ibm_botocore.client import Config

api_key = "ZRZDoNoUseOLL7bRO8SAMPLEHPUzUL_-fsampleyYE"
service_instance_id = "85SAMPLE-eDOb-4NOT-bUSE-86nnnb31eaxx"
auth_endpoint = "https://iam.cloud.ibm.com/identity/token"
service_endpoint = "https://s3.us-south.cloud-object-storage.appdomain.cloud"

cos = ibm_boto3.client('s3',
                         ibm_api_key_id=api_key,
                         ibm_service_instance_id=service_instance_id,
                         ibm_auth_endpoint=auth_endpoint,
                         config=Config(signature_version='oauth'),
                         endpoint_url=service_endpoint)

response = cos.put_bucket_lifecycle_configuration(
    Bucket='string',
    LifecycleConfiguration={
        'Rules': [
            {
                'Status': 'Enabled',
                'Filter': {},
                'Expiration':
                {
                    'Days': 123
                },
            },
        ]
    }
)

print("Bucket lifecyle: {0}".format(response))

Exemple de code à utiliser avec le SDK COS Java

L'utilisation des SDK IBM Cloud® Object Storage nécessite uniquement d'appeler les fonctions appropriées avec les paramètres corrects et la configuration adéquate.

package com.ibm.cloud;

    import java.sql.Timestamp;
    import java.util.List;
    import java.util.Arrays;

    import com.ibm.cloud.objectstorage.ClientConfiguration;
    import com.ibm.cloud.objectstorage.SDKGlobalConfiguration;
    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.BucketLifecycleConfiguration;
    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 App
    {
        private static AmazonS3 _cosClient;

        /**
         * @param args
         */
        public static void main(String[] args)
        {
            SDKGlobalConfiguration.IAM_ENDPOINT = "https://iam.cloud.ibm.com/identity/token";
            String bucketName = "<sample-bucket-name>";
            String api_key = "ZRZDoNoUseOLL7bRO8SAMPLEHPUzUL_-fsampleyYE";
            String service_instance_id = "85SAMPLE-eDOb-4NOT-bUSE-86nnnb31eaxx"
            String endpoint_url = "https://s3.us-south.cloud-object-storage.appdomain.cloud";
            String storageClass = "us-south";
            String location = "us";

            _cosClient = createClient(api_key, service_instance_id, endpoint_url, location);

            // Define a rule for expiring items in a bucket
            int days_to_delete = 10;
            BucketLifecycleConfiguration.Rule rule = new BucketLifecycleConfiguration.Rule()
                    .withId("Delete rule")
                    .withExpirationInDays(days_to_delete)
                    .withStatus(BucketLifecycleConfiguration.ENABLED);
                    rule.setFilter(new LifecycleFilter());

            // Add the rule to a new BucketLifecycleConfiguration.
            BucketLifecycleConfiguration configuration = new BucketLifecycleConfiguration()
                    .withRules(Arrays.asList(rule));

            // Use the client to set the LifecycleConfiguration on the bucket.
            _cosClient.setBucketLifecycleConfiguration(bucketName, configuration);
        }

        /**
         * @param bucketName
         * @param clientNum
         * @param api_key
         * @param service_instance_id
         * @param endpoint_url
         * @param location
         * @return AmazonS3
         */
        public static AmazonS3 createClient(String api_key, String service_instance_id, String endpoint_url, String location)
        {
            AWSCredentials credentials;
            credentials = new BasicIBMOAuthCredentials(api_key, service_instance_id);

            ClientConfiguration clientConfig = new ClientConfiguration().withRequestTimeout(5000);
            clientConfig.setUseTcpKeepAlive(true);

            AmazonS3 cosClient = AmazonS3ClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(credentials))
                    .withEndpointConfiguration(new EndpointConfiguration(endpoint_url, location)).withPathStyleAccessEnabled(true)
                    .withClientConfiguration(clientConfig).build();
            return cosClient;
        }
    }

Examen d'une configuration de cycle de vie d'un compartiment, y compris l'expiration

Cette implémentation de l'opération GET utilise le paramètre de requête lifecycle pour examiner les paramètres de cycle de vie du compartiment. Une réponse HTTP 404 sera renvoyée si aucune configuration de cycle de vie n'est présente.

Les utilisateurs de Cloud IAM doivent avoir le rôle Reader pour examiner une politique de cycle de vie à partir d'un seau.

Infrastructure classique Les utilisateurs doivent disposer des autorisations Read sur le seau pour examiner une politique de cycle de vie à partir d'un seau.

Syntaxe

GET https://{endpoint}/{bucket}?lifecycle # path style
GET https://{bucket}.{endpoint}?lifecycle # virtual host style

Exemple d'en-tête de demande

GET /images?lifecycle HTTP/1.1
Host: s3.us.cloud-object-storage.appdomain.cloud
Date: Wed, 7 Feb 2018 17:50:00 GMT
Authorization: authorization string
Content-Type: text/plain
Content-MD5: M625BaNwd/OytcM7O5gIaQ==
Content-Length: 305

L'utilisation des SDK IBM Cloud® Object Storage nécessite uniquement d'appeler les fonctions appropriées avec les paramètres corrects et la configuration adéquate.

var aws = require('ibm-cos-sdk');
var ep = new aws.Endpoint('s3.us-south.cloud-object-storage.appdomain.cloud');
var config = {
    endpoint: ep,
    apiKeyId: 'ZRZDoNoUseOLL7bRO8SAMPLEHPUzUL_-fsampleyYE',
    ibmAuthEndpoint: 'https://iam.cloud.ibm.com/identity/token',
    serviceInstanceId: 'crn:v1:bluemix:public:cloud-object-storage:global:a/<CREDENTIAL_ID_AS_GENERATED>:<SERVICE_ID_AS_GENERATED>::',
};
var s3 = new aws.S3(config);

var params = {
  Bucket: 'STRING_VALUE' /* required */
};

s3.getBucketLifecycleConfiguration(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

import sys
import ibm_boto3
from ibm_botocore.client import Config

api_key = "ZRZDoNoUseOLL7bRO8SAMPLEHPUzUL_-fsampleyYE"
service_instance_id = "85SAMPLE-eDOb-4NOT-bUSE-86nnnb31eaxx"
auth_endpoint = "https://iam.cloud.ibm.com/identity/token"
service_endpoint = "https://s3.us-south.cloud-object-storage.appdomain.cloud"

cos = ibm_boto3.resource('s3',
                         ibm_api_key_id=api_key,
                         ibm_service_instance_id=service_instance_id,
                         ibm_auth_endpoint=auth_endpoint,
                         config=Config(signature_version='oauth'),
                         endpoint_url=service_endpoint)

response = cos.Bucket('<name-of-bucket>').get_bucket_lifecycle_configuration(
    Bucket='string'
)

print("Bucket lifecyle: {0}".format(response))

L'utilisation des SDK IBM Cloud® Object Storage nécessite uniquement d'appeler les fonctions appropriées avec les paramètres corrects et la configuration adéquate.

package com.ibm.cloud;

    import java.sql.Timestamp;
    import java.util.List;
    import java.util.Arrays;

    import com.ibm.cloud.objectstorage.ClientConfiguration;
    import com.ibm.cloud.objectstorage.SDKGlobalConfiguration;
    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.BucketLifecycleConfiguration;
    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 App
    {
        private static AmazonS3 _cosClient;

        /**
         * @param args
         */
        public static void main(String[] args)
        {
            SDKGlobalConfiguration.IAM_ENDPOINT = "https://iam.cloud.ibm.com/identity/token";
            String bucketName = "<sample-bucket-name>";
            String api_key = "ZRZDoNoUseOLL7bRO8SAMPLEHPUzUL_-fsampleyYE";
            String service_instance_id = "85SAMPLE-eDOb-4NOT-bUSE-86nnnb31eaxx"
            String endpoint_url = "https://s3.us-south.cloud-object-storage.appdomain.cloud";

            String storageClass = "us-south";
            String location = "us";

            _cosClient = createClient(api_key, service_instance_id, endpoint_url, location);

            // Use the client to read the configuration
            BucketLifecycleConfiguration config = _cosClient.getBucketLifecycleConfiguration(bucketName);

            System.out.println(config.toString());
        }

        /**
         * @param bucketName
         * @param clientNum
         * @param api_key
         * @param service_instance_id
         * @param endpoint_url
         * @param location
         * @return AmazonS3
         */
        public static AmazonS3 createClient(String api_key, String service_instance_id, String endpoint_url, String location)
        {
            AWSCredentials credentials;
            credentials = new BasicIBMOAuthCredentials(api_key, service_instance_id);

            ClientConfiguration clientConfig = new ClientConfiguration().withRequestTimeout(5000);
            clientConfig.setUseTcpKeepAlive(true);

            AmazonS3 cosClient = AmazonS3ClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(credentials))
                    .withEndpointConfiguration(new EndpointConfiguration(endpoint_url, location)).withPathStyleAccessEnabled(true)
                    .withClientConfiguration(clientConfig).build();
            return cosClient;
        }

    }

Suppression d'une configuration de cycle de vie d'un compartiment, y compris l'expiration

Cette implémentation de l'opération DELETE utilise le paramètre de requête lifecycle pour examiner les paramètres de cycle de vie du compartiment. Toutes les règles de cycle de vie associées au compartiment seront supprimées. Les transitions définies par les règles ne seront plus effectuées pour les nouveaux objets. Toutefois, les règles de transition existantes seront conservées pour les objets qui avaient déjà été écrits dans le compartiment avant la suppression des règles. Les règles d'expiration n'existeront plus. Une réponse HTTP 404 sera renvoyée si aucune configuration de cycle de vie n'est présente.

Les utilisateurs Cloud IAM doivent disposer du rôle Writer afin de pouvoir retirer une règle de cycle de vie d'un compartiment.

Les utilisateurs d'infrastructure classique doivent disposer des droits d'accès Owner sur le compartiment afin de pouvoir retirer une règle de cycle de vie d'un compartiment.

Syntaxe

DELETE https://{endpoint}/{bucket}?lifecycle # path style
DELETE https://{bucket}.{endpoint}?lifecycle # virtual host style

Exemple d'en-tête de demande

DELETE /images?lifecycle HTTP/1.1
Host: s3.us.cloud-object-storage.appdomain.cloud
Date: Wed, 7 Feb 2018 17:50:00 GMT
Authorization: authorization string
Content-Type: text/plain
Content-Length: 305

L'utilisation des SDK IBM Cloud® Object Storage nécessite uniquement d'appeler les fonctions appropriées avec les paramètres corrects et la configuration adéquate.

var aws = require('ibm-cos-sdk');
var ep = new aws.Endpoint('s3.us-south.cloud-object-storage.appdomain.cloud');
var config = {
    endpoint: ep,
    apiKeyId: 'ZRZDoNoUseOLL7bRO8SAMPLEHPUzUL_-fsampleyYE',
    ibmAuthEndpoint: 'https://iam.cloud.ibm.com/identity/token',
    serviceInstanceId: 'crn:v1:bluemix:public:cloud-object-storage:global:a/<CREDENTIAL_ID_AS_GENERATED>:<SERVICE_ID_AS_GENERATED>::',
};
var s3 = new aws.S3(config);

var params = {
  Bucket: 'STRING_VALUE' /* required */
};

s3.deleteBucketLifecycleConfiguration(params, function(err, data) {
  if (err) console.log(err, err.stack); // an error occurred
  else     console.log(data);           // successful response
});

L'utilisation des SDK IBM Cloud® Object Storage nécessite uniquement d'appeler les fonctions appropriées avec les paramètres corrects et la configuration adéquate.

import sys
import ibm_boto3
from ibm_botocore.client import Config

api_key = "ZRZDoNoUseOLL7bRO8SAMPLEHPUzUL_-fsampleyYE"
service_instance_id = "85SAMPLE-eDOb-4NOT-bUSE-86nnnb31eaxx"
auth_endpoint = "https://iam.cloud.ibm.com/identity/token"
service_endpoint = "https://s3.us-south.cloud-object-storage.appdomain.cloud"

cos = ibm_boto3.resource('s3',
                         ibm_api_key_id=api_key,
                         ibm_service_instance_id=service_instance_id,
                         ibm_auth_endpoint=auth_endpoint,
                         config=Config(signature_version='oauth'),
                         endpoint_url=service_endpoint)

response = cos.Bucket('<name-of-bucket>').delete_bucket_lifecycle_configuration(
    Bucket='string'
)

print("Bucket lifecyle: {0}".format(response))

L'utilisation des SDK IBM Cloud® Object Storage nécessite uniquement d'appeler les fonctions appropriées avec les paramètres corrects et la configuration adéquate.

package com.ibm.cloud;

    import java.sql.Timestamp;
    import java.util.List;
    import java.util.Arrays;

    import com.ibm.cloud.objectstorage.ClientConfiguration;
    import com.ibm.cloud.objectstorage.SDKGlobalConfiguration;
    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.BucketLifecycleConfiguration;
    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 App
    {
        private static AmazonS3 _cosClient;

        /**
         * @param args
         */
        public static void main(String[] args)
        {
            SDKGlobalConfiguration.IAM_ENDPOINT = "https://iam.cloud.ibm.com/identity/token";
            String bucketName = "<sample-bucket-name>";
            String api_key = "ZRZDoNoUseOLL7bRO8SAMPLEHPUzUL_-fsampleyYE";
            String service_instance_id = "85SAMPLE-eDOb-4NOT-bUSE-86nnnb31eaxx"
            String endpoint_url = "https://s3.us-south.cloud-object-storage.appdomain.cloud";

            String storageClass = "us-south";
            String location = "us";

            _cosClient = createClient(api_key, service_instance_id, endpoint_url, location);

            // Delete the configuration.
            _cosClient.deleteBucketLifecycleConfiguration(bucketName);

            // Verify that the configuration has been deleted by attempting to retrieve it.
            config = _cosClient.getBucketLifecycleConfiguration(bucketName);
            String s = (config == null) ? "Configuration has been deleted." : "Configuration still exists.";
            System.out.println(s);
        }

        /**
         * @param bucketName
         * @param clientNum
         * @param api_key
         * @param service_instance_id
         * @param endpoint_url
         * @param location
         * @return AmazonS3
         */
        public static AmazonS3 createClient(String api_key, String service_instance_id, String endpoint_url, String location)
        {
            AWSCredentials credentials;
            credentials = new BasicIBMOAuthCredentials(api_key, service_instance_id);

            ClientConfiguration clientConfig = new ClientConfiguration().withRequestTimeout(5000);
            clientConfig.setUseTcpKeepAlive(true);

            AmazonS3 cosClient = AmazonS3ClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(credentials))
                    .withEndpointConfiguration(new EndpointConfiguration(endpoint_url, location)).withPathStyleAccessEnabled(true)
                    .withClientConfiguration(clientConfig).build();
            return cosClient;
        }

    }

NoncurrentVersionExpiration règle du cycle de vie

NoncurrentVersionExpiration est un moyen pratique de contrôler automatiquement l'accumulation des versions et les coûts de stockage. Voir les exemples suivants.

Il n'est pas possible d'utiliser les règles NoncurrentVersionTransition pour archiver uniquement les versions non courantes des objets dans une configuration de cycle de vie, comme indiqué dans Archivage et expiration des objets versionnés

    curl -X "PUT" "https://$BUCKET.s3.$REGION.cloud-object-storage.appdomain.cloud/?lifecycle" \
    -H 'Authorization: bearer $TOKEN' \
    -H 'Content-Type: text/xml' \
    -d '<?xml version="1.0" encoding="UTF-8"?>
    <LifecycleConfiguration>
    <Rule>
        <ID>expire-old-versions</ID>
        <Status>Enabled</Status>
        <Filter></Filter>
        <NoncurrentVersionExpiration>
        <NoncurrentDays>30</NoncurrentDays>
        </NoncurrentVersionExpiration>
    </Rule>
    </LifecycleConfiguration>'

    cosClient.put_bucket_lifecycle_configuration(
        Bucket=BUCKET,
        LifecycleConfiguration={
            'Rules': [{
                'ID': 'expire-old-versions',
                'Status': 'Enabled',
                'Filter': {},
                'NoncurrentVersionExpiration': {
                    'NoncurrentDays': 30
                }
            }]
        }
    )

Etapes suivantes

L'expiration n'est qu'un des nombreux concepts de cycle de vie disponibles pour IBM Cloud Object Storage. Chacun des concepts abordés dans cette vue d'ensemble peut être exploré plus en détail dans la rubrique PlateformeIBM Cloud.