Gérer le cycle de vie des objets

Accéder aux concepts

Cette page explique comment activer la gestion du cycle de vie des objets et présente des exemples de configurations de cycle de vie. Les configurations de cycle de vie sont gérées au niveau du bucket et s'appliquent à tous les objets actuels et futurs du bucket.

Configurer la gestion du cycle de vie sur un bucket

Avertissement : Lorsque vous modifiez la configuration du cycle de vie, la gestion du cycle de vie des objets peut exécuter des opérations basées sur l'ancienne configuration pendant encore 24 heures maximum. Par exemple, si vous modifiez une condition Age de 10 jours pour la passer à 20 jours, un objet de 11 jours pourra être supprimé par la gestion du cycle de vie des objets jusqu'à 24 heures plus tard, sur la base de l'ancienne configuration.

Remarque : La disponibilité de cette fonctionnalité via la bibliothèque cliente Java de Google Cloud est actuellement limitée à la commande DeleteRules. La disponibilité complète en Java est accessible via la bibliothèque cliente des API Google pour Java.

Activer la gestion du cycle de vie

Pour activer la gestion du cycle de vie d'un bucket, procédez comme suit :

Console

1. Dans Google Cloud Console, accédez à la page du Navigateur Cloud Storage.
   

   Accéder à la page du navigateur

2. Dans la liste des buckets, recherchez le bucket que vous souhaitez activer, puis cliquez sur son nom.

3. Cliquez sur l'onglet Cycle de vie.

   La page des règles de cycle de vie s'affiche.

4. Cliquez sur Ajouter une règle.

5. Dans la page qui s'affiche, spécifiez une configuration.

   1. Sélectionnez l'action à effectuer lorsqu'un objet remplit les conditions.

   2. Cliquez sur Continuer.

   3. Sélectionnez les conditions dans lesquelles une action est effectuée.

   4. Cliquez sur Continuer.

   5. Cliquez sur Create (Créer).

Pour savoir comment obtenir des informations d'erreur détaillées sur les opérations ayant échoué dans le navigateur Cloud Storage, consultez la page Dépannage.

gsutil

1. Créez un fichier .json en incluant les règles de configuration du cycle de vie que vous souhaitez appliquer. Consultez ces exemples de configuration pour obtenir des exemples de fichiers .json.

2. Utilisez la commande lifecycle set pour appliquer la configuration :

   gsutil lifecycle set LIFECYCLE_CONFIG_FILE gs://BUCKET_NAME

   Où :

   • LIFECYCLE_CONFIG_FILE correspond au nom du fichier que vous avez créé à l'étape 2.
   • BUCKET_NAME correspond au nom du bucket concerné. Exemple :my-bucket

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

Afficher sur GitHub Commentaires

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  gcs::BucketLifecycle bucket_lifecycle_rules = gcs::BucketLifecycle{
      {gcs::LifecycleRule(gcs::LifecycleRule::ConditionConjunction(
                              gcs::LifecycleRule::MaxAge(30),
                              gcs::LifecycleRule::IsLive(true)),
                          gcs::LifecycleRule::Delete())}};

  StatusOr<gcs::BucketMetadata> updated_metadata = client.PatchBucket(
      bucket_name,
      gcs::BucketMetadataPatchBuilder().SetLifecycle(bucket_lifecycle_rules));

  if (!updated_metadata) {
    throw std::runtime_error(updated_metadata.status().message());
  }

  if (!updated_metadata->has_lifecycle() ||
      updated_metadata->lifecycle().rule.empty()) {
    std::cout << "Bucket lifecycle management is not enabled for bucket "
              << updated_metadata->name() << ".\n";
    return;
  }
  std::cout << "Successfully enabled bucket lifecycle management for bucket "
            << updated_metadata->name() << ".\n";
  std::cout << "The bucket lifecycle rules are";
  for (auto const& kv : updated_metadata->lifecycle().rule) {
    std::cout << "\n " << kv.condition() << ", " << kv.action();
  }
  std::cout << "\n";
}

C#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

Afficher sur GitHub Commentaires

using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;
using System.Collections.Generic;

public class EnableBucketLifecycleManagementSample
{
    public Bucket EnableBucketLifecycleManagement(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);
        bucket.Lifecycle = new Bucket.LifecycleData
        {
            Rule = new List<Bucket.LifecycleData.RuleData>
            {
                new Bucket.LifecycleData.RuleData
                {
                    Condition = new Bucket.LifecycleData.RuleData.ConditionData { Age = 100 },
                    Action = new Bucket.LifecycleData.RuleData.ActionData { Type = "Delete" }
                }
            }
        };
        bucket = storage.UpdateBucket(bucket);

