Cкачивание объектов

1
aws s3 cp s3://<имя бакета>/<имя объекта> <имя файла в локальной файловой системе>

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
bucket =  'bucket'
8
key = 'file.txt'
9
local_path  = 'folder/file.txt'
10
s3.download_file(
11
    Bucket=bucket,
12
    Key=key,
13
    Filename=local_path
14
)
15
print(f'Successfully downloaded object {key} to {local_path}')

1
package main
2
import (
3
    "context"
4
    "flag"
5
    "fmt"
6
    "io"
7
    "log"
8
    "os"
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
func main() {
14
    // Получаем имя бакета из аргумента командной строки
15
    bucketName := flag.String("b", "", "The name of the bucket")
16
    objectKey := flag.String("k", "", "Key of the object to download")
17
    file := flag.String("f", "", "The local path to save the downloaded object")
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 object key (-k KEY)")
27
        return
28
    }
29

30
    if *file == "" {
31
        fmt.Println("You must supply the local file path (-f PATH)")
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
    localFile, err := os.Create(*file)
46
    if err != nil {
47
        log.Fatalf("Unable to create local file %q, %v", *file, err)
48
    }
49
    defer localFile.Close()
50

51
    downloadInput := &s3.GetObjectInput{
52
        Bucket: aws.String(*bucketName),
53
        Key:    aws.String(*objectKey),
54
    }
55

56
    objectResponse, err := client.GetObject(context.TODO(), downloadInput)
57
    if err != nil {
58
        log.Fatalf("Unable to download object %q from bucket %q, %v", *objectKey, *bucketName, err)
59
    }
60

61
    defer objectResponse.Body.Close()
62

63
    // Копируем содержимое объекта S3 в локальный файл
64
    bytesWritten, err := io.Copy(localFile, objectResponse.Body)
65
    if err != nil {
66
        log.Fatalf("Unable to write object contents to local file %q, %v", *file, err)
67
    }
68

69
    fmt.Printf("Successfully downloaded %q from bucket %q and wrote %d bytes to %q\n",
70
        *objectKey, *bucketName, bytesWritten, *file)
71
}

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

1
aws s3 cp s3://<префикс>/ . --recursive

1
import boto3
2
import os
3

4
def download_bucket(bucket_name, local_folder):
5
    """
6
    Скачивает все содержимое бакета
7
    """
8
    try:
9
        # Создаем сессию
10
        session = boto3.session.Session(profile_name='default')
11
        s3 = session.client(
12
            service_name='s3',
13
            endpoint_url='https://storage.mwsapis.ru/'
14
        )
15

16
        # Создаем локальную папку, если она не существует
17
        os.makedirs(local_folder, exist_ok=True)
18

19
        # Получаем список всех объектов в бакете
20
        paginator = s3.get_paginator('list_objects_v2')
21
        pages = paginator.paginate(Bucket=bucket_name)
22

23
        # Счетчики для статистики
24
        downloaded = 0
25
        failed = 0
26

27
        # Проходим по всем объектам
28
        for page in pages:
29
            if 'Contents' in page:
30
                for obj in page['Contents']:
31
                    key = obj['Key']
32

33
                    # Пропускаем пустые объекты (папки)
34
                    if key.endswith('/'):
35
                        # Создаем локальную папку
36
                        folder_path = os.path.join(local_folder, key)
37
                        os.makedirs(folder_path, exist_ok=True)
38
                        continue
39

40
                    local_path = os.path.join(local_folder, key)
41

42
                    # Создаем структуру папок
43
                    os.makedirs(os.path.dirname(local_path), exist_ok=True)
44

45
                    try:
46
                        print(f"Downloading: {key}")
47
                        s3.download_file(
48
                            Bucket=bucket_name,
49
                            Key=key,
50
                            Filename=local_path
51
                        )
52
                        downloaded += 1
53
                    except Exception as e:
54
                        print(f"Error downloading {key}: {e}")
55
                        failed += 1
56

57
        print(f"\nDownload completed:")
58
        print(f"Successfully downloaded: {downloaded} files")
59
        print(f"Failed to download: {failed} files")
60

61
    except Exception as e:
62
        print(f"Error: {e}")
63

64
# Использование
65
bucket_name = 'bucket'
66
local_folder = 'folder'
67

68
download_bucket(bucket_name, local_folder)

1
import boto3
2
import os
3

4
def download_files_with_prefix(bucket_name, prefix, local_folder):
5
    """
6
    Скачивает все файлы из бакета с указанным префиксом
7
    """
8
    try:
9
        # Создаем сессию
10
        session = boto3.session.Session(profile_name='default')
11
        s3 = session.client(
12
            service_name='s3',
13
            endpoint_url='https://storage.mwsapis.ru/'
14
        )
15

16
        # Создаем локальную папку, если она не существует
17
        os.makedirs(local_folder, exist_ok=True)
18

19
        # Получаем список всех объектов с указанным префиксом
20
        paginator = s3.get_paginator('list_objects_v2')
21
        pages = paginator.paginate(Bucket=bucket_name, Prefix=prefix)
22

23
        downloaded = 0
24
        failed = 0
25

26
        for page in pages:
27
            if 'Contents' in page:
28
                for obj in page['Contents']:
29
                    key = obj['Key']
30

31
                    # Пропускаем "папки" (объекты, заканчивающиеся на '/')
32
                    if key.endswith('/'):
33
                        continue
34

35
                    try:
36
                        # Формируем локальный путь
37
                        relative_path = key[len(prefix):] if key.startswith(prefix) else key
38
                        local_path = os.path.join(local_folder, relative_path.lstrip('/'))
39

40
                        # Создаем директорию для файла
41
                        directory = os.path.dirname(local_path)
42
                        if directory:
43
                            os.makedirs(directory, exist_ok=True)
44

45
                        print(f"Downloading: {key} to {local_path}")
46
                        s3.download_file(bucket_name, key, local_path)
47
                        downloaded += 1
48

49
                    except Exception as e:
50
                        print(f"Error downloading {key}: {e}")
51
                        failed += 1
52

53
        print(f"\nDownload completed:")
54
        print(f"Successfully downloaded: {downloaded} files")
55
        print(f"Failed to download: {failed} files")
56

57
    except Exception as e:
58
        print(f"Error: {e}")
59

60
    if __name__ == "__main__":
61
    bucket_name = 'bucket'
62
    prefix = 'folder1/'  # Префикс должен включать '/' если это папка
63
    local_folder = 'downloads'  # Локальная папка для сохранения
64

65
    download_files_with_prefix(bucket_name, prefix, local_folder)

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "io"
8
    "log"
9
    "os"
10
    "path/filepath"
11

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

17
func downloadObject(client *s3.Client, bucketName, objectKey, localPath string) error {
18
    // Создаем директории, если их нет
19
    if err := os.MkdirAll(filepath.Dir(localPath), 0755); err != nil {
20
        return fmt.Errorf("unable to create directory: %v", err)
21
    }
22

23
    // Создаем локальный файл
24
    localFile, err := os.Create(localPath)
25
    if err != nil {
26
        return fmt.Errorf("unable to create file %q: %v", localPath, err)
27
    }
28
    defer localFile.Close()
29

30
    // Скачиваем объект
31
    objectResponse, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
32
        Bucket: aws.String(bucketName),
33
        Key:    aws.String(objectKey),
34
    })
