Wersjonowanie obiektów S3 bucket w NSIS

Wersjonowanie bucketów S3 umożliwia przechowywanie różnych wersji pliku przechowywanego w object storage. Oto kilka typowych przypadków użycia:

Odzyskiwanie danych i tworzenie kopii zapasowych

Ochrona przed przypadkowym usunięciem

Współpraca i zarządzanie dokumentami

Testowanie i wycofywanie aplikacji

Śledzenie zmian dla dużych zbiorów danych

Synchronizacja i archiwizacja plików

W tym artykule dowiesz się, jak

skonfigurować wersjonowanie obiektów w bukcet S3 na NSIS OpenStack

pobierać różne wersje plików

skonfigurować automatyczne usuwanie poprzednich wersji.

Wymagania wstępne

Nr 1 Konto

Potrzebne jest konto hostingowe NSIS z dostępem do interfejsu Horizon: https://horizon.cloudferro.com.

Nr 2 AWS CLI zainstalowany na komputerze lokalnym lub maszynie wirtualnej

AWS CLI to darmowe i otwarte oprogramowanie, które może zarządzać różnymi chmurami, nie tylko tymi hostowanymi przez Amazon Web Services. W tym artykule użyjesz go do kontrolowania zasobów hostowanych w chmurze NSIS.

Ten artykuł został napisany dla Ubuntu 22.04. Polecenia mogą działać na innych systemach operacyjnych, ale mogą wymagać dostosowania.

Oto jak zainstalować AWS CLI na Ubuntu 22.04:

sudo apt install awscli

Nr 3 Generowane poświadczenia EC2

Aby uwierzytelnić się w chmurze NSIS podczas korzystania z AWS CLI, musisz użyć poświadczeń EC2. Jeśli jeszcze ich nie masz, sprawdź Jak wygenerować poświadczenia EC2 i zarządzać nimi na NSIS Cloud

Nr 4 Zasady nazewnictwa bucketów

W trakcie tego artykułu utworzysz kilka bukcetów. Upewnij się, że znasz zasady dotyczące dozwolonych znaków w nazwach kontenerów. Zobacz sekcję Tworzenie nowego kontenera przechowywania obiektów w Jak korzystać z Object Storage w NSIS, aby dowiedzieć się więcej.

Nr 5 Terminologia: kontener vs bucket

W tym artykule zarówno „kontener”, jak i „bucket” reprezentują tę samą kategorię zasobów hostowanych w chmurze NSIS. Pierwszy termin jest częściej używany przez pulpit nawigacyjny Horizon, a drugi termin jest częściej używany przez AWS CLI.

Co będziemy omawiać

Konfigurowanie i testowanie AWS CLI

Konfiguracja AWS CLI

Sprawdź, czy AWS CLI działa

Przypisywanie nazw bucketów do zmiennych powłoki

Upewnienie się, że nazwy bukcketów są unikatowe

Tworzenie bucketów bez wersjonowania

Włączanie wersjonowania na bucketów

Przesyłanie pliku

Ścieżki S3

Przesyłanie innej wersji pliku

Wyświetlanie dostępnych wersji pliku

Przykład 1: Jeden plik, dwie wersje

Przykład 2: Wiele plików, wiele wersji

Pobieranie wybranej wersji pliku

Usuwanie obiektów na bucketach z włączoną wersją

Konfigurowanie znacznika usunięcia

Usuwanie znacznika usunięcia

Trwałe usunięcie pliku z bucketu z włączoną wersją

Używanie zasad cyklu życia do konfigurowania automatycznego usuwania poprzednich wersji plików

Przygotowanie środowiska testowego

Konfigurowanie automatycznego usuwania poprzednich wersji

Usuwanie zasad cyklu życia

Zawieszanie wersjonowania

Bucket, w którym nigdy nie włączono wersjonowania

Zawieszenie wersjonowania

Konfigurowanie i testowanie AWS CLI

