Festlegen der Lebenszyklus-Konfiguration für einen Bucket

In diesem Abschnitt wird erläutert, wie Sie mithilfe von AWS-SDKs, der AWS CLI oder der Amazon-S3-Konsole eine S3-Lebenszyklus-Konfiguration für einen Bucket festlegen können. Weitere Informationen zur S3-Lebenszyklus-Konfiguration finden Sie unter Verwalten Ihres Speicher-Lebenszyklus.

Mit Lebenszyklusregeln können Sie Aktionen definieren, die Amazon S3 während der Lebensdauer eines Objekts ausführen soll (z. B. die Überführung von Objekten in eine andere Speicherklasse, ihre Archivierung oder ihr Löschen nach einem bestimmten Zeitraum).

Bevor Sie eine Lebenszyklus-Konfiguration festlegen, beachten Sie Folgendes:

Verzögerung bei der Verbreitung

Wenn Sie eine S3-Lebenszyklus-Konfiguration zu einem Bucket hinzufügen, tritt eine gewisse Verzögerung ein, bis eine neue oder aktualisierte Lebenszyklus-Konfiguration vollständig auf alle Amazon-S3-Systeme verteilt ist. Rechnen Sie mit einer Verzögerung von einigen Minuten, bis die Konfiguration vollständig wirksam ist. Diese Verzögerung kann auch auftreten, wenn Sie eine S3-Lebenszyklus-Konfiguration löschen.

Deaktivieren oder Löschen von Lebenszyklusregeln

Wenn Sie eine Lebenszyklusregel deaktivieren oder löschen, stellt Amazon S3 nach einer kurzen Verzögerung die Planung neuer Objekte zur Löschung oder Übertragung ein. Die Planung aller bereits geplanten Objekte wird aufgehoben und sie werden nicht gelöscht oder überführt.

Anmerkung

Verwenden Sie vor dem Aktualisieren, Deaktivieren oder Löschen von Lebenszyklusregeln die LIST-API-Operationen (z. B. ListObjectsV2ListObjectVersions, und ListMultipartUploads) oder , Amazon S3 Inventory um zu überprüfen, ob Amazon S3 basierend auf Ihren Anwendungsfällen berechtigte Objekte übertragen und abgelaufen hat. Wenn Probleme beim Aktualisieren, Deaktivieren oder Löschen von Lebenszyklusregeln auftreten, finden Sie weitere Informationen unter Fehlerbehebung bei Problemen mit dem Amazon-S3-Lebenszyklus.

Bestehende und neue Objekte

Wenn Sie einem Bucket eine Lebenszyklus-Konfiguration hinzufügen, gelten die Konfigurationsregeln für vorhandene Objekte und für Objekte, die Sie später hinzufügen. z. B.: Wenn Sie heute eine Lebenszyklus-Konfiguration mit einer Ablaufaktion hinzufügen, die dazu führt, dass Objekte mit einem bestimmten Präfix 30 Tage nach ihrer Erstellung ablaufen, setzt Amazon S3 alle bestehenden Objekte, die mehr als 30 tage alt sind, in die Löschwarteschlange.

Änderungen bei der Abrechnung

Zwischen dem Zeitpunkt der Erfüllung der Lebenszyklus-Konfigurationsregeln und der dadurch ausgelösten Aktion kann eine Verzögerung eintreten. Buchhaltungsänderungen werden jedoch sofort nach der Erfüllung der Lebenszyklus-Konfigurationsregel durchgeführt, auch wenn die Maßnahme noch nicht durchgeführt wurde.

Beispielsweise wird Ihnen nach dem Ablaufzeitpunkt des Objekts keine Speichergebühr in Rechnung gestellt, auch wenn das Objekt nicht sofort gelöscht wird. Ein weiteres Beispiel: Sobald die Objektübergangszeit abgelaufen ist, werden Ihnen Speichergebühren von S3 Glacier Flexible Retrieval in Rechnung gestellt, auch wenn das Objekt nicht sofort in die Speicherklasse S3 Glacier Flexible Retrieval überführt wird. Lebenszyklusübergänge auf die S3-Intelligent-Tiering-Speicherklasse sind die Ausnahme. Änderungen bei der Abrechnung treten erst auf, wenn das Objekt in die S3-Intelligent-Tiering-Speicherklasse übergegangen ist.

