Objektversionierung in S3-Buckets auf CODE-DE-Lab

Mit der S3-Bucket-Versionierung können Sie verschiedene Versionen einer Datei im Object Storage aufbewahren. Typische Anwendungsfälle sind:

Datenwiederherstellung und Backups

Schutz vor versehentlichem Löschen

Zusammenarbeit und Dokumentenverwaltung

Anwendungstests und Zurücksetzen von Änderungen

Nachverfolgung von Änderungen an großen Datensätzen

Dateisynchronisierung und Archivierung

In diesem Artikel erfahren Sie, wie Sie

die S3-Objektversionierung auf CODE-DE-Lab OpenStack einrichten,

verschiedene Dateiversionen herunterladen und

das automatische Entfernen früherer Versionen konfigurieren.

Voraussetzungen

Nr. 1 Konto

Sie benötigen ein Hosting-Konto bei CODE-DE-Lab mit Zugriff auf die Horizon-Oberfläche: https://identity.cloudferro.com/auth/realms/CODE-DE3/account/.

Nr. 2 AWS CLI auf Ihrem lokalen Computer oder Ihrer virtuellen Maschine installiert

AWS CLI ist kostenlose, quelloffene Software zur Verwaltung verschiedener Clouds, nicht nur der von Amazon Web Services betriebenen. In diesem Artikel verwalten Sie damit Ihre Ressourcen in der CODE-DE-Lab Cloud.

Dieser Artikel wurde für Ubuntu 22.04 verfasst. Die Befehle können auch auf anderen Betriebssystemen funktionieren, müssen aber möglicherweise angepasst werden.

So installieren Sie AWS CLI unter Ubuntu 22.04:

sudo apt install awscli

Nr. 3 Erzeugte EC2-Zugangsdaten

Für die Authentifizierung bei der CODE-DE-Lab Cloud mit AWS CLI benötigen Sie EC2-Zugangsdaten. Falls Sie noch keine haben, lesen Sie Erstellen und Verwalten von EC2-Anmeldedaten auf CODE-DE-Lab

Nr. 4 Regeln für Bucket-Namen

Im Verlauf dieses Artikels erstellen Sie mehrere Buckets. Machen Sie sich mit den zulässigen Zeichen in Bucket-Namen vertraut. Weitere Informationen finden Sie im Abschnitt Einen neuen Object-Storage-Container erstellen von Wie verwendet man den Objektspeicher?.

Nr. 5 Begriffe: Container und Bucket

In diesem Artikel bezeichnen „Container“ und „Bucket“ dieselbe Ressourcenkategorie in der CODE-DE-Lab Cloud. Das Horizon-Dashboard verwendet häufiger „Container“, AWS CLI häufiger „Bucket“.

Inhalt dieser Anleitung

AWS CLI konfigurieren und testen

AWS CLI konfigurieren

Die Funktion von AWS CLI überprüfen

Bucket-Namen Shell-Variablen zuweisen

Eindeutige Bucket-Namen sicherstellen

Einen Bucket ohne Versionierung erstellen

Die Versionierung für einen Bucket aktivieren

Eine Datei hochladen

S3-Pfade

Eine weitere Dateiversion hochladen

Verfügbare Dateiversionen auflisten

Beispiel 1: Eine Datei, zwei Versionen

Beispiel 2: Mehrere Dateien, mehrere Versionen

Eine bestimmte Dateiversion herunterladen

Objekte in Buckets mit aktivierter Versionierung löschen

Eine Löschmarkierung setzen

Eine Löschmarkierung entfernen

Eine Datei dauerhaft aus einem Bucket mit aktivierter Versionierung entfernen

Frühere Dateiversionen mit einer Lebenszyklusrichtlinie automatisch löschen

Die Testumgebung vorbereiten

Das automatische Entfernen früherer Versionen einrichten

Die Lebenszyklusrichtlinie löschen

Die Versionierung aussetzen

Ein Bucket, für den die Versionierung nie aktiviert wurde

Die Versionierung aussetzen

AWS CLI konfigurieren und testen

Im Folgenden konfigurieren Sie AWS CLI zum ersten Mal. Falls bereits eine Konfiguration vorhanden ist, passen Sie diese bei Bedarf an die Anforderungen dieses Artikels an.

Schritt 1: AWS CLI konfigurieren

Erstellen Sie zur Konfiguration von AWS CLI das Verzeichnis .aws in Ihrem Benutzerverzeichnis:

mkdir ~/.aws

Erstellen Sie darin eine Textdatei namens credentials

touch ~/.aws/credentials

Wechseln Sie in das Verzeichnis .aws:

cd ~/.aws

Die Auflistung des Verzeichnisinhalts von .aws könnte nun so aussehen:

Öffnen Sie credentials in einem Texteditor Ihrer Wahl, beispielsweise nano oder vim. Für nano lautet der Befehl:

nano credentials

Geben Sie Folgendes ein:

[default]
aws_access_key_id = <<YOUR_ACCESS_KEY>>
aws_secret_access_key = <<YOUR_SECRET_KEY>>

Ersetzen Sie <<YOUR_ACCESS_KEY>> durch Ihren Zugriffsschlüssel und <<YOUR_SECRET_KEY>> durch Ihren geheimen Schlüssel.

Speichern Sie die Datei und schließen Sie den Texteditor.

Die Befehle dieses Artikels enthalten bereits den passenden Endpunkt über den Parameter --endpoint-url. Wählen Sie jeweils den Befehl für Ihre Cloud.

Schritt 2: Die Funktion von AWS CLI überprüfen

Führen Sie list-buckets aus, um die Buckets aufzulisten:

aws s3api list-buckets \
--endpoint-url https://s3.fra1-3.cloudferro.com

Die Ausgabe sollte im JSON-Format erfolgen. Mit den Buckets bucket1 und bucket2 könnte sie so aussehen:

