Tous les produits
Search
Centre de documentation

Object Storage Service:Activer le versioning pour la restauration des données et le contrôle de versions

Dernière mise à jour :Sep 09, 2026

Le versioning protège vos données au niveau du bucket en conservant les versions historiques des objets lorsqu'ils sont écrasés ou supprimés. Cette fonctionnalité vous permet de restaurer n'importe quel objet dans une version antérieure.

Cas d'utilisation

Utilisez le versioning dans les scénarios suivants pour protéger vos données.

  • Suppression accidentelle de données

    OSS ne disposant pas de corbeille, le versioning constitue le principal moyen de récupérer les données supprimées par erreur.

  • Écrasement de fichiers

    Pour les fichiers fréquemment modifiés (lecteurs cloud, outils collaboratifs), le versioning vous permet de récupérer n'importe quelle version précédente.

Notes d'utilisation

  • Facturation

    Le versioning lui-même est gratuit. Toutefois, toutes les versions d'objet (actuelles et historiques) entraînent des frais de stockage. Utilisez des règles de cycle de vie pour supprimer automatiquement les versions historiques inutiles. Pour plus d'informations, consultez la rubrique Règles de cycle de vie. Les requêtes et le trafic générés par le téléchargement ou la restauration des versions historiques sont également facturés. Consultez la section Mesure et facturation. Pour arrêter complètement tous les frais OSS, supprimez toutes les données du bucket (y compris les objets, les parties et les versions précédentes) ainsi que le bucket lui-même. Pour plus d'informations, consultez la rubrique Supprimer un bucket pour arrêter la facturation.

  • Autorisations

    Seul le propriétaire du bucket et les utilisateurs Resource Access Management (RAM) disposant de l'autorisation PutBucketVersioning peuvent configurer le versioning.

  • Fonctionnalités mutuellement exclusives

    Si le versioning d'un bucket est activé ou suspendu :

    • La règle interdisant l'écrasement des objets ne s'applique pas. Consultez la rubrique Interdire l'écrasement des objets.

    • L'en-tête de requête x-oss-forbid-overwrite, utilisé pour empêcher l'écrasement d'un objet, ne prend pas effet lors des uploads. Pour plus d'informations, consultez la rubrique PutObject.

  • Versioning et OSS-HDFS

    N'activez pas le service OSS-HDFS et le versioning sur le même bucket. Cela pourrait entraîner une instabilité du service. Pour garantir un fonctionnement stable, suspendez le versioning dès que possible et configurez une règle de cycle de vie pour nettoyer les marqueurs de suppression.

États du versioning

Le versioning d'un bucket peut se trouver dans l'un des trois états suivants : Désactivé (par défaut), Activé ou Suspendu.

  • Par défaut, le versioning est désactivé pour un bucket. Une fois activé, le versioning ne peut pas revenir à l'état Désactivé. Il peut uniquement être suspendu.

  • Lorsque le versioning est activé, OSS conserve les versions historiques des objets. Pour plus d'informations, consultez la rubrique Gérer les objets versionnés.

  • Lorsque le versioning est suspendu, un objet nouvellement uploadé remplace la version actuelle d'un objet portant le même nom. Les versions historiques existantes sont conservées. Pour plus d'informations, consultez la rubrique Gérer les objets dans un bucket dont le versioning est suspendu.

Remarque

Toutes les versions d'objet entraînent des coûts de stockage. Utilisez des règles de cycle de vie pour transférer les versions vers des classes de stockage moins coûteuses (telles que Infrequent Access ou Archive) ou pour supprimer les versions historiques inutiles. Pour plus d'informations, consultez la rubrique Réduire les coûts de stockage en combinant les règles de cycle de vie basées sur la dernière date de modification avec le versioning.

Protection des données

Le tableau suivant décrit les différences de comportement lors de l'écrasement et de la suppression d'objets selon les états du versioning.

État du versioning

Écraser un objet

Supprimer un objet

Désactivé

L'objet existant est écrasé et ne peut pas être restauré. Vous pouvez uniquement récupérer la dernière version de l'objet.

L'objet est définitivement supprimé et ne peut pas être récupéré.

Activé