35
    if err != nil {
36
        return fmt.Errorf("unable to download object %q: %v", objectKey, err)
37
    }
38
    defer objectResponse.Body.Close()
39

40
    // Копируем содержимое в файл
41
    bytesWritten, err := io.Copy(localFile, objectResponse.Body)
42
    if err != nil {
43
        return fmt.Errorf("unable to write object to file: %v", err)
44
    }
45

46
    fmt.Printf("Downloaded %q (%d bytes)\n", objectKey, bytesWritten)
47
    return nil
48
}
49

50
func main() {
51
    // Получаем параметры из командной строки
52
    bucketName := flag.String("b", "", "The name of the bucket")
53
    outputDir := flag.String("o", "", "Output directory for downloaded files")
54
    flag.Parse()
55

56
    if *bucketName == "" {
57
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
58
        return
59
    }
60

61
    if *outputDir == "" {
62
        fmt.Println("You must supply the output directory (-o DIR)")
63
        return
64
    }
65

66
    // Создаем выходную директорию
67
    if err := os.MkdirAll(*outputDir, 0755); err != nil {
68
        log.Fatalf("Unable to create output directory: %v", err)
69
    }
70

71
    // Загружаем конфигурацию AWS
72
    cfg, err := config.LoadDefaultConfig(context.TODO())
73
    if err != nil {
74
        log.Fatal(err)
75
    }
76

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

80
    // Счетчики для статистики
81
    var downloaded, failed int
82

83
    // Получаем список всех объектов в бакете
84
    paginator := s3.NewListObjectsV2Paginator(client, &s3.ListObjectsV2Input{
85
        Bucket: aws.String(*bucketName),
86
    })
87

88
    // Проходим по всем объектам
89
    for paginator.HasMorePages() {
90
        page, err := paginator.NextPage(context.TODO())
91
        if err != nil {
92
            log.Printf("Error getting page: %v", err)
93
            continue
94
        }
95

96
        for _, obj := range page.Contents {
97
            // Пропускает "папки" (объекты, заканчивающиеся на '/')
98
            if aws.ToString(obj.Key) == "" || aws.ToString(obj.Key)[len(aws.ToString(obj.Key))-1] == '/' {
99
                continue
100
            }
101

102
            // Формируем локальный путь
103
            localPath := filepath.Join(*outputDir, aws.ToString(obj.Key))
104

105
            // Скачиваем объект
106
            err := downloadObject(client, *bucketName, aws.ToString(obj.Key), localPath)
107
            if err != nil {
108
                log.Printf("Error downloading %q: %v", aws.ToString(obj.Key), err)
109
                failed++
110
            } else {
111
                downloaded++
112
            }
113
        }
114
    }
115

116
    fmt.Printf("\nDownload completed:\n")
117
    fmt.Printf("Successfully downloaded: %d files\n", downloaded)
118
    fmt.Printf("Failed to download: %d files\n", failed)
119
}

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "io"
8
    "log"
