Добавление, изменение и удаление конфигурации

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

1
import boto3
2

3
# Создаем клиент S3
4
s3 = boto3.client('s3')
5

6
# Имя бакета
7
bucket_name = 'bucket'
8

9
try:
10
    # Получаем конфигурацию жизненного цикла
11
    response = s3.get_bucket_lifecycle_configuration(Bucket=bucket_name)
12

13
    # Выводим список правил жизненного цикла
14
    for rule in response.get('Rules', []):
15
        print(f"ID: {rule.get('ID')}")
16
        print(f"Status: {rule.get('Status')}")
17

18
        filter = rule.get('Filter', {})
19
        if 'Prefix' in filter:
20
            print(f"Prefix: {filter['Prefix']}")
21
        elif 'And' in filter:
22
            print("And Filter:")
23
            for key, value in filter['And'].items():
24
                print(f"  {key}: {value}")
25

26
        expiration = rule.get('Expiration', {})
27
        if 'Days' in expiration:
28
            print(f"Expiration Days: {expiration['Days']}")
29
        if 'Date' in expiration:
30
            print(f"Expiration Date: {expiration['Date']}")
31

32
        print()
33

34
except s3.exceptions.NoSuchLifecycleConfiguration:
35
    print(f"No lifecycle configuration found for bucket {bucket_name}")
36
except Exception as e:
37
    print(f"Error retrieving lifecycle configuration: {e}")

1
package main
2

3
import (
4
    "context"
5
    "log"
6
    "fmt"
7
    "github.com/aws/aws-sdk-go-v2/aws"
8
    "github.com/aws/aws-sdk-go-v2/config"
9
    "github.com/aws/aws-sdk-go-v2/service/s3"
10
)
11
var (
12
        bucketName = "new"
13
)
14

15
func main() {
16

17
    // Подгружаем конфигурацию из ~/.aws/*
18
    cfg, err := config.LoadDefaultConfig(context.TODO())
19
    if err != nil {
20
        log.Fatal(err)
21
    }
22

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

26
  // Получаем конфигурацию жизненного цикла
27
    output, err := client.GetBucketLifecycleConfiguration(context.TODO(), &s3.GetBucketLifecycleConfigurationInput{
28
        Bucket: aws.String(bucketName),
29
    })
30
    if err != nil {
31
        log.Fatalf("unable to get lifecycle configuration, %v", err)
32
    }
33

34
    // Выводим список правил жизненного цикла
35
    for _, rule := range output.Rules {
36
        fmt.Printf("ID: %s, Status: %s\n", aws.ToString(rule.ID), rule.Status)
37
        if rule.Filter != nil && rule.Filter.Prefix != nil {
38
            fmt.Printf("Prefix: %s\n", aws.ToString(rule.Filter.Prefix))
39
        }
40
        if rule.Expiration != nil && rule.Expiration.Days != nil {
41
            fmt.Printf("Expiration Days: %d\n", aws.ToInt32(rule.Expiration.Days))
42
        }
43
        fmt.Println()
44
    }
45
}

1
aws s3api put-bucket-lifecycle-configuration --bucket <имя бакета> --lifecycle-configuration file://<путь к файлу с правилами>

1
import boto3
2

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

6
# Имя бакета
7
bucket_name = 'bucket'
8

9
# Определяем правило жизненного цикла
10
lifecycle_configuration = {
11
    'Rules': [
12
        {
13
            'ID': 'DeleteObjectsInAWeek',
14
            'Status': 'Enabled',
15
            'Filter': {
16
                'Prefix': ''  # Применяется ко всем объектам
17
            },
18
            'Expiration': {
19
                'Days': 7  # Удаление через 1 неделю (7 дней)
20
            }
21
        }
22
    ]
23
}
24

25
# Устанавливаем конфигурацию жизненного цикла
26
s3.put_bucket_lifecycle_configuration(
27
    Bucket=bucket_name,
28
    LifecycleConfiguration=lifecycle_configuration
29
)
30
# Выводим сообщение об успешном добавлении правила
31
print("Lifecycle rule added successfully")