Une nouvelle version est créée. Les versions historiques ne sont pas affectées.

L'objet est marqué comme supprimé. Les versions historiques ne sont pas affectées et peuvent être restaurées.

Suspendu

Une nouvelle version est créée. Si une version du même objet existe déjà depuis la période de suspension, la nouvelle version l'écrase. Les autres versions historiques ne sont pas affectées.

L'objet est marqué comme supprimé. Si un marqueur de suppression pour le même objet existe déjà depuis la période de suspension, le nouveau marqueur l'écrase. Les autres versions historiques ne sont pas affectées.

Activer le versioning

Utiliser la console OSS

Lorsque le versioning est activé pour un bucket, OSS attribue un ID unique à chaque version d'un objet stocké dans le bucket.

  • Activez le versioning lors de la création d'un bucket.

    1. Connectez-vous à la console OSS.

    2. Cliquez sur Buckets, puis cliquez sur Create Bucket.

    3. Sur la page Create Bucket, configurez les paramètres.

      Dans la section Versioning, définissez le commutateur Versioning sur On. Par défaut, cette fonctionnalité est Off. Pour plus d'informations sur les autres paramètres, consultez la rubrique Créer un bucket.

    4. Cliquez sur Create.

  • Activez le versioning pour un bucket existant.

    1. Dans le volet de navigation de gauche, cliquez sur Buckets. Sur la page Buckets, recherchez et cliquez sur le bucket souhaité.

    2. Dans le volet de navigation de gauche, choisissez Content Security > Versioning.

    3. Sur la page Versioning, cliquez sur Enable Now.

    4. Dans la boîte de dialogue qui s'affiche, cliquez sur Confirm On.

Après avoir activé le versioning, sur la page Objects, cliquez sur Show à côté de Previous Versions pour afficher toutes les versions de fichier. Pour afficher uniquement les versions actuelles des fichiers, cliquez sur Hide à côté de Previous Versions. Le masquage des versions précédentes n'améliore pas les performances de listage des fichiers. Si la page répond lentement lors du listage des fichiers, consultez la rubrique Vitesse de réponse lente pour diagnostiquer et résoudre le problème.

Utiliser les SDK Alibaba Cloud

Les exemples suivants montrent comment activer le versioning à l'aide de différents SDK. Consultez la rubrique Présentation des SDK.

import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.*;