9
    "os"
10
    "path/filepath"
11
    "strings"
12

13
    "github.com/aws/aws-sdk-go-v2/aws"
14
    "github.com/aws/aws-sdk-go-v2/config"
15
    "github.com/aws/aws-sdk-go-v2/service/s3"
16
)
17

18
func downloadObject(client *s3.Client, bucketName, objectKey, localPath string) error {
19
    // Создаем директории, если их нет
20
    if err := os.MkdirAll(filepath.Dir(localPath), 0755); err != nil {
21
        return fmt.Errorf("unable to create directory: %v", err)
22
    }
23

24
    // Создаем локальный файл
25
    localFile, err := os.Create(localPath)
26
    if err != nil {
27
        return fmt.Errorf("unable to create file %q: %v", localPath, err)
28
    }
29
    defer localFile.Close()
30

31
    // Скачиваем объект
32
    objectResponse, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
33
        Bucket: aws.String(bucketName),
34
        Key:    aws.String(objectKey),
35
    })
36
    if err != nil {
37
        return fmt.Errorf("unable to download object %q: %v", objectKey, err)
38
    }
39
    defer objectResponse.Body.Close()
40

41
    // Копируем содержимое в файл
42
    bytesWritten, err := io.Copy(localFile, objectResponse.Body)
43
    if err != nil {
44
        return fmt.Errorf("unable to write object to file: %v", err)
45
    }
46

47
    fmt.Printf("Downloaded %q (%d bytes)\n", objectKey, bytesWritten)
48
    return nil
49
}
50

51
func main() {
52
    // Получаем параметры из командной строки
53
    bucketName := flag.String("b", "", "The name of the bucket")
54
    prefix := flag.String("p", "", "Prefix for objects to download")
55
    outputDir := flag.String("o", "", "Output directory for downloaded files")
56
    flag.Parse()
57

58
    if *bucketName == "" {
59
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
60
        return
61
    }
62

63
    if *outputDir == "" {
64
        fmt.Println("You must supply the output directory (-o DIR)")
65
        return
66
    }
67

68
    // Создаем выходную директорию
69
    if err := os.MkdirAll(*outputDir, 0755); err != nil {
70
        log.Fatalf("Unable to create output directory: %v", err)
71
    }
72

73
    // Загружаем конфигурацию AWS
74
    cfg, err := config.LoadDefaultConfig(context.TODO())
75
    if err != nil {
76
        log.Fatal(err)
77
    }
78

79
    // Создаем клиент S3
80
    client := s3.NewFromConfig(cfg)
81

82
    // Счетчики для статистики
83
    var downloaded, failed int
84

85
    // Получаем список объектов с указанным префиксом
86
    paginator := s3.NewListObjectsV2Paginator(client, &s3.ListObjectsV2Input{
87
        Bucket: aws.String(*bucketName),
88
        Prefix: prefix,  // Добавляет префикс
89
    })
90

91
    // Проходим по всем объектам
92
    for paginator.HasMorePages() {
93
        page, err := paginator.NextPage(context.TODO())
94
        if err != nil {
95
            log.Printf("Error getting page: %v", err)
96
            continue
97
        }
98

99
        for _, obj := range page.Contents {
100
            key := aws.ToString(obj.Key)
101

102
            // Пропускаем "папки"
103
            if key == "" || strings.HasSuffix(key, "/") {
104
                continue
105
            }
106

107
            // Формируем локальный путь, удаляя префикс
108
            relativePath := strings.TrimPrefix(key, *prefix)
109
            localPath := filepath.Join(*outputDir, relativePath)
110

111
            // Скачиваем объект
112
            err := downloadObject(client, *bucketName, key, localPath)
113
            if err != nil {
114
                log.Printf("Error downloading %q: %v", key, err)
115
                failed++
116
            } else {
117
                downloaded++
118
            }
119
        }
120
    }
121

122
    fmt.Printf("\nDownload completed:\n")
123
    fmt.Printf("Successfully downloaded: %d files\n", downloaded)
124
    fmt.Printf("Failed to download: %d files\n", failed)
125
}

