Einstellung einer Lebenszykluskonfiguration für einen Bucket

In diesem Abschnitt wird erklärt, wie Sie mithilfe der Amazon S3-Konsole, der AWS Command Line Interface (AWS CLI), der oder der Amazon S3 eine Amazon S3 S3-Lifecycle-Konfiguration für einen Bucket einrichten können RESTAPI. AWS SDKs 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 Übertragung der Lebenszykluskonfiguration

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.

Verzögerung bei Übergang oder Ablauf

Es gibt eine Verzögerung zwischen dem Zeitpunkt, an dem eine Lebenszyklusregel erfüllt ist, und dem Abschluss der Aktion für die Regel. Nehmen wir beispielsweise an, dass eine Gruppe von Objekten aufgrund einer Lebenszyklusregel am 1. Januar abgelaufen ist. Obwohl die Ablaufregel am 1. Januar erfüllt wurde, löscht Amazon S3 diese Objekte möglicherweise erst Tage oder sogar Wochen später. Diese Verzögerung tritt auf, weil S3 Lifecycle Objekte für Übergänge oder Ablaufzeiten asynchron in die Warteschlange stellt. Änderungen an der Abrechnung werden jedoch normalerweise angewendet, wenn die Lebenszyklusregel erfüllt ist, auch wenn die Aktion noch nicht abgeschlossen ist. Weitere Informationen finden Sie unter Änderungen bei der Abrechnung. Informationen zur Überwachung der Auswirkungen von Aktualisierungen, die durch aktive Lebenszyklusregeln vorgenommen wurden, finden Sie unter Wie überwache ich die im Rahmen meiner Lebenszyklusregeln ergriffenen Maßnahmen?

Lebenszyklusregeln deaktivieren oder löschen

Wenn Sie Lebenszyklusregeln deaktivieren oder löschen, beendet Amazon S3 nach einer kleinen Verzögerung die Planung neuer Objekte für das Löschen oder den Übergang. Die Planung aller bereits geplanten Objekte wird aufgehoben und sie werden nicht gelöscht oder überführt.

Anmerkung

Bevor Sie Lebenszyklusregeln aktualisieren, deaktivieren oder löschen, verwenden Sie die LIST API Operationen (wie ListObjectsV2ListObjectVersions, und ListMultipartUploads) oder Amazon S3 Inventory überprüfen Sie anhand Ihrer Anwendungsfälle, ob Amazon S3 umgestellt wurde und berechtigte Objekte abgelaufen sind. Falls Sie Probleme beim Aktualisieren, Deaktivieren oder Löschen von Lebenszyklusregeln haben, 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. Wenn Sie beispielsweise heute eine Lebenszyklus-Konfigurationsregel mit einer Ablaufaktion hinzufügen, die bewirkt, dass Objekte mit einem bestimmten Präfix 30 Tage nach ihrer Erstellung ablaufen, stellt Amazon S3 eine Warteschlange für die Entfernung aller vorhandenen Objekte, die älter als 30 Tage sind und das angegebene Präfix haben, in die Warteschlange.

Überwachung der Auswirkungen von Lebenszyklusregeln

Informationen zur Überwachung der Auswirkungen von Aktualisierungen, die durch aktive Lebenszyklusregeln vorgenommen wurden, finden Sie unter Wie überwache ich die im Rahmen meiner Lebenszyklusregeln ergriffenen Maßnahmen?

Änderungen bei der Abrechnung

Möglicherweise besteht eine Verzögerung zwischen dem Zeitpunkt, an dem die Lebenszyklus-Konfigurationsregeln erfüllt sind, und dem Zeitpunkt, zu dem die Aktion ausgeführt wird, die durch die Erfüllung der Regel ausgelöst wurde. Änderungen an der Abrechnung werden jedoch vorgenommen, sobald die Lifecycle-Konfigurationsregel erfüllt ist, auch wenn die Maßnahme noch nicht ergriffen wurde.

Beispielsweise wird Ihnen nach Ablauf des Objektablaufs kein Speicherplatz in Rechnung gestellt, auch wenn das Objekt nicht sofort gelöscht wird. Ebenso werden Ihnen nach Ablauf der Objektübergangszeit die Speichertarife für S3 Glacier Flexible Retrieval berechnet, auch wenn das Objekt nicht sofort in die Speicherklasse S3 Glacier Flexible Retrieval umgestellt wird.