Verwenden der S3-Konsole

Sie können für alle Objekte oder eine Teilmenge der Objekte in einem Bucket Lebenszyklusregeln definieren, indem Sie ein gemeinsames Präfix (Objektnamen, die mit einer gemeinsamen Zeichenfolge beginnen) oder einen Tag verwenden. Mit einer Lebenszyklusregel können Sie spezifische Aktionen für aktuelle und nicht aktuelle Objektversionen definieren. Weitere Informationen finden Sie unter:

• Verwalten Ihres Speicher-Lebenszyklus

• Verwenden der Versioning in S3-Buckets

So erstellen Sie eine Lebenszyklusregel:

1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon S3-Konsole unter https://console.aws.amazon.com/s3/.

2. Wählen Sie in der Liste Buckets den Namen des Buckets aus, für den Sie eine Lebenszyklusregel erstellen möchten.

3. Wählen Sie den Tab Management (Verwaltung) und dann die Option Create lifecycle rule (Lebenszyklusregel erstellen).

4. Geben Sie unter Lifecycle rule name (Name der Lebenszyklusregel) einen Namen für Ihre Regel ein.

   Der Name muss innerhalb des Buckets eindeutig sein.

5. Wählen Sie den Umfang der Lebenszyklusregel:

   • Um diese Lebenszyklusregel auf alle Objekte mit einem bestimmten Präfix oder Tag anzuwenden, wählen Sie Umfang auf bestimmte Präfixe oder Markierungen beschränken aus.

     • Um den Bereich nach Präfix zu beschränken, geben Sie unter Prefix (Präfix) das Präfix ein.

     • Um den Bereich nach Tag einzuschränken, wählen Sie Add tag (Tag hinzufügen), und geben Sie den Tag-Schlüssel und den Wert ein.

     Weitere Hinweise zu Präfixen für Objektnamen finden Sie unter Erstellen von Objektschlüsselnamen. Weitere Informationen über Objekt-Markierungen finden Sie unter Kategorisieren des Speichers mithilfe von Markierungen.

   • Um diese Lebenszyklusregel auf alle Objekte im Bucket anzuwenden, wählen Sie This rule applies to all objects in the bucket (Diese Regel gilt für alle Objekte in dem Bucket) und wählen Sie I acknowledge that this rule applies to all objects in the bucket (Ich bestätige, dass diese Regel für alle Objekte in dem Bucket gilt).

6. Um eine Regel nach Objektgröße zu filtern, können Sie Minimale Objektgröße angeben, Maximale Objektgröße angeben oder beide Optionen aktivieren.

   • Wenn Sie eine minimale Objektgröße oder eine maximale Objektgröße angeben, muss der Wert größer als 0 Byte und bis zu 5 TB sein. Sie können diesen Wert in Byte, KB, MB oder GB angeben.

   • Wenn Sie beides angeben, muss die maximale Objektgröße größer als die minimale Objektgröße sein.

7. Wählen Sie unter Lifecycle rule actions (Lebenszyklusregelaktionen) die Aktionen aus, die Ihre Lebenszyklusregel ausführen soll:

   • Umsetzung aktueller Versionen von Objekten zwischen Speicherklassen

   • Umsetzung früherer Versionen von Objekten zwischen Speicherklassen

   • Ablauf aktueller Versionen von Objekten

   • Dauerhaftes Löschen früherer Versionen von Objekten

   • Löschen abgelaufener Löschmarkierungen oder unvollständiger mehrteiliger Uploads

   Abhängig von den von Ihnen ausgewählten Aktionen werden verschiedene Optionen angezeigt.