public class Demo {
    public static void main(String[] args) throws Exception {
        // Set the endpoint. Use China (Hangzhou) as an example. Set the endpoint to the actual endpoint.
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // Specify the region where the bucket is located, for example, cn-hangzhou.
        String region = "cn-hangzhou";
        // Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // Specify the bucket name, for example, examplebucket.
        String bucketName = "examplebucket";

        // Create an OSSClient instance.
        // When the OSSClient instance is no longer used, call the shutdown method to release resources.
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        // Explicitly declare that the V4 signature algorithm is used.
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        try {
            // Enable versioning.
            BucketVersioningConfiguration configuration = new BucketVersioningConfiguration();
            configuration.setStatus(BucketVersioningConfiguration.ENABLED);
            SetBucketVersioningRequest request = new SetBucketVersioningRequest(bucketName, configuration);
            ossClient.setBucketVersioning(request);
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}
<?php
if (is_file(__DIR__ . '/../autoload.php')) {
    require_once __DIR__ . '/../autoload.php';
}
if (is_file(__DIR__ . '/../vendor/autoload.php')) {
    require_once __DIR__ . '/../vendor/autoload.php';
}

use OSS\OssClient;
use OSS\Core\OssException;

// Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
$accessKeyId = getenv("OSS_ACCESS_KEY_ID");
$accessKeySecret = getenv("OSS_ACCESS_KEY_SECRET");
// Set the endpoint. Use Hangzhou as an example. Set the endpoint to the actual endpoint.
$endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
$bucket= "yourBucketName";

$ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint);

try {
    // Enable versioning.
    $ossClient->putBucketVersioning($bucket, "Enabled");
} catch (OssException $e) {
    printf(__FUNCTION__ . ": FAILED\n");
    printf($e->getMessage() . "\n");
    return;
}

print(__FUNCTION__ . ": OK" . "\n");
const OSS = require("ali-oss");

const client = new OSS({
  // Specify the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the region to oss-cn-hangzhou.
  region: "oss-cn-hangzhou",
  // Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
  accessKeyId: process.env.OSS_ACCESS_KEY_ID,
  accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
  // Specify the bucket name, for example, examplebucket.
  bucket: "examplebucket",
});

async function putBucketVersioning() {
  // Enable versioning.
  const status = "Enabled";
  const result = await client.putBucketVersioning("examplebucket", status);
  console.log(result);
}
putBucketVersioning();
# -*- coding: utf-8 -*-
import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider
from oss2.models import BucketVersioningConfig
# Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
# Specify the endpoint based on the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com.
# Set yourBucketName to the name of the bucket.
bucket = oss2.Bucket(auth, 'https://oss-cn-hangzhou.aliyuncs.com', 'yourBucketName')

# Create a bucket versioning configuration.
config = BucketVersioningConfig()
# Enable versioning.
config.status = oss2.BUCKET_VERSIONING_ENABLE

result = bucket.put_bucket_versioning(config)
# View the HTTP status code.
print('http response code:', result.status)
using Aliyun.OSS;
using Aliyun.OSS.Common;

// Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
var endpoint = "yourEndpoint";
// Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID");
var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET");
// Specify the name of the bucket. Example: examplebucket. 
var bucketName = "examplebucket";
// Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou.
const string region = "cn-hangzhou";

// Create a ClientConfiguration instance and modify parameters as required.
var conf = new ClientConfiguration();

// Use the signature algorithm V4.
conf.SignatureVersion = SignatureVersion.V4;

// Create an OSSClient instance.
var client = new OssClient(endpoint, accessKeyId, accessKeySecret, conf);
client.SetRegion(region);
try
{
    // Set the versioning status of the bucket to Enabled. 
    client.SetBucketVersioning(new SetBucketVersioningRequest(bucketName, VersioningStatus.Enabled));
    Console.WriteLine("Create bucket Version succeeded");
}
catch (Exception ex)
{
    Console.WriteLine("Create bucket Version failed. {0}", ex.Message);
}
package main

import (
  "fmt"
  "os"

  "github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
    // Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
    provider, err := oss.NewEnvironmentVariableCredentialsProvider()
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }

    // Create an OSSClient instance.
    // Set yourEndpoint to the endpoint of the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. Set the endpoint to the actual endpoint.
    client, err := oss.New("yourEndpoint", "", "", oss.SetCredentialsProvider(&provider))
    if err != nil {
       fmt.Println("Error:", err)
       os.Exit(-1)
  }

  // Create a bucket.
  // Set yourBucketName to the name of the bucket.
  err = client.CreateBucket("yourBucketName")
  if err != nil {
    fmt.Println("Error:", err)
    os.Exit(-1)
  }
  // The following code provides an example of how to set the versioning state of a bucket to Enabled.
  config := oss.VersioningConfig{Status: "Enabled"}
  err = client.SetBucketVersioning("yourBucketName", config)
  if err != nil {
    fmt.Println("Error:", err)
    os.Exit(-1)
  }
}
#include <alibabacloud/oss/OssClient.h>
using namespace AlibabaCloud::OSS;

int main(void)
{
    /* Initialize OSS account information. */
            
    /* Set yourEndpoint to the endpoint of the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. */
    std::string Endpoint = "yourEndpoint";
    /* Specify the bucket name, for example, examplebucket. */
    std::string BucketName = "examplebucket";

    /* Initialize network resources. */
    InitializeSdk();

    ClientConfiguration conf;
    /* Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. */
    auto credentialsProvider = std::make_shared<EnvironmentVariableCredentialsProvider>();
    OssClient client(Endpoint, credentialsProvider, conf);

    /* Create a bucket versioning configuration and set the status to Enabled. */
    SetBucketVersioningRequest setrequest(BucketName, VersioningStatus::Enabled);
    auto outcome = client.SetBucketVersioning(setrequest);

    if (!outcome.isSuccess()) {
        /* Handle exceptions. */
        std::cout << "SetBucketVersioning fail" <<
        ",code:" << outcome.error().Code() <<
        ",message:" << outcome.error().Message() <<
        ",requestId:" << outcome.error().RequestId() << std::endl;
        return -1;
    }

    /* Release network resources. */
    ShutdownSdk();
    return 0;
}