Poniżej opisano, jak skonfigurować AWS CLI po raz pierwszy; jeśli był już wcześniej skonfigurowany, może być konieczne dostosowanie konfiguracji do potrzeb tego artykułu.

Krok 1: Konfiguracja AWS CLI

Aby skonfigurować AWS CLI, utwórz folder o nazwie .aws w swoim katalogu domowym:

mkdir ~/.aws

Utwórz w nim plik tekstowy o nazwie credentials

touch ~/.aws/credentials

Przejdź do folderu .aws:

cd ~/.aws

Tak może teraz wyglądać lista zawartości folderu .aws:

../_images/s3-bucket-versioning-01_creodias.png

Otwórz plik credentials w wybranym edytorze tekstowym (np. nano lub vim). Jeśli używasz nano, to jest to polecenie:

nano credentials

Wprowadź następujące dane:

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

Zastąp <<YOUR_ACCESS_KEY>> i <<YOUR_SECRET_KEY>> odpowiednio kluczem dostępu i kluczem tajnym.

Zapisz plik i zamknij edytor tekstu.

Polecenia, które udostępniamy w tym artykule, będą już zawierały odpowiedni punkt końcowy za pośrednictwem parametru --endpoint-url, a wszystko, co musisz zrobić, to wybrać polecenie dla używanej chmury.

Krok 2: Sprawdzenie, czy AWS CLI działa

Wykonaj polecenie list-buckets, aby wyświetlić listę bucketów:

aws s3api list-buckets \
--endpoint-url https://s3.waw4-1.cloudferro.com

Dane wyjściowe powinny być w formacie JSON. Jeśli masz wiadro o nazwie bucket1 i inny bucket o nazwie bucket2, tak to może wyglądać:

{
    "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"
    }
}

Tutaj:

Wartość klucza Buckets powinna zawierać listę bucketów (nazwy i daty utworzenia).

Wartość klucza Owner powinna zawierać nazwę i identyfikator projektu.

Informacja

W tym artykule dodano kolory, aby JSON był bardziej czytelny. AWS CLI zazwyczaj nie wyświetla kolorowego tekstu.

Przypisywanie nazw bucketów do zmiennych powłoki

Aby rozróżnić różne buckety używane w różnych przykładach tego artykułu, użyjemy następujących zmiennych powłoki:

bucket_name1: używany w większości przykładów w tym artykule
bucket_name2: do przesyłania pliku do katalogu innego niż główny
bucket_name3: do korzystania z polityki cyklu życia
bucket_name4: bucket, na którym nigdy nie włączono wersjonowania, używane jako wstęp do zawieszenia wersjonowania
bucket_name5: Przykład zawieszenia wersjonowania

Wybierz nazwy dla tych pięciu bucketów. Upewnij się, że przestrzegasz zasad nazewnictwa z punktu 4.

Przypisz nazwy do tych zmiennych, na przykład:

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

Ważne

Zmienne powłoki będą ważne tak długo, jak aktywna jest sesja terminala. Po rozpoczęciu nowej sesji terminala konieczne będzie ponowne przypisanie tych zmiennych. Dlatego należy je gdzieś zapisać, aby ich nie utracić.

Aby użyć zawartości zmiennej powłoki jako argumentu polecenia, należy poprzedzić nazwę zmiennej $. Przykładowe polecenie utworzenia bucketu, którego nazwa przechowywana jest w zmiennej $bucket_name1 (gdzie <<SOME_URL>> to adres URL punktu końcowego):

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

Upewnienie się, że nazwy bucketów są unikatowe

Jeśli w chmurze, z której korzystasz, włączona jest pojedyncza dzierżawa (single tenancy), nazwa twojego bucketa musi być unikalna w całej chmurze. Oznacza to, że nazwy takie jak versioning-test, examplebucket itp. mogą już być zajęte. W takim przypadku wynik polecenia create-bucket będzie wyglądał mniej więcej tak:

argument of type 'NoneType' is not iterable

Aby utworzyć unikalne nazwy, można na przykład dodać unikalny ciąg znaków do podstawowej nazwy bucketa. Rozważmy dodanie