1
package main
2

3
import (
4
    "context"
5
    "fmt"
6
    "log"
7
    "github.com/aws/aws-sdk-go-v2/aws"
8
    "github.com/aws/aws-sdk-go-v2/config"
9
    "github.com/aws/aws-sdk-go-v2/service/s3"
10
    "github.com/aws/aws-sdk-go-v2/service/s3/types"
11
)
12

13
func main() {
14

15
// Подгружаем конфигурацию из ~/.aws/*
16
    cfg, err := config.LoadDefaultConfig(context.TODO())
17
    if err != nil {
18
        log.Fatal(err)
19
    }
20

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

24
    // Имя бакета
25
    bucketName := "bucket"
26

27
    // Определяем правило жизненного цикла
28
    lifecycleRule := types.LifecycleRule{
29
        ID:     aws.String("DeleteObjectsInAWeek"),
30
        Status: types.ExpirationStatusEnabled,
31
        Filter: &types.LifecycleRuleFilter{
32
            Prefix: aws.String(""), // Применяется ко всем объектам
33
        },
34
        Expiration: &types.LifecycleExpiration{
35
            Days: aws.Int32(7), // Удаление через 1 неделю
36
        },
37
    }
38

39
    // Устанавливаем конфигурацию жизненного цикла
40
    _, err = client.PutBucketLifecycleConfiguration(context.TODO(), &s3.PutBucketLifecycleConfigurationInput{
41
        Bucket: aws.String(bucketName),
42
        LifecycleConfiguration: &types.BucketLifecycleConfiguration{
43
            Rules: []types.LifecycleRule{lifecycleRule},
44
        },
45
    })
46
    if err != nil {
47
        log.Fatalf("unable to set lifecycle configuration, %v", err)
48
    }
49
     # Выводим сообщение об успешном добавлении правила
50
    fmt.Println("Lifecycle rule added successfully")
51
}

1
aws s3api put-bucket-lifecycle-configuration --bucket <имя бакета> --lifecycle-configuration file://<путь к файлу с правилами>

1
import boto3
2

3
# Создаем клиент S3
4
s3 = boto3.client('s3')
5

6
# Имя бакета
7
bucket_name = 'bucket'
8

9
# Получаем текущую конфигурацию жизненного цикла
10
try:
11
    response = s3.get_bucket_lifecycle_configuration(Bucket=bucket_name)
12
    lifecycle_rules = response.get('Rules', [])
13
except s3.exceptions.NoSuchLifecycleConfiguration:
14
    lifecycle_rules = []
15

16
# Изменяем или добавляем правила жизненного цикла
17
# Например, добавляем новое правило, если его еще нет
18
new_rule = {
19
    'ID': 'DeleteObjectsAfterOneDay',
20
    'Status': 'Enabled',
21
    'Filter': {
22
        'Prefix': ''  # Применяется ко всем объектам
23
    },
24
    'Expiration': {
25
        'Days': 1  # Удаление через 1 день
26
    }
27
}
28

29
# Проверяем, существует ли правило с таким ID, и обновляем его
30
rule_exists = False
31
for rule in lifecycle_rules:
32
    if rule['ID'] == new_rule['ID']:
33
        rule.update(new_rule)
34
        rule_exists = True
35
        break
36

37
# Если правило не существует, добавляем его
38
if not rule_exists:
39
    lifecycle_rules.append(new_rule)
40

41
# Устанавливаем обновленную конфигурацию жизненного цикла
42
s3.put_bucket_lifecycle_configuration(
43
    Bucket=bucket_name,
44
    LifecycleConfiguration={'Rules': lifecycle_rules}
45
)
46

47
print("Lifecycle configuration updated successfully")

1
package main
2

3
import (
4
    "context"
5
    "errors"
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
    "github.com/aws/smithy-go"
14
)
15

16
var (
17
    bucketName = "bucket"
18
)
19

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

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

30
    // Получаем текущую конфигурацию жизненного цикла
31
    lifecycleConfig, err := client.GetBucketLifecycleConfiguration(context.TODO(), &s3.GetBucketLifecycleConfigurationInput{
32
        Bucket: aws.String(bucketName),
33
    })