Utiliser l'interface de ligne de commande ossutil

Utilisez ossutil pour définir l'état du versioning d'un bucket. Pour savoir comment installer ossutil, consultez la rubrique Installer ossutil.

La commande suivante active le versioning pour un bucket spécifié.

ossutil api put-bucket-versioning --bucket examplebucket --versioning-configuration "{\"Status\":\"Enabled\"}"

Pour plus d'informations sur cette commande, consultez la rubrique put-bucket-versioning.

Suspendre le versioning

Si une politique de rétention est activée pour un bucket, vous ne pouvez pas modifier l'état du versioning de Activé à Suspendu. En revanche, vous pouvez passer de l'état Suspendu à Activé.

Utiliser la console OSS

Vous pouvez suspendre le versioning d'un bucket versionné pour empêcher OSS de générer de nouvelles versions pour les objets. Si une nouvelle version est générée pour un objet dans un bucket dont le versioning est suspendu, OSS définit l'ID de la nouvelle version sur null et conserve les versions précédentes de l'objet.

Pour suspendre le versioning d'un bucket, procédez comme suit :

  1. Dans le volet de navigation de gauche, cliquez sur Buckets. Sur la page Buckets, recherchez et cliquez sur le bucket souhaité.

  2. Dans le volet de navigation de gauche, choisissez Content Security > Versioning.

  3. Sur la page Versioning, cliquez sur Suspend.

  4. Dans la boîte de dialogue qui s'affiche, cliquez sur OK.

Utiliser les SDK Alibaba Cloud

Les exemples suivants montrent comment suspendre le versioning à l'aide des SDK courants. Consultez la rubrique Présentation des SDK.

import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.*;

public class Demo {
    public static void main(String[] args) throws Exception {
        // Set the endpoint. Use China (Hangzhou) as an example. Set the endpoint to the actual endpoint.
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // Specify the region where the bucket is located, for example, cn-hangzhou.
        String region = "cn-hangzhou";
        // Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // Specify the bucket name, for example, examplebucket.
        String bucketName = "examplebucket";

        // Create an OSSClient instance.
        // When the OSSClient instance is no longer used, call the shutdown method to release resources.
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        // Explicitly declare that the V4 signature algorithm is used.
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        try {
            // Suspend versioning.
            BucketVersioningConfiguration configuration = new BucketVersioningConfiguration();
            configuration.setStatus(BucketVersioningConfiguration.SUSPENDED);
            SetBucketVersioningRequest request = new SetBucketVersioningRequest(bucketName, configuration);
            ossClient.setBucketVersioning(request);
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}
<?php
if (is_file(__DIR__ . '/../autoload.php')) {
    require_once __DIR__ . '/../autoload.php';
}
if (is_file(__DIR__ . '/../vendor/autoload.php')) {
    require_once __DIR__ . '/../vendor/autoload.php';
}

use OSS\OssClient;
use OSS\Core\OssException;

// Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
$accessKeyId = getenv("OSS_ACCESS_KEY_ID");
$accessKeySecret = getenv("OSS_ACCESS_KEY_SECRET");
// Set the endpoint. Use Hangzhou as an example. Set the endpoint to the actual endpoint.
$endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
$bucket= "yourBucketName";

$ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint);

try {
    // Suspend versioning.
    $ossClient->putBucketVersioning($bucket, "Suspended");
} catch (OssException $e) {
    printf(__FUNCTION__ . ": FAILED\n");
    printf($e->getMessage() . "\n");
    return;
}

print(__FUNCTION__ . ": OK" . "\n");
const OSS = require("ali-oss");

const client = new OSS({
  // Specify the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the region to oss-cn-hangzhou.
  region: "oss-cn-hangzhou",
  // Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
  accessKeyId: process.env.OSS_ACCESS_KEY_ID,
  accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
  // Specify the bucket name, for example, examplebucket.
  bucket: "examplebucket",
});

async function putBucketVersioning() {
  // Suspend versioning.
  const status = "Suspended";
  const result = await client.putBucketVersioning("examplebucket", status);
  console.log(result);
}
putBucketVersioning();
# -*- coding: utf-8 -*-
import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider
from oss2.models import BucketVersioningConfig
# Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
# Specify the endpoint based on the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com.
# Set yourBucketName to the name of the bucket.
bucket = oss2.Bucket(auth, 'https://oss-cn-hangzhou.aliyuncs.com', 'yourBucketName')

# Create a bucket versioning configuration.
config = BucketVersioningConfig()
# Suspend versioning.
config.status = oss2.BUCKET_VERSIONING_SUSPEND

result = bucket.put_bucket_versioning(config)
# View the HTTP status code.
print('http response code:', result.status)
using Aliyun.OSS;
using Aliyun.OSS.Common;
// Set yourEndpoint to the endpoint of the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com.
var endpoint = "yourEndpoint";
// Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID");
var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET");
// Specify the bucket name, for example, examplebucket.
var bucketName = "examplebucket";
// Configure the client to use V4 signature.
var conf = new ClientConfiguration();
conf.SignatureVersion = SignatureVersion.V4;
// Initialize the OSSClient with V4 signature.
var client = new OssClient(endpoint, accessKeyId, accessKeySecret, conf);
try
{
    // Set the versioning state of the bucket to Suspended.
    client.SetBucketVersioning(new SetBucketVersioningRequest(bucketName, VersioningStatus.Suspended));
    Console.WriteLine("SetBucketVersioning succeeded");
}
catch (Exception ex)
{
    Console.WriteLine("SetBucketVersioning failed. {0}", ex.Message);
}
package main

import (
  "fmt"
  "os"

  "github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
    // Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
    provider, err := oss.NewEnvironmentVariableCredentialsProvider()
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }

    // Create an OSSClient instance.
    // Set yourEndpoint to the endpoint of the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. Set the endpoint to the actual endpoint.
    client, err := oss.New("yourEndpoint", "", "", oss.SetCredentialsProvider(&provider))
    if err != nil {
       fmt.Println("Error:", err)
       os.Exit(-1)
  }

  // Create a bucket.
  // Set yourBucketName to the name of the bucket.
  err = client.CreateBucket("yourBucketName")
  if err != nil {
    fmt.Println("Error:", err)
    os.Exit(-1)
  }
  // Suspend versioning.
  config := oss.VersioningConfig{Status: "Suspended"}
  err = client.SetBucketVersioning("yourBucketName", config)
  if err != nil {
    fmt.Println("Error:", err)
    os.Exit(-1)
  }
}
#include <alibabacloud/oss/OssClient.h>
using namespace AlibabaCloud::OSS;

int main(void)
{
    /* Initialize OSS account information. */
            
    /* Set yourEndpoint to the endpoint of the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. */
    std::string Endpoint = "yourEndpoint";
    /* Specify the bucket name, for example, examplebucket. */
    std::string BucketName = "examplebucket";

    /* Initialize network resources. */
    InitializeSdk();

    ClientConfiguration conf;
    /* Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. */
    auto credentialsProvider = std::make_shared<EnvironmentVariableCredentialsProvider>();
    OssClient client(Endpoint, credentialsProvider, conf);

    /* Create a bucket versioning configuration and set the status to Suspended. */
    SetBucketVersioningRequest setrequest(BucketName, VersioningStatus::Suspended);
    auto outcome = client.SetBucketVersioning(setrequest);

    if (!outcome.isSuccess()) {
        /* Handle exceptions. */
        std::cout << "SetBucketVersioning fail" <<
        ",code:" << outcome.error().Code() <<
        ",message:" << outcome.error().Message() <<
        ",requestId:" << outcome.error().RequestId() << std::endl;
        return -1;
    }

    /* Release network resources. */
    ShutdownSdk();
    return 0;
}

Utiliser l'interface de ligne de commande ossutil

Utilisez ossutil pour définir l'état du versioning d'un bucket. Pour savoir comment installer ossutil, consultez la rubrique Installer ossutil.

La commande suivante suspend le versioning pour un bucket spécifié.

ossutil api put-bucket-versioning --bucket examplebucket --versioning-configuration "{\"Status\":\"Suspended\"}"