inicjały,

data i godzina

liczba losowa

identyfikator UUID (losowy ciąg znaków i cyfr)

lub nawet połączenie tych metod.

Jako praktyczny przykład, na Ubuntu 22.04, użyj polecenia o nazwie uuidgen, aby wygenerować UUID:

uuidgen

Dane wyjściowe powinny zawierać identyfikator UUID:

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

Następnie można skopiować wygenerowany numer i dodać go na przykład do nazwy bucketa:

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

W razie potrzeby powtórz ten proces dla każdej zmiennej.

Najlepszym rozwiązaniem jest przechowywanie nazw bucketów w bezpiecznym miejscu, ponieważ możliwe są dwa scenariusze:

Ponowne wykorzystanie istniejących bucketów: Być może terminal został w pewnym momencie zrestartowany, ale chcesz kontynuować pracę nad artykułem. Albo wcześniej korzystałeś z artykułu, aby utworzyć kilka bucketów, i teraz chcesz nadal z nich korzystać.
Unikaj używania istniejących bucketów: Przejrzyj artykuł bez wcześniejszego bucketu, stosując podejście „czystej karty”. To jest to, co zwykle robisz, gdy używasz artykułu po raz pierwszy.

Tworzenie bucketu bez wersjonowania

Polecenie create-bucket utworzy bucket pod wybraną nazwą (zmienna $bucket_name1).

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

Wyjście tego polecenia powinno być puste, jeśli wszystko poszło dobrze.

Włączanie wersjonowania na bucket

Aby włączyć wersjonowanie w buckecie $bucket_name1, należy użyć polecenia put-bucket-versioning:

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

Informacja

W Amazon Web Services obecność parametru MFADelete zwiększa bezpieczeństwo, wymagając dwóch czynników bezpieczeństwa podczas zmiany statusu wersjonowania lub usuwania wersji pliku. Tutaj wyłączamy go dla uproszczenia.

Wynik tego polecenia również powinien być pusty.

Przesyłanie pliku

Załóżmy, że przesyłamy plik do katalogu głównego naszego kontenera. Niech nazwa pliku będzie something.txt i niech ma następującą zawartość: This is version 1.

../_images/s3-bucket-versioning-02_creodias.png

Znajdujemy się w folderze zawierającym ten plik i wykonujemy polecenie put-object, aby przesłać plik do naszego bucketu:

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

W tym poleceniu wartościami parametrów są:

--body: nazwa pliku w naszym lokalnym systemie plików
--key: lokalizacja (jak nazwa pliku), pod którą plik ma zostać zapisany w kontenerze.

Otrzymujemy następujące dane wyjściowe:

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

To przesłanie utworzyło pierwszą wersję pliku. ID tej wersji to whrj2pDFrrFq0WLdH0zGzprfkebQykf (wartość klucza VersionId). Możesz go zapisać, ponieważ użyjesz go ponownie, aby uzyskać dostęp do bucketu.

Dane wyjściowe zawierają również klucz ETag, który jest skrótem przesłanego obiektu.

Ścieżki S3

Parametr --key z polecenia put-object może być również użyty w innych poleceniach, aby odwołać się do już przesłanego bucketu w kontenerze.

Jeśli użyty bez ukośników, jak w powyższym przykładzie, plik znajduje się w katalogu głównym.

Jeśli plik znajduje się poza katalogiem głównym, wartość parametru --key musi zawierać katalog, w którym się znajduje. Podając tę ścieżkę, należy oddzielić katalogi i pliki ukośnikami (/). W przeciwieństwie do systemu plików Linux, nie należy dodawać ukośnika na początku ścieżki. Jeśli bucket zawiera

katalog o nazwie place1, który zawiera

inny katalog, place2, który z kolei zawiera

plik o nazwie

myfile.txt

oto jak określić jego ścieżkę dla parametru --key:

--key place1/place2/myfile.txt

Aby poćwiczyć, można utworzyć nowy bucket, którego nazwa jest przechowywana w zmiennej $bucket2

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

