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

1
aws s3 rm s3://<имя бакета>/<ключ объекта>

1
# Импортируем boto3
2
import boto3
3

4
# Создаем сессию и клиент
5
session = boto3.session.Session(profile_name='default')
6
s3 = session.client(
7
   service_name='s3',
8
   endpoint_url='https://storage.mwsapis.ru'
9
)
10

11
# Определяем имя бакета и ключ объекта, который нужно удалить
12
bucket_name = 'bucket'
13
object_key = 'file.txt'
14

15
# Удаляем объект
16
try:
17
    s3.delete_object(
18
        Bucket=bucket_name,
19
        Key=object_key
20
    )
21
    print(f'Successfully deleted {object_key} 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
    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")
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
    deleteInput := &s3.DeleteObjectInput{
41
        Bucket: aws.String(*bucketName),
42
        Key:    aws.String(*objectKey),
43
    }
44

45
    _, err = client.DeleteObject(context.TODO(), deleteInput)
46
    if err != nil {
47
        log.Fatalf("Unable to delete %q from %q, %v", *objectKey, *bucketName, err)
48
    }
49

50
    fmt.Printf("Successfully deleted %q to %q\n", *objectKey, *bucketName)
51
}

1
aws s3 rm s3://<имя бакета> --recursive

1
import boto3
2
session = boto3.session.Session(profile_name='default')
3
s3 = session.client(
4
   service_name='s3',
5
   endpoint_url='https://storage.mwsapis.ru'
6
)
7
s3 = boto3.resource('s3')
8
bucket = s3.Bucket('bucket')
9
bucket_versioning = s3.BucketVersioning('bucket')
10
if bucket_versioning.status == 'Enabled':
11
    bucket.object_versions.delete()
12
else:
13
    bucket.objects.all().delete()

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

42
// Удаляем все объекты из бакета
43
deleteObjectsInput := &s3.DeleteObjectsInput{
44
    Bucket: aws.String(*bucketName),
45
    Delete: &types.Delete{
46
        Objects: make([]types.ObjectIdentifier, 0, len(result.Contents)),
47
    },
48
}
49

50
for _, object := range result.Contents {
51
    deleteObjectsInput.Delete.Objects = append(deleteObjectsInput.Delete.Objects, types.ObjectIdentifier{
52
        Key: object.Key,
53
    })
54
}
55

56
_, err = client.DeleteObjects(context.TODO(), deleteObjectsInput)
57
if err != nil {
58
    log.Fatal(err)
59
}
60
log.Printf("Successfully deleted all objects from bucket %s", *bucketName)
61

62
}

1
aws s3 rm s3://<имя бакета>/<префикс> --recursive

1
import boto3
2
import argparse
3

4
def delete_objects_with_prefix(bucket_name, prefix):
5
    session = boto3.session.Session(profile_name='default')
6
    s3 = session.client(
7
       service_name='s3',
8
       endpoint_url='https://storage.mwsapis.ru/'
9
    )
10

11
    # Получаем список всех объектов в бакете с указанным префиксом
12
    objects = s3.list_objects_v2(Bucket=bucket_name, Prefix=prefix)
13
    objects_to_delete = [{'Key': obj['Key']} for obj in objects.get('Contents', [])]
14

15
    # Удаляем объекты по частям, т.к. есть ограничение на количество объектов в одном запросе
16
    max_keys = 1000
17
    for i in range(0, len(objects_to_delete), max_keys):
18
        response = s3.delete_objects(
19
            Bucket=bucket_name,
20
            Delete={'Objects': objects_to_delete[i:i+max_keys]}
21
        )
22
        print(f"Deleted {len(response.get('Deleted', []))} objects")
23

24
    print(f"Object with {prefix} deleted")
25

26
if __name__ == "__main__":
27
    parser = argparse.ArgumentParser(description='Delete objects with a specific prefix from an S3 bucket')
28
    parser.add_argument('-b', '--bucket', required=True, help='Name of the bucket')
29
    parser.add_argument('-p', '--prefix', required=True, help='Prefix of the objects to delete')
30
    args = parser.parse_args()
31

32
    delete_objects_with_prefix(args.bucket, args.prefix)

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
    prefix := flag.String("p", "", "The name of the folder 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 *prefix == "" {
27
        fmt.Println("You must supply the prefix -p PREFIX)")
28
        return
29
    }
30

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

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

40
    // Получаем список всех объектов с указанным префиксом
41
    listObjectsInput := &s3.ListObjectsV2Input{
42
        Bucket:  aws.String(*bucketName),
43
        Prefix:  aws.String(*prefix),
44
        MaxKeys: aws.Int32(1000), // Максимальное количество объектов, которое можно получить за один вызов
45
    }
46

47
    listObjectsOutput, err := client.ListObjectsV2(context.TODO(), listObjectsInput)
48
    if err != nil {
49
        log.Fatal(err)
50
    }
51

52
    var objectIdentifiers []types.ObjectIdentifier
53
    for _, obj := range listObjectsOutput.Contents {
54
        objectIdentifiers = append(objectIdentifiers, types.ObjectIdentifier{Key: obj.Key})
55
    }
56

57
    // Удаляем все объекты с указанным префиксом
58
    deleteObjectsInput := &s3.DeleteObjectsInput{
59
        Bucket: aws.String(*bucketName),
60
        Delete: &types.Delete{
61
             Objects: objectIdentifiers,
62
        },
63
    }
64

65
    _, err = client.DeleteObjects(context.TODO(), deleteObjectsInput)
66
    if err != nil {
67
        log.Fatal(err)
68
    }
69

70
    log.Printf("Successfully deleted all objects with prefix %s", *prefix)
71
}