复制文件（Go）

普通复制

普通复制适用于小文件的复制（文件大小建议小于1GB），当文件超过5GB时，需要使用分块复制。

以下代码用于复制文件：

package main

import (
    "fmt"
    "github.com/ks3sdklib/aws-sdk-go/aws"
    "github.com/ks3sdklib/aws-sdk-go/aws/awsutil"
    "github.com/ks3sdklib/aws-sdk-go/aws/credentials"
    "github.com/ks3sdklib/aws-sdk-go/service/s3"
)

func main() {
    // 创建访问凭证，请将<AccessKeyID>与<SecretAccessKey>替换成真正的值
    cre := credentials.NewStaticCredentials("<AccessKeyID>", "<SecretAccessKey>", "")
    // 创建S3Client，更多配置项请查看Go-SDK初始化文档
    client := s3.New(&aws.Config{
       Credentials: cre,                          // 访问凭证
       Region:      "BEIJING",                    // 填写您的Region
       Endpoint:    "ks3-cn-beijing.ksyuncs.com", // 填写您的Endpoint
    })
    // 填写存储空间名称
    bucket := "<bucket_name>"
    // 填写对象的key
    key := "<object_key>"
    // 填写源对象的key
    sourceKey := "<source_object_key>"
    // 复制文件
    resp, err := client.CopyObject(&s3.CopyObjectInput{
       Bucket:            aws.String(bucket),                         // 存储空间名称
       Key:               aws.String(key),                            // 对象的key
       CopySource:        aws.String("/" + bucket + "/" + sourceKey), // 源对象路径，空间名称与对象key的组合，通过斜杠分隔(’/’)，必填
       MetadataDirective: aws.String("COPY"),                         // 指定如何设置目标Object的对象元数据：COPY(默认)：复制源Object的对象元数据到目标Object；REPLACE：忽略源Object的对象元数据，直接采用请求中指定的对象元数据，必填
    })
    if err != nil {
       panic(err)
    }
    fmt.Println("结果：\n", awsutil.StringValue(resp))
}

复制加密文件

KS3托管密钥的服务器端加密（SSE-S3）

以下代码用于复制加密文件，加密方式为：KS3托管密钥的服务器端加密（SSE-S3）。

package main

import (
    "fmt"
    "github.com/ks3sdklib/aws-sdk-go/aws"
    "github.com/ks3sdklib/aws-sdk-go/aws/awsutil"
    "github.com/ks3sdklib/aws-sdk-go/aws/credentials"
    "github.com/ks3sdklib/aws-sdk-go/service/s3"
)

func main() {
    // 创建访问凭证，请将<AccessKeyID>与<SecretAccessKey>替换成真正的值
    cre := credentials.NewStaticCredentials("<AccessKeyID>", "<SecretAccessKey>", "")
    // 创建S3Client，更多配置项请查看Go-SDK初始化文档
    client := s3.New(&aws.Config{
        Credentials: cre,                          // 访问凭证
        Region:      "BEIJING",                    // 填写您的Region
        Endpoint:    "ks3-cn-beijing.ksyuncs.com", // 填写您的Endpoint
    })
    // 填写存储空间名称
    bucket := "<bucket_name>"
    // 填写对象的key
    key := "<object_key>"
    // 填写源对象的key
    sourceKey := "<source_object_key>"
    // 复制文件，使用KS3托管密钥的服务器端加密 (SSE-S3）
    resp, err := client.CopyObject(&s3.CopyObjectInput{
        Bucket:               aws.String(bucket),                         // 存储空间名称
        Key:                  aws.String(key),                            // 对象的key
        CopySource:           aws.String("/" + bucket + "/" + sourceKey), // 源对象路径，空间名称与对象key的组合，通过斜杠分隔(’/’)，必填
        ServerSideEncryption: aws.String("AES256"),                       // 使用KS3托管密钥的服务器端加密，合法值：AES256
    })
    if err != nil {
        panic(err)
    }
    fmt.Println("结果：\n", awsutil.StringValue(resp))
}

客户提供加密密钥的服务器端加密（SSE-C）

以下代码用于复制加密文件，加密方式为：客户提供加密密钥的服务器端加密（SSE-C）

package main

import (
    "fmt"
    "github.com/ks3sdklib/aws-sdk-go/aws"
    "github.com/ks3sdklib/aws-sdk-go/aws/awsutil"
    "github.com/ks3sdklib/aws-sdk-go/aws/credentials"
    "github.com/ks3sdklib/aws-sdk-go/service/s3"
    "github.com/ks3sdklib/aws-sdk-go/service/s3/s3util"
)