        Console.WriteLine($"Lifecycle management is enabled for bucket {bucketName} and the rules are:");
        foreach (var rule in bucket.Lifecycle.Rule)
        {
            Console.WriteLine("Action:");
            Console.WriteLine($"Type: {rule.Action.Type}");
            Console.WriteLine($"Storage Class: {rule.Action.StorageClass}");

            Console.WriteLine("Condition:");
            Console.WriteLine($"Age: \t{rule.Condition.Age}");
            Console.WriteLine($"Created Before: \t{rule.Condition.CreatedBefore}");
            Console.WriteLine($"Time Before: \t{rule.Condition.CustomTimeBefore}");
            Console.WriteLine($"Days Since Custom Time: \t{rule.Condition.DaysSinceCustomTime}");
            Console.WriteLine($"Days Since Non-current Time: \t{rule.Condition.DaysSinceNoncurrentTime}");
            Console.WriteLine($"IsLive: \t{rule.Condition.IsLive}");
            Console.WriteLine($"Pattern: \t{rule.Condition.MatchesPattern}");
            Console.WriteLine($"Storage Class: \t{rule.Condition.MatchesStorageClass}");
            Console.WriteLine($"Noncurrent Time Before: \t{rule.Condition.NoncurrentTimeBefore}");
            Console.WriteLine($"Newer Versions: \t{rule.Condition.NumNewerVersions}");
        }
        return bucket;
    }
}

Go

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

Afficher sur GitHub Commentaires

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// enableBucketLifecycleManagement adds a lifecycle delete rule with the
// condition that the object is 100 days old.
func enableBucketLifecycleManagement(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	bucket := client.Bucket(bucketName)
	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
		Lifecycle: &storage.Lifecycle{
			Rules: []storage.LifecycleRule{
				{
					Action: storage.LifecycleAction{Type: "Delete"},
					Condition: storage.LifecycleCondition{
						AgeInDays: 100,
					},
				},
			},
		},
	}

	attrs, err := bucket.Update(ctx, bucketAttrsToUpdate)
	if err != nil {
		return fmt.Errorf("Bucket(%q).Update: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Lifecycle management is enabled for bucket %v\n and the rules are:\n", bucketName)
	for _, rule := range attrs.Lifecycle.Rules {
		fmt.Fprintf(w, "Action: %v\n", rule.Action)
		fmt.Fprintf(w, "Condition: %v\n", rule.Condition)
	}

	return nil
}

Java

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

Afficher sur GitHub Commentaires

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo.LifecycleRule;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import com.google.common.collect.ImmutableList;

public class EnableLifecycleManagement {
  public static void enableLifecycleManagement(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Bucket bucket = storage.get(bucketName);

    // See the LifecycleRule documentation for additional info on what you can do with lifecycle
    // management rules. This one deletes objects that are over 100 days old.
    // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/BucketInfo.LifecycleRule.html
    bucket.toBuilder()
        .setLifecycleRules(
            ImmutableList.of(
                new LifecycleRule(
                    LifecycleRule.LifecycleAction.newDeleteAction(),
                    LifecycleRule.LifecycleCondition.newBuilder().setAge(100).build())))
        .build()
        .update();

    System.out.println("Lifecycle management was enabled and configured for bucket " + bucketName);
  }
}

Node.js

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

Afficher sur GitHub Commentaires

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function enableBucketLifecycleManagement() {
  const [metadata] = await storage.bucket(bucketName).addLifecycleRule({
    action: 'delete',
    condition: {age: 100},
  });

  console.log(
    `Lifecycle management is enabled for bucket ${bucketName} and the rules are:`
  );

  console.log(metadata.lifecycle.rule);
}

enableBucketLifecycleManagement().catch(console.error);

PHP

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

Afficher sur GitHub Commentaires

use Google\Cloud\Storage\StorageClient;
use Google\Cloud\Storage\Bucket;

/**
 * Enable bucket lifecycle management.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 */
function enable_bucket_lifecycle_management($bucketName)
{
    // $bucketName = 'my-bucket';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    $lifecycle = Bucket::lifecycle()
        ->addDeleteRule([
            'age' => 100
        ]);

    $bucket->update([
        'lifecycle' => $lifecycle
    ]);

    $lifecycle = $bucket->currentLifecycle();

    printf('Lifecycle management is enabled for bucket %s and the rules are:' . PHP_EOL, $bucketName);
    foreach ($lifecycle as $rule) {
        print_r($rule);
        print(PHP_EOL);
    }
}

Python

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

Afficher sur GitHub Commentaires

from google.cloud import storage

def enable_bucket_lifecycle_management(bucket_name):
    """Enable lifecycle management for a bucket"""
    # bucket_name = "my-bucket"

    storage_client = storage.Client()

    bucket = storage_client.get_bucket(bucket_name)
    rules = bucket.lifecycle_rules

    print("Lifecycle management rules for bucket {} are {}".format(bucket_name, list(rules)))
    bucket.add_lifecycle_delete_rule(age=2)
    bucket.patch()

    rules = bucket.lifecycle_rules
    print("Lifecycle management is enable for bucket {} and the rules are {}".format(bucket_name, list(rules)))

    return bucket

Ruby

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

Afficher sur GitHub Commentaires

def enable_bucket_lifecycle_management bucket_name:
  # Enable lifecycle management for a bucket
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket = storage.bucket bucket_name

  rules = bucket.lifecycle do |l|
    l.add_delete_rule age: 2
  end

  puts "Lifecycle management is enabled for bucket #{bucket_name} and the rules are #{rules}"
end

API REST

API JSON

1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth. Pour obtenir des instructions, consultez la page Authentification des API.

2. Créez un fichier .json en incluant les règles de configuration du cycle de vie que vous souhaitez appliquer. Consultez ces exemples de configuration pour obtenir des exemples de fichiers .json.

