通过Golang应用实现AWS S3到Azure Blob大文件高效复制方案咨询

针对10GB文件用StartCopyFromURL耗时10分钟的问题，核心原因是该接口为单线程后台复制，跨云场景下无法充分利用带宽。Azure Blob支持分段并行复制（对应AWS的分段跨桶复制），以下是Golang实现方案：

核心实现步骤 #

1. 前置准备 #

• 获取S3文件的元信息（大小），用于计算分块数
• 生成S3对象的预签名URL（Azure需要可访问的源URL，有效期设为复制所需时长，比如4小时）

2. 分段并行复制代码示例 #

import (
    "context"
    "fmt"
    "math"
    "sync"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3"
    "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)

const (
    chunkSize       = 64 * 1024 * 1024 // 64MB分块，最大支持100MB
    maxConcurrency  = 15               // 控制并发数，避免请求过载
)

// 获取S3文件大小
func getS3ObjectSize(bucket, key string) (int64, error) {
    sess, err := session.NewSession(&aws.Config{Region: aws.String("us-east-1")})
    if err != nil {
        return 0, err
    }
    svc := s3.New(sess)
    resp, err := svc.HeadObject(&s3.HeadObjectInput{
        Bucket: aws.String(bucket),
        Key:    aws.String(key),
    })
    if err != nil {
        return 0, err
    }
    return *resp.ContentLength, nil
}

// 生成S3预签名URL
func generateS3PresignedURL(bucket, key string) (string, error) {
    sess, err := session.NewSession(&aws.Config{Region: aws.String("us-east-1")})
    if err != nil {
        return "", err
    }
    svc := s3.New(sess)
    req, _ := svc.GetObjectRequest(&s3.GetObjectInput{
        Bucket: aws.String(bucket),
        Key:    aws.String(key),
    })
    return req.Presign(3600 * 4) // 4小时有效期
}

// 并行复制大文件到Azure Blob
func parallelCopyS3ToAzure(s3PresignedURL, azConnStr, azContainer, azBlobName string, fileSize int64) error {
    ctx := context.Background()
    containerClient, err := azblob.NewContainerClientFromConnectionString(azConnStr, azContainer, nil)
    if err != nil {
        return err
    }
    blobClient := containerClient.NewBlockBlobClient(azBlobName)

    chunkCount := int(math.Ceil(float64(fileSize) / float64(chunkSize)))
    var wg sync.WaitGroup
    var blockIDs []string
    var mu sync.Mutex
    sem := make(chan struct{}, maxConcurrency) // 并发控制信号量

    for i := 0; i < chunkCount; i++ {
        sem <- struct{}{}
        wg.Add(1)
        go func(idx int) {
            defer func() {
                wg.Done()
                <-sem
            }()

            startOffset := int64(idx) * chunkSize
            endOffset := startOffset + chunkSize - 1
            if endOffset >= fileSize {
                endOffset = fileSize - 1
            }

            blockID := azblob.BlockID(fmt.Sprintf("block-%06d", idx))
            _, err := blobClient.StageBlockFromURL(ctx, blockID, s3PresignedURL, &azblob.StageBlockFromURLOptions{
                SourceRange: &azblob.HttpRange{
                    Offset: startOffset,
                    Count:  endOffset - startOffset + 1,
                },
            })
            if err != nil {
                // 实际项目中建议添加指数退避重试逻辑，比如使用backoff库
                panic(fmt.Errorf("stage block %d failed: %w", idx, err))
            }

            mu.Lock()
            blockIDs = append(blockIDs, string(blockID))
            mu.Unlock()
        }(i)
    }

    wg.Wait()
    // 提交块列表，合并为完整Blob
    _, err = blobClient.CommitBlockList(ctx, blockIDs, nil)
    return err
}

关键优化细节 #

• 分块大小：选择64MB或100MB，平衡单个块的传输时间和请求数量
• 并发控制：用信号量限制并发数（建议10-20），避免触发S3或Azure的请求频率限制
• 错误重试：对StageBlockFromURL添加重试逻辑，处理跨云网络波动导致的失败
• 预签名URL：确保有效期覆盖整个复制过程，TB级文件可能需要更长时间

效果对比 #

采用分段并行复制后，10GB文件的复制时间可缩短至2-3分钟（取决于带宽和并发数），远优于单线程的StartCopyFromURL。

内容的提问来源于stack exchange，提问作者omer blechman