8. So setzen Sie aktuelle Versionen von Objekten zwischen Speicherklassen unter Transition current versions of objects between storage classes (Umsetzen von aktuellen Versionen von Objekten zwischen Speicherklassen) um:

   1. Wählen Sie unter Storage class transitions (Speicherklassenumsetzungen) die Speicherklasse aus, zu der Sie wechseln möchten:

      • Standard-IA

      • Intelligent-Tiering

      • One Zone-IA

      • S3 Glacier Flexible Retrieval

      • Glacier Deep Archive

   2. Geben Sie im Feld Days after object creation (Tage nach der Objekterstellung) die Anzahl der Tage nach der Erstellung für die Umsetzung des Objekts ein.

   Weitere Informationen über Speicherklassen finden Sie unter Verwenden von Amazon-S3-Speicherklassen. Sie können Übergänge für aktuelle oder vorhergehende Objektversionen definieren oder sowohl für aktuelle als auch vorhergehende Versionen. Versioning ermöglicht Ihnen, mehrere Versionen eines Objekts in einem Bucket aufzubewahren. Weitere Informationen über die Versionssteuerung finden Sie unter Verwenden der S3-Konsole.

   Wichtig

   Wenn Sie die Speicherklasse S3 Glacier Flexible Retrieval oder Glacier Deep Archive wählen, bleibt Ihr Objekt in Amazon S3. Sie können nicht direkt über den separaten Amazon-S3-Glacier-Service auf sie zugreifen. Weitere Informationen finden Sie unter Übergang von Objekten mit Amazon-S3-Lebenszyklus.

9. So setzen Sie nicht aktuelle Versionen von Objekten zwischen Speicherklassen unter Transition non-current versions of objects between storage classes (Umsetzen von nicht aktuellen Versionen von Objekten zwischen Speicherklassen) um:

   1. Wählen Sie unter Storage class transitions (Speicherklassenumsetzungen) die Speicherklasse aus, zu der Sie wechseln möchten:

      • Standard-IA

      • Intelligent-Tiering

      • One Zone-IA

      • S3 Glacier Flexible Retrieval

      • Glacier Deep Archive

   2. Geben Sie im Feld Days after object becomes non-current (Tage, nachdem das Objekt nicht mehr aktuell ist) die Anzahl der Tage nach der Erstellung für die Umsetzung des Objekts ein.

10. Um den Ablauf aktueller Versionen von Objekten auszulösen, geben Sie unter Expire current versions of objects (Ablauf aktueller Objektversionen) in Number of days after object creation (Anzahl der Tage nach der Objekterstellung) die Anzahl der Tage ein.

    Wichtig

    In einem Bucket ohne Versionierung führt die Ablaufaktion dazu, dass Amazon S3 das Objekt dauerhaft entfernt. Weitere Informationen über die Lebenszyklus-Aktionen finden Sie unter Elemente, die Lebenszyklus-Aktionen beschreiben.

11. Um frühere Versionen von Objekten dauerhaft zu löschen, geben Sie unter Permanently delete previous versions of objects (Dauerhaftes Löschen nicht aktueller Versionen von Objekten) in Days after objects become noncurrent (Tage nach dem Erlöschen von Objekten) die Anzahl der Tage ein. Sie können die Anzahl der beizubehaltenden neueren Versionen optional angeben, indem Sie einen Wert unter Number of newer versions to retain (Anzahl der beizubehaltenden neueren Versionen) eingeben.

12. Wählen Sie unter Delete expired delete markers or incomplete multipart uploads (Abgelaufene Löschmarkierungen oder unvollständige mehrteilige Uploads löschen) Delete expired object delete markers (Abgelaufene Objektlöschmarken löschen) und Delete incomplete multipart uploads (Unvollständige mehrteilige Uploads löschen) aus. Geben Sie dann die Anzahl der Tage nach der mehrteiligen Upload-Initiierung ein, die Sie beenden und für die Sie unvollständige mehrteilige Uploads löschen möchten.

    Weitere Informationen über mehrteilige Uploads finden Sie unter Hochladen und Kopieren von Objekten mit mehrteiligen Uploads.

13. Wählen Sie Create rule aus.

    Wenn die Regel keine Fehler enthält, aktiviert Amazon S3 sie, und Sie können sie im Tab Management (Verwaltung) unter Lifecycle rules (Lebenszyklusregeln) sehen.

Informationen zu CloudFormation Vorlagen und Beispielen finden Sie unter Arbeiten mit AWS CloudFormation Vorlagen und AWS::S3::Bucket im AWS CloudFormation -Benutzerhandbuch.

Verwendung der AWS CLI

Zur Verwaltung der S3-Lebenszyklus-Konfigurationen können Sie die folgenden AWS CLI-Befehle verwenden:

• put-bucket-lifecycle-configuration

• get-bucket-lifecycle-configuration

• delete-bucket-lifecycle

Weitere Informationen zum Einrichten der AWS CLI finden Sie unter Entwickeln mit Amazon S3 über die AWS CLI.

Beachten Sie, dass die Amazon-S3-Lebenszyklus-Konfiguration eine XML-Datei ist. Wenn Sie jedoch die AWS CLI verwenden, können Sie die XML nicht angeben. Sie müssen stattdessen das JSON-Format angeben. Nachfolgend finden Sie Beispiele für XML-Lebenszyklus-Konfigurationen und entsprechenden JSON-Code, den Sie in einem AWS CLI-Befehl angeben können:

Betrachten Sie das folgende Beispiel einer S3-Lebenszyklus-Konfiguration:

Beispiel 1

JSON

{
    "Rules": [
        {
            "Filter": {
                "Prefix": "documents/"
            },
            "Status": "Enabled",
            "Transitions": [
                {
                    "Days": 365,
                    "StorageClass": "GLACIER"
                }
            ],
            "Expiration": {
                "Days": 3650
            },
            "ID": "ExampleRule"
        }
    ]
        }

XML

<LifecycleConfiguration>
    <Rule>
        <ID>ExampleRule</ID>
        <Filter>
           <Prefix>documents/</Prefix>
        </Filter>
        <Status>Enabled</Status>
        <Transition>        
           <Days>365</Days>        
           <StorageClass>GLACIER</StorageClass>
        </Transition>    
        <Expiration>
             <Days>3650</Days>
        </Expiration>
    </Rule>
</LifecycleConfiguration>

Beispiel 2

JSON

{
    "Rules": [
        {
            "ID": "id-1",
            "Filter": {
                "And": {
                    "Prefix": "myprefix", 
                    "Tags": [
                        {
                            "Value": "mytagvalue1", 
                            "Key": "mytagkey1"
                        }, 
                        {
                            "Value": "mytagvalue2", 
                            "Key": "mytagkey2"
                        }
                    ]
                }
            }, 
            "Status": "Enabled", 
            "Expiration": {
                "Days": 1
            }
        }
    ]
}

XML

<LifecycleConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
    <Rule>
        <ID>id-1</ID>
        <Expiration>
            <Days>1</Days>
        </Expiration>
        <Filter>
            <And>
                <Prefix>myprefix</Prefix>
                <Tag>
                    <Key>mytagkey1</Key>
                    <Value>mytagvalue1</Value>
                </Tag>
                <Tag>
                    <Key>mytagkey2</Key>
                    <Value>mytagvalue2</Value>
                </Tag>
            </And>
        </Filter>
        <Status>Enabled</Status>    
    </Rule>
</LifecycleConfiguration>

Sie können den Befehl put-bucket-lifecycle-configuration wie folgt testen.

So testen Sie die Konfiguration

1. Speichern Sie die JSON-Lebenszyklus-Konfiguration in einer Datei (lifecycle.json).

2. Führen Sie den folgenden AWS CLI-Befehl aus, um die Lebenszyklus-Konfiguration auf Ihrem Bucket einzurichten.

   $ aws s3api put-bucket-lifecycle-configuration  \
   --bucket bucketname  \
   --lifecycle-configuration file://lifecycle.json 

3. Rufen Sie zur Prüfung die S3-Lebenszyklus-Konfiguration wie folgt mit dem get-bucket-lifecycle-configuration AWS CLI-Befehl ab.

   $ aws s3api get-bucket-lifecycle-configuration  \
   --bucket bucketname  

4. Verwenden Sie zum Löschen der S3-Lebenszyklus-Konfiguration wie folgt den delete-bucket-lifecycle AWS CLI-Befehl.

   aws s3api delete-bucket-lifecycle \
   --bucket bucketname

Verwenden der AWS-SDKs

Java

Sie können das AWS SDK for Java verwenden, um die S3-Lebenszyklus-Konfiguration eines Buckets zu verwalten. Weitere Informationen zur Verwaltung einer S3-Lebenszyklus-Konfiguration finden Sie unter Verwalten Ihres Speicher-Lebenszyklus.

Anmerkung

