Работа с версиями объектов

1
aws s3api get-bucket-versioning --bucket <имя бакета>

1
{
2
    "Status": "Enabled"
3
}

1
{
2
    "Status": "Suspended"
3
}

1
import boto3
2
import argparse
3

4
def check_bucket_versioning(bucket_name):
5
    # Создаем клиент для работы с Object Storage
6
    s3_client = boto3.client('s3')
7

8
    try:
9
        # Получаем информацию о версионировании бакета
10
        response = s3_client.get_bucket_versioning(Bucket=bucket_name)
11

12
        # Проверяем статус версионирования
13
        status = response.get('Status', 'Not Enabled')
14
        if status == 'Enabled':
15
            print(f"Versioning is enabled for bucket '{bucket_name}'.")
16
        elif status == 'Suspended':
17
            print(f"Versioning is suspended for bucket '{bucket_name}'.")
18
        else:
19
            print(f"Versioning is not enabled for bucket '{bucket_name}'.")
20
    except Exception as e:
21
        print(f"Error checking versioning status for bucket '{bucket_name}': {e}")
22

23
def main():
24
    # Создаем парсер аргументов командной строки
25
    parser = argparse.ArgumentParser(description='Check S3 bucket versioning status.')
26
    parser.add_argument('bucket_name', type=str, help='The name of the S3 bucket')
27

28
    # Парсим аргументы
29
    args = parser.parse_args()
30

31
    # Проверяем статус версионирования для указанного бакета
32
    check_bucket_versioning(args.bucket_name)
33

34
if __name__ == '__main__':
35
    main()

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "log"
8

9
    "github.com/aws/aws-sdk-go-v2/aws"
10
    "github.com/aws/aws-sdk-go-v2/config"
11
    "github.com/aws/aws-sdk-go-v2/service/s3"
12
    "github.com/aws/aws-sdk-go-v2/service/s3/types"
13
)
14

15
func main() {
16
    // Получаем имя бакета из аргумента командной строки
17
    bucketName := flag.String("b", "", "The name of the bucket")
18
    flag.Parse()
19

20
    if *bucketName == "" {
21
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
22
        return
23
    }
24

25
    // Подгружаем конфигурацию из ~/.aws/*
26
    cfg, err := config.LoadDefaultConfig(context.TODO())
27
    if err != nil {
28
        log.Fatal(err)
29
    }
30

31
    // Создаем клиент для доступа к Object Storage
32
    client := s3.NewFromConfig(cfg)
33

34
    // Получаем статус версионирования для бакета
35
    result, err := client.GetBucketVersioning(context.TODO(), &s3.GetBucketVersioningInput{
36
        Bucket: aws.String(*bucketName),
37
    })
38
    if err != nil {
39
        log.Fatal(err)
40
    }
41

42
    // Проверяем статус версионирования
43
    if result.Status == types.BucketVersioningStatusEnabled {
44
        log.Printf("Bucket %s has versioning enabled", *bucketName)
45
    } else if result.Status == types.BucketVersioningStatusSuspended {
46
        log.Printf("Bucket %s has versioning suspended", *bucketName)
47
    } else {
48
        log.Printf("Bucket %s has no versioning", *bucketName)
49
    }
50
}

1
aws s3api put-bucket-versioning --bucket <имя бакета> --versioning-configuration Status=Enabled

1
import boto3
2
import argparse
3

4
def enable_bucket_versioning(bucket_name):
5
    # Создаем клиент для работы с Object Storage
6
    s3_client = boto3.client('s3')
7

8
    try:
9
        # Включаем версионирование для указанного бакета
10
        s3_client.put_bucket_versioning(
11
            Bucket=bucket_name,
12
            VersioningConfiguration={
13
                'Status': 'Enabled'
14
            }
15
        )
16
        print(f"Versioning has been enabled for bucket '{bucket_name}'.")
17
    except Exception as e:
18
        print(f"Error enabling versioning for bucket '{bucket_name}': {e}")
19

20
def main():
21
    # Создаем парсер аргументов командной строки
