Настройка блокировки версии

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

1
import boto3
2
import argparse
3

4
def get_bucket_object_lock_status(bucket_name):
5
    # Создает клиент для подключения к Object Storage
6
    s3_client = boto3.client('s3')
7

8
    try:
9
        # Получает конфигурацию блокировки версии для бакета
10
        response = s3_client.get_object_lock_configuration(Bucket=bucket_name)
11
        object_lock_config = response.get('ObjectLockConfiguration', {})
12

13
        # Проверяет, включена ли блокировка
14
        if object_lock_config.get('ObjectLockEnabled') == 'Enabled':
15
            print(f"Object Lock is enabled on bucket: {bucket_name}")
16

17
            # Проверяет настройки временной блокировки (Retention)
18
            if 'Rule' in object_lock_config and 'DefaultRetention' in object_lock_config['Rule']:
19
                retention = object_lock_config['Rule']['DefaultRetention']
20
                print(f"Object Lock mode: {retention.get('Mode')}")
21

22
                if 'Days' in retention:
23
                    print(f"Default retention period: {retention['Days']} days")
24
                if 'Years' in retention:
25
                    print(f"Default retention period: {retention['Years']} years")
26
            else:
27
                print("No default retention policy is set.")
28
        else:
29
            print(f"Object Lock is not enabled for the bucket: {bucket_name}")
30

31
    except Exception as e:
32
        print(f"Error: {e}")
33

34
def main():
35
    # Создает парсер аргументов командной строки
36
    parser = argparse.ArgumentParser(description='Check object lock status.')
37
    parser.add_argument('bucket_name', type=str, help='The name of the bucket')# Имя бакета
38

39
    # Парсит аргументы
40
    args = parser.parse_args()
41

42
    # Проверяет статус блокировки для указанного бакета
43
    get_bucket_object_lock_status(args.bucket_name)
44

45
if __name__ == '__main__':
46
    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.GetObjectLockConfiguration(context.TODO(), &s3.GetObjectLockConfigurationInput{
36
        Bucket: aws.String(*bucketName),
37
    })
38
    if err != nil {
39
        log.Fatal(err)
40
    }
41

42
    // Проверяет, включена ли блокировка
43
    if result.ObjectLockConfiguration == nil {
44
        fmt.Println("Object Lock is not enabled on this bucket.")
45
        return
46
    }
47

48
    // Выводит статус блокировки
49
    if result.ObjectLockConfiguration.ObjectLockEnabled == types.ObjectLockEnabledEnabled {
50
        fmt.Println("Object Lock is enabled on this bucket.")
51

52
        // Проверяет, есть ли правило DefaultRetention
53
        if result.ObjectLockConfiguration.Rule != nil && result.ObjectLockConfiguration.Rule.DefaultRetention != nil {
54
            retention := result.ObjectLockConfiguration.Rule.DefaultRetention
55
            fmt.Printf("Object Lock mode: %s\n", retention.Mode)
56

57
            // Проверяет, задан ли период в днях
58
            if retention.Days != nil {
59
                fmt.Printf("Default retention period: %d days\n", *retention.Days)
60
            }
61

62
            // Проверяет, задан ли период в годах
63
            if retention.Years != nil {
64
                fmt.Printf("Default retention period: %d years\n", *retention.Years)
65
            }
66

67
            // Если не задан период ни в днях, ни в годах, выводит соответствующее сообщение
68
            if retention.Days == nil && retention.Years == nil {
69
                fmt.Println("No retention period is set.")
70
            }
71
        } else {
72
            fmt.Println("No default retention policy is set.")
73
        }
74
    } else {
75
        fmt.Println("Object Lock is not enabled on this bucket.")
76
    }
77
}

1
import boto3
2

3
# Создает клиент для подключения к Object Storage
4
s3_client = boto3.client('s3')
5

6
# Определяет имя бакета
7
bucket_name = '<имя бакета>'
8
# Определяет режим (COMPLIANCE или GOVERNANCE) и срок действия блокировки
9
mode = '<режим блокировки>'
10
days = <срок действия блокировки в днях>
11
# Включает блокировку версий для бакета
12
response = s3_client.put_object_lock_configuration(
13
    Bucket=bucket_name,
14
    ObjectLockConfiguration={
15
        'ObjectLockEnabled': 'Enabled',
16
        'Rule': {
17
            'DefaultRetention': {
18
                'Mode':  mode,
19
                'Days': days
20
            }
21
        }
22
    }
23
)
24

