Удаление и восстановление объектов

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

1
mport boto3
2

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
# Параметры
11
bucket_name = 'bucket'
12
object_key = 'object.txt'
13
version_id ='000628EF3260410C'
14
# Удаляем объект
15
try:
16
    s3.delete_object(
17
        Bucket=bucket_name,
18
        Key=object_key,
19
        VersionId=version_id
20
    )
21
    print(f'Successfully deleted {object_key}, version {version_id} from {bucket_name}')
22
except Exception as e:
23
    print(f'Error deleting object: {e}')

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
    objectKey := flag.String("k", "", "The key of the object to delete")
18
    versionId := flag.String("v", "", "The ID of the version to delete")
19
    flag.Parse()
20

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

26
    if *objectKey == "" {
27
        fmt.Println("You must supply the key of an object")
28
        return
29
    }
30
    if *versionId == "" {
31
        fmt.Println("You must supply the ID of the version")
32
        return
33
    }
34

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

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

44
    deleteInput := &s3.DeleteObjectInput{
45
        Bucket:    aws.String(*bucketName),
46
        Key:       aws.String(*objectKey),
47
        VersionId: aws.String(*versionId),
48
    }
49

50
    _, err = client.DeleteObject(context.TODO(), deleteInput)
51
    if err != nil {
52
        log.Fatalf("Unable to delete version %q of object %q from %q, %v", *versionId, *objectKey, *bucketName, err)
53
    }
54

55
    fmt.Printf("Successfully deleted version %q of object %q from %q\n", *versionId, *objectKey, *bucketName)
56
}

1
import boto3
2

3
# Создаем ресурс S3
4
session = boto3.session.Session(profile_name='default')
5
s3 = session.resource('s3', endpoint_url='https://storage.mwsapis.ru')
6

7
# Указываем имя бакета
8
bucket_name = 'bucket'
9
bucket = s3.Bucket(bucket_name)
10

11
# Проверяем, включено ли версионирование
12
bucket_versioning = s3.BucketVersioning(bucket_name)
13
if bucket_versioning.status == 'Enabled':
14
    # Удаляем все версии объектов
15
    for version in bucket.object_versions.all():
16
        version.delete()
17
    print("All objects and versions have been successfully deleted")
18
else:
19
    print("Versioning is not enabled in the bucket")

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
    paginator := s3.NewListObjectVersionsPaginator(client, &s3.ListObjectVersionsInput{
36
        Bucket: aws.String(*bucketName),
37
    })
38

39
    for paginator.HasMorePages() {
40
        page, err := paginator.NextPage(context.TODO())
41
        if err != nil {
42
            log.Fatal(err)
43
        }
44

45
        // Удаляем все версии объектов из бакета
46
        deleteObjectsInput := &s3.DeleteObjectsInput{
47
            Bucket: aws.String(*bucketName),
48
            Delete: &types.Delete{
49
                Objects: make([]types.ObjectIdentifier, 0, len(page.Versions)+len(page.DeleteMarkers)),
50
            },
51
        }
52

53
        for _, version := range page.Versions {
54
            deleteObjectsInput.Delete.Objects = append(deleteObjectsInput.Delete.Objects, types.ObjectIdentifier{
55
                Key:       version.Key,
56
                VersionId: version.VersionId,
57
            })
58
        }
59

60
        for _, marker := range page.DeleteMarkers {
61
            deleteObjectsInput.Delete.Objects = append(deleteObjectsInput.Delete.Objects, types.ObjectIdentifier{
62
                Key:       marker.Key,
63
                VersionId: marker.VersionId,
64
            })
65
        }
66

67
        if len(deleteObjectsInput.Delete.Objects) > 0 {
68
            _, err = client.DeleteObjects(context.TODO(), deleteObjectsInput)
69
            if err != nil {
70
                log.Fatal(err)
71
            }
72
        }
73
    }
74

75
    log.Printf("Successfully deleted all versions and delete markers from bucket %s", *bucketName)
76
}

1
import boto3
2

3
# Создаем сессию и клиент
4
session = boto3.session.Session(profile_name='default')
5
s3 = session.client('s3')
6

7
# Параметры
8
bucket_name = 'bucket'
9
object_key = 'object.txt'
10

11
# Получаем список всех версий объекта
12
response = s3.list_object_versions(
13
    Bucket=bucket_name,
14
    Prefix=object_key
15
)
16

17
# Ищем последний маркер удаления (IsLatest: True)
18
delete_marker_version_id = None
19
for delete_marker in response.get('DeleteMarkers', []):
20
    if delete_marker['Key'] == object_key and delete_marker['IsLatest']:
21
        delete_marker_version_id = delete_marker['VersionId']
22
        print(f"Found latest delete marker with version ID: {delete_marker_version_id}")
23
        break
24

25
# Удаляем маркер удаления, если он найден
26
if delete_marker_version_id:
27
    s3.delete_object(
28
        Bucket=bucket_name,
29
        Key=object_key,
30
        VersionId=delete_marker_version_id
31
    )
32
    print(f"Successfully removed the latest delete marker for {object_key} in {bucket_name}")
33
else:
34
    print(f"No delete marker found for {object_key} in {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/config"
10
    "github.com/aws/aws-sdk-go-v2/service/s3"
11
    "github.com/aws/aws-sdk-go-v2/service/s3/types"
12
)
13

14
func main() {
15
    // Получаем имя бакета и ключ объекта из аргумента командной строки
16
    bucketName := flag.String("b", "", "The name of the bucket")
17
    objectKey := flag.String("k", "", "The key of the object to restore")
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
    if *objectKey == "" {
26
        fmt.Println("You must supply the key of an object (-k KEY)")
27
        return
28
    }
29

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

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

39
    // Получаем список всех версий объекта
40
    listInput := &s3.ListObjectVersionsInput{
41
        Bucket: bucketName,
42
        Prefix: objectKey,
43
    }
44

45
    listOutput, err := client.ListObjectVersions(context.TODO(), listInput)
46
    if err != nil {
47
        log.Fatalf("Failed to list object versions: %v", err)
48
    }
49

50
    // Ищем последний маркер удаления (IsLatest: true)
51
    var latestDeleteMarker *types.DeleteMarkerEntry
52
    for _, marker := range listOutput.DeleteMarkers {
53
        if *marker.Key == *objectKey && *marker.IsLatest {
54
            latestDeleteMarker = &marker
55
            break
56
        }
57
    }
58

59
    // Удаляем маркер удаления, если он найден
60
    if latestDeleteMarker != nil {
61
        _, err = client.DeleteObject(context.TODO(), &s3.DeleteObjectInput{
62
            Bucket:    bucketName,
63
            Key:       objectKey,
64
            VersionId: latestDeleteMarker.VersionId,
65
        })
66
        if err != nil {
67
            log.Fatalf("Failed to delete delete marker: %v", err)
68
        }
69
        fmt.Printf("Successfully removed the latest delete marker and restored object %q to the latest version in bucket %q (Version ID: %s)\n",
70
            *objectKey, *bucketName, *latestDeleteMarker.VersionId)
71
    } else {
72
        fmt.Printf("No delete marker found for object %q in bucket %q\n", *objectKey, *bucketName)
73
    }
74
}