Następnie możesz utworzyć plik o nazwie myfile.txt i przesłać go do wyżej wymienionego katalogu tego wiadra:

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

Przesyłanie innej wersji pliku

Wróćmy teraz do $bucket_name1.

Mamy już plik something.txt w katalogu głównym kontenera, w chmurze.

Użyjmy lokalnego komputera, aby zmodyfikować go tak, aby zawierał ciąg To jest wersja 2.

../_images/s3-bucket-versioning-03_creodias.png

Następnie używamy tego samego polecenia, put-object, aby przesłać zmodyfikowany plik do tej samej lokalizacji w buckecie:

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

Wynik jest podobny, ale tym razem zawiera inny VersionId: whrj2pDFrrFq0WLdH0zGzprfkebQykf.

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

Aby wyświetlić listę wszystkich plików w tym zasobniku, wykonaj polecenie list-objects :

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

Wynik będzie podobny do tego:

{
    "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
}

Oto, co oznaczają poszczególne parametry:

Key: nazwa i/lub ścieżka do pliku.
LastModified: znacznik czasu ostatniej modyfikacji pliku.
ETag: skrót pliku.
Size: rozmiar pliku w bajtach.
StorageClass: informacje dotyczące klasy pamięci masowej (w tym przykładzie STANDARD).
Owner: informacje o projekcie - nazwa (parametr DisplayName) i identyfikator.

W powyższym przykładzie bucket nadal zawiera tylko jeden plik - something.txt. To przesłanie nadpisało go nową wersją, ale poprzednia wersja jest nadal obecna.

Wyświetlanie dostępnych wersji pliku

Przykład 1: Jeden plik, dwie wersje

Aby wyświetlić listę dostępnych wersji plików w tym bucket, użyj list-object-versions:

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

Dane wyjściowe mogą wyglądać następująco:

{
    "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
}

Zawiera on dwie utworzone wcześniej wersje. Każda z nich ma swój własny identyfikator, który jest wartością parametru VersionId:

Klucz vs. VersionId
Klucz	VersionId
something.txt	t22ZzEq6kt5ILKFfLZgoeSzW.I9HVtN
something.txt	whrj2pDFrrFq0WLdH0zGzprfkebQykf

Oba są powiązane z tym samym plikiem o nazwie something.txt.

Przykład 2: Wiele plików, wiele wersji

Rozważmy teraz alternatywną sytuację, w której mamy dwa pliki, a jeden z nich ma dwie wersje.

Wynik list-object-versions mógłby wyglądać następująco:

{
    "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
 }

Klucz vs. VersionId
Klucz	VersionId
something1.txt	kv7QRQsfHhEe-T6c9g-v3uIPoyX6FTs
something2.txt	no1KrA3MbEtjIk1CnN5U.rTtFKFXSpj
something2.txt	gRYReY1SpVI3rS-Qp0NYDPofoAfGfc7

Plik something1.txt ma jedną wersję, podczas gdy plik something2.txt ma dwie wersje….

Pobieranie wybranej wersji pliku

Wróćmy do $bucket_name1.

Aby pobrać wersję pliku przechowywanego w tym buckecie o nazwie something.txt, który ma VersionId o wartości whrj2pDFrrFq0WLdH0zGzprfkebQykf, wykonujemy polecenie get-object:

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

W tym poleceniu:

--key: to nazwa i/lub lokalizacja pliku w zasobniku
--version-id: to identyfikator wybranej wersji pliku
./something.txt: to nazwa i/lub lokalizacja w lokalnym systemie plików, do której ma zostać pobrany plik. Jeśli plik już tam jest, zostanie nadpisany.

Plik powinien zostać pobrany i powinniśmy otrzymać następujące dane wyjściowe:

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

Plik powinien znajdować się w naszym bieżącym katalogu roboczym:

../_images/s3-bucket-versioning-04_creodias.png

Wyświetlenie jego zawartości za pomocą polecenia cat ujawnia, że jest to rzeczywiście pierwsza wersja tego pliku:

../_images/s3-bucket-versioning-05_creodias.png

Usuwanie obiektów na bucketach z włączoną wersją

AWS CLI zawiera komendę delete-object, która służy do usuwania plików przechowywanych na bucketach. Zachowuje się ono różnie w zależności od okoliczności:

W przypadku zwykłych bucketów po prostu usunie określony plik.

W przypadku zasobników z włączoną wersją istnieją dwie możliwości:

Wersja do usunięcia nie została określona: Polecenie to nie usunie wskazanego pliku, ale zamiast tego umieści w nim znacznik usunięcia.
Wersja do usunięcia jest określona: Określona wersja zostanie trwale usunięta.

Oto przykłady dla zasobników z włączoną wersją.

Konfigurowanie znacznika usunięcia

Polecenie do usuwania plików z bucketów to delete-object.

Spróbujmy usunąć plik o nazwie something.txt z bucketu $bucket_name1 i NIE określajmy wersji:

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

Polecenie to powinno zwrócić następujące dane wyjściowe:

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

Znacznik, który właśnie umieściliśmy, powoduje, że plik jest niewidoczny podczas normalnego wyświetlania plików. VersionId jest przydatny, jeśli, powiedzmy, chcesz usunąć ten znacznik i przywrócić plik.

Aby w pełni zobaczyć efekt polecenia delete-object, ponownie wylistujemy obiekty za pomocą list-objects:

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

Tym razem dane wyjściowe nie zawierają żadnych plików - plik something.txt stał się niewidoczny.

Jeśli nie ma plików do wylistowania, możesz otrzymać następujące dane wyjściowe:

{
    "RequestCharged": null
}

w przeciwnym razie dane wyjściowe mogą być puste.

Jeśli na przykład wylistujemy wersje plików w naszym buckecie za pomocą list-object-versions:

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

zobaczymy, że poprzednie wersje nadal tam są:

{
    "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
}

Oprócz wcześniej przesłanych wersji można również znaleźć znacznik usuwania (klucz DeleteMarkers) z identyfikatorem wersji A0hVZCX0z6yMrlmoYymeaGPT4nzInS2.

Informacja

Jeśli bucket zawiera dodatkowe pliki, one również zostaną tutaj wymienione.

Na pulpicie nawigacyjnym Horizon plik jest również „niewidoczny”:

../_images/s3-bucket-versioning-06_creodias.png

Nawet jeśli plik nie jest widoczny, rozmiar zasobnika jest nadal wyświetlany poprawnie - 36 bajtów. Każda zapisana wersja każdego pliku zwiększa całkowity rozmiar.

Usuwanie znacznika usunięcia

Aby przywrócić widoczność pliku, należy usunąć jego znacznik usunięcia, wydając polecenie delete-object i określając VersionID znacznika usunięcia:

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

W tym poleceniu:

something.txt to nazwa pliku

A0hVZCX0z6yMrlmoYymeaGPT4nzInS2 to VersionID markera usunięcia, który został uzyskany podczas wykonywania poprzedniej sekcji tego artykułu.

Ostrzeżenie

Upewnij się, że wprowadziłeś poprawny VersionID, aby zapobiec przypadkowemu usunięciu ważnych danych!

Otrzymujemy następujące dane wyjściowe:

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

Jeszcze raz wypiszmy wersje obiektów za pomocą polecenia list-object-versions:

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

Znacznik usunięcia już nie istnieje:

{
    "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
}

A jeśli wylistujemy pliki za pomocą list-objects:

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

dane wyjściowe ponownie pokazują jeden plik - 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
}

Plik powinien być teraz ponownie widoczny w Horizon:

../_images/s3-bucket-versioning-07_creodias.png

Na tym zrzucie ekranu widoczny plik ma rozmiar 18 bajtów, podczas gdy całkowity rozmiar tego bucketu wynosi 36 bajtów. Wynika to z faktu, że całkowity rozmiar obejmuje obie przechowywane wersje pliku.