25
print(f"Object lock enabled for {bucket_name}:")
26
print(f"Retention mode: {mode}")
27
print(f"Retention period: {days} days")

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
    objectLockConfig := &types.ObjectLockConfiguration{
36
        ObjectLockEnabled: types.ObjectLockEnabledEnabled,
37
        Rule: &types.ObjectLockRule{
38
            DefaultRetention: &types.DefaultRetention{
39
                Mode: types.ObjectLockRetentionModeGovernance, // режим блокировки : COMPLIANCE или GOVERNANCE
40
                Days: aws.Int32(365), // Срок блокировки  версий в днях
41
            },
42
        },
43
    }
44

45
    // Включает блокировку для бакета
46
    _, err = client.PutObjectLockConfiguration(context.TODO(), &s3.PutObjectLockConfigurationInput{
47
        Bucket:                  aws.String(*bucketName),
48
        ObjectLockConfiguration: objectLockConfig,
49
    })
50
    if err != nil {
51
        log.Fatalf("Error enabling object lock: %v", err)
52
    }
53

54
    fmt.Println("Object Lock successfully enabled for the bucket", *bucketName) //Выводит сообщение об успешной установке блокировки
55
}

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

1
{
2
    "Retention": {
3
        "Mode": "<режим блокировки >",
4
        "RetainUntilDate": "<дата и время окончания блокировки в формате ISO 8601>"
5
    }
6
}

1
import boto3
2
import argparse
3

4
def get_object_retention_status(bucket_name, object_key, version_id):
5
    # Создает клиент для подключения к Object Storage
6
    s3_client = boto3.client('s3')
7

8
    try:
9
        # Получаем настройки блокировки для указанной версии объекта
10
        response = s3_client.get_object_retention(
11
            Bucket=bucket_name,
12
            Key=object_key,
13
            VersionId=version_id
14
        )
15
        retention = response.get('Retention', {})
16

17
        # Проверяет, применяется ли временная блокировка
18
        if retention: # Если временная блокировка применяется, выводит информацию о ее настройках
19
            print(f"Object Retention is applied to version {version_id} of the object {object_key}.")
20
            print(f"Object Lock mode: {retention.get('Mode')}")
21
            print(f"Retain until date: {retention.get('RetainUntilDate')}")
22
        else: # Если блокировка не применяется, выводит соответствующее сообщение
23
            print(f"Object Retention is not applied to version {version_id} of the object {object_key}.")
24

25
    except Exception as e:
26
        print(f"Error: {e}")
27

28
def main():
29
    # Создает парсер аргументов командной строки
30
    parser = argparse.ArgumentParser(description='Check object retention status for the specified version.')
31
    parser.add_argument('bucket_name', type=str, help='The name of the bucket')
32
    parser.add_argument('object_key', type=str, help='The key of the object')
33
    parser.add_argument('version_id', type=str, help='The ID of the version')
34

35
    # Парсит аргументы
36
    args = parser.parse_args()
37

38
    # Проверяет статус  временной блокировки для указанной версии объекта
39
    get_object_retention_status(args.bucket_name, args.object_key, args.version_id)
40

41
if __name__ == '__main__':
42
    main()

1
package main
2

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

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

16
func main() {
17
    // Получает имя бакета, ключ объекта и версию из аргументов командной строки
18
    bucketName := flag.String("b", "", "The name of the bucket")
19
    objectKey := flag.String("k", "", "The key of the object")
20
    versionID := flag.String("v", "", "The ID of the version")
21
    flag.Parse()
22

23
    // Проверяет обязательные аргументы
24
    if *bucketName == "" {
25
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
26
        return
27
    }
28
    if *objectKey == "" {
29
        fmt.Println("You must supply the key of the object (-k KEY)")
30
        return
31
    }
32
    if *versionID == "" {
33
        fmt.Println("You must supply the ID of the version (-v VERSION_ID)")
34
        return
35
    }
36

37
    // Подгружает конфигурацию из ~/.aws/*
38
    cfg, err := config.LoadDefaultConfig(context.TODO())
39
    if err != nil {
40
        log.Fatal(err)
41
    }
42

43
    // Создает клиент для доступа к Object Storage
44
    client := s3.NewFromConfig(cfg)
45

46
    // Получает  настройки временной блокировки для указанной версии объекта
47
    retention, err := getObjectRetention(client, *bucketName, *objectKey, *versionID)
48
    if err != nil {
49
        log.Fatalf("Failed to get Object Retention: %v", err)
50
    }
51

52
    // Выводит информацию о настройках временной блокировки
53
    if retention != nil {
54
        fmt.Printf("Object Retention is applied to version %s of object %s.\n", *versionID, *objectKey)
55
        fmt.Printf("Object Lock mode: %s\n", retention.Mode)
56
        fmt.Printf("Retain until date: %s\n", retention.RetainUntilDate.Format(time.RFC3339))
57
    } else {
58
        fmt.Printf("Object Retention is not applied to version %s of object %s.\n", *versionID, *objectKey)
59
    }
60
}
61