Wenn Sie einem Bucket eine S3-Lebenszyklus-Konfiguration hinzufügen, ersetzt Amazon S3 die aktuelle Lebenszyklus-Konfiguration des Buckets, sofern vorhanden. Um eine Lebenszyklus-Konfiguration zu aktualisieren, rufen Sie sie ab, nehmen die gewünschten Änderungen vor und fügen die geänderte Konfiguration dann dem Bucket hinzu.

Das folgende Beispiel veranschaulicht, wie Sie mit AWS SDK for Java die Lebenszyklus-Konfiguration eines Buckets hinzufügen, aktualisieren und löschen. Das Beispiel erledigt Folgendes:

• Fügt eine Lebenszyklus-Konfiguration zu einem Bucket hinzu.

• Ruft die Lebenszyklus-Konfiguration und Updates durch Hinzufügen einer weiteren Regel ab.

• Fügt die abgeänderte Lebenszyklus-Konfiguration dem Bucket hinzu. Amazon S3 ersetzt die vorhandene Konfiguration.

• Ruft die Konfiguration erneut ab und überprüft, ob sie die richtige Anzahl von Regeln enthält, indem die Anzahl der Regeln ausgegeben wird.

• Löscht die Lebenszyklus-Konfiguration und überprüft, ob sie gelöscht wurde, indem versucht wird, sie erneut abzurufen.

Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter Testen der Java-Codebeispiele für Amazon S3.

import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.BucketLifecycleConfiguration;
import com.amazonaws.services.s3.model.BucketLifecycleConfiguration.Transition;
import com.amazonaws.services.s3.model.StorageClass;
import com.amazonaws.services.s3.model.Tag;
import com.amazonaws.services.s3.model.lifecycle.LifecycleAndOperator;
import com.amazonaws.services.s3.model.lifecycle.LifecycleFilter;
import com.amazonaws.services.s3.model.lifecycle.LifecyclePrefixPredicate;
import com.amazonaws.services.s3.model.lifecycle.LifecycleTagPredicate;

import java.io.IOException;
import java.util.Arrays;

public class LifecycleConfiguration {

        public static void main(String[] args) throws IOException {
                Regions clientRegion = Regions.DEFAULT_REGION;
                String bucketName = "*** Bucket name ***";

                // Create a rule to archive objects with the "glacierobjects/" prefix to Glacier
                // immediately.
                BucketLifecycleConfiguration.Rule rule1 = new BucketLifecycleConfiguration.Rule()
                                .withId("Archive immediately rule")
                                .withFilter(new LifecycleFilter(new LifecyclePrefixPredicate("glacierobjects/")))
                                .addTransition(new Transition().withDays(0).withStorageClass(StorageClass.Glacier))
                                .withStatus(BucketLifecycleConfiguration.ENABLED);

                // Create a rule to transition objects to the Standard-Infrequent Access storage
                // class
                // after 30 days, then to Glacier after 365 days. Amazon S3 will delete the
                // objects after 3650 days.
                // The rule applies to all objects with the tag "archive" set to "true".
                BucketLifecycleConfiguration.Rule rule2 = new BucketLifecycleConfiguration.Rule()
                                .withId("Archive and then delete rule")
                                .withFilter(new LifecycleFilter(new LifecycleTagPredicate(new Tag("archive", "true"))))
                                .addTransition(new Transition().withDays(30)
                                                .withStorageClass(StorageClass.StandardInfrequentAccess))
                                .addTransition(new Transition().withDays(365).withStorageClass(StorageClass.Glacier))
                                .withExpirationInDays(3650)
                                .withStatus(BucketLifecycleConfiguration.ENABLED);

                // Add the rules to a new BucketLifecycleConfiguration.
                BucketLifecycleConfiguration configuration = new BucketLifecycleConfiguration()
                                .withRules(Arrays.asList(rule1, rule2));

                try {
                        AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                                        .withCredentials(new ProfileCredentialsProvider())
                                        .withRegion(clientRegion)
                                        .build();

                        // Save the configuration.
                        s3Client.setBucketLifecycleConfiguration(bucketName, configuration);

                        // Retrieve the configuration.
                        configuration = s3Client.getBucketLifecycleConfiguration(bucketName);

                        // Add a new rule with both a prefix predicate and a tag predicate.
                        configuration.getRules().add(new BucketLifecycleConfiguration.Rule().withId("NewRule")
                                        .withFilter(new LifecycleFilter(new LifecycleAndOperator(
                                                        Arrays.asList(new LifecyclePrefixPredicate("YearlyDocuments/"),
                                                                        new LifecycleTagPredicate(new Tag(
                                                                                        "expire_after",
                                                                                        "ten_years"))))))
                                        .withExpirationInDays(3650)
                                        .withStatus(BucketLifecycleConfiguration.ENABLED));

                        // Save the configuration.
                        s3Client.setBucketLifecycleConfiguration(bucketName, configuration);

                        // Retrieve the configuration.
                        configuration = s3Client.getBucketLifecycleConfiguration(bucketName);

                        // Verify that the configuration now has three rules.
                        configuration = s3Client.getBucketLifecycleConfiguration(bucketName);
                        System.out.println("Expected # of rules = 3; found: " + configuration.getRules().size());

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

                        // Verify that the configuration has been deleted by attempting to retrieve it.
                        configuration = s3Client.getBucketLifecycleConfiguration(bucketName);
                        String s = (configuration == null) ? "No configuration found." : "Configuration found.";
                        System.out.println(s);
                } catch (AmazonServiceException e) {
                        // The call was transmitted successfully, but Amazon S3 couldn't process
                        // it, so it returned an error response.
                        e.printStackTrace();
                } catch (SdkClientException e) {
                        // Amazon S3 couldn't be contacted for a response, or the client
                        // couldn't parse the response from Amazon S3.
                        e.printStackTrace();
                }
        }
}