Pour plus d'informations sur cette commande, consultez la rubrique put-bucket-versioning.

Afficher les versions

Utilisez ossutil pour afficher toutes les versions d'un objet. Pour savoir comment installer ossutil, consultez la rubrique Installer ossutil.

La commande suivante liste les informations sur toutes les versions de tous les objets dans le bucket examplebucket.

ossutil api list-object-versions --bucket examplebucket

Pour plus d'informations sur cette commande, consultez la rubrique list-object-versions.

Restaurer une version

Utiliser la console OSS

Lorsque vous supprimez un objet d'un bucket dont le versioning est activé, l'objet n'est pas définitivement supprimé. Il est plutôt marqué comme supprimé. Vous pouvez restaurer une version précédente dans la console.

  1. Dans le volet de navigation de gauche, cliquez sur Buckets. Sur la page Buckets, recherchez et cliquez sur le bucket souhaité.

  2. Dans le volet de navigation de gauche, choisissez Object Management > Objects.

  3. Cliquez sur Show à côté de Previous Versions.

  4. Sélectionnez la version que vous souhaitez restaurer et cliquez sur Restore en bas de la page.

  5. Dans la boîte de dialogue qui s'affiche, cliquez sur OK.

Utiliser l'interface de ligne de commande ossutil

Utilisez ossutil pour restaurer une version historique d'un fichier supprimé. Pour savoir comment installer ossutil, consultez la rubrique Installer ossutil.

La commande suivante restaure l'objet example.txt dans le bucket examplebucket vers la version 123.

ossutil revert oss://examplebucket/example.txt 123

Pour plus d'informations sur cette commande, consultez la rubrique revert.

Opérations API associées

Les opérations précédentes sont implémentées sur la base d'opérations API. Si votre programme nécessite un haut degré de personnalisation, vous pouvez appeler directement les opérations API REST. Notez que vous devez écrire manuellement le code pour calculer les signatures. Pour plus d'informations, consultez la rubrique PutBucketVersioning.

Utiliser les politiques de rétention

Dans des scénarios tels que la protection des sauvegardes (Veeam), le suivi des modifications d'actifs (schémas de conception de circuits) ou l'archivage de conformité (finance), vous pouvez avoir besoin d'autoriser les mises à jour des données tout en conservant toutes les versions historiques immuables. Activez à la fois le versioning et une politique de rétention : le versioning préserve les versions historiques lors d'un écrasement ou d'une suppression, tandis que la politique de rétention empêche toute version d'être supprimée ou modifiée pendant la période de protection.

Le versioning et les politiques de rétention fonctionnent conjointement selon les principes suivants :

  • Ordre d'activation des fonctionnalités : Vous pouvez activer le versioning et les politiques de rétention dans n'importe quel ordre.

  • Configurations autorisées :

    • Politique de rétention + Versioning désactivé

    • Politique de rétention + Versioning activé

  • Restrictions :

    • Vous ne pouvez pas activer une politique de rétention pour un bucket dont le versioning est suspendu.

    • Une fois qu'une politique de rétention est activée, les restrictions suivantes s'appliquent à l'état du versioning :

      • Vous ne pouvez pas modifier l'état de Activé à Suspendu.

      • Vous ne pouvez pas modifier l'état de Désactivé à Suspendu.

  • Mécanisme de protection des versions d'objet :

    • La politique de rétention protège toutes les versions d'un objet. Aucune version ne peut être supprimée ou modifiée pendant la période de protection.

    • Vous pouvez uploader un objet portant le même nom pour créer une nouvelle version, mais cette nouvelle version est également protégée par la politique de rétention.

    • La politique de rétention ne s'applique pas aux marqueurs de suppression. La suppression des marqueurs de suppression n'est pas restreinte par la politique de rétention.

  • Interaction avec la réplication des données :

    • Les buckets source et destination supportent des configurations indépendantes pour le versioning et les politiques de rétention.

    • Les informations de version sont transférées normalement pendant la réplication. Le bucket destination gère les versions en fonction de sa propre configuration.

    • Tenter de supprimer une version répliquée dans le bucket destination échouera si elle est protégée par une politique de rétention, mais réussira après l'expiration de la politique.

Références