22
    parser = argparse.ArgumentParser(description='Enable versioning in the specified bucket')
23
    parser.add_argument('bucket_name', type=str, help='The name of the S3 bucket')
24

25
    # Парсим аргументы
26
    args = parser.parse_args()
27

28
    # Проверяем статус версионирования для указанного бакета
29
    enable_bucket_versioning(args.bucket_name)
30

31
if __name__ == '__main__':
32
    main()

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "log"
8

9
    "github.com/aws/aws-sdk-go-v2/aws"
10
    "github.com/aws/aws-sdk-go-v2/config"
11
    "github.com/aws/aws-sdk-go-v2/service/s3"
12
    "github.com/aws/aws-sdk-go-v2/service/s3/types"
13
)
14

15
func main() {
16
    // Получаем имя бакета из аргумента командной строки
17
    bucketName := flag.String("b", "", "The name of the bucket")
18
    flag.Parse()
19

20
    if *bucketName == "" {
21
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
22
        return
23
    }
24

25
    // Подгружаем конфигурацию из ~/.aws/*
26
    cfg, err := config.LoadDefaultConfig(context.TODO())
27
    if err != nil {
28
        log.Fatal(err)
29
    }
30

31
    // Создаем клиент для доступа к ObjectStorage
32
    client := s3.NewFromConfig(cfg)
33

34
    // Включаем версионирование
35
    _, err = client.PutBucketVersioning(context.TODO(), &s3.PutBucketVersioningInput{
36
        Bucket: aws.String(*bucketName),
37
        VersioningConfiguration: &types.VersioningConfiguration{
38
            Status: types.BucketVersioningStatusEnabled,
39
        },
40
    })
41
    if err != nil {
42
        log.Fatal(err)
43
    }
44

45
    fmt.Printf("Successfully enabled versioning on bucket %q\n", *bucketName)
46
}

1
aws s3api put-bucket-versioning --bucket <имя бакета> --versioning-configuration Status=Suspended

1
import boto3
2
import argparse
3

4
def suspend_bucket_versioning(bucket_name):
5
    # Создаем клиент для работы с S3
6
    s3_client = boto3.client('s3')
7

8
    try:
9
        # Включаем версионирование для указанного бакета
10
        s3_client.put_bucket_versioning(
11
            Bucket=bucket_name,
12
            VersioningConfiguration={
13
                'Status': 'Suspended'
14
            }
15
        )
16
        print(f"Versioning has been suspended for bucket '{bucket_name}'.")
17
    except Exception as e:
18
        print(f"Error suspending versioning for bucket '{bucket_name}': {e}")
19

20
def main():
21
    # Создаем парсер аргументов командной строки
22
    parser = argparse.ArgumentParser(description='Enable versioning in the specified bucket')
23
    parser.add_argument('bucket_name', type=str, help='The name of the S3 bucket')
24

25
    # Парсим аргументы
26
    args = parser.parse_args()
27

28
    # Проверяем статус версионирования для указанного бакета
29
    suspend_bucket_versioning(args.bucket_name)
30

31
if __name__ == '__main__':
32
    main()

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "log"
8

9
    "github.com/aws/aws-sdk-go-v2/aws"
10
    "github.com/aws/aws-sdk-go-v2/config"
11
    "github.com/aws/aws-sdk-go-v2/service/s3"
12
    "github.com/aws/aws-sdk-go-v2/service/s3/types"
13
)
14

15
func main() {
16
    // Получаем имя бакета из аргумента командной строки
17
    bucketName := flag.String("b", "", "The name of the bucket")
18
    flag.Parse()
19

20
    if *bucketName == "" {
21
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
22
        return
23
    }
24

25
    // Подгружаем конфигурацию из ~/.aws/*
26
    cfg, err := config.LoadDefaultConfig(context.TODO())
27
    if err != nil {
28
        log.Fatal(err)
29
    }
30

31
    // Создаем клиента для доступа к Object Storage
32
    client := s3.NewFromConfig(cfg)
33

34
    // Получаем статус версионирования для бакета
35
    _, err = client.PutBucketVersioning(context.TODO(), &s3.PutBucketVersioningInput{
36
        Bucket: aws.String(*bucketName),
37
        VersioningConfiguration: &types.VersioningConfiguration{
38
            Status: types.BucketVersioningStatusSuspended,
39
        },
40
    })
41
    if err != nil {
42
        log.Fatal(err)
43
    }
44

45
    fmt.Printf("Successfully suspended versioning on bucket %q\n", *bucketName)
46
}