.NET

Sie können das AWS SDK for .NET verwenden, um die S3-Lebenszyklus-Konfiguration eines Buckets zu verwalten. Weitere Informationen zur Verwaltung einer Lebenszyklus-Konfiguration finden Sie unter Verwalten Ihres Speicher-Lebenszyklus.

Anmerkung

Wenn Sie eine Lebenszyklus-Konfiguration hinzufügen, ersetzt Amazon S3 die vorhandene Konfiguration für den angegebenen Bucket. Um eine Konfiguration zu aktualisieren, müssen Sie zuerst die Lebenszyklus-Konfiguration abrufen, die Änderungen vornehmen und dann die geänderte Lebenszyklus-Konfiguration dem Bucket hinzufügen.

Das folgende Beispiel veranschaulicht, wie Sie mit AWS SDK for .NET die Lebenszyklus-Konfiguration eines Buckets hinzufügen, aktualisieren und löschen. Das Codebeispiel führt die folgenden Aufgaben durch:

• Fügt eine Lebenszyklus-Konfiguration zu einem Bucket hinzu.

• Ruft die Lebenszyklus-Konfiguration und Updates durch Hinzufügen einer weiteren Regel ab.

• Fügt die abgeänderte Lebenszyklus-Konfiguration dem Bucket hinzu. Amazon S3 ersetzt die vorhandene Lebenszyklus-Konfiguration.

• Ruft die Konfiguration erneut ab und überprüft sie durch Ausgabe der Anzahl von Regeln in der Konfiguration.

• Löscht die Lebenszyklus-Konfiguration und überprüft den Löschvorgang.

Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter Ausführen der .NET-Codebeispiele für Amazon S3.