func main() {
    // 创建访问凭证，请将<AccessKeyID>与<SecretAccessKey>替换成真正的值
    cre := credentials.NewStaticCredentials("<AccessKeyID>", "<SecretAccessKey>", "")
    // 创建S3Client，更多配置项请查看Go-SDK初始化文档
    client := s3.New(&aws.Config{
        Credentials: cre,                          // 访问凭证
        Region:      "BEIJING",                    // 填写您的Region
        Endpoint:    "ks3-cn-beijing.ksyuncs.com", // 填写您的Endpoint
    })
    // 填写存储空间名称
    bucket := "<bucket_name>"
    // 填写对象的key
    key := "<object_key>"
    // 填写源对象的key
    sourceKey := "<source_object_key>"
    // 填写您用于加密的密钥，密钥长度支持16/24/32位
    SSECustomerKey := "<encryption_key>"
    // 复制文件，使用客户提供的加密密钥的服务器端加密（SSE-C）
    resp, err := client.CopyObject(&s3.CopyObjectInput{
        Bucket:               aws.String(bucket),                              // 存储空间名称
        Key:                  aws.String(key),                                 // 对象的key
        CopySource:           aws.String("/" + bucket + "/" + sourceKey),      // 源对象路径，空间名称与对象key的组合，通过斜杠分隔(’/’)，必填
        SSECustomerAlgorithm: aws.String("AES256"),                            // 客户端提供的加密算法，合法值：AES256
        SSECustomerKey:       aws.String(s3util.GetBase64Str(SSECustomerKey)), // 客户端提供的加密密钥进行Base64编码后的值
        SSECustomerKeyMD5:    aws.String(s3util.GetBase64MD5Str(SSECustomerKey)),    // 客户端提供的通过BASE64编码的通过128位MD5加密的密钥的MD5值
    })
    if err != nil {
        panic(err)
    }
    fmt.Println("结果：\n", awsutil.StringValue(resp))
}

普通复制对应的API为：PUT Object Copy。

分块复制

以下代码用于分块复制文件：

package main

import (
    "fmt"
    "github.com/ks3sdklib/aws-sdk-go/aws"
    "github.com/ks3sdklib/aws-sdk-go/aws/awsutil"
    "github.com/ks3sdklib/aws-sdk-go/aws/credentials"
    "github.com/ks3sdklib/aws-sdk-go/service/s3"
    "strconv"
)

func main() {
    // 创建访问凭证，请将<AccessKeyID>与<SecretAccessKey>替换成真正的值
    cre := credentials.NewStaticCredentials("<AccessKeyID>", "<SecretAccessKey>", "")
    // 创建S3Client，更多配置项请查看Go-SDK初始化文档
    client := s3.New(&aws.Config{
        Credentials: cre,                          // 访问凭证
        Region:      "BEIJING",                    // 填写您的Region
        Endpoint:    "ks3-cn-beijing.ksyuncs.com", // 填写您的Endpoint
    })
    // 填写存储空间名称
    bucket := "<bucket_name>"
    // 填写对象的Key
    dstKey := "<dst_object_key>"
    // 填写源对象的key
    sourceKey := "<src_object_key>"
    // 获取源对象信息
    headObjectResp, err := client.HeadObject(&s3.HeadObjectInput{
        Bucket: aws.String(bucket),
        Key:    aws.String(sourceKey),
    })
    if err != nil {
        panic(err)
    }
    // 源对象文件长度
    contentLength := *headObjectResp.ContentLength
    fmt.Println("源对象文件长度：", contentLength)
    // init
    initRet, err := client.CreateMultipartUpload(&s3.CreateMultipartUploadInput{
        Bucket: aws.String(bucket),
        Key:    aws.String(dstKey),
    })
    if err != nil {
        panic(err)
    }
    // 获取分块上传Id
    uploadId := *initRet.UploadID
    fmt.Println("uploadId：", uploadId)
    // 分块大小
    partSize := int64(5 * 1024 * 1024)
    // 待合并分块
    var compParts []*s3.CompletedPart
    // 块的序号
    var partNum int64 = 1
    // 块的起始位置
    var start int64 = 0
    // 块的结束位置
    var end int64 = 0
    for {
        // 如果结尾大于等于文件长度，结束
        if end >= contentLength {
            break
        }
        // 如果剩余长度小于分块大小，取剩余长度
        if start+partSize >= contentLength {
            end = contentLength
        } else {
            // 取分块大小
            end = start + partSize
        }
        // 分块拷贝
        resp, err := client.UploadPartCopy(&s3.UploadPartCopyInput{
            Bucket:          aws.String(bucket),
            Key:             aws.String(dstKey),
            CopySource:      aws.String("/" + bucket + "/" + sourceKey),
            UploadID:        aws.String(uploadId),
            PartNumber:      aws.Long(partNum),
            CopySourceRange: aws.String("bytes=" + strconv.FormatInt(start, 10) + "-" + strconv.FormatInt(end-1, 10)),
        })
        if err != nil {
            panic(err)
        }
        // 保存分块信息
        compParts = append(compParts, &s3.CompletedPart{PartNumber: aws.Long(partNum), ETag: resp.CopyPartResult.ETag})
        fmt.Printf("已拷贝上传第%d块,etag:%s\n", partNum, *resp.CopyPartResult.ETag)
        // 下一个块
        partNum++
        // 更新下一次拷贝的开始位置
        start = end
    }
    // complete
    compResp, err := client.CompleteMultipartUpload(&s3.CompleteMultipartUploadInput{
        Bucket:   aws.String(bucket),
        Key:      aws.String(dstKey),
        UploadID: aws.String(uploadId),
        MultipartUpload: &s3.CompletedMultipartUpload{
            Parts: compParts,
        },
    })
    if err != nil {
        panic(err)
    }
    fmt.Println("结果：\n", awsutil.StringValue(compResp))
}

分块复制对应的API为：Upload Part Copy。