1
aws s3api list-object-versions --bucket <имя бакета>

1
import boto3
2

3
def list_versions(bucket_name):
4
    s3 = boto3.client('s3')
5

6
    try:
7
        paginator = s3.get_paginator('list_object_versions')
8
        for page in paginator.paginate(Bucket=bucket_name):
9
            # Вывод обычных версий
10
            for version in page.get('Versions', []):
11
                print(f"Key: {version['Key']}, "
12
                      f"VersionId: {version['VersionId']}, "
13
                      f"LastModified: {version['LastModified']}, "
14
                      f"Size: {version['Size']}")
15

16
            # Вывод маркеров удаления
17
            for marker in page.get('DeleteMarkers', []):
18
                print(f"Key: {marker['Key']}, "
19
                      f"VersionId: {marker['VersionId']} (delete marker), "
20
                      f"LastModified: {marker['LastModified']}")
21

22
    except Exception as e:
23
        print(f"Error: {str(e)}")
24

25
# Использование
26
bucket_name = "bucket"
27
list_versions(bucket_name)

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "log"
8

9
    "github.com/aws/aws-sdk-go-v2/aws"
10
    "github.com/aws/aws-sdk-go-v2/config"
11
    "github.com/aws/aws-sdk-go-v2/service/s3"
12
)
13

14
func main() {
15
    // Получаем имя бакета из аргумента командной строки
16
    bucketName := flag.String("b", "", "The name of the bucket")
17
    flag.Parse()
18

19
    if *bucketName == "" {
20
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
21
        return
22
    }
23

24
    // Подгружаем конфигурацию из ~/.aws/*
25
    cfg, err := config.LoadDefaultConfig(context.TODO())
26
    if err != nil {
27
        log.Fatal(err)
28
    }
29

30
    // Создаем клиент для доступа к Object Storage
31
    client := s3.NewFromConfig(cfg)
32

33
    // Запрашиваем список всех версий объектов в бакете
34
    input := &s3.ListObjectVersionsInput{
35
        Bucket: aws.String(*bucketName),
36
    }
37

38
    paginator := s3.NewListObjectVersionsPaginator(client, input)
39

40
    // Проходим по всем страницам результатов
41
    for paginator.HasMorePages() {
42
        result, err := paginator.NextPage(context.TODO())
43
        if err != nil {
44
            log.Fatal(err)
45
        }
46

47
        // Выводим информацию о версиях объектов
48
        for _, version := range result.Versions {
49
            log.Printf(
50
                "object=%s version=%s size=%d Bytes last modified=%s is_latest=%t",
51
                aws.ToString(version.Key),
52
                aws.ToString(version.VersionId),
53
                version.Size,
54
                version.LastModified.Local().Format("2006-01-02 15:04:05 Monday"),
55
                aws.ToBool(version.IsLatest),
56
            )
57
        }
58

59
        // Выводим информацию о маркерах удаления
60
        for _, marker := range result.DeleteMarkers {
61
            log.Printf(
62
                "object=%s version=%s (delete marker) last modified=%s is_latest=%t",
63
                aws.ToString(marker.Key),
64
                aws.ToString(marker.VersionId),
65
                marker.LastModified.Local().Format("2006-01-02 15:04:05 Monday"),
66
                aws.ToBool(marker.IsLatest),
67
            )
68
        }
69
    }
70
}

1
aws s3api get-object --bucket <имя бакета> --key <ключ объекта> --version-id "<идентификатор версии>" <путь в локальной файловой системе>