{
    "Buckets": [
        {
            "Name": "bucket1",
            "CreationDate": "2023-11-14T08:55:38.526Z"
        },
        {
            "Name": "bucket2",
            "CreationDate": "2024-01-30T10:11:44.157Z"
        }
    ],
    "Owner": {
        "DisplayName": "my-project",
        "ID": "1234567890abcdefghijklmnopqrstuv"
    }
}

Dabei gilt:

Der Wert des Schlüssels Buckets enthält eine Liste Ihrer Buckets mit Namen und Erstellungsdatum

Der Wert des Schlüssels Owner enthält den Namen und die ID Ihres Projekts

Bemerkung

In diesem Artikel wurden Farben ergänzt, um JSON besser lesbar zu machen. AWS CLI gibt üblicherweise keinen farbigen Text aus.

Bucket-Namen Shell-Variablen zuweisen

Um die Buckets der verschiedenen Beispiele dieses Artikels zu unterscheiden, verwenden Sie folgende Shell-Variablen:

bucket_name1: für die meisten Beispiele dieses Artikels
bucket_name2: zum Hochladen einer Datei in ein Unterverzeichnis
bucket_name3: für die Verwendung einer Lebenszyklusrichtlinie
bucket_name4: für einen Bucket, dessen Versionierung nie aktiviert wurde, als Einführung zum Aussetzen der Versionierung
bucket_name5: als Beispiel für das Aussetzen der Versionierung

Wählen Sie Namen für diese fünf Buckets. Beachten Sie die Namensregeln aus Voraussetzung Nr. 4.

Weisen Sie die Namen den Variablen zu, beispielsweise:

bucket_name1="versioning-test"
bucket_name2="examplebucket"
bucket_name3="testnoncurrent"
bucket_name4="no-versioning"
bucket_name5="anotherbucket"

Wichtig

Die Shell-Variablen gelten nur, solange Ihre Terminalsitzung aktiv ist. In einer neuen Sitzung müssen Sie sie erneut zuweisen. Notieren Sie daher die Werte, damit sie nicht verloren gehen.

Um den Inhalt einer Shell-Variablen als Befehlsargument zu verwenden, stellen Sie ihrem Namen $ voran. Beispiel für das Erstellen eines Buckets mit dem Namen aus $bucket_name1, wobei <<SOME_URL>> die Endpunkt-URL ist:

aws s3api create-bucket \
--endpoint-url <<SOME_URL>> \
--bucket $bucket_name1

Eindeutige Bucket-Namen sicherstellen

Wenn in Ihrer Cloud Single Tenancy aktiviert ist, muss der Bucket-Name innerhalb der gesamten Cloud eindeutig sein. Buckets namens versioning-test, examplebucket usw. können bereits existieren. In diesem Fall sieht die Ausgabe von create-bucket so aus:

argument of type 'NoneType' is not iterable

Für eindeutige Namen können Sie beispielsweise eine eindeutige Zeichenfolge an den Basisnamen des Buckets anhängen, etwa

Ihre Initialen,

Datum und Uhrzeit,

eine Zufallszahl,

eine UUID (zufällige Folge von Zeichen und Ziffern)

oder eine Kombination dieser Methoden.

Unter Ubuntu 22.04 können Sie beispielsweise mit uuidgen eine UUID erzeugen:

uuidgen

Die Ausgabe sollte eine UUID enthalten:

889fa8de-9623-4735-99c7-9f1567e2a965

Kopieren Sie diese erzeugte Nummer und ergänzen Sie damit den Bucket-Namen, beispielsweise:

bucket_name1="versioning-test-889fa8de-9623-4735-99c7-9f1567e2a965"

Wiederholen Sie dies bei Bedarf für jede Variable.

Bewahren Sie die Bucket-Namen an einem sicheren Ort auf. Es gibt zwei mögliche Szenarien:

Vorhandene Buckets weiterverwenden: Möglicherweise wurde das Terminal neu gestartet und Sie möchten den Artikel weiter durcharbeiten. Oder Sie haben bereits anhand dieses Artikels Buckets erstellt und möchten diese weiterverwenden.
Vorhandene Buckets nicht verwenden: Arbeiten Sie den Artikel mit einer neuen, leeren Umgebung durch. Dies ist das übliche Vorgehen, wenn Sie ihn zum ersten Mal verwenden.

Einen Bucket ohne Versionierung erstellen

Der Befehl create-bucket erstellt einen Bucket mit dem gewählten Namen aus $bucket_name1.

aws s3api create-bucket \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1

Bei erfolgreicher Ausführung sollte dieser Befehl keine Ausgabe erzeugen.

Die Versionierung für einen Bucket aktivieren

Aktivieren Sie die Versionierung für $bucket_name1 mit put-bucket-versioning:

aws s3api put-bucket-versioning \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--versioning-configuration MFADelete=Disabled,Status=Enabled

Bemerkung

Bei Amazon Web Services erhöht MFADelete die Sicherheit, indem beim Ändern des Versionierungsstatus oder Entfernen einer Dateiversion zwei Authentifizierungsfaktoren erforderlich sind. Hier wird diese Funktion zur Vereinfachung deaktiviert.

Auch dieser Befehl sollte keine Ausgabe erzeugen.

Eine Datei hochladen

Laden Sie eine Datei in das Stammverzeichnis Ihres Containers hoch. Im Beispiel heißt sie something.txt und enthält den Text This is version 1.

Führen Sie im Verzeichnis mit dieser Datei put-object aus, um sie in Ihren Bucket hochzuladen:

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com\
--bucket $bucket_name1 \
--body something.txt \
--key something.txt

Die Parameter dieses Befehls bedeuten:

--body: Name der Datei im lokalen Dateisystem
--key: Speicherort, beispielsweise der Dateiname, unter dem die Datei im Container abgelegt wird.

Die Ausgabe sieht etwa so aus:

{
    "ETag": "\"a4d8980efbd9b71f416595a3d5588b32\"",
    "VersionId": "whrj2pDFrrFq0WLdH0zGzprfkebQykf"
}