Trwałe usuwanie plików z buck z włączoną wersją

Wersje plików przechowywanych w zasobniku można usuwać tak samo, jak wcześniej wspomniany znacznik usuwania.

Dwie wersje pliku something.txt, t22ZzEq6kt5ILKFfLZgoeSzW.I9HVtN i whrj2pDFrrFq0WLdH0zGzprfkebQykf nadal istnieją w buckecie $bucket_name1.

Aby trwale usunąć pierwszą wersję, używamy polecenia delete-object podobnego do tego używanego do usuwania znacznika usuwania. Różnica polega na tym, że tutaj określamy VersionID, który chcemy usunąć.

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

Dane wyjściowe powinny wyglądać następująco:

{
    "VersionId": "t22ZzEq6kt5ILKFfLZgoeSzW.I9HVtN"
}

Kiedy wylistujemy wersje plików przechowywanych na buckecie za pomocą list-object-versions:

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

dane wyjściowe pokażą nam tylko jedną wersję jednego pliku:

{
    "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
}

W pulpicie nawigacyjnym Horizon całkowity rozmiar bucketu został zmniejszony do 18 bajtów:

../_images/s3-bucket-versioning-08_creodias.png

Jeśli usuniemy ostatnią wersję za pomocą polecenia delete-object,

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

ostatni plik z pulpitu nawigacyjnego Horizon powinien zniknąć, a rozmiar bucketu powinien zostać zmniejszony do zera bajtów:

../_images/s3-bucket-versioning-09_creodias.png

Jeśli teraz wykonamy polecenie list-object-versions:

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

zobaczymy, że nie ma tam żadnych plików ani wersji:

{
    "RequestCharged": null
}

Używanie zasad cyklu życia do konfigurowania automatycznego usuwania poprzednich wersji plików

„Wersja nieaktualna” to każda wersja pliku, która nie jest najnowsza. W tej sekcji omówimy, jak skonfigurować automatyczne usuwanie tych wersji po określonej liczbie dni.

W tym celu użyjemy funkcji zwanej „polityką cyklu życia”.

Ten przykład obejmuje konfigurację automatycznego usuwania nieaktualnych wersji pliku 1 dzień po przesłaniu nowszej wersji tego samego pliku.

Przygotowanie środowiska testowego

Na potrzeby testów utwórz bucket, którego nazwa jest przechowywana w zmiennej $bucket_name3 i włącz wersjonowanie:

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

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

Na potrzeby tego artykułu załóżmy, że znajdujemy się w folderze zawierającym następujące dwa pliki:

mycode.py

announcement.md

Rzeczywista zawartość tych plików nie jest tutaj istotna.

Przesyłamy te pliki do $bucket_name3 za pomocą standardowego polecenia put-object:

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

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

Aby zobaczyć te pliki po przesłaniu, wykonaj list-object-versions na buckecie:

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

Otrzymujemy następujące dane wyjściowe:

{
    "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
}

Aby przetestować automatyczne usuwanie poprzednich wersji, modyfikujemy plik o nazwie mycode.py na naszym komputerze lokalnym i przesyłamy go jeszcze raz za pomocą put-object:

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

Ponowne wykonanie list-object-versions:

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

potwierdza, że jeden z plików ma dwie wersje, podczas gdy drugi ma tylko jedną wersję:

{
    "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
}

W przeciwieństwie do innych wersji plików przechowywanych tutaj, pierwsza wersja pliku mycode.py ma false pod kluczem IsLatest. Oznacza to, że nie jest to najnowsza wersja tego pliku.

Konfigurowanie automatycznego usuwania poprzednich wersji

Polityka cyklu życia jest zapisana w formacie JSON. Utwórz plik o nazwie noncurrent-policy.json w bieżącym katalogu roboczym (nie musi to być lokalizacja pliku zawierającego dane logowania) i wprowadź do niego następujący kod:

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

Zastąp 1 liczbą dni, po których nieaktualne wersje mają zostać usunięte.

