Загрузка объекта

1
aws s3 cp <путь_к_локальному_файлу>/ s3://<имя_бакета>/<ключ_объекта>

1
aws s3api put-object \
2
  --bucket <имя_бакета> \
3
  --key <ключ объекта> \
4
  --body <путь к локальному файлу> \
5
  --storage-class <(опционально) класс хранения — STANDARD или WARM>

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.upload_file(
8
   'FILE_NAME',
9
   'BUCKET_NAME',
10
   'OBJECT_NAME',
11
   # ExtraArgs={'StorageClass': '<(опционально) класс хранения — STANDARD или WARM>'}
12
   )

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "log"
8
    "os"
9
    "path/filepath"
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
)
14

15
func main() {
16
    // Получаем имя бакета из аргумента командной строки
17
    bucketName := flag.String("b", "", "The name of the bucket")
18
    // Получаем из аргумента командной строки имя файла, который нужно загрузить в Object Storage
19
    filePath := flag.String("f", "", "Path to the file to upload")
20
    flag.Parse()
21

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

27
    if *filePath == "" {
28
        fmt.Println("You must supply the path to a file")
29
        return
30
    }
31

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

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

41
file, err := os.Open(*filePath)
42
    if err != nil {
43
        log.Fatalf("Unable to open file %q, %v", *filePath, err)
44
    }
45
    defer file.Close()
46

47
// Загружаем файл
48
    uploadInput := &s3.PutObjectInput{
49
        Bucket: aws.String(*bucketName),
50
        Key:    aws.String(filepath.Base(*filePath)), // Имя файла в S3
51
        Body:   file,
52
    }
53

54
    _, err = client.PutObject(context.TODO(), uploadInput)
55
    if err != nil {
56
        log.Fatalf("Unable to upload %q to %q, %v", *filePath, *bucketName, err)
57
    }
58

59
    fmt.Printf("Successfully uploaded %q to %q\n", *filePath, *bucketName)
60
}

1
import boto3
2
from botocore.config import Config
3

4
# Создаем сессию с указанием профиля по умолчанию
5
session = boto3.session.Session(profile_name='default')
6

7
# Создаем клиент S3
8
s3 = session.client(
9
    service_name='s3',
10
    endpoint_url='https://storage.mwsapis.ru/',
11
    config=Config(s3={'payload_signing_enabled': True})  # Включаем подпись полезной нагрузки для совместимости с конечной точкой
12
)
13

14
# Путь к локальному файлу
15
FILE_NAME = 'path/to/file.ext'
16

17
# Имя бакета и объекта в S3
18
BUCKET_NAME = 'bucket'
19
OBJECT_NAME = 'object'
20

21
# Открываем локальный файл в бинарном режиме
22
with open(FILE_NAME, 'rb') as file:
23
    # Выполняем составную загрузку файла в S3
24
    s3.upload_fileobj(
25
        file,
26
        BUCKET_NAME,
27
        OBJECT_NAME,
28
        # ExtraArgs={'StorageClass': '<(опционально) класс хранения — STANDARD или WARM>'}
29
    )
30

31
print(f'Successfully uploaded {FILE_NAME} to {BUCKET_NAME}/{OBJECT_NAME}')

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "log"
8
    "os"
9
    "path/filepath"
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
    "github.com/aws/aws-sdk-go-v2/feature/s3/manager"
15
    // "github.com/aws/aws-sdk-go-v2/service/s3/types" // Опциональный импорт для указания классов хранения
16
)
17

18
func main() {
19
    // Получаем имя бакета из аргумента командной строки
20
    bucketName := flag.String("b", "", "The name of the bucket")
21
    filePath := flag.String("f", "", "Path to the file to upload")
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 *filePath == "" {
30
        fmt.Println("You must supply the path to a file")
31
        return
32
    }
33

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

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

43
    file, err := os.Open(*filePath)
44
    if err != nil {
45
        log.Fatalf("Unable to open file %q, %v", *filePath, err)
46
    }
47
    defer file.Close()
48

49
    // Создаем составную загрузку
50
    uploader := manager.NewUploader(client)
51
    response, err := uploader.Upload(context.TODO(), &s3.PutObjectInput{
52
        Bucket:       aws.String(*bucketName),
53
        Key:          aws.String(filepath.Base(*filePath)),
54
        Body:         file,
55
        // StorageClass: types.StorageClass("<(опционально) класс хранения — STANDARD или WARM>")
56
    })
57
    if err != nil {
58
        log.Fatalf("Unable to upload %q to %q, %v", *filePath, *bucketName, err)
59
    }
60

61
    fmt.Printf("Successfully uploaded %q to %q, %+v\n", *filePath, *bucketName, response)
62
}

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

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