Lebenszyklusübergänge zur Speicherklasse S3 Intelligent-Tiering sind jedoch die Ausnahme. Änderungen an der Abrechnung werden erst vorgenommen, nachdem das Objekt in die S3 Intelligent-Tiering-Speicherklasse übergegangen ist.

Mehrere oder widersprüchliche Regeln

Wenn Sie mehrere Regeln in einer S3 Lifecycle-Konfiguration haben, kann ein Objekt am selben Tag für mehrere S3 Lifecycle-Aktionen in Frage kommen. In solchen Fällen folgt Amazon S3 diesen allgemeinen Regeln:

• Das permanente Löschen hat Vorrang vor einem Übergang.

• Der Übergang hat Vorrang vor der Erstellung von Löschmarkierungen.

• Wenn ein Objekt sowohl für eine Umstellung auf S3 Glacier Flexible Retrieval als auch für eine Umstellung auf S3 Standard-IA (oder eine S3 One Zone-IA) in Frage kommt, entscheidet sich Amazon S3 für die Umstellung auf S3 Glacier Flexible Retrieval.

Beispiele finden Sie unter Beispiel 5: Überlappende Filter, widersprüchliche Lebenszyklus-Aktionen, und was Amazon S3 mit nichtversionierten Buckets macht.

Verwenden der S3-Konsole

Sie können Lebenszyklusregeln für alle Objekte oder eine Teilmenge von Objekten in einem Bucket definieren, indem Sie ein gemeinsames Präfix (Objektnamen, die mit einer gemeinsamen Zeichenfolge beginnen) oder ein Tag verwenden. In Ihrer Lebenszyklusregel können Sie Aktionen definieren, die für aktuelle und nicht aktuelle Objektversionen spezifisch sind. Weitere Informationen finden Sie hier:

• Verwalten Ihres Speicher-Lebenszyklus

• Verwenden der Versioning in S3-Buckets

So erstellen Sie eine Lebenszyklusregel:

1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 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 Diese Regel gilt für alle Objekte im Bucket und anschließend Ich bestätige, dass diese Regel für alle Objekte im 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 auswählen.

   • Wenn Sie einen Wert für Minimale Objektgröße oder 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 beide Werte angeben, muss die maximale Objektgröße größer als die minimale Objektgröße sein.

     Anmerkung

     Die Filter Minimale Objektgröße und Maximale Objektgröße schließen die angegebenen Werte aus. Wenn Sie beispielsweise einen Filter so einrichten, dass Objekte mit einer Mindestobjektgröße von 128 KB ablaufen, laufen Objekte, die genau 128 KB groß sind, nicht ab. Stattdessen gilt die Regel nur für Objekte mit einer Größe von mehr als 128 KB.

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

     Anmerkung

     Bei Buckets, für die die S3-Versionierung nicht aktiviert ist, führt das Ablaufen aktueller Versionen dazu, dass Amazon S3 die Objekte dauerhaft löscht. Weitere Informationen finden Sie unter Lebenszyklus-Aktionen und der Versioning-Status eines Buckets.

   • 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 Speicherklassenübergänge die Speicherklasse aus, zu der Sie wechseln möchten. Eine Liste möglicher Übergänge finden Sie unterUnterstützte Lebenszyklusübergänge. Sie können aus den folgenden Speicherklassen wählen:

      • S3 Standard-IA

      • S3 Intelligent-Tiering

      • S3 One Zone-IA

      • S3 Glacier Flexible Retrieval

      • S3 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. Um ältere Versionen von Objekten zwischen Speicherklassen zu übertragen, gehen Sie unter Übergang von veralteten Versionen von Objekten zwischen Speicherklassen wie folgt vor:

   1. Wählen Sie unter Speicherklassenübergänge die Speicherklasse aus, zu der der Übergang erfolgen soll. Eine Liste möglicher Übergänge finden Sie unterUnterstützte Lebenszyklusübergänge. Sie können aus den folgenden Speicherklassen wählen:

      • S3 Standard-IA

      • S3 Intelligent-Tiering

      • S3 One Zone-IA

      • S3 Glacier Flexible Retrieval

      • S3 Glacier Deep Archive

   2. Geben Sie im Feld Tage, nachdem das Objekt nicht mehr aktuell ist, die Anzahl der Tage nach der Erstellung ein, um das Objekt umzustellen.

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 AWS CloudFormation Vorlagen und Beispielen finden Sie unter Arbeiten mit AWS CloudFormation Vorlagen und AWS::S3::Bucketim AWS CloudFormation Benutzerhandbuch.