Mit diesem Upload wurde die erste Dateiversion erstellt. Ihre ID lautet whrj2pDFrrFq0WLdH0zGzprfkebQykf, der Wert des Schlüssels VersionId. Notieren Sie sie für den späteren Zugriff auf den Bucket.

Die Ausgabe enthält außerdem den Schlüssel ETag, einen Hashwert des hochgeladenen Objekts.

S3-Pfade

Der Parameter --key des Befehls put-object kann auch in anderen Befehlen verwendet werden, um auf bereits hochgeladene Objekte im Container zu verweisen.

Wird er wie im obigen Beispiel ohne Schrägstriche verwendet, liegt die Datei im Stammverzeichnis.

Liegt die Datei außerhalb des Stammverzeichnisses, muss --key das zugehörige Verzeichnis enthalten. Trennen Sie Verzeichnisse und Dateien durch Schrägstriche (/). Anders als im Linux-Dateisystem darf der Pfad nicht mit einem Schrägstrich beginnen. Wenn Ihr Bucket Folgendes enthält:

ein Verzeichnis place1, darin

ein weiteres Verzeichnis place2, darin wiederum

eine Datei namens

myfile.txt

geben Sie den Pfad für --key so an:

--key place1/place2/myfile.txt

Zum Üben können Sie einen neuen Bucket erstellen, dessen Name in $bucket2 gespeichert ist

aws s3api create-bucket \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name2

Erstellen Sie anschließend myfile.txt und laden Sie die Datei in das oben genannte Verzeichnis dieses Buckets hoch:

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name2 \
--body myfile.txt \
--key place1/place2/myfile.txt

Eine weitere Dateiversion hochladen

Kehren Sie nun zu $bucket_name1 zurück

Im Stammverzeichnis des Containers in der Cloud liegt bereits something.txt.

Ändern Sie die lokale Datei so, dass sie die Zeichenfolge This is version 2 enthält.

Laden Sie die geänderte Datei mit demselben Befehl put-object an denselben Speicherort im Bucket hoch:

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--key something.txt \
--body something.txt

Die Ausgabe ist ähnlich, enthält diesmal jedoch eine andere VersionId: whrj2pDFrrFq0WLdH0zGzprfkebQykf.

{
    "ETag": "\"ded190b85763d32ce9c09a8aef51f44c\"",
    "VersionId": "t22ZzEq6kt5ILKFfLZgoeSzW.I9HVtN"
}

Führen Sie list-objects aus, um alle Dateien dieses Buckets aufzulisten:

aws s3api list-objects \
--bucket $bucket_name1 \
--endpoint-url https://s3.fra1-3.cloudferro.com

Die Ausgabe sieht etwa so aus:

{
    "Contents": [
        {
            "Key": "something.txt",
            "LastModified": "2024-08-23T10:32:30.259Z",
            "ETag": "\"ded190b85763d32ce9c09a8aef51f44c\"",
            "Size": 18,
            "StorageClass": "STANDARD",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Die Parameter bedeuten:

Key: Name und/oder Pfad der Datei.
LastModified: Zeitstempel der letzten Änderung.
Etag: Hashwert der Datei.
Size: Dateigröße in Byte.
StorageClass: Angaben zur Speicherklasse, in diesem Beispiel STANDARD.
Owner: Angaben zu Ihrem Projekt: Name (Parameter DisplayName) und ID.

Im obigen Beispiel enthält der Bucket weiterhin nur eine Datei: something.txt. Der Upload hat sie mit einer neuen Version überschrieben, die vorherige Version bleibt jedoch erhalten.

Verfügbare Dateiversionen auflisten

Beispiel 1: Eine Datei, zwei Versionen

Verwenden Sie list-object-versions, um die verfügbaren Dateiversionen in diesem Bucket aufzulisten:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1

Die Ausgabe könnte so aussehen:

{
    "Versions": [
        {
            "ETag": "\"ded190b85763d32ce9c09a8aef51f44c\"",
            "Size": 18,
            "StorageClass": "STANDARD",
            "Key": "something.txt",
            "VersionId": "t22ZzEq6kt5ILKFfLZgoeSzW.I9HVtN",
            "IsLatest": true,
            "LastModified": "2024-08-23T10:32:30.259Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"a4d8980efbd9b71f416595a3d5588b32\"",
            "Size": 18,
            "StorageClass": "STANDARD",
            "Key": "something.txt",
            "VersionId": "whrj2pDFrrFq0WLdH0zGzprfkebQykf",
            "IsLatest": false,
            "LastModified": "2024-08-23T10:19:24.943Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Sie enthält die beiden zuvor erstellten Versionen. Jede besitzt eine eigene ID als Wert von VersionId:

Zuordnung von Key und VersionId
Key	VersionId
something.txt	t22ZzEq6kt5ILKFfLZgoeSzW.I9HVtN
something.txt	whrj2pDFrrFq0WLdH0zGzprfkebQykf

Beide gehören zur selben Datei something.txt.

Beispiel 2: Mehrere Dateien, mehrere Versionen

Betrachten Sie nun eine andere Situation mit zwei Dateien, von denen eine zwei Versionen besitzt.

Die Ausgabe von list-object-versions könnte dann so aussehen:

{
    "Versions": [
        {
            "ETag": "\"adda90afa69e725c2f551e0722014726\"",
            "Size": 575,
            "StorageClass": "STANDARD",
            "Key": "something1.txt",
            "VersionId": "kv7QRQsfHhEe-T6c9g-v3uIPoyX6FTs",
            "IsLatest": true,
            "LastModified": "2024-08-26T16:10:49.979Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890qwertyuiopasdfghjklzxc"
            }
        },
        {
            "ETag": "\"947073995b23baa9a565cf21bf56a2ba\"",
            "Size": 6,
            "StorageClass": "STANDARD",
            "Key": "something2.txt",
            "VersionId": "no1KrA3MbEtjIk1CnN5U.rTtFKFXSpj",
            "IsLatest": true,
            "LastModified": "2024-08-26T16:12:29.961Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890qwertyuiopasdfghjklzxc"
            }
        },
        {
            "ETag": "\"7d7b28bafa5222d9083fa4ea7e97cff6\"",
            "Size": 106,
            "StorageClass": "STANDARD",
            "Key": "something2.txt",
            "VersionId": "gRYReY1SpVI3rS-Qp0NYDPofoAfGfc7",
            "IsLatest": false,
            "LastModified": "2024-08-26T16:11:21.584Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890qwertyuiopasdfghjklzxc"
            }
        }
    ],
    "RequestCharged": null
 }

Zuordnung von Key und VersionId
Key	VersionId
something1.txt	kv7QRQsfHhEe-T6c9g-v3uIPoyX6FTs
something2.txt	no1KrA3MbEtjIk1CnN5U.rTtFKFXSpj
something2.txt	gRYReY1SpVI3rS-Qp0NYDPofoAfGfc7

Die Datei something1.txt besitzt eine Version, die Datei something2.txt zwei Versionen.

Eine bestimmte Dateiversion herunterladen

Kehren Sie zu $bucket_name1 zurück.

Um die Version von something.txt mit der VersionId whrj2pDFrrFq0WLdH0zGzprfkebQykf aus diesem Bucket herunterzuladen, verwenden Sie get-object:

aws s3api get-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--key something.txt \
--version-id whrj2pDFrrFq0WLdH0zGzprfkebQykf \
./something.txt

Dabei gilt:

--key: Name und/oder Speicherort der Datei im Bucket
--version-id: ID der gewünschten Dateiversion
./something.txt: Name und/oder Speicherort im lokalen Dateisystem, unter dem die Datei gespeichert werden soll. Eine dort bereits vorhandene Datei wird überschrieben.

Die Datei sollte heruntergeladen werden und die Ausgabe etwa so aussehen:

{
    "AcceptRanges": "bytes",
    "LastModified": "Fri, 23 Aug 2024 10:19:24 GMT",
    "ContentLength": 18,
    "ETag": "\"a4d8980efbd9b71f416595a3d5588b32\"",
    "VersionId": "whrj2pDFrrFq0WLdH0zGzprfkebQykf",
    "ContentType": "binary/octet-stream",
    "Metadata": {}
}

Die Datei sollte im aktuellen Arbeitsverzeichnis liegen:

Die Anzeige ihres Inhalts mit cat bestätigt, dass es sich um die erste Dateiversion handelt:

Objekte in Buckets mit aktivierter Versionierung löschen

AWS CLI enthält delete-object zum Löschen von Dateien in Buckets. Das Verhalten hängt von den Umständen ab:

In gewöhnlichen Buckets wird die angegebene Datei gelöscht.

In Buckets mit aktivierter Versionierung gibt es zwei Möglichkeiten:

Die zu löschende Version wird nicht angegeben: Der Befehl löscht die Datei nicht, sondern setzt eine Löschmarkierung.
Die zu löschende Version wird angegeben: Die angegebene Version wird dauerhaft gelöscht.

Es folgen Beispiele für Buckets mit aktivierter Versionierung.

Eine Löschmarkierung setzen

Der Befehl zum Löschen von Dateien aus Buckets lautet delete-object.

Versuchen Sie, something.txt aus $bucket_name1 zu löschen, OHNE eine Version anzugeben:

aws s3api delete-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--key something.txt

Dieser Befehl sollte eine Ausgabe wie diese liefern:

{
    "DeleteMarker": true,
    "VersionId": "A0hVZCX0z6yMrlmoYymeaGPT4nzInS2"
}

Die soeben gesetzte Markierung blendet die Datei bei einer gewöhnlichen Dateiauflistung aus. Die VersionId benötigen Sie beispielsweise, um die Markierung zu entfernen und die Datei wiederherzustellen.

Um die Wirkung von delete-object zu prüfen, listen Sie die Objekte erneut mit list-objects auf:

aws s3api list-objects \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1

Diesmal werden keine Dateien aufgelistet. Die Datei something.txt ist ausgeblendet.

Wenn keine Dateien aufgelistet werden können, erhalten Sie möglicherweise folgende Ausgabe:

{
    "RequestCharged": null
}

Oder die Ausgabe bleibt leer.

Wenn Sie die Dateiversionen im Bucket mit list-object-versions auflisten, beispielsweise:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1

sehen Sie, dass die vorherigen Versionen weiterhin vorhanden sind:

{
    "Versions": [
        {
            "ETag": "\"ded190b85763d32ce9c09a8aef51f44c\"",
            "Size": 18,
            "StorageClass": "STANDARD",
            "Key": "something.txt",
            "VersionId": "t22ZzEq6kt5ILKFfLZgoeSzW.I9HVtN",
            "IsLatest": false,
            "LastModified": "2024-08-23T10:32:30.259Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"a4d8980efbd9b71f416595a3d5588b32\"",
            "Size": 18,
            "StorageClass": "STANDARD",
            "Key": "something.txt",
            "VersionId": "whrj2pDFrrFq0WLdH0zGzprfkebQykf",
            "IsLatest": false,
            "LastModified": "2024-08-23T10:19:24.943Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "DeleteMarkers": [
        {
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            },
            "Key": "something.txt",
            "VersionId": "A0hVZCX0z6yMrlmoYymeaGPT4nzInS2",
            "IsLatest": true,
            "LastModified": "2024-08-23T11:28:48.128Z"
        }
    ],
    "RequestCharged": null
}

Neben den zuvor hochgeladenen Versionen finden Sie eine Löschmarkierung unter DeleteMarkers mit der Versions-ID A0hVZCX0z6yMrlmoYymeaGPT4nzInS2.

Bemerkung

Falls Ihr Bucket weitere Dateien enthält, werden diese ebenfalls aufgelistet.

Auch im Horizon-Dashboard ist die Datei ausgeblendet:

Obwohl die Datei nicht sichtbar ist, wird die Bucket-Größe weiterhin korrekt mit 36 Byte angezeigt. Jede gespeicherte Version jeder Datei trägt zur Gesamtgröße bei.

Die Löschmarkierung entfernen

Um die Datei wieder sichtbar zu machen, löschen Sie ihre Löschmarkierung mit delete-object und geben deren VersionID an:

aws s3api delete-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--key something.txt \
--version-id A0hVZCX0z6yMrlmoYymeaGPT4nzInS2

Dabei gilt:

something.txt ist der Dateiname

A0hVZCX0z6yMrlmoYymeaGPT4nzInS2 ist die VersionID der Löschmarkierung aus dem vorherigen Abschnitt dieses Artikels.

Warnung

Achten Sie auf die richtige VersionID, damit Sie keine wichtigen Daten versehentlich löschen!

Sie erhalten folgende Ausgabe:

{
    "DeleteMarker": true,
    "VersionId": "A0hVZCX0z6yMrlmoYymeaGPT4nzInS2"
}

Listen Sie die Objektversionen erneut mit list-object-versions auf:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1

Die Löschmarkierung ist nicht mehr vorhanden:

{
    "Versions": [
        {
            "ETag": "\"ded190b85763d32ce9c09a8aef51f44c\"",
            "Size": 18,
            "StorageClass": "STANDARD",
            "Key": "something.txt",
            "VersionId": "t22ZzEq6kt5ILKFfLZgoeSzW.I9HVtN",
            "IsLatest": true,
            "LastModified": "2024-08-23T10:32:30.259Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"a4d8980efbd9b71f416595a3d5588b32\"",
            "Size": 18,
            "StorageClass": "STANDARD",
            "Key": "something.txt",
            "VersionId": "whrj2pDFrrFq0WLdH0zGzprfkebQykf",
            "IsLatest": false,
            "LastModified": "2024-08-23T10:19:24.943Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Wenn Sie die Dateien mit list-objects auflisten:

s3api list-objects \
--bucket $bucket_name1 \
--endpoint-url https://s3.fra1-3.cloudferro.com

erscheint wieder eine Datei: something.txt:

{
    "Contents": [
        {
            "Key": "something.txt",
            "LastModified": "2024-08-23T10:32:30.259Z",
            "ETag": "\"ded190b85763d32ce9c09a8aef51f44c\"",
            "Size": 18,
            "StorageClass": "STANDARD",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Die Datei sollte nun auch in Horizon wieder sichtbar sein:

Im Screenshot ist die sichtbare Datei 18 Byte groß, der gesamte Bucket jedoch 36 Byte. Die Gesamtgröße umfasst beide gespeicherten Dateiversionen.

Dateien dauerhaft aus einem Bucket mit aktivierter Versionierung entfernen

Gespeicherte Dateiversionen können Sie genauso löschen wie die zuvor beschriebene Löschmarkierung.

Die beiden Versionen von something.txt, t22ZzEq6kt5ILKFfLZgoeSzW.I9HVtN und whrj2pDFrrFq0WLdH0zGzprfkebQykf, sind weiterhin in $bucket_name1 vorhanden.

Löschen Sie die erste Version dauerhaft mit delete-object, ähnlich wie beim Entfernen der Löschmarkierung. Geben Sie hier die VersionID der zu entfernenden Dateiversion an.

aws s3api delete-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--key something.txt \
--version-id t22ZzEq6kt5ILKFfLZgoeSzW.I9HVtN

Sie sollten eine Ausgabe wie diese erhalten:

{
    "VersionId": "t22ZzEq6kt5ILKFfLZgoeSzW.I9HVtN"
}

Wenn Sie die Dateiversionen im Bucket mit list-object-versions auflisten:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1

zeigt die Ausgabe nur noch eine Version einer Datei:

{
    "Versions": [
        {
            "ETag": "\"a4d8980efbd9b71f416595a3d5588b32\"",
            "Size": 18,
            "StorageClass": "STANDARD",
            "Key": "something.txt",
            "VersionId": "whrj2pDFrrFq0WLdH0zGzprfkebQykf",
            "IsLatest": true,
            "LastModified": "2024-08-23T10:19:24.943Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Im Horizon-Dashboard ist die Gesamtgröße des Buckets auf 18 Byte gesunken:

Wenn Sie die letzte Version mit delete-object löschen,

aws s3api delete-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--key something.txt \
--version-id whrj2pDFrrFq0WLdH0zGzprfkebQykf

sollte die letzte Datei aus dem Horizon-Dashboard verschwinden und die Bucket-Größe auf null Byte sinken:

Wenn Sie nun list-object-versions ausführen:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1

sehen Sie, dass keine Dateien oder Versionen mehr vorhanden sind:

{
    "RequestCharged": null
}

Frühere Dateiversionen mit einer Lebenszyklusrichtlinie automatisch löschen

„Noncurrent version“ bezeichnet jede Dateiversion, die nicht die neueste ist. In diesem Abschnitt konfigurieren Sie die automatische Löschung solcher Versionen nach einer festgelegten Anzahl von Tagen.

Dafür verwenden Sie eine Lebenszyklusrichtlinie (Lifecycle Policy).

Im Beispiel werden ältere Dateiversionen automatisch einen Tag nach dem Hochladen einer neueren Version derselben Datei entfernt.

Die Testumgebung vorbereiten

Erstellen Sie zum Testen einen Bucket mit dem Namen aus $bucket_name3 und aktivieren Sie die Versionierung:

aws s3api create-bucket \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name3

aws s3api put-bucket-versioning \
--endpoint-url https://s3.fra1-3.cloudferro.com}} \
--bucket $bucket_name3 \
--versioning-configuration MFADelete=Disabled,Status=Enabled

Angenommen, Sie befinden sich in einem Verzeichnis mit folgenden zwei Dateien:

mycode.py

announcement.md

Der konkrete Inhalt dieser Dateien ist hier nicht relevant.

Laden Sie die Dateien mit dem üblichen Befehl put-object in $bucket_name3 hoch:

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--body mycode.py \
--key mycode.py

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--body announcement.md \
--key announcement.md

Führen Sie nach dem Upload list-object-versions für den Bucket aus, um die Dateien anzuzeigen:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name3

Sie erhalten folgende Ausgabe:

{
    "Versions": [
        {
            "ETag": "\"d185982da39fb33854a5b49c8e416e07\"",
            "Size": 34,
            "StorageClass": "STANDARD",
            "Key": "announcement.md",
            "VersionId": "r714CQ6MLAo4l300Fv9iBCqfNpESPpN",
            "IsLatest": true,
            "LastModified": "2024-10-04T14:51:26.015Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"6cf02e36dd1dc8b58ea77ba4a94291f2\"",
            "Size": 21,
            "StorageClass": "STANDARD",
            "Key": "mycode.py",
            "VersionId": ".qBE6Dx91dxnU7aYOzmBMM1qRg3QwAx",
            "IsLatest": true,
            "LastModified": "2024-10-04T14:51:41.115Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Ändern Sie zum Testen der automatischen Löschung früherer Versionen die lokale Datei mycode.py und laden Sie sie erneut mit put-object hoch:

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name3 \
--body mycode.py \
--key mycode.py

Ein erneuter Aufruf von list-object-versions:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name3

bestätigt, dass eine Datei zwei Versionen und die andere nur eine Version besitzt:

{
    "Versions": [
        {
            "ETag": "\"d185982da39fb33854a5b49c8e416e07\"",
            "Size": 34,
            "StorageClass": "STANDARD",
            "Key": "announcement.md",
            "VersionId": "r714CQ6MLAo4l300Fv9iBCqfNpESPpN",
            "IsLatest": true,
            "LastModified": "2024-10-04T14:51:26.015Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"3a474b21ab418d007ad677262dfed5b6\"",
            "Size": 39,
            "StorageClass": "STANDARD",
            "Key": "mycode.py",
            "VersionId": "tYJ6IazGryIWjv4iwSM1mLTW4-AnhMN",
            "IsLatest": true,
            "LastModified": "2024-10-04T14:55:07.223Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"6cf02e36dd1dc8b58ea77ba4a94291f2\"",
            "Size": 21,
            "StorageClass": "STANDARD",
            "Key": "mycode.py",
            "VersionId": ".qBE6Dx91dxnU7aYOzmBMM1qRg3QwAx",
            "IsLatest": false,
            "LastModified": "2024-10-04T14:51:41.115Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Anders als die übrigen gespeicherten Dateiversionen hat die erste Version von mycode.py unter IsLatest den Wert false. Damit ist sie als frühere Version gekennzeichnet.

Das automatische Entfernen früherer Versionen einrichten

Die Lebenszyklusrichtlinie wird in JSON geschrieben. Erstellen Sie noncurrent-policy.json im aktuellen Arbeitsverzeichnis. Dies muss nicht das Verzeichnis mit Ihren Zugangsdaten sein. Tragen Sie folgenden Code ein:

{
   "Rules": [
      {
         "ID": "NoncurrentVersionExpiration",
         "Filter": {
            "Prefix": ""
         },
         "Status": "Enabled",
         "NoncurrentVersionExpiration": {
            "NoncurrentDays": 1
         }
      }
   ]
}

Ersetzen Sie 1 durch die Anzahl der Tage, nach denen frühere Versionen gelöscht werden sollen.

In diesem Beispiel wenden Sie die Richtlinie mit put-bucket-lifecycle-configuration auf $bucket_name1 an:

aws s3api put-bucket-lifecycle-configuration \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name3 \
--lifecycle-configuration file://noncurrent-policy.json

Die Ausgabe sollte leer sein.

Prüfen Sie mit get-bucket-lifecycle-configuration, ob die Richtlinie angewendet wurde:

aws s3api get-bucket-lifecycle-configuration \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name3

Die Ausgabe sollte Ihre angewendete Richtlinie enthalten:

{
    "Rules": [
        {
            "ID": "NoncurrentVersionExpiration",
            "Filter": {
                "Prefix": ""
            },
            "Status": "Enabled",
            "NoncurrentVersionExpiration": {
                "NoncurrentDays": 1
            }
        }
    ]
}

Dateiversionen, die nicht die neuesten sind, sollten nun nach einem Tag entfernt werden.

Wenn Sie sich in diesem Beispiel nach einem Tag erneut anmelden und list-object-versions ausführen:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name3

sehen Sie, dass die frühere Version von mycode.py gelöscht wurde:

{
    "Versions": [
        {
            "ETag": "\"d185982da39fb33854a5b49c8e416e07\"",
            "Size": 34,
            "StorageClass": "STANDARD",
            "Key": "announcement.md",
            "VersionId": "r714CQ6MLAo4l300Fv9iBCqfNpESPpN",
            "IsLatest": true,
            "LastModified": "2024-10-04T14:51:26.015Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"3a474b21ab418d007ad677262dfed5b6\"",
            "Size": 39,
            "StorageClass": "STANDARD",
            "Key": "mycode.py",
            "VersionId": "tYJ6IazGryIWjv4iwSM1mLTW4-AnhMN",
            "IsLatest": true,
            "LastModified": "2024-10-04T14:55:07.223Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Die Lebenszyklusrichtlinie löschen

Der Befehl delete-bucket-lifecycle löscht die Lebenszyklusrichtlinie eines Buckets. Für $bucket_name3 gehen Sie so vor:

aws s3api delete-bucket-lifecycle \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name3

Dieser Befehl sollte keine Ausgabe erzeugen.

Prüfen Sie zur Bestätigung erneut die aktuelle Lebenszykluskonfiguration:

aws s3api get-bucket-lifecycle-configuration \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name3

Der Befehl sollte entweder keine Ausgabe oder Folgendes zurückgeben:

argument of type 'NoneType' is not iterable

Die Richtlinie sollte nun nicht mehr gelten.

Die Versionierung aussetzen

Wenn Sie keine mehreren Dateiversionen mehr speichern möchten, können Sie die Versionierung aussetzen.

Ein Bucket, für den die Versionierung nie aktiviert wurde

Betrachten Sie zum besseren Verständnis zunächst einen Bucket, für den die Versionierung nie aktiviert wurde.

In einem solchen Bucket besitzt jede Datei nur eine Version mit derselben ID: null.

Wenn Sie eine weitere Datei unter demselben Namen hochladen, hat auch sie die VersionID null und ersetzt die zuvor hochgeladene Datei.

Beispiel

Erstellen Sie für dieses Beispiel $bucket_name4, dessen Versionierung nie aktiviert wurde.

aws s3api create-bucket \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name4

Buckets können unterschiedliche Dateitypen enthalten. Nehmen Sie für dieses Beispiel an, dass der Bucket folgende drei Dateien verschiedener Typen enthält:

Datei und zugehöriger Editor
Datei	Editor
document.odt	LibreOffice
screenshot1.png	GIMP, Krita usw.
script.sh	nano, vim usw.

Der konkrete Inhalt dieser Dateien ist hier nicht relevant. Erstellen Sie sie mit den Editoren aus der Tabelle und laden Sie sie anschließend mit put-object hoch:

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--body document.odt \
--key document.odt

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--body screenshot1.png \
--key screenshot1.png

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name1 \
--body script.sh \
--key script.sh

Führen Sie zunächst den bereits erwähnten Befehl list-object-versions für diesen Bucket aus:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name4

Beispielausgabe:

{
    "Versions": [
        {
            "ETag": "\"5064a9c6200fd7dae7c25f2ed01a6f8f\"",
            "Size": 9639,
            "StorageClass": "STANDARD",
            "Key": "document.odt",
            "VersionId": "null",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:19:02.425Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"e3fedcd58235e90e7a676a84cd6c7ee6\"",
            "Size": 174203,
            "StorageClass": "STANDARD",
            "Key": "screenshot1.png",
            "VersionId": "null",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:17:17.085Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"5600fdc5aa752cba9895d985a9cf709e\"",
            "Size": 36,
            "StorageClass": "STANDARD",
            "Key": "script.sh",
            "VersionId": "null",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:17:47.206Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Alle Dateien besitzen nur eine Version mit der ID null.

Ändern Sie nun eine der drei Dateien lokal, hier script.sh, und laden Sie die geänderte Version unter demselben Namen und Schlüssel hoch.

Führen Sie dazu im Verzeichnis mit dieser Datei folgenden put-object-Befehl aus:

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name4 \
--body script.sh \
--key script.sh

Zur Bestätigung sollten Sie eine Ausgabe mit ETag erhalten:

{
    "ETag": "\"b6b82cb2376934bcf6877705bae6ac58\""
}

Wenn Sie die Objektversionen erneut mit list-object-versions auflisten:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name4

sollte die Ausgabe etwa so aussehen:

{
    "Versions": [
        {
            "ETag": "\"5064a9c6200fd7dae7c25f2ed01a6f8f\"",
            "Size": 9639,
            "StorageClass": "STANDARD",
            "Key": "document.odt",
            "VersionId": "null",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:19:02.425Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"e3fedcd58235e90e7a676a84cd6c7ee6\"",
            "Size": 174203,
            "StorageClass": "STANDARD",
            "Key": "screenshot1.png",
            "VersionId": "null",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:17:17.085Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"b6b82cb2376934bcf6877705bae6ac58\"",
            "Size": 60,
            "StorageClass": "STANDARD",
            "Key": "script.sh",
            "VersionId": "null",
            "IsLatest": true,
            "LastModified": "2024-10-02T10:16:11.589Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Erneut sind drei Dateien mit jeweils genau einer gespeicherten Version vorhanden. script.sh wurde beim Upload überschrieben. Ihre Werte für Size, ETag und LastModified (Zeitstempel der letzten Änderung) haben sich geändert.

Die Versionierung aussetzen

Nach dem Aussetzen der Versionierung verhält sich Ihr Bucket ähnlich wie ein Bucket, für den sie nie aktiviert wurde. Alle ab diesem Zeitpunkt hochgeladenen Dateien erhalten null als VersionId.

Angenommen, Sie laden danach eine Datei unter demselben key hoch, also mit demselben Namen und Speicherort wie eine vorhandene Datei. Das weitere Verhalten hängt davon ab, ob bereits eine Version dieser Datei mit der VersionID null existiert:

Existiert keine Version mit null als VersionId, wird der Upload zu einer neuen Version dieser Datei.

Existiert eine Version mit null als VersionId, überschreibt der Upload die vorherige Version mit der VersionId null.

In beiden Fällen hat die neu hochgeladene Version die VersionId null.

Dieses Überschreiben erfolgt auch dann, wenn die Version mit null als VersionId die einzige verbleibende Dateiversion ist.

Das Aussetzen der Versionierung beeinflusst für sich genommen keine zuvor gespeicherten Versionen, deren VersionId nicht null ist. Sie können diese bei Bedarf manuell löschen.

Erstellen Sie zur Veranschaulichung einen neuen Bucket $bucket_name5:

aws s3api create-bucket \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name5

Aktivieren Sie anschließend die Versionierung:

aws s3api put-bucket-versioning \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name5 \
--versioning-configuration MFADelete=Disabled,Status=Enabled

Laden Sie einige Dateien mit put-object in diesen Bucket hoch. Stellen Sie sicher, dass mindestens eine davon mehrere Versionen besitzt.

In diesem Beispiel enthält der Bucket folgende Dateien:

Zuordnung von Key und VersionId
Key	VersionId
file1.txt	CTv9FT1Wp9pxDZdlZXx2cJ5C2juPNA6
file1.txt	eaJNZLZTqtPAq9l09Nrm-CN-UAVtFHQ
file2.txt	HVRcuAOQ.gpqiU50mJkdAj4bAvgfCFN

Alle Versionen können Sie mit list-object-versions auflisten:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name5

Die Ausgabe:

{
    "Versions": [
        {
            "ETag": "\"1f5f1ebe10ac3457ca87427e1772d71f\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file1.txt",
            "VersionId": "CTv9FT1Wp9pxDZdlZXx2cJ5C2juPNA6",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:28:47.501Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"174b29d6d688c2b34f6c1bb7361a8b7e\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file1.txt",
            "VersionId": "eaJNZLZTqtPAq9l09Nrm-CN-UAVtFHQ",
            "IsLatest": false,
            "LastModified": "2024-09-16T11:28:10.006Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"174b29d6d688c2b34f6c1bb7361a8b7e\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file2.txt",
            "VersionId": "HVRcuAOQ.gpqiU50mJkdAj4bAvgfCFN",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:28:20.830Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Setzen Sie die Versionierung dieses Buckets mit put-bucket-versioning aus:

aws s3api put-bucket-versioning \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name5 \
--versioning-configuration MFADelete=Disabled,Status=Suspended

Dieser Befehl sollte keine Ausgabe erzeugen.

Listen Sie die Dateiversionen erneut mit list-object-versions auf:

aws s3api list-object-versions \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name5

Die Ausgabe zeigt, dass die bisherigen Dateiversionen nicht entfernt wurden:

{
    "Versions": [
        {
            "ETag": "\"1f5f1ebe10ac3457ca87427e1772d71f\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file1.txt",
            "VersionId": "CTv9FT1Wp9pxDZdlZXx2cJ5C2juPNA6",
            "IsLatest": false,
            "LastModified": "2024-09-16T11:28:47.501Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"174b29d6d688c2b34f6c1bb7361a8b7e\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file1.txt",
            "VersionId": "eaJNZLZTqtPAq9l09Nrm-CN-UAVtFHQ",
            "IsLatest": false,
            "LastModified": "2024-09-16T11:28:10.006Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"174b29d6d688c2b34f6c1bb7361a8b7e\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file2.txt",
            "VersionId": "HVRcuAOQ.gpqiU50mJkdAj4bAvgfCFN",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:28:20.830Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Anschließend

ändern Sie den Inhalt der zuvor hochgeladenen Datei file1.txt auf Ihrem lokalen Computer und

laden die Datei erneut mit put-object hoch:

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name5 \
--body file1.txt \
--key file1.txt

Listen Sie nach erfolgreichem Upload erneut alle Dateiversionen im Bucket auf (Befehl list-versions):

{
    "Versions": [
        {
            "ETag": "\"4d3828bb564834c45a522e3492cbdf4a\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file1.txt",
            "VersionId": "null",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:31:01.968Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"1f5f1ebe10ac3457ca87427e1772d71f\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file1.txt",
            "VersionId": "CTv9FT1Wp9pxDZdlZXx2cJ5C2juPNA6",
            "IsLatest": false,
            "LastModified": "2024-09-16T11:28:47.501Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"174b29d6d688c2b34f6c1bb7361a8b7e\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file1.txt",
            "VersionId": "eaJNZLZTqtPAq9l09Nrm-CN-UAVtFHQ",
            "IsLatest": false,
            "LastModified": "2024-09-16T11:28:10.006Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"174b29d6d688c2b34f6c1bb7361a8b7e\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file2.txt",
            "VersionId": "HVRcuAOQ.gpqiU50mJkdAj4bAvgfCFN",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:28:20.830Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Die vorherigen Dateiversionen wurden nicht ersetzt. Stattdessen wurde eine neue Version von file1.txt mit der VersionId null hochgeladen.

Ab jetzt erhält jeder Upload die VersionId null. Falls diese Version der Datei bereits existiert, wird sie ersetzt.

Zur Veranschaulichung

ändern Sie file1.txt erneut auf Ihrem lokalen Computer und

laden die geänderte Version erneut mit put-object hoch:

aws s3api put-object \
--endpoint-url https://s3.fra1-3.cloudferro.com \
--bucket $bucket_name5 \
--body file1.txt \
--key file1.txt

Wenn Sie nach diesem Upload die Versionen noch einmal auflisten, erhalten Sie folgende Ausgabe:

{
    "Versions": [
        {
            "ETag": "\"c96e9d7d1e4655b15493cc31ab7cfc24\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file1.txt",
            "VersionId": "null",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:34:25.528Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"1f5f1ebe10ac3457ca87427e1772d71f\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file1.txt",
            "VersionId": "CTv9FT1Wp9pxDZdlZXx2cJ5C2juPNA6",
            "IsLatest": false,
            "LastModified": "2024-09-16T11:28:47.501Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"174b29d6d688c2b34f6c1bb7361a8b7e\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file1.txt",
            "VersionId": "eaJNZLZTqtPAq9l09Nrm-CN-UAVtFHQ",
            "IsLatest": false,
            "LastModified": "2024-09-16T11:28:10.006Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        },
        {
            "ETag": "\"174b29d6d688c2b34f6c1bb7361a8b7e\"",
            "Size": 10,
            "StorageClass": "STANDARD",
            "Key": "file2.txt",
            "VersionId": "HVRcuAOQ.gpqiU50mJkdAj4bAvgfCFN",
            "IsLatest": true,
            "LastModified": "2024-09-16T11:28:20.830Z",
            "Owner": {
                "DisplayName": "this-project",
                "ID": "1234567890abcdefghijklmnopqrstuv"
            }
        }
    ],
    "RequestCharged": null
}

Erneut gibt es nur eine Version mit null als ID. Der Upload hat die vorherige Version überschrieben. Der Zeitstempel der letzten Änderung (LastModified) hat sich von 2024-09-16T11:31:01.968Z auf 2024-09-16T11:34:25.528Z geändert

Nächste Schritte

AWS CLI ist nicht die einzige Möglichkeit für den Zugriff auf Object Storage. Weitere Möglichkeiten sind:

Horizon-Dashboard: Wie verwendet man den Objektspeicher?
s3fs: Wie mountet man Objektspeicher-Container als Dateisystem in Linux mit s3fs?
Rclone: Einhängen eines Objektspeicher-Containers von CODE-DE-Lab als Dateisystem auf einem lokalen Windows-Computer
s3cmd: Wie man auf Objektspeicher auf der CODE-DE-Lab Cloud mit s3cmd zugreift

Still need help?

If this article does not answer all of your questions, the support team will help you.

Contact support