5
def list_multipart_uploads(bucket_name):
6
    # Cоздаем клиент для подключения к Object Storage
7
    s3 = boto3.client('s3')
8
    # Определяем функцию
9
    try:
10
        response = s3.list_multipart_uploads(Bucket=bucket_name)
11

12
        if 'Uploads' in response:
13
            print(f"Currently running uploads in the bucket '{bucket_name}':")
14
            print(f"Total: {len(response['Uploads'])}\n")
15

16
            for upload in response['Uploads']:
17
                print(f"Key: {upload['Key']}")
18
                print(f"Upload ID: {upload['UploadId']}")
19
                print(f"Started at: {upload['Initiated'].strftime('%Y-%m-%d %H:%M:%S')}")
20
        else:
21
            print("No running uploads found")
22

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

26
def main():
27
    # Создаем парсер аргументов
28
    parser = argparse.ArgumentParser(description='List multipart uploads in a bucket')
29
    parser.add_argument('bucket', help='S3 bucket name')
30

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

34
    # Вызываем функцию с переданным именем бакета
35
    list_multipart_uploads(args.bucket)
36

37
if __name__ == "__main__":
38
    main()

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "log"
8
    "time"
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
    result, err := client.ListMultipartUploads(context.TODO(), &s3.ListMultipartUploadsInput{
34
        Bucket: aws.String(*bucketName),
35
    })
36
    if err != nil {
37
        log.Fatal(err)
38
    }
39

40
    // Вывод результатов
41
    fmt.Printf("Currently running uploads in the bucket '%s':\n", *bucketName)
42
    fmt.Printf("Total: %d\n\n", len(result.Uploads))
43

44
    for _, upload := range result.Uploads {
45
        fmt.Printf("Object Key: %s\n", *upload.Key)
46
        fmt.Printf("Upload ID: %s\n", *upload.UploadId)
47
        fmt.Printf("Started at: %s\n", upload.Initiated.Local().Format(time.RFC3339))
48

49
    }
50
}

1
aws s3api abort-multipart-upload   --bucket <имя бакета>   --key "<ключ объекта>"   --upload-id "<идентификатор загрузки"

1
import boto3
2
import argparse
3

4
def abort_multipart_upload(bucket_name, key, upload_id):
5
    s3 = boto3.client('s3')
6

7
    try:
8
        s3.abort_multipart_upload(
9
            Bucket=bucket_name,
10
            Key=key,
11
            UploadId=upload_id
12
        )
13
        # Вывод в столбик с помощью многострочной f-строки
14
        print(f"""
15
Successfully aborted upload:
16
Bucket: {bucket_name}
17
Key: {key}
18
Upload ID: {upload_id}
19
""")
20
    except Exception as e:
21
        print(f"Error aborting upload {key}: {e}")
22

23
def main():
24
    parser = argparse.ArgumentParser(description='Abort multipart upload')
25
    parser.add_argument('bucket', help='S3 bucket name')
26
    parser.add_argument('key', help='Object key')
27
    parser.add_argument('upload_id', help='Upload ID')
28

29
    args = parser.parse_args()
30

31
    abort_multipart_upload(args.bucket, args.key, args.upload_id)
32

33
if __name__ == "__main__":
34
    main()

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "log"
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
    // Получаем имя бакета из аргумента командной строки
15
    bucketName := flag.String("b", "", "The name of the bucket")
16
    objectKey := flag.String("k", "", "The object key")
17
    uploadId := flag.String("i", "", "Upload ID")
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
    if *uploadId == "" {
31
        fmt.Println("You must supply the upload ID (-i UPLOAD_ID)")
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
    // Останавливаем незавершенную загрузку
45
    _, err = client.AbortMultipartUpload(context.TODO(), &s3.AbortMultipartUploadInput{
46
        Bucket:   aws.String(*bucketName),
47
        Key:      aws.String(*objectKey),
48
        UploadId: aws.String(*uploadId),
49
    })
50
    if err != nil {
51
        log.Fatal("Failed to abort multipart upload: ", err)
52
    }
53

54
    fmt.Printf("Successfully aborted multipart upload:\n")
55
    fmt.Printf("Bucket: %s\n", *bucketName)
56
    fmt.Printf("Object: %s\n", *objectKey)
57
    fmt.Printf("Upload ID: %s\n", *uploadId)
58
}

1
aws s3api list-multipart-uploads --bucket multipart \
2
  --query 'Uploads[].[Key, UploadId]' \
3
  --output text | \