Verwenden des AWS CLI

Sie können die folgenden AWS CLI Befehle verwenden, um S3 Lifecycle-Konfigurationen zu verwalten:

• put-bucket-lifecycle-configuration

• get-bucket-lifecycle-configuration

• delete-bucket-lifecycle

Anweisungen zur Einrichtung von finden Sie AWS CLI unterEntwickeln mit Amazon S3 über die AWS CLI.

Die Amazon S3 Lifecycle-Konfiguration ist eine XML Datei. Aber wenn Sie die verwenden AWS CLI, können Sie das XML Format nicht angeben. Sie müssen stattdessen das JSON Format angeben. Im Folgenden finden Sie Beispiele für XML Lebenszykluskonfigurationen und die entsprechenden JSON Konfigurationen, die Sie in einem AWS CLI Befehl angeben können.

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

Beispiel 1

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>

JSON

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

Beispiel 2

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>

JSON

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

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

So testen Sie die Konfiguration

1. Speichern Sie die JSON Lifecycle-Konfiguration in einer Datei (z. B. lifelycle.json).

2. Führen Sie den folgenden AWS CLI Befehl aus, um die Lifecycle-Konfiguration für Ihren Bucket festzulegen. Ersetzen Sie user input placeholders durch Ihre Informationen.

   $ aws s3api put-bucket-lifecycle-configuration  \
   --bucket amzn-s3-demo-bucket  \
   --lifecycle-configuration file://lifecycle.json 

3. Rufen Sie zur Überprüfung die S3-Lifecycle-Konfiguration mit dem folgenden get-bucket-lifecycle-configuration AWS CLI Befehl ab:

   $ aws s3api get-bucket-lifecycle-configuration  \
   --bucket amzn-s3-demo-bucket  

4. Verwenden Sie den delete-bucket-lifecycle AWS CLI Befehl wie folgt, um die S3 Lifecycle-Konfiguration zu löschen:

   aws s3api delete-bucket-lifecycle \
   --bucket amzn-s3-demo-bucket

Mit dem AWS SDKs

Java

Sie können den verwenden AWS SDK for Java , um die S3-Lifecycle-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 zeigt, wie Sie die AWS SDK for Java Lifecycle-Konfiguration eines Buckets hinzufügen, aktualisieren und löschen können. 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 gedruckt 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 Arbeitsbeispiels finden Sie unter Erste Schritte im AWS SDK for Java Entwicklerhandbuch.

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 den verwenden AWS SDK for .NET , um die S3-Lifecycle-Konfiguration in einem Bucket 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 zeigt, wie Sie die AWS SDK for .NET Lifecycle-Konfiguration eines Buckets hinzufügen, aktualisieren und löschen können. 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.

Informationen zum Einrichten und Ausführen der Codebeispiele finden Sie unter Erste Schritte mit dem AWS SDK for. NETim AWS SDKfür. NETLeitfaden für Entwickler.

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 AWS SDK for Ruby S3-Lifecycle-Konfiguration in einem Bucket mithilfe der Klasse AWS::S3::BucketLifecycleConfiguration verwalten. Weitere Informationen zur Verwaltung einer Lebenszyklus-Konfiguration finden Sie unter Verwalten Ihres Speicher-Lebenszyklus.

Mit dem REST API

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

• PutBucketLifecycleConfiguration

• GetBucketLifecycleConfiguration

• DeleteBucketLifecycle

Fehlerbehebung bei S3 Lifecycle

Informationen zu häufigen Problemen, die bei der Arbeit mit S3 Lifecycle auftreten können, finden Sie unterFehlerbehebung bei Problemen mit dem Amazon-S3-Lebenszyklus.