using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Amazon.DocSamples.S3
{
    class LifecycleTest
    {
        private const string bucketName = "*** bucket name ***";
        // Specify your bucket region (an example region is shown).
        private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
        private static IAmazonS3 client;
        public static void Main()
        {
            client = new AmazonS3Client(bucketRegion);
            AddUpdateDeleteLifecycleConfigAsync().Wait();
        }

        private static async Task AddUpdateDeleteLifecycleConfigAsync()
        {
            try
            {
                var lifeCycleConfiguration = new LifecycleConfiguration()
                {
                    Rules = new List<LifecycleRule>
                        {
                            new LifecycleRule
                            {
                                 Id = "Archive immediately rule",
                                 Filter = new LifecycleFilter()
                                 {
                                     LifecycleFilterPredicate = new LifecyclePrefixPredicate()
                                     {
                                         Prefix = "glacierobjects/"
                                     }
                                 },
                                 Status = LifecycleRuleStatus.Enabled,
                                 Transitions = new List<LifecycleTransition>
                                 {
                                      new LifecycleTransition
                                      {
                                           Days = 0,
                                           StorageClass = S3StorageClass.Glacier
                                      }
                                  },
                            },
                            new LifecycleRule
                            {
                                 Id = "Archive and then delete rule",
                                  Filter = new LifecycleFilter()
                                 {
                                     LifecycleFilterPredicate = new LifecyclePrefixPredicate()
                                     {
                                         Prefix = "projectdocs/"
                                     }
                                 },
                                 Status = LifecycleRuleStatus.Enabled,
                                 Transitions = new List<LifecycleTransition>
                                 {
                                      new LifecycleTransition
                                      {
                                           Days = 30,
                                           StorageClass = S3StorageClass.StandardInfrequentAccess
                                      },
                                      new LifecycleTransition
                                      {
                                        Days = 365,
                                        StorageClass = S3StorageClass.Glacier
                                      }
                                 },
                                 Expiration = new LifecycleRuleExpiration()
                                 {
                                       Days = 3650
                                 }
                            }
                        }
                };

                // Add the configuration to the bucket. 
                await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration);

                // Retrieve an existing configuration. 
                lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);

                // Add a new rule.
                lifeCycleConfiguration.Rules.Add(new LifecycleRule
                {
                    Id = "NewRule",
                    Filter = new LifecycleFilter()
                    {
                        LifecycleFilterPredicate = new LifecyclePrefixPredicate()
                        {
                            Prefix = "YearlyDocuments/"
                        }
                    },
                    Expiration = new LifecycleRuleExpiration()
                    {
                        Days = 3650
                    }
                });

                // Add the configuration to the bucket. 
                await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration);

                // Verify that there are now three rules.
                lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
                Console.WriteLine("Expected # of rulest=3; found:{0}", lifeCycleConfiguration.Rules.Count);

                // Delete the configuration.
                await RemoveLifecycleConfigAsync(client);

                // Retrieve a nonexistent configuration.
                lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);

            }
            catch (AmazonS3Exception e)
            {
                Console.WriteLine("Error encountered ***. Message:'{0}' when writing an object", e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
            }
        }

        static async Task AddExampleLifecycleConfigAsync(IAmazonS3 client, LifecycleConfiguration configuration)
        {

            PutLifecycleConfigurationRequest request = new PutLifecycleConfigurationRequest
            {
                BucketName = bucketName,
                Configuration = configuration
            };
            var response = await client.PutLifecycleConfigurationAsync(request);
        }

        static async Task<LifecycleConfiguration> RetrieveLifecycleConfigAsync(IAmazonS3 client)
        {
            GetLifecycleConfigurationRequest request = new GetLifecycleConfigurationRequest
            {
                BucketName = bucketName
            };
            var response = await client.GetLifecycleConfigurationAsync(request);
            var configuration = response.Configuration;
            return configuration;
        }

        static async Task RemoveLifecycleConfigAsync(IAmazonS3 client)
        {
            DeleteLifecycleConfigurationRequest request = new DeleteLifecycleConfigurationRequest
            {
                BucketName = bucketName
            };
            await client.DeleteLifecycleConfigurationAsync(request);
        }
    }
}

Ruby

Sie können die verwendenAWS SDK for Ruby, um die S3-Lebenszykluskonfiguration für einen Bucket mithilfe der Klasse AWS::S3::BucketLifecycleKonfiguration zu verwalten. Weitere Informationen zur Verwendung von AWS SDK for Ruby mit Amazon S3 finden Sie unter Verwenden von AWS SDK for Ruby – Version 3. Weitere Informationen zur Verwaltung einer Lebenszyklus-Konfiguration finden Sie unter Verwalten Ihres Speicher-Lebenszyklus.

Verwenden der REST-API

In den folgenden Abschnitten der Amazon Simple Storage Service API-Referenz wird die REST API im Zusammenhang mit der S3 Lebenszykluskonfiguration beschrieben.

• PUT Bucket-Lebenszyklus

• GET Bucket-Lebenszyklus

• DELETE Bucket-Lebenszyklus