使用go将文件流上传到AWS S3

Question

我想直接将multipart/form-data（大型）文件上传到AWS S3，并尽可能地减少内存和文件磁盘占用。 我该如何实现？ 在线资源仅解释如何上传并在服务器上本地存储文件。

- machete

Answer 1

你可以使用上传管理器来流式传输文件并上传它，你可以在源代码中阅读注释。 你也可以配置参数来设置分块大小、并发数和最大上传分块数，下面是一个参考示例代码。

package main

import (
    "fmt"
    "os"

    "github.com/aws/aws-sdk-go/aws/credentials"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3/s3manager"
)

var filename = "file_name.zip"
var myBucket = "myBucket"
var myKey = "file_name.zip"
var accessKey = ""
var accessSecret = ""

func main() {
    var awsConfig *aws.Config
    if accessKey == "" || accessSecret == "" {
        //load default credentials
        awsConfig = &aws.Config{
            Region: aws.String("us-west-2"),
        }
    } else {
        awsConfig = &aws.Config{
            Region:      aws.String("us-west-2"),
            Credentials: credentials.NewStaticCredentials(accessKey, accessSecret, ""),
        }
    }

    // The session the S3 Uploader will use
    sess := session.Must(session.NewSession(awsConfig))

    // Create an uploader with the session and default options
    //uploader := s3manager.NewUploader(sess)

    // Create an uploader with the session and custom options
    uploader := s3manager.NewUploader(sess, func(u *s3manager.Uploader) {
        u.PartSize = 5 * 1024 * 1024 // The minimum/default allowed part size is 5MB
        u.Concurrency = 2            // default is 5
    })

    //open the file
    f, err := os.Open(filename)
    if err != nil {
        fmt.Printf("failed to open file %q, %v", filename, err)
        return
    }
    //defer f.Close()

    // Upload the file to S3.
    result, err := uploader.Upload(&s3manager.UploadInput{
        Bucket: aws.String(myBucket),
        Key:    aws.String(myKey),
        Body:   f,
    })

    //in case it fails to upload
    if err != nil {
        fmt.Printf("failed to upload file, %v", err)
        return
    }
    fmt.Printf("file uploaded to, %s\n", result.Location)
}

- maaz

---

谢谢您的回答。如果我的文件小于5MB，它仍然会被流式传输到S3吗？但是我理解，无论如何，只有在完全上传后，该文件才会出现在S3上？ - Vitaly Zdanevich

是的，它将会一次性地以流的形式传输。正确的，文件将在完全上传后出现。 - maaz

Answer 2

你可以使用 minio-go 来实现：

n, err := s3Client.PutObject("bucket-name", "objectName", object, size, "application/octet-stream")

PutObject()会自动在内部执行分段上传。示例

- koolhead17

---

我认为这不是正确的答案，因为在这里我们无法对部分进行控制，而AWS API使我们能够访问单独上传每个部分并发送初始/完成/中止上传命令。 - meshkati

这里链接的示例实际上并没有使用PubObject进行流式传输。 - fIwJlxSzApHEZIl

Answer 3

我试图使用aws-sdk v2包来完成这个任务，所以必须稍微修改@maaz的代码。我把它留在这里供其他人参考 -

type TokenMeta struct {
    AccessToken  string 
    SecretToken  string 
    SessionToken string 
    BucketName   string
}


// Create S3Client struct with the token meta and use it as a receiver for this method
func (s3Client S3Client) StreamUpload(fileToUpload string, fileKey string) error {
    accessKey := s3Client.TokenMeta.AccessToken
    secretKey := s3Client.TokenMeta.SecretToken

    awsConfig, err := config.LoadDefaultConfig(context.TODO(),
        config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKey, secretKey, s3Client.TokenMeta.SessionToken)),
    )
    if err != nil {
        return fmt.Errorf("error creating aws config: %v", err)
    }

    client := s3.NewFromConfig(awsConfig)
    uploader := manager.NewUploader(client, func(u *manager.Uploader) {
        u.PartSize = 5 * 1024 * 1024
        u.BufferProvider = manager.NewBufferedReadSeekerWriteToPool(10 * 1024 * 1024)
    })

    f, err := os.Open(fileToUpload)
    if err != nil {
        return fmt.Errorf("failed to open fileToUpload %q, %v", fileToUpload, err)
    }
    defer func(f *os.File) {
        err := f.Close()
        if err != nil {
            fmt.Errorf("error closing fileToUpload: %v", err)
        }
    }(f)

    inputObj := &s3.PutObjectInput{
        Bucket: aws.String(s3Client.TokenMeta.BucketName),
        Key:    aws.String(fileKey),
        Body:   f,
    }
    uploadResult, err := uploader.Upload(context.TODO(), inputObj)
    if err != nil {
        return fmt.Errorf("failed to uploadResult fileToUpload, %v", err)
    }

    fmt.Printf("%s uploaded to, %s\n", fileToUpload, uploadResult.Location)
    return nil
}

- leoOrion

Answer 4

另一个选择是使用 goofys挂载S3存储桶，然后将写入流传输到挂载点。goofys不会在本地缓冲内容，因此对于大文件可以正常工作。

- khc

Answer 5

我没有尝试过，但如果我是你，我会尝试使用多部分上传选项。

你可以阅读文档multipartupload。

这里提供了关于多部分上传和多部分上传中止的go示例。

- MIkCode

---

嗯，看起来我只能在主体中使用ReaderSeeker，这意味着直接流式传输不可能。 - machete