3. Exécutez cURL pour appeler l'API JSON avec une requête de bucket PATCH :

   curl -X PATCH --data-binary @LIFECYCLE_CONFIG_FILE.json \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     -H "Content-Type: application/json" \
     "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=lifecycle"

   Où :

   • LIFECYCLE_CONFIG_FILE correspond au nom du fichier que vous avez créé à l'étape 2.
   • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
   • BUCKET_NAME correspond au nom du bucket concerné. Exemple : my-bucket.

API XML

1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth. Pour obtenir des instructions, consultez la page Authentification des API.

2. Créez un fichier .xml en incluant les règles de configuration du cycle de vie que vous souhaitez appliquer. Consultez ces exemples de configuration pour obtenir des exemples de fichiers .xml.

3. Utilisez cURL pour appeler l'API XML avec une requête de bucket PUT :

   curl -X PUT --data-binary @XML_FILE.xml \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     "https://storage.googleapis.com/BUCKET_NAME?lifecycle"

   Où :

   • XML_FILE correspond au nom du fichier que vous avez créé à l'étape 2.
   • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
   • BUCKET_NAME correspond au nom du bucket concerné. Exemple :my-bucket

Désactiver la gestion du cycle de vie

Pour désactiver la gestion du cycle de vie d'un bucket, procédez comme suit :

Console

1. Dans Google Cloud Console, accédez à la page du Navigateur Cloud Storage.
   

   Accéder à la page du navigateur

2. Dans la liste des buckets, recherchez le bucket pour lequel vous souhaitez désactiver la fonctionnalité, puis cliquez sur l'entrée dans la colonne Règles de cycle de vie.

   La page des règles de cycle de vie s'affiche.

3. Cliquez sur Supprimer tout.

4. Dans la fenêtre de confirmation qui apparaît, cliquez sur Confirmer.

Remarque : Vous pouvez supprimer des règles une par une en cliquant sur l'icône Corbeille associée à la règle à supprimer.

Pour savoir comment obtenir des informations d'erreur détaillées sur les opérations ayant échoué dans le navigateur Cloud Storage, consultez la page Dépannage.

gsutil

1. Créez un fichier .json contenant une configuration de cycle de vie vide :

   {
     "lifecycle": {
       "rule": []
     }
   }

2. Exécutez la commande lifecycle set :

   gsutil lifecycle set LIFECYCLE_CONFIG_FILE gs://BUCKET_NAME

   Où :

   • LIFECYCLE_CONFIG_FILE correspond au nom du fichier que vous avez créé à l'étape 2.
   • BUCKET_NAME correspond au nom du bucket concerné. Exemple :my-bucket

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

Afficher sur GitHub Commentaires

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  StatusOr<gcs::BucketMetadata> updated_metadata = client.PatchBucket(
      bucket_name, gcs::BucketMetadataPatchBuilder().ResetLifecycle());

  if (!updated_metadata) {
    throw std::runtime_error(updated_metadata.status().message());
  }

  std::cout << "Successfully disabled bucket lifecycle management for bucket "
            << updated_metadata->name() << ".\n";
}

C#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

Afficher sur GitHub Commentaires

using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class DisableBucketLifecycleManagementSample
{
    public Bucket DisableBucketLifecycleManagement(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);
        bucket.Lifecycle = null;
        bucket = storage.UpdateBucket(bucket);

        Console.WriteLine($"Lifecycle management is disabled for bucket {bucketName}.");
        return bucket;
    }
}

Go

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

Afficher sur GitHub Commentaires

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// disableBucketLifecycleManagement removes all existing lifecycle rules
// from the bucket.
func disableBucketLifecycleManagement(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	bucket := client.Bucket(bucketName)
	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
		Lifecycle: &storage.Lifecycle{},
	}

	_, err = bucket.Update(ctx, bucketAttrsToUpdate)
	if err != nil {
		return fmt.Errorf("Bucket(%q).Update: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Lifecycle management is disabled for bucket %v.\n", bucketName)

	return nil
}

Java

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

Afficher sur GitHub Commentaires

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class DisableLifecycleManagement {
  public static void disableLifecycleManagement(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Bucket bucket = storage.get(bucketName);
    bucket.toBuilder().deleteLifecycleRules().build().update();

    System.out.println("Lifecycle management was disabled for bucket " + bucketName);
  }
}

Node.js

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

Afficher sur GitHub Commentaires

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function disableBucketLifecycleManagement() {
  await storage.bucket(bucketName).setMetadata({lifecycle: null});

  console.log(`Lifecycle management is disabled for bucket ${bucketName}`);
}

disableBucketLifecycleManagement().catch(console.error);

PHP

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

Afficher sur GitHub Commentaires

use Google\Cloud\Storage\StorageClient;

/**
 * Disable bucket lifecycle management.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 */
function disable_bucket_lifecycle_management($bucketName)
{
    // $bucketName = 'my-bucket';

    $storage = new StorageClient();

    $bucket = $storage->bucket($bucketName);

    $bucket->update([
        'lifecycle' => null
    ]);

    printf('Lifecycle management is disabled for bucket %s.' . PHP_EOL, $bucketName);
}

Python

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

Afficher sur GitHub Commentaires

from google.cloud import storage

def disable_bucket_lifecycle_management(bucket_name):
    """Disable lifecycle management for a bucket"""
    # bucket_name = "my-bucket"

    storage_client = storage.Client()

    bucket = storage_client.get_bucket(bucket_name)
    bucket.clear_lifecyle_rules()
    bucket.patch()
    rules = bucket.lifecycle_rules

    print("Lifecycle management is disable for bucket {} and the rules are {}".format(bucket_name, list(rules)))
    return bucket