4
while read key uploadid; do
5
    echo "Stopping upload: $key"
6
    aws s3api abort-multipart-upload \
7
      --bucket multipart \
8
      --key "$key" \
9
      --upload-id "$uploadid"
10
done

1
import boto3
2
import argparse
3

4
def abort_all_multipart_uploads(bucket_name):
5

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

9
    try:
10
        # Получаем список всех незавершенных загрузок
11
        response = s3.list_multipart_uploads(Bucket=bucket_name)
12

13
        if 'Uploads' not in response or not response['Uploads']:
14
            print(f"No multipart uploads found in bucket '{bucket_name}'")
15
            return
16

17
        uploads = response['Uploads']
18
        print(f"Found {len(uploads)} multipart upload(s) in bucket '{bucket_name}':")
19

20
        # Выводим информацию о загрузках
21
        for i, upload in enumerate(uploads, 1):
22
            print(f"{i}. Key: {upload['Key']}, Upload ID: {upload['UploadId']}")
23

24
        # Запрос подтверждения
25
        confirm = input(f"\nAre you sure you want to abort all {len(uploads)} upload(s)? (yes/no): ")
26

27
        if confirm.lower() != 'yes':
28
            print("Operation cancelled")
29
            return
30

31
        # Останавливаем все загрузки
32
        success_count = 0
33
        for upload in uploads:
34
            try:
35
                s3.abort_multipart_upload(
36
                    Bucket=bucket_name,
37
                    Key=upload['Key'],
38
                    UploadId=upload['UploadId']
39
                )
40
                print(f"Successfully aborted: {upload['Key']}")
41
                success_count += 1
42
            except Exception as e:
43
                print(f"Failed to abort {upload['Key']}: {e}")
44

45
        # Выводим информацию о завершении всех загрузок
46
        print(f"\nOperation completed. Successfully aborted {success_count} out of {len(uploads)} upload(s)")
47

48
    except Exception as e:
49
        print(f"Error: {e}")
50

51
def main():
52
    parser = argparse.ArgumentParser(description='Abort all multipart uploads in a bucket')
53
    parser.add_argument('bucket', help='S3 bucket name')
54

55
    args = parser.parse_args()
56
    abort_all_multipart_uploads(args.bucket)
57

58
if __name__ == "__main__":
59
    main()

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "log"
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
    // Получаем имя бакета из аргумента командной строки
15
    bucketName := flag.String("b", "", "The name of the bucket")
16
    flag.Parse()
17

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

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

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

32
    // Получаем список составных загрузок
33
    result, err := client.ListMultipartUploads(context.TODO(), &s3.ListMultipartUploadsInput{
34
        Bucket: aws.String(*bucketName),
35
    })
36
    if err != nil {
37
        log.Fatal(err)
38
    }
39

40
    // Проверяем, есть ли незавершенные загрузки
41
    if len(result.Uploads) == 0 {
42
        fmt.Printf("No multipart uploads found in bucket '%s'\n", *bucketName)
43
        return
44
    }
45

46
    // Выводим информацию о найденных незавершенных загрузках
47
    fmt.Printf("Found %d multipart upload(s) in bucket '%s':\n", len(result.Uploads), *bucketName)
48
    for i, upload := range result.Uploads {
49
        fmt.Printf("%d. Key: %s, Upload ID: %s\n", i+1, *upload.Key, *upload.UploadId)
50
    }
51

52
    // Запрашиваем подтверждение
53
    fmt.Printf("\nAre you sure you want to abort all %d upload(s)? (yes/no): ", len(result.Uploads))
54
    var confirm string
55
    fmt.Scanln(&confirm)
56

57
    if confirm != "yes" {
58
        fmt.Println("Operation cancelled")
59
        return
60
    }
61

62
    // Завершаем все составные загрузки
63
    successCount := 0
64
    for _, upload := range result.Uploads {
65
        _, err := client.AbortMultipartUpload(context.TODO(), &s3.AbortMultipartUploadInput{
66
            Bucket:   aws.String(*bucketName),
67
            Key:      aws.String(*upload.Key),
68
            UploadId: aws.String(*upload.UploadId),
69
        })
70
        if err != nil {
71
            fmt.Printf("Failed to abort upload '%s': %v\n", *upload.Key, err)
72
        } else {
73
            fmt.Printf("Successfully aborted upload: %s\n", *upload.Key)
74
            successCount++
75
        }
76
    }
77

78
    // Выводим итоговый результат
79
    fmt.Printf("\nOperation completed. Successfully aborted %d out of %d upload(s)\n",
80
        successCount, len(result.Uploads))
81
}