1
aws s3api get-object --bucket <имя бакета> --key <ключ объекта> --range bytes=0-500

1
import boto3
2

3
session = boto3.session.Session(profile_name='default')
4
s3 = session.client(
5
    service_name='s3',
6
    endpoint_url='https://storage.mwsapis.ru/'
7
)
8

9
bucket = 'bucket'
10
key = 'file.txt'
11
local_path = 'folder/file.txt'
12

13
# Указываем диапазон байтов для скачивания
14
start_byte = 1000
15
end_byte = 2000
16

17
range_header = f'bytes={start_byte}-{end_byte}'
18

19
try:
20
    response = s3.get_object(
21
        Bucket=bucket,
22
        Key=key,
23
        Range=range_header
24
    )
25

26
    with open(local_path, 'wb') as file:
27
        file.write(response['Body'].read())
28

29
    print(f'Successfully downloaded {response["ContentRange"]} bytes of object {key} to {local_path}')
30
except Exception as e:
31
    print(f'Error downloading object: {e}')

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "io"
8
    "log"
9
    "os"
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
)
15

16
func main() {
17
    bucketName := flag.String("b", "", "The name of the bucket")
18
    objectKey := flag.String("k", "", "Key of the object to download")
19
    file := flag.String("f", "", "The local path to save the downloaded object")
20
    startByte := flag.Int64("s", 0, "Start byte position to download from")
21
    endByte := flag.Int64("e", 0, "End byte position to download to (inclusive)")
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 *objectKey == "" {
30
        fmt.Println("You must supply the object key (-k KEY)")
31
        return
32
    }
33

34
    if *file == "" {
35
        fmt.Println("You must supply the local file path (-f PATH)")
36
        return
37
    }
38

39
    cfg, err := config.LoadDefaultConfig(context.TODO())
40
    if err != nil {
41
        log.Fatal(err)
42
    }
43

44
    client := s3.NewFromConfig(cfg)
45

46
    localFile, err := os.Create(*file)
47
    if err != nil {
48
        log.Fatalf("Unable to create local file %q, %v", *file, err)
49
    }
50
    defer localFile.Close()
51

52
    rangeHeader := fmt.Sprintf("bytes=%d-%d", *startByte, *endByte)
53

54
    downloadInput := &s3.GetObjectInput{
55
        Bucket: aws.String(*bucketName),
56
        Key:    aws.String(*objectKey),
57
        Range:  aws.String(rangeHeader),
58
    }
59

60
    objectResponse, err := client.GetObject(context.TODO(), downloadInput)
61
    if err != nil {
62
        log.Fatalf("Unable to download object %q from bucket %q, %v", *objectKey, *bucketName, err)
63
    }
64

65
    defer objectResponse.Body.Close()
66

67
    bytesWritten, err := io.Copy(localFile, objectResponse.Body)
68
    if err != nil {
69
        log.Fatalf("Unable to write object contents to local file %q, %v", *file, err)
70
    }
71

72
    fmt.Printf("Successfully downloaded %q from bucket %q and wrote %d bytes to %q\n",
73
        *objectKey, *bucketName, bytesWritten, *file)
74
}