Ruby

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

Afficher sur GitHub Commentaires

def disable_bucket_lifecycle_management bucket_name:
  # Disable lifecycle management for a bucket
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket = storage.bucket bucket_name

  bucket.lifecycle do |l|
    l.clear
  end

  puts "Lifecycle management is disabled for bucket #{bucket_name}"
end

API REST

API JSON

1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth. Pour obtenir des instructions, consultez la page Authentification des API.

2. Créez un fichier .json contenant une configuration de cycle de vie vide :

   {
     "lifecycle": {
       "rule": []
     }
   }

3. Exécutez cURL pour appeler l'API JSON avec une requête de bucket PATCH :

   curl -X PATCH --data-binary @LIFECYCLE_CONFIG_FILE.json \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     -H "Content-Type: application/json" \
     "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=lifecycle"

   Où :

   • LIFECYCLE_CONFIG_FILE correspond au nom du fichier que vous avez créé à l'étape 2.
   • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
   • BUCKET_NAME correspond au nom du bucket concerné. Exemple : my-bucket.

API XML

1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth. Pour obtenir des instructions, consultez la page Authentification des API.

2. Créez un fichier .xml contenant une configuration de cycle de vie vide :

   <LifecycleConfiguration/>

3. Utilisez cURL pour appeler l'API XML avec une requête de bucket PUT :

   curl -X PUT --data-binary @XML_FILE.xml \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     "https://storage.googleapis.com/BUCKET_NAME?lifecycle"

   Où :

   • XML_FILE correspond au nom du fichier que vous avez créé à l'étape 2.
   • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
   • BUCKET_NAME correspond au nom du bucket concerné. Exemple :my-bucket

Vérifier la configuration du cycle de vie

Pour vérifier la configuration du cycle de vie définie sur un bucket, procédez comme suit :

Console

1. Dans Google Cloud Console, accédez à la page du Navigateur Cloud Storage.
   

   Accéder à la page du navigateur

2. Dans la liste de buckets, l'état du cycle de vie de chaque bucket se trouve dans la colonne Cycle de vie.

   Cliquez sur cet état pour ajouter, afficher, modifier et supprimer des règles.

Pour savoir comment obtenir des informations d'erreur détaillées sur les opérations ayant échoué dans le navigateur Cloud Storage, consultez la page Dépannage.

gsutil

1. Exécutez la commande lifecycle get :

   gsutil lifecycle get gs://BUCKET_NAME

   Où BUCKET_NAME est le nom du bucket concerné. Par exemple, my-bucket.

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

Afficher sur GitHub Commentaires

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  StatusOr<gcs::BucketMetadata> updated_metadata =
      client.GetBucketMetadata(bucket_name);

  if (!updated_metadata) {
    throw std::runtime_error(updated_metadata.status().message());
  }

  if (!updated_metadata->has_lifecycle() ||
      updated_metadata->lifecycle().rule.empty()) {
    std::cout << "Bucket lifecycle management is not enabled for bucket "
              << updated_metadata->name() << ".\n";
    return;
  }
  std::cout << "Bucket lifecycle management is enabled for bucket "
            << updated_metadata->name() << ".\n";
  std::cout << "The bucket lifecycle rules are";
  for (auto const& kv : updated_metadata->lifecycle().rule) {
    std::cout << "\n " << kv.condition() << ", " << kv.action();
  }
  std::cout << "\n";
}

C#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

Pour afficher les règles de cycle de vie du bucket, suivez les instructions permettant d'afficher les métadonnées d'un bucket et recherchez les champs des règles de cycle de vie dans la réponse.

Afficher sur GitHub Commentaires

using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class GetBucketMetadataSample
{
    public Bucket GetBucketMetadata(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });
        Console.WriteLine($"Bucket:\t{bucket.Name}");
        Console.WriteLine($"Acl:\t{bucket.Acl}");
        Console.WriteLine($"Billing:\t{bucket.Billing}");
        Console.WriteLine($"Cors:\t{bucket.Cors}");
        Console.WriteLine($"DefaultEventBasedHold:\t{bucket.DefaultEventBasedHold}");
        Console.WriteLine($"DefaultObjectAcl:\t{bucket.DefaultObjectAcl}");
        Console.WriteLine($"Encryption:\t{bucket.Encryption}");
        if (bucket.Encryption != null)
        {
            Console.WriteLine($"KmsKeyName:\t{bucket.Encryption.DefaultKmsKeyName}");
        }
        Console.WriteLine($"Id:\t{bucket.Id}");
        Console.WriteLine($"Kind:\t{bucket.Kind}");
        Console.WriteLine($"Lifecycle:\t{bucket.Lifecycle}");
        Console.WriteLine($"Location:\t{bucket.Location}");
        Console.WriteLine($"LocationType:\t{bucket.LocationType}");
        Console.WriteLine($"Logging:\t{bucket.Logging}");
        Console.WriteLine($"Metageneration:\t{bucket.Metageneration}");
        Console.WriteLine($"Owner:\t{bucket.Owner}");
        Console.WriteLine($"ProjectNumber:\t{bucket.ProjectNumber}");
        Console.WriteLine($"RetentionPolicy:\t{bucket.RetentionPolicy}");
        Console.WriteLine($"SelfLink:\t{bucket.SelfLink}");
        Console.WriteLine($"StorageClass:\t{bucket.StorageClass}");
        Console.WriteLine($"TimeCreated:\t{bucket.TimeCreated}");
        Console.WriteLine($"Updated:\t{bucket.Updated}");
        Console.WriteLine($"Versioning:\t{bucket.Versioning}");
        Console.WriteLine($"Website:\t{bucket.Website}");
        if (bucket.Labels != null)
        {
            Console.WriteLine("Labels:");
            foreach (var label in bucket.Labels)
            {
                Console.WriteLine($"{label.Key}:\t{label.Value}");
            }
        }
        return bucket;
    }
}