62
// Получает настройки временной блокировки для указанной версии объекта
63
func getObjectRetention(client *s3.Client, bucketName, objectKey, versionID string) (*types.ObjectLockRetention, error) {
64
    // Создает входные данные для запроса
65
    input := &s3.GetObjectRetentionInput{
66
        Bucket:    aws.String(bucketName),
67
        Key:       aws.String(objectKey),
68
        VersionId: aws.String(versionID),
69
    }
70

71
    // Выполняет запрос
72
    output, err := client.GetObjectRetention(context.TODO(), input)
73
    if err != nil {
74
        return nil, fmt.Errorf("failed to get Object Retention: %w", err)
75
    }
76

77
    return output.Retention, nil
78
}

1
aws s3api put-object-retention --bucket <имя бакета> --key <ключ объекта> --version-id <идентификатор версии объекта>  --retention '{"Mode": "<режим блокировки>", "RetainUntilDate": "<дата и время окончания блокировки в формате ISO 8601"}'

1
import boto3
2
from datetime import datetime, timedelta
3

4
# Создает клиент для подключения к Object Storage
5
s3_client = boto3.client('s3')
6

7
# Имя бакета
8
bucket_name = '<имя бакета>'
9
# Ключ объекта
10
object_key = '<ключ объекта>'
11
# Идентификатор версии (опционально)
12
version_id = '<версия объекта>'
13
# Настройки блокировки
14
retention_config = {
15
    'Mode': '<режим блокировки>' #COMPLIANCE или GOVERNANCE
16
    'RetainUntilDate': datetime.utcnow() + timedelta(days=365)  # Дата, до которой будет действовать блокировка
17
}
18

19
# Включает блокировку
20
response = s3_client.put_object_retention(
21
        Bucket=bucket_name,
22
        Key=object_key,
23
        Retention=retention_config,
24
        VersionId=version_id
25
    )
26
print(f"Retention settings applied successfully  for version {version_id} of the object {object_key}")

1
package main
2

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

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