1
import boto3
2
import botocore
3
#Создаем сессию
4
session = boto3.session.Session(profile_name='default')
5
s3 = session.client(
6
    service_name='s3',
7
    endpoint_url='https://storage.mwsapis.ru'
8
)
9
#Определяем имя бакета, ключ объекта, идентификатор версии и путь в локальной файловой системе
10
bucket_name = 'bucket'
11
key = 'object.txt'
12
version_id = '00062849C90079F6'
13
local_path = 'folder/object.txt'
14
#Скачиваем версию
15
try:
16
    s3.download_file(
17
        Bucket=bucket_name,
18
        Key=key,
19
        VersionId=version_id,
20
        Filename=local_path
21
    )
22
     #Выводим сообщение об успешном скачивании версии
23
    print(f'Object {key}, version {version_id} successfully downloaded to {local_path}')
24
except botocore.exceptions.ClientError as e:
25
    if e.response['Error']['Code'] == '404':
26
        print(f'Object {key}, version {version_id} not found') # Если версия с указанным идентификатором не найдена, сообщаем об этом
27
    else:
28
        print(f'Error downloading object: {e}')
29
except Exception as e:
30
    print(f'Error downloading object: {e}')

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "io"
8
    "log"
9
    "os"
10

11
    "github.com/aws/aws-sdk-go-v2/aws"
12
    "github.com/aws/aws-sdk-go-v2/config"
13
    "github.com/aws/aws-sdk-go-v2/service/s3"
14
)
15

16
func main() {
17
    // Получаем имя бакета, ключ объекта, локальный путь и идентификатор версии из аргументов командной строки
18
    bucketName := flag.String("b", "", "The name of the bucket")
19
    objectKey := flag.String("k", "", "Key of the object to download")
20
    file := flag.String("f", "", "The local path to save the downloaded object")
21
    versionID := flag.String("v", "", "The version ID of the object to download")
22
    flag.Parse()
23

24
    if *bucketName == "" {
25
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
26
        return
27
    }
28

29
    if *objectKey == "" {
30
        fmt.Println("You must supply the object key (-k KEY)")
31
        return
32
    }
33

34
    if *file == "" {
35
        fmt.Println("You must supply the local file path (-f PATH)")
36
        return
37
    }
38

39
    if *versionID == "" {
40
        fmt.Println("You must supply the version ID of the object (-v VERSION_ID)")
41
        return
42
    }
43

44
    // Подгружаем конфигурацию из ~/.aws/*
45
    cfg, err := config.LoadDefaultConfig(context.TODO())
46
    if err != nil {
47
        log.Fatal(err)
48
    }
49

50
    // Создаем клиент для доступа к хранилищу S3
51
    client := s3.NewFromConfig(cfg)
52

53
    // Создаем локальный файл для записи
54
    localFile, err := os.Create(*file)
55
    if err != nil {
56
        log.Fatalf("Unable to create local file %q, %v", *file, err)
57
    }
58
    defer localFile.Close()
59

60
    downloadInput := &s3.GetObjectInput{
61
        Bucket:    aws.String(*bucketName),
62
        Key:       aws.String(*objectKey),
63
        VersionId: aws.String(*versionID),
64
    }
65

66
    objectResponse, err := client.GetObject(context.TODO(), downloadInput)
67
    if err != nil {
68
        log.Fatalf("Unable to download object %q from bucket %q with version %q, %v", *objectKey, *bucketName, *versionID, err)
69
    }
70

71
    defer objectResponse.Body.Close()
72

73
    // Копируем содержимое объекта в локальный файл
74
    bytesWritten, err := io.Copy(localFile, objectResponse.Body)
75
    if err != nil {
76
        log.Fatalf("Unable to write object contents to local file %q, %v", *file, err)
77
    }
78

79
    fmt.Printf("Successfully downloaded object %q from bucket %q with version %q and wrote %d bytes to %q\n",
80
        *objectKey, *bucketName, *versionID, bytesWritten, *file)
81
}