Go

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

Pour afficher les règles de cycle de vie du bucket, suivez les instructions permettant d'afficher les métadonnées d'un bucket et recherchez les champs des règles de cycle de vie dans la réponse.

Afficher sur GitHub Commentaires

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// getBucketMetadata gets the bucket metadata.
func getBucketMetadata(w io.Writer, bucketName string) (*storage.BucketAttrs, error) {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()
	attrs, err := client.Bucket(bucketName).Attrs(ctx)
	if err != nil {
		return nil, fmt.Errorf("Bucket(%q).Attrs: %v", bucketName, err)
	}
	fmt.Fprintf(w, "BucketName: %v\n", attrs.Name)
	fmt.Fprintf(w, "Location: %v\n", attrs.Location)
	fmt.Fprintf(w, "LocationType: %v\n", attrs.LocationType)
	fmt.Fprintf(w, "StorageClass: %v\n", attrs.StorageClass)
	fmt.Fprintf(w, "TimeCreated: %v\n", attrs.Created)
	fmt.Fprintf(w, "Metageneration: %v\n", attrs.MetaGeneration)
	fmt.Fprintf(w, "PredefinedACL: %v\n", attrs.PredefinedACL)
	if attrs.Encryption != nil {
		fmt.Fprintf(w, "DefaultKmsKeyName: %v\n", attrs.Encryption.DefaultKMSKeyName)
	}
	if attrs.Website != nil {
		fmt.Fprintf(w, "IndexPage: %v\n", attrs.Website.MainPageSuffix)
		fmt.Fprintf(w, "NotFoundPage: %v\n", attrs.Website.NotFoundPage)
	}
	fmt.Fprintf(w, "DefaultEventBasedHold: %v\n", attrs.DefaultEventBasedHold)
	if attrs.RetentionPolicy != nil {
		fmt.Fprintf(w, "RetentionEffectiveTime: %v\n", attrs.RetentionPolicy.EffectiveTime)
		fmt.Fprintf(w, "RetentionPeriod: %v\n", attrs.RetentionPolicy.RetentionPeriod)
		fmt.Fprintf(w, "RetentionPolicyIsLocked: %v\n", attrs.RetentionPolicy.IsLocked)
	}
	fmt.Fprintf(w, "RequesterPays: %v\n", attrs.RequesterPays)
	fmt.Fprintf(w, "VersioningEnabled: %v\n", attrs.VersioningEnabled)
	if attrs.Logging != nil {
		fmt.Fprintf(w, "LogBucket: %v\n", attrs.Logging.LogBucket)
		fmt.Fprintf(w, "LogObjectPrefix: %v\n", attrs.Logging.LogObjectPrefix)
	}
	if attrs.CORS != nil {
		fmt.Fprintln(w, "CORS:")
		for _, v := range attrs.CORS {
			fmt.Fprintf(w, "\tMaxAge: %v\n", v.MaxAge)
			fmt.Fprintf(w, "\tMethods: %v\n", v.Methods)
			fmt.Fprintf(w, "\tOrigins: %v\n", v.Origins)
			fmt.Fprintf(w, "\tResponseHeaders: %v\n", v.ResponseHeaders)
		}
	}
	if attrs.Labels != nil {
		fmt.Fprintf(w, "\n\n\nLabels:")
		for key, value := range attrs.Labels {
			fmt.Fprintf(w, "\t%v = %v\n", key, value)
		}
	}
	return attrs, nil
}

Java

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

Pour afficher les règles de cycle de vie du bucket, suivez les instructions permettant d'afficher les métadonnées d'un bucket et recherchez les champs des règles de cycle de vie dans la réponse.

Afficher sur GitHub Commentaires

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.util.Map;