16
func main() {
17
    // Получает параметры из аргументов командной строки
18
    bucketName := flag.String("b", "", "The name of the bucket")
19
    objectKey := flag.String("k", "", "The key of the object")
20
    versionID := flag.String("v", "", "The version of the object (optional)")
21
    mode := flag.String("m", "GOVERNANCE", "The retention mode: COMPLIANCE or GOVERNANCE")
22
    days := flag.Int("d", 10, "Number of days to retain the object")
23
    bypassGovernance := flag.Bool("bypass", false, "Bypass governance retention")
24

25
    flag.Parse()
26

27
    // Проверяет обязательные параметры
28
    if *bucketName == "" {
29
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
30
        return
31
    }
32

33
    if *objectKey == "" {
34
        fmt.Println("You must supply the key of an object (-k KEY)")
35
        return
36
    }
37

38
    // Сообщает, что произойдет, если не указан идентификатор версии: временная блокировка будет применена к последней версии
39
    if *versionID == "" {
40
        fmt.Println("VersionID not specified. Object lock settings will be applied to the latest version")
41
    }
42

43
    // Проверяет, что режим временной блокировки указан корректно: либо COMPLIANCE, либо GOVERNANCE
44
    var retentionMode types.ObjectLockRetentionMode
45
    switch *mode {
46
    case "COMPLIANCE":
47
        retentionMode = types.ObjectLockRetentionModeCompliance
48
    case "GOVERNANCE":
49
        retentionMode = types.ObjectLockRetentionModeGovernance
50
    default:
51
        fmt.Printf("Invalid mode: %s. Must be either COMPLIANCE or GOVERNANCE.\n", *mode)
52
        return
53
    }
54

55
    // Подгружает конфигурацию из ~/.aws/*
56
    cfg, err := config.LoadDefaultConfig(context.TODO())
57
    if err != nil {
58
        log.Fatalf("Failed to load SDK configuration: %v", err)
59
    }
60

61
    // Создает клиент для доступа к Object Storage
62
    client := s3.NewFromConfig(cfg)
63

64
    // Задает настройки временной блокировки
65
    retention := &types.ObjectLockRetention{
66
        Mode:            retentionMode,
67
        RetainUntilDate: aws.Time(time.Now().Add(time.Duration(*days) * 24 * time.Hour)),
68
    }
69

70
    input := &s3.PutObjectRetentionInput{
71
        Bucket:                    aws.String(*bucketName),
72
        Key:                       aws.String(*objectKey),
73
        Retention:                 retention,
74
        BypassGovernanceRetention: aws.Bool(*bypassGovernance),
75
    }
76

77
    // Добавляет VersionId, если он указан
78
    if *versionID != "" {
79
        input.VersionId = aws.String(*versionID)
80
    }
81

82
    // Применяет настройки временной блокировки
83
    _, err = client.PutObjectRetention(context.TODO(), input)
84
    if err != nil {
85
        log.Fatalf("Error applying Object Lock settings: %v", err)
86
    }
87

88
    // Выводит сообщение об успешном включении временной блокировки
89
    if *versionID != "" {
90
        fmt.Printf("Object Lock settings successfully applied to version %s of object %s in bucket %s\n",
91
            *versionID, *objectKey, *bucketName)
92
    } else {
93
        fmt.Printf("Object Lock settings successfully applied to the latest version of object %s in bucket %s\n",
94
            *objectKey, *bucketName)
95
    }
96

97
    // Выводит дополнительную информацию о настройках
98
    fmt.Printf("Mode: %s\n", *mode)
99
    fmt.Printf("Retention period: %d days (until %s)\n",
100
        *days,
101
        retention.RetainUntilDate.Format(time.RFC3339))
102
}

1
aws s3api put-object-retention --bucket <имя бакета> --key <ключ объекта> --version-id <идентификатор версии объекта>  --retention '{}' --bypass-governance-retention

1
import boto3
2
from datetime import datetime, timedelta
3
import argparse
4

5
def remove_retention(bucket_name, object_key, version_id):
6
    """
7
    Отключает временную блокировку версий (только для управляемого режима)
8
    """
9
    s3_client = boto3.client('s3')
10

11
    # Изменяет срок действия блокировки: сокращает его до одной минуты с момента выполнения программы
12
    retain_until = (datetime.utcnow() + timedelta(minutes=1)).isoformat() + "Z"
13

14
    params = {
15
        'Bucket': bucket_name,
16
        'Key': object_key,
17
        'Retention': {
18
            'Mode': 'GOVERNANCE',
19
            'RetainUntilDate': retain_until  # Дата должна быть в будущем
20
        },
21
        'BypassGovernanceRetention': True
22
    }
23

24
    if version_id:
25
        params['VersionId'] = version_id
26

27
    try:
28
        s3_client.put_object_retention(**params)
29
        print(f"Retention disabled for object: {object_key} (version: {version_id or 'LATEST'})")# Выводит сообщение об успешном снятии временной блокировки
30
    except Exception as e:
31
        print(f"Error: {e}")
32
        if "Compliance" in str(e): # Если для объекта установлена временная блокировка в строгом режиме, сообщает, что снять ее невозможно
33
            print("→ The object is being protected in the Compliance Mode. You cannot unblock it until the retention period is over")
34

35
def main(): # Создает парсер аргументов
36
    parser = argparse.ArgumentParser(description='Disable S3 Object Lock (Governance Mode only).')
37
    parser.add_argument('--bucket', '-b', required=True, help='Bucket name')
38
    parser.add_argument('--key', '-k', required=True, help='Object key')
39
    parser.add_argument('--version-id', '-v', help='Version ID (optional)')
40
    args = parser.parse_args() # Парсит аргументы