W tym przykładzie zastosujemy tę politykę do bucketu $bucket_name1. Polecenie to put-bucket-lifecycle-configuration:

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

Wyjście powinno być puste.

Aby sprawdzić, czy polityka została zastosowana, należy wykonać polecenie get-bucket-lifecycle-configuration:

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

W wynikach powinna być widoczna zastosowana polityka:

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

Wersje plików, które nie są najnowsze, powinny być teraz usuwane po 1 dniu.

W tym przykładzie zalogowanie się po jednym dniu i ponowne wykonanie list-object-versions:

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

ujawnia, że wersja pliku mycode.py, która nie jest najnowsza, została usunięta:

{
    "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
}

Usuwanie zasad cyklu życia

Polecenie delete-bucket-lifecycle usuwa politykę cyklu życia bucketu. Oto jak to zrobić na buckecie $bucket_name3.

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

Wynik tego polecenia powinien być pusty.

Aby to zweryfikować, ponownie sprawdzamy bieżącą konfigurację cyklu życia:

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

Polecenie to powinno zwrócić pusty wynik lub:

argument of type 'NoneType' is not iterable

Polityka ta nie powinna już mieć zastosowania.

Zawieszanie wersjonowania

Jeśli nie chcesz już przechowywać wielu wersji plików, możesz zawiesić wersjonowanie.

Bucket, w którym nigdy nie włączono wersjonowania

Aby lepiej zrozumieć, jak to działa, zacznijmy od bucketu, w którym wersjonowanie nigdy nie zostało włączone.

Na takim buckecie każdy plik będzie miał tylko jedną wersję, która ma jeden i ten sam identyfikator, a mianowicie null.

Jeśli prześlesz inny plik pod tą samą nazwą, jego VersionID będzie również null i zastąpi poprzednio przesłany plik.

Przykład

W tym przykładzie utworzymy bucket $bucket_name4, na którym nigdy nie włączono wersjonowania.

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

Buckety mogą oczywiście zawierać pliki różnych typów. Na potrzeby tego przykładu załóżmy, że wiadro zawiera następujące trzy pliki różnych typów:

Plik kontra edytor
Plik	Editor
document.odt	LibreOffice
screenshot1.png	GIMP, Krita itp.
script.sh	nano, vim itp.

Rzeczywista zawartość tych plików nie jest tutaj ważna. Możesz użyć edytorów z tej tabeli, aby utworzyć pliki, a następnie przesłać je za pomocą put-object:

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

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

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

Najpierw spróbujmy wykonać wcześniej wspomnianą komendę list-object-versions na tym buckecie:

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

Przykładowe dane wyjściowe:

{
    "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
}

Wszystkie te pliki mają tylko jedną wersję, której identyfikatorem jest null.

Załóżmy, że lokalnie modyfikujemy jeden z tych trzech plików (tutaj używamy script.sh) i przesyłamy zmodyfikowaną wersję pod tą samą nazwą i kluczem.

W tym celu, z poziomu folderu zawierającego nasz plik, wykonujemy następujące polecenie put-object:

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

W celu potwierdzenia powinniśmy otrzymać dane wyjściowe zawierające ETag:

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

Jeśli ponownie wylistujemy wersje obiektów za pomocą list-object-versions:

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

powinniśmy otrzymać następujące dane wyjściowe:

{
    "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
}

Ponownie, istnieją trzy pliki, każdy z dokładnie jedną zapisaną wersją. Plik script.sh został nadpisany podczas naszego przesyłania - jego parametry Rozmiar, ETag i LastModified (znacznik czasu ostatniej modyfikacji) uległy zmianie.

Zawieszenie wersjonowania

Po zawieszeniu wersjonowania, bucket zacznie zachowywać się podobnie do bucketu, w którym wersjonowanie nigdy nie było włączone. Wszystkie pliki przesłane od tego momentu będą miały null jako swój VersionId.

Załóżmy, że po zawieszeniu wersjonowania przesyłasz plik do tego samego klucza (nazwa i lokalizacja w kubełku), co wcześniej istniejący plik. To, co stanie się dalej, zależy od tego, czy w buckecie znajduje się już wersja tego pliku z VersionID równym null:

Jeśli wersja, która ma null jako swój VersionId nie istnieje, przesyłana wersja stanie się nową wersją tego pliku.

Jeśli wersja, która ma null jako swój VersionId istnieje, wersja, którą przesyłasz zastąpi poprzednią wersję tego pliku z VersionId o wartości null.

Tak czy inaczej, nowo przesłana wersja będzie miała VersionId o wartości null.

To nadpisanie nastąpi również, jeśli wersja, która ma null jako swój VersionId jest jedyną pozostałą wersją pliku.

Samo zawieszenie wersjonowania nie wpłynie jednak na wcześniej zapisane wersje, które nie mają identyfikatora VersionId równego null. Jeśli chcesz, możesz usunąć je ręcznie.

Aby zilustrować zawieszenie wersjonowania, utworzymy nowy bucket $bucket_name5. Najpierw utwórz to wiadro:

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

a następnie włączyć na nim wersjonowanie:

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

Prześlij kilka plików do tego bucketu za pomocą polecenia put-object. Upewnij się, że przynajmniej jeden z nich ma wiele wersji.

W tym przykładzie nasz bucket zawiera następujące pliki:

Klucz vs. VersionId
Klucz	VersionId
plik1.txt	CTv9FT1Wp9pxDZdlZXx2cJ5C2juPNA6
plik1.txt	eaJNZLZTqtPAq9l09Nrm-CN-UAVtFHQ
plik2.txt	HVRcuAOQ.gpqiU50mJkdAj4bAvgfCFN

Możemy wyświetlić listę wszystkich tych wersji za pomocą list-object-versions:

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

Wynik:

{
    "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
}

Aby zawiesić wersjonowanie tego bucketu, należy wykonać put-bucket-versioning:

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

Wynik tego polecenia powinien być pusty.

Ponownie wyświetlamy wersje plików za pomocą list-object-versions:

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

Dane wyjściowe pokazują, że poprzednie wersje plików nie zostały usunięte:

{
    "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
}

Następnie

zmodyfikować zawartość wcześniej przesłanego pliku plik1.txt na naszym komputerze lokalnym i

Prześlij ten plik ponownie, używając put-object:

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

Po pomyślnym przesłaniu ponownie wyświetlamy listę wszystkich wersji (polecenie list-versions) plików w naszym buckecie:

{
    "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
}

Poprzednie wersje tego pliku nie zostały zastąpione, ale przesłano nową wersję pliku plik1.txt (który ma VersionId o wartości null).

Od teraz każdy przesłany plik będzie przesyłany z VersionId o wartości null. Jeśli ta wersja pliku już istnieje, zostanie zastąpiona.

Aby to zilustrować

ponownie zmodyfikować plik plik1.txt na naszym komputerze lokalnym i

Prześlij tę zmodyfikowaną wersję ponownie, używając put-object:

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

Po tym załadowaniu jeszcze raz wylistujemy wersje i otrzymamy następujące dane wyjściowe:

{
    "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
}

Po raz kolejny istnieje tylko jedna wersja, która ma null jako identyfikator - przesłanie nadpisało poprzednią wersję. Data ostatniej modyfikacji (LastModified) uległa zmianie. Jej poprzednia wartość wynosiła 2024-09-16T11:31:01.968Z, a teraz jest to 2024-09-16T11:34:25.528Z.

Co robić dalej

AWS CLI nie jest jedynym dostępnym sposobem interakcji z object storage. Inne sposoby obejmują:

Pulpit nawigacyjny Horizon
Jak korzystać z Object Storage w NSIS

s3fs
Jak zamontować kontener object storage jako system plików w Linuksie przy użyciu s3fs na NSIS Cloud

Rclone
Jak zamontować kontener object storage z NSIS jako system plików na lokalnym komputerze z systemem Windows?

s3cmd
Jak uzyskać dostęp do object storage z NSIS za pomocą s3cmd