public class GetBucketMetadata {
  public static void getBucketMetadata(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    // Select all fields. Fields can be selected individually e.g. Storage.BucketField.NAME
    Bucket bucket =
        storage.get(bucketName, Storage.BucketGetOption.fields(Storage.BucketField.values()));

    // Print bucket metadata
    System.out.println("BucketName: " + bucket.getName());
    System.out.println("DefaultEventBasedHold: " + bucket.getDefaultEventBasedHold());
    System.out.println("DefaultKmsKeyName: " + bucket.getDefaultKmsKeyName());
    System.out.println("Id: " + bucket.getGeneratedId());
    System.out.println("IndexPage: " + bucket.getIndexPage());
    System.out.println("Location: " + bucket.getLocation());
    System.out.println("LocationType: " + bucket.getLocationType());
    System.out.println("Metageneration: " + bucket.getMetageneration());
    System.out.println("NotFoundPage: " + bucket.getNotFoundPage());
    System.out.println("RetentionEffectiveTime: " + bucket.getRetentionEffectiveTime());
    System.out.println("RetentionPeriod: " + bucket.getRetentionPeriod());
    System.out.println("RetentionPolicyIsLocked: " + bucket.retentionPolicyIsLocked());
    System.out.println("RequesterPays: " + bucket.requesterPays());
    System.out.println("SelfLink: " + bucket.getSelfLink());
    System.out.println("StorageClass: " + bucket.getStorageClass().name());
    System.out.println("TimeCreated: " + bucket.getCreateTime());
    System.out.println("VersioningEnabled: " + bucket.versioningEnabled());
    if (bucket.getLabels() != null) {
      System.out.println("\n\n\nLabels:");
      for (Map.Entry<String, String> label : bucket.getLabels().entrySet()) {
        System.out.println(label.getKey() + "=" + label.getValue());
      }
    }
    if (bucket.getLifecycleRules() != null) {
      System.out.println("\n\n\nLifecycle Rules:");
      for (BucketInfo.LifecycleRule rule : bucket.getLifecycleRules()) {
        System.out.println(rule);
      }
    }
  }
}

Node.js

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

Pour afficher les règles de cycle de vie du bucket, suivez les instructions permettant d'afficher les métadonnées d'un bucket et recherchez les champs des règles de cycle de vie dans la réponse.

Afficher sur GitHub Commentaires

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function getBucketMetadata() {
  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // The ID of your GCS bucket
  // const bucketName = 'your-unique-bucket-name';

  // Get Bucket Metadata
  const [metadata] = await storage.bucket(bucketName).getMetadata();

  for (const [key, value] of Object.entries(metadata)) {
    console.log(`${key}: ${value}`);
  }
}

PHP

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

Pour afficher les règles de cycle de vie du bucket, suivez les instructions permettant d'afficher les métadonnées d'un bucket et recherchez les champs des règles de cycle de vie dans la réponse.

Afficher sur GitHub Commentaires

use Google\Cloud\Storage\StorageClient;

/**
 * Get bucket metadata.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 */
function get_bucket_metadata($bucketName)
{
    // $bucketName = 'my-bucket';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $info = $bucket->info();

    printf('Bucket Metadata: %s' . PHP_EOL, print_r($info));
}

Python

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

Pour afficher les règles de cycle de vie du bucket, suivez les instructions permettant d'afficher les métadonnées d'un bucket et recherchez les champs des règles de cycle de vie dans la réponse.

Afficher sur GitHub Commentaires

from google.cloud import storage

def bucket_metadata(bucket_name):
    """Prints out a bucket's metadata."""
    # bucket_name = 'your-bucket-name'

    storage_client = storage.Client()
    bucket = storage_client.get_bucket(bucket_name)

    print(f"ID: {bucket.id}")
    print(f"Name: {bucket.name}")
    print(f"Storage Class: {bucket.storage_class}")
    print(f"Location: {bucket.location}")
    print(f"Location Type: {bucket.location_type}")
    print(f"Cors: {bucket.cors}")
    print(f"Default Event Based Hold: {bucket.default_event_based_hold}")
    print(f"Default KMS Key Name: {bucket.default_kms_key_name}")
    print(f"Metageneration: {bucket.metageneration}")
    print(
        f"Public Access Prevention: {bucket.iam_configuration.public_access_prevention}"
    )
    print(f"Retention Effective Time: {bucket.retention_policy_effective_time}")
    print(f"Retention Period: {bucket.retention_period}")
    print(f"Retention Policy Locked: {bucket.retention_policy_locked}")
    print(f"Requester Pays: {bucket.requester_pays}")
    print(f"Self Link: {bucket.self_link}")
    print(f"Time Created: {bucket.time_created}")
    print(f"Versioning Enabled: {bucket.versioning_enabled}")
    print(f"Labels: {bucket.labels}")

Ruby

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

Pour afficher les règles de cycle de vie du bucket, suivez les instructions permettant d'afficher les métadonnées d'un bucket et recherchez les champs des règles de cycle de vie dans la réponse.

Afficher sur GitHub Commentaires

def get_bucket_metadata bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name

  puts "ID:                       #{bucket.id}"
  puts "Name:                     #{bucket.name}"
  puts "Storage Class:            #{bucket.storage_class}"
  puts "Location:                 #{bucket.location}"
  puts "Location Type:            #{bucket.location_type}"
  puts "Cors:                     #{bucket.cors}"
  puts "Default Event Based Hold: #{bucket.default_event_based_hold?}"
  puts "Default KMS Key Name:     #{bucket.default_kms_key}"
  puts "Logging Bucket:           #{bucket.logging_bucket}"
  puts "Logging Prefix:           #{bucket.logging_prefix}"
  puts "Metageneration:           #{bucket.metageneration}"
  puts "Retention Effective Time: #{bucket.retention_effective_at}"
  puts "Retention Period:         #{bucket.retention_period}"
  puts "Retention Policy Locked:  #{bucket.retention_policy_locked?}"
  puts "Requester Pays:           #{bucket.requester_pays}"
  puts "Self Link:                #{bucket.api_url}"
  puts "Time Created:             #{bucket.created_at}"
  puts "Versioning Enabled:       #{bucket.versioning?}"
  puts "Index Page:               #{bucket.website_main}"
  puts "Not Found Page:           #{bucket.website_404}"
  puts "Labels:"
  bucket.labels.each do |key, value|
    puts " - #{key} = #{value}"
  end
  puts "Lifecycle Rules:"
  bucket.lifecycle.each do |rule|
    puts "#{rule.action} - #{rule.storage_class} - #{rule.age} - #{rule.matches_storage_class}"
  end