41
    remove_retention(args.bucket, args.key, args.version_id)
42

43
if __name__ == '__main__':
44
    main()

1
package main
2

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

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

16
func main() {
17
    // Получает из аргументов командной строки имя бакета, ключ объекта и идентификатор версии
18
    bucketName := flag.String("bucket", "", "The name of the bucket")
19
    objectKey := flag.String("key", "", "The key of the object")
20
    versionID := flag.String("version-id", "", "Object version ID")
21
    flag.Parse()
22
    // Проверяет обязательные аргументы
23
    if *bucketName == "" {
24
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
25
        return
26
    }
27

28
    if *objectKey == "" {
29
        fmt.Println("You must supply the key of an object (-k KEY)")
30
        return
31
    }
32
    //Подгружает конфигурацию из ~/.aws/*
33
    cfg, err := config.LoadDefaultConfig(context.TODO())
34
    if err != nil {
35
        log.Fatalf("Failed to load SDK configuration: %v", err)
36
    }
37
    // Создает клиент для подключения к Object Storage
38
    client := s3.NewFromConfig(cfg)
39

40
    // Изменяет срок действия временной блокировки: сокращает его до одной минуты с момента выполнения программы
41
    futureDate := time.Now().Add(1 * time.Minute)
42

43
    input := &s3.PutObjectRetentionInput{
44
        Bucket: aws.String(*bucketName),
45
        Key:    aws.String(*objectKey),
46
        Retention: &types.ObjectLockRetention{
47
            Mode:            types.ObjectLockRetentionModeGovernance,
48
            RetainUntilDate: aws.Time(futureDate), // Дата должна быть в будущем
49
        },
50
        BypassGovernanceRetention: aws.Bool(true),
51
    }
52

53
    if *versionID != "" {
54
        input.VersionId = aws.String(*versionID)
55
    }
56

57
    _, err = client.PutObjectRetention(context.TODO(), input)
58
    if err != nil {
59
        log.Fatalf("An error occurred while removing retention: %v", err)
60
    }
61
    // Выводит сообщение об успешном снятии временной блокировки
62
    if *versionID != "" {
63
        fmt.Printf("Retention successfully removed for the version %s of the object %s in the bucket %s\n", *versionID, *objectKey, *bucketName)
64
    } else {
65
        fmt.Printf("Retention successfully removed for the latest version of the object %s in the bucket %s\n", *objectKey, *bucketName)
66
    }
67
}

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

1
{
2
    "LegalHold": {
3
        "Status": "<текущий статус бессрочной блокировки  (ON или OFF)>"
4
    }
5
}

1
import boto3
2
import argparse
3

4
def get_object_legal_hold(bucket_name, object_key, version_id):
5
    # Создает клиент для подключения к Object Storage
6
    s3_client = boto3.client('s3')
7

8
    try:
9
        # Получает настройки бессрочной блокировки  для указанной версии объекта
10
        response = s3_client.get_object_legal_hold(
11
            Bucket=bucket_name,
12
            Key=object_key,
13
            VersionId=version_id
14
        )
15
        legal_hold = response.get('LegalHold', {})
16

17
        # Проверяет, применяется ли бессрочная блокировка:
18
        if legal_hold: # Если применяется, выводит соответствующее сообщение
19
            print(f"Legal hold is applied to version {version_id} of the object {object_key}.")
20
            print(f"Object Lock mode: {retention.get('Mode')}")
21
        else:
22
            print(f"Legal Hold is not applied to version {version_id} of the object {object_key}.")
23

24
    except Exception as e:
25
        print(f"Error: {e}")
26

27
def main():
28
    # Создает парсер аргументов командной строки
29
    parser = argparse.ArgumentParser(description='Check object legal hold status for the specified version.')
30
    parser.add_argument('bucket_name', type=str, help='The name of the bucket')
31
    parser.add_argument('object_key', type=str, help='The key of the object')
32
    parser.add_argument('version_id', type=str, help='The ID of the version')
33

34
    # Парсит аргументы
35
    args = parser.parse_args()
36

37
    # Проверяет статус бессрочной блокировки для указанной версии объекта
38
    get_object_legal_hold(args.bucket_name, args.object_key, args.version_id)
39

40
if __name__ == '__main__':
41
    main()

1
package main
2

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

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