34

35
    if err != nil {
36
        var apiErr smithy.APIError
37
        if errors.As(err, &apiErr) && apiErr.ErrorCode() == "NoSuchLifecycleConfiguration" {
38
            // Если конфигурация отсутствует, инициализируем пустой список правил
39
            lifecycleConfig = &s3.GetBucketLifecycleConfigurationOutput{
40
                Rules: []types.LifecycleRule{},
41
            }
42
        } else {
43
            log.Fatalf("unable to get lifecycle configuration, %v", err)
44
        }
45
    }
46

47
    // Определяем новое правило жизненного цикла
48
    newRule := types.LifecycleRule{
49
        ID:     aws.String("DeleteObjectsAfterOneDay"),
50
        Status: types.ExpirationStatusEnabled,
51
        Filter: &types.LifecycleRuleFilter{
52
            Prefix: aws.String(""), // Применяется ко всем объектам
53
        },
54
        Expiration: &types.LifecycleExpiration{
55
            Days: aws.Int32(1), // Удаление через 1 день
56
        },
57
    }
58

59
    // Проверяем, существует ли правило с таким ID, и обновляем его
60
    ruleExists := false
61
    for i, rule := range lifecycleConfig.Rules {
62
        if aws.ToString(rule.ID) == aws.ToString(newRule.ID) {
63
            lifecycleConfig.Rules[i] = newRule
64
            ruleExists = true
65
            break
66
        }
67
    }
68

69
    // Если правило не существует, добавляем его
70
    if !ruleExists {
71
        lifecycleConfig.Rules = append(lifecycleConfig.Rules, newRule)
72
    }
73

74
    // Устанавливаем обновленную конфигурацию жизненного цикла
75
    _, err = client.PutBucketLifecycleConfiguration(context.TODO(), &s3.PutBucketLifecycleConfigurationInput{
76
        Bucket: aws.String(bucketName),
77
        LifecycleConfiguration: &types.BucketLifecycleConfiguration{
78
            Rules: lifecycleConfig.Rules,
79
        },
80
    })
81
    if err != nil {
82
        log.Fatalf("unable to set lifecycle configuration, %v", err)
83
    }
84

85
    fmt.Println("Lifecycle configuration updated successfully")
86
}

1
aws s3api delete-bucket-lifecycle --bucket <имя бакета>

1
import boto3
2

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

8
        # Удаляем конфигурацию жизненного цикла
9
        s3_client.delete_bucket_lifecycle(Bucket=bucket_name)
10

11
        print(f"Lifecycle configuration successfully deleted for bucket: {bucket_name}")
12

13
    except ClientError as e:
14
        print(f"Error deleting lifecycle configuration: {e}")
15
        raise
16
    except Exception as e:
17
        print(f"Unexpected error: {e}")
18
        raise
19

20
# Использование функции
21
try:
22
    bucket_name = "bucket"
23
    delete_bucket_lifecycle(bucket_name)
24
except Exception as e:
25
    print(f"Failed to delete lifecycle configuration: {e}")

1
package main
2

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

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

13
func main() {
14
    // Подгружаем конфигурацию из ~/.aws/*
15
    cfg, err := config.LoadDefaultConfig(context.TODO())
16
    if err != nil {
17
        log.Fatal(err)
18
    }
19

20
    // Создаем клиент для подключения к Object Storage
21
    client := s3.NewFromConfig(cfg)
22

23
    // Указываем имя бакета
24
    bucketName := "bucket"
25

26
    // Удаляем конфигурацию жизненного цикла
27
    _, err = client.DeleteBucketLifecycle(context.TODO(), &s3.DeleteBucketLifecycleInput{
28
        Bucket: aws.String(bucketName),
29
    })
30
    if err != nil {
31
        log.Fatalf("unable to delete lifecycle configuration, %v", err)
32
    }
33

34
    // Выводим сообщение об успешном удалении конфигурации
35
    fmt.Println("Lifecycle configuration deleted successfully for bucket:", bucketName)
36
}