end

API REST

API JSON

1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth. Pour obtenir des instructions, consultez la page Authentification des API.

2. Exécutez cURL pour appeler l'API JSON avec une requête de bucket GET :

   curl -X GET \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=lifecycle"

   Où :

   • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
   • BUCKET_NAME correspond au nom du bucket concerné. Exemple : my-bucket.

API XML

1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth. Pour obtenir des instructions, consultez la page Authentification des API.

2. Utilisez cURL pour appeler l'API XML avec une requête de bucket GET :

   curl -X GET \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     "https://storage.googleapis.com/BUCKET_NAME?lifecycle"

   Où :

   • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
   • BUCKET_NAME correspond au nom du bucket concerné. Exemple :my-bucket

Exemples de configuration du cycle de vie des objets

Les exemples suivants montrent des configurations de cycle de vie spécifiques qui effectuent des opérations du cycle de vie lorsque certaines conditions du cycle de vie courantes sont remplies. Ces configurations s'appliquent à tous les objets actuels et futurs du bucket configuré.

Supprimer les anciennes versions des objets

Avertissement : Cet exemple implique la suppression de données. Une fois supprimés définitivement, les objets ne peuvent pas être récupérés. Veillez à configurer vos règles de cycle de vie de manière à ne pas supprimer plus de données que prévu. Nous vous recommandons de tester les règles de cycle de vie sur les données de développement avant de les appliquer en production pour vous assurer qu'elles produisent l'effet escompté.

La configuration de cycle de vie suivante définit deux règles. Notez que ces règles ne s'appliquent que si vous utilisez la gestion des versions des objets sur le bucket :

1. Supprimez les versions obsolètes d'objets s'il existe deux versions plus récentes de l'objet dans le bucket. Les objets auxquels cette règle s'applique sont définitivement supprimés et ne peuvent pas être récupérés.

2. Supprimez les versions obsolètes des objets qui sont obsolètes depuis sept jours. Les objets auxquels cette règle s'applique sont définitivement supprimés et ne peuvent pas être récupérés.

La combinaison de ces deux règles dans les buckets qui utilisent la gestion des versions des objets implique que les objets actifs peuvent être récupérés pendant un certain temps s'ils sont écrasés ou supprimés : l'objet reste dans le bucket à l'état obsolète pendant sept jours ou jusqu'à ce que deux versions plus récentes de l'objet existent dans le bucket.

Console

Ces paramètres utilisent les instructions de la section concernant l'activation.

1. Pour supprimer les versions obsolètes des objets s'il existe une version plus récente, procédez comme suit :

   1. Sélectionnez l'action Supprimer un objet.
   2. Sélectionnez la condition En cours, puis cochez la case d'option Archivé (obsolète).
   3. Sélectionnez la condition Nombre de versions plus récentes, puis saisissez la valeur 2.

2. Pour supprimer les versions obsolètes des objets après sept jours d'archivage, procédez comme suit :

   1. Sélectionnez l'action Supprimer un objet.
   2. Sélectionnez la condition Nombre de jours écoulés depuis l'archivage, puis saisissez la valeur 7.

gsutil

La configuration de cycle de vie ci-dessous peut être appliquée à un bucket en activant la gestion du cycle de vie.

{
"lifecycle": {
  "rule": [
  {
    "action": {"type": "Delete"},
    "condition": {
      "numNewerVersions": 2,
      "isLive": false
    }
  },
  {
    "action": {"type": "Delete"},
    "condition": {
      "daysSinceNoncurrentTime": 7
    }
  }
]
}
}

Pour connaître le format généralisé d'un fichier de configuration de cycle de vie, consultez la page représentation des ressources de bucket pour JSON.

API REST

API JSON

La configuration de cycle de vie ci-dessous peut être appliquée à un bucket en activant la gestion du cycle de vie.

{
"lifecycle": {
  "rule": [
  {
    "action": {"type": "Delete"},
    "condition": {
      "numNewerVersions": 2,
      "isLive": false
    }
  },
  {
    "action": {"type": "Delete"},
    "condition": {
      "daysSinceNoncurrentTime": 7
    }
  }
]
}
}

Pour connaître le format généralisé d'un fichier de configuration de cycle de vie, consultez la page représentation des ressources de bucket pour JSON.

API XML

La configuration de cycle de vie ci-dessous peut être appliquée à un bucket en activant la gestion du cycle de vie.

<?xml version="1.0" encoding="UTF-8" ?>
<LifecycleConfiguration>
    <Rule>
        <Action>
            <Delete/>
        </Action>
        <Condition>
            <IsLive>false</IsLive>
            <NumberOfNewerVersions>2</Age>
        </Condition>
    </Rule>
    <Rule>
        <Action>
            <Delete/>
        </Action>
        <Condition>
            <DaysSinceNoncurrentTime>7</DaysSinceNoncurrentTime>
        </Condition>
    </Rule>
</LifecycleConfiguration>

Pour connaître le format général d'un fichier de configuration de cycle de vie, consultez la section sur le format de configuration de cycle de vie pour XML.