16
func main() {
17
    // Получает имя бакета, ключ объекта и версию из аргументов командной строки
18
    bucketName := flag.String("b", "", "The name of the bucket")
19
    objectKey := flag.String("k", "", "The key of the object")
20
    versionID := flag.String("v", "", "The ID of the version")
21
    flag.Parse()
22

23
    // Проверяет обязательные аргументы
24
    if *bucketName == "" {
25
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
26
        return
27
    }
28
    if *objectKey == "" {
29
        fmt.Println("You must supply the key of the object (-k KEY)")
30
        return
31
    }
32
    if *versionID == "" {
33
        fmt.Println("You must supply the ID of the version (-v VERSION_ID)")
34
        return
35
    }
36

37
    // Подгружает конфигурацию из ~/.aws/*
38
    cfg, err := config.LoadDefaultConfig(context.TODO())
39
    if err != nil {
40
        log.Fatal(err)
41
    }
42

43
    // Создает клиент для доступа к Object Storage
44
    client := s3.NewFromConfig(cfg)
45

46
    // Получает настройки бессрочной блокировки  для указанной версии объекта
47
    legalHold, err := getObjectLegalHold(client, *bucketName, *objectKey, *versionID)
48
    if err != nil {
49
        log.Fatalf("Failed to get Legal Hold: %v", err)
50
    }
51

52
    // Выводит информацию о настройках бессрочной блокировки
53
    if legalHold != nil {
54
        fmt.Printf("Legal Hold is applied to version %s of object %s.\n", *versionID, *objectKey)
55
        fmt.Printf("Legal Hold status: %s\n", legalHold.Status)
56
    } else {
57
        fmt.Printf("Legal Hold is not applied to version %s of object %s.\n", *versionID, *objectKey)
58
    }
59
}
60

61
// getObjectLegalHold получает настройки бессрочной блокировки для указанной версии объекта
62
func getObjectLegalHold(client *s3.Client, bucketName, objectKey, versionID string) (*types.ObjectLockLegalHold, error) {
63
    // Создает входные данные для запроса
64
    input := &s3.GetObjectLegalHoldInput{
65
        Bucket:    aws.String(bucketName),
66
        Key:       aws.String(objectKey),
67
        VersionId: aws.String(versionID),
68
    }
69

70
    // Выполняет запрос
71
    output, err := client.GetObjectLegalHold(context.TODO(), input)
72
    if err != nil {
73
        return nil, fmt.Errorf("failed to get Legal Hold: %w", err)
74
    }
75

76
    return output.LegalHold, nil
77
}

1
aws s3api put-object-legal-hold --bucket <имя бакета> --key <ключ объекта> --version-id <идентификатор версии> --legal-hold '{"Status":"ON"}'

1
import boto3
2
import argparse
3

4
def put_object_legal_hold(bucket_name, object_key, version_id, legal_hold_status):
5
    # Создает клиент для подключения к Object Storage
6
    s3_client = boto3.client('s3')
7

8
    try:
9
        # Применяет бессрочную блокировку для указанной версии объекта
10
        response = s3_client.put_object_legal_hold(
11
            Bucket=bucket_name,
12
            Key=object_key,
13
            VersionId=version_id,
14
            LegalHold={
15
                'Status': legal_hold_status
16
            }
17
        )
18
        # Выводит сообщение об успешной активации блокировки
19
        print(f"Legal hold enabled to version {version_id} of the object {object_key}.")
20

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

24
def main():
25
    # Создает  парсер аргументов командной строки
26
    parser = argparse.ArgumentParser(description='Apply legal hold status to the specified version of an object.')
27
    parser.add_argument('bucket_name', type=str, help='The name of the bucket')
28
    parser.add_argument('object_key', type=str, help='The key of the object')
29
    parser.add_argument('version_id', type=str, help='The ID of the version')
30
    parser.add_argument('legal_hold_status', type=str, choices=['ON', 'OFF'], help='The legal hold status to apply')
31

32
    # Парсит аргументы
33
    args = parser.parse_args()
34

35
    # В зависимости от переданного статуса применяет бессрочную блокировку для указанной версии объекта или снимает ее
36
    put_object_legal_hold(args.bucket_name, args.object_key, args.version_id, args.legal_hold_status)
37

38
if __name__ == '__main__':
39
    main()