Modifications de configuration

En fonction de vos objectifs, vous pouvez apporter plusieurs modifications à cet exemple de configuration :

• Si vous souhaitez protéger vos données contre la suppression accidentelle mais pas contre l'écrasement accidentel, définissez le nombre de versions plus récentes sur 1, ce qui présente également l'avantage de réduire les coûts de stockage car vous conservez moins de versions d'un objet.

• Si vos données sont stockées dans les classes Nearline, Coldline ou Archive, ajoutez une condition Age ou utilisez une valeur plus élevée pour DaysSinceNoncurrent afin d'éviter les frais de suppression anticipée. Notez que même avec ces modifications, des frais de suppression anticipée peuvent vous être facturés selon la fréquence à laquelle vous écrasez et supprimez vos objets.

Modifier la classe de stockage d'un objet

La configuration de cycle de vie suivante définit deux règles :

1. Changer la classe de stockage d'un objet pour Stockage Nearline si son âge est supérieur à 365 jours (un an) et si sa classe de stockage actuelle est définie sur Stockage standard, Stockage multirégional ou Stockage DRA.
2. Changer la classe de stockage d'un objet pour Stockage Coldline si son âge est supérieur à 1 095 jours (trois ans) et si sa classe de stockage actuelle est définie sur Stockage Nearline.

Remarque : Cette configuration de cycle de vie s'applique aux buckets situés dans un emplacement de type multirégional ou birégional. Pour les buckets situés dans des emplacements régionaux, remplacez MULTI_REGIONAL par REGIONAL.

Console

Ces paramètres utilisent les instructions de la section concernant l'activation.

1. Pour déplacer des objets vers Cloud Storage Nearline 365 jours après leur création, procédez comme suit :

   1. Sélectionnez l'action Passer en classe de stockage Nearline.
   2. Sélectionnez la condition Âge, puis saisissez la valeur 365.
   3. Sélectionnez la condition La classe de stockage correspond à, puis choisissez les options Standard, Multirégional et Durable Reduced Availability (Disponibilité limitée durable).

2. Pour déplacer des objets vers Cloud Storage Coldline 1 095 jours après leur création, procédez comme suit :

   1. Sélectionnez l'action Passer en classe de stockage Coldline.
   2. Sélectionnez la condition Âge, puis saisissez la valeur 1095.
   3. Sélectionnez la condition La classe de stockage correspond à, puis choisissez l'option Nearline.

gsutil

La configuration de cycle de vie ci-dessous peut être appliquée à un bucket en activant la gestion du cycle de vie.

{
"lifecycle": {
  "rule": [
  {
    "action": {
      "type": "SetStorageClass",
      "storageClass": "NEARLINE"
    },
    "condition": {
      "age": 365,
      "matchesStorageClass": ["MULTI_REGIONAL", "STANDARD", "DURABLE_REDUCED_AVAILABILITY"]
    }
  },
  {
    "action": {
      "type": "SetStorageClass",
      "storageClass": "COLDLINE"
    },
    "condition": {
      "age": 1095,
      "matchesStorageClass": ["NEARLINE"]
    }
  }
]
}
}

Pour connaître le format généralisé d'un fichier de configuration de cycle de vie, consultez la page représentation des ressources de bucket pour JSON.

API REST

API JSON

La configuration de cycle de vie ci-dessous peut être appliquée à un bucket en activant la gestion du cycle de vie.

{
"lifecycle": {
  "rule": [
  {
    "action": {
      "type": "SetStorageClass",
      "storageClass": "NEARLINE"
    },
    "condition": {
      "age": 365,
      "matchesStorageClass": ["MULTI_REGIONAL", "STANDARD", "DURABLE_REDUCED_AVAILABILITY"]
    }
  },
  {
    "action": {
      "type": "SetStorageClass",
      "storageClass": "COLDLINE"
    },
    "condition": {
      "age": 1095,
      "matchesStorageClass": ["NEARLINE"]
    }
  }
]
}
}

Pour connaître le format généralisé d'un fichier de configuration de cycle de vie, consultez la page représentation des ressources de bucket pour JSON.

API XML

La configuration de cycle de vie ci-dessous peut être appliquée à un bucket en activant la gestion du cycle de vie.

<?xml version="1.0" encoding="UTF-8" ?>
<LifecycleConfiguration>
    <Rule>
        <Action>
            <SetStorageClass>NEARLINE</SetStorageClass>
        </Action>
        <Condition>
            <Age>365</Age>
            <MatchesStorageClass>MULTI_REGIONAL</MatchesStorageClass>
            <MatchesStorageClass>STANDARD</MatchesStorageClass>
            <MatchesStorageClass>DURABLE_REDUCED_AVAILABILITY</MatchesStorageClass>
        </Condition>
    </Rule>
    <Rule>
        <Action>
            <SetStorageClass>COLDLINE</SetStorageClass>
        </Action>
        <Condition>
            <Age>1095</Age>
            <MatchesStorageClass>NEARLINE</MatchesStorageClass>
        </Condition>
    </Rule>
</LifecycleConfiguration>

Pour connaître le format général d'un fichier de configuration de cycle de vie, consultez la section sur le format de configuration de cycle de vie pour XML.

Étape suivante

• Apprenez-en plus sur la gestion du cycle de vie des objets, y compris sur les opérations du cycle de vie et conditions du cycle de vie disponibles.