初始化分片上传任务

功能说明

分片上传操作可以将超过5GB的大文件分割后上传，分片上传对象首先需要发起分片上传请求获取一个upload id。

代码示例

func CreateMultipartUpload(svc *s3.S3) {
    createMultipartUploadInput := &s3.CreateMultipartUploadInput{
        Bucket: aws.String("<your-bucket-name>"),
        Key:    aws.String("<your-object-key>"),
    }
    createMultipartUploadOutput, err := svc.CreateMultipartUpload(createMultipartUploadInput)
    if err != nil {
        fmt.Printf("fail to create multipart upload. %v", err)
    } else {
        fmt.Printf("upload id: %v\n", *createMultipartUploadOutput.UploadId)
    }
}

通过CreateMultipartUploadRequest操作获取对象：

CreateMultipartUploadRequest操作首先生成一个"request.Request"对象，该对象是一个执行CreateMultipartUpload操作的请求。通过调用Request对象的Send方法完成初始化分片上传的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。
func CreateMultipartUploadRequest(svc *s3.S3) {
    createMultipartUploadInput := &s3.CreateMultipartUploadInput{
        Bucket: aws.String("<your-bucket-name>"),
        Key:    aws.String("<your-object-key>"),
    }
    req, createMultipartUploadOutput := svc.CreateMultipartUploadRequest(createMultipartUploadInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to create multipart upload. %v", err)
    } else {
        fmt.Printf("upload id: %v\n", *createMultipartUploadOutput.UploadId)
    }
}

请求参数

CreateMultipartUploadInput可设置的参数如下：

参数	类型	说明	是否必要
ACL	*string	配置上传对象的预定义的标准ACL信息，例如private，public-read，public-read-write等	否
Bucket	*string	bucket的名称	是
ContentType	*string	描述上传文件格式的标准MIME类型	否
GrantFullControl	*string	用于自定义用户对此对象的FULL_CONTROL权限信息	否
GrantRead	*string	用于自定义用户对此对象的READ权限信息	否
GrantReadACP	*string	用于自定义用户对此对象的READ_ACP权限信息	否
GrantWrite	*string	用于自定义用户对此对象的WRITE权限信息	否
GrantWriteACP	*string	用于自定义用户对此对象的WRITE_ACP权限信息	否
Key	*string	上传文件到对象存储服务后对应的key	是
Metadata	map[string]*string	对象的元数据信息	否
Tagging	*string	对象的标签信息，必须是URL请求参数的形式。例如，"Key1=Value1"	否
WebsiteRedirectLocation	*string	如果bucket被配置用于提供网站的静态数据，该参数可以用于设置访问对象时候重定向到当前bucket下的其他对象或者外部的URL	否

返回结果

CreateMultipartUploadOutput返回的属性如下：

参数	类型	说明
Bucket	*string	执行分片上传的桶的名称
Key	*string	本次分片上传对象的名称
UploadId	*string	本次生成分片上传任务的id

上传分片

功能说明

初始化分片上传任务后，指定分片上传任务的id可以上传分片数据，可以将大文件分割成分片后上传，除了最后一个分片，每个分片的数据大小为5MB~5GB，每个分片上传任务最多上传10000个分片。

代码示例

func UploadPart(svc *s3.S3) {
    file, err := os.Open("<file-path>")
    if err != nil {
        fmt.Printf("Unable to open file:%v", err)
        os.Exit(1)
    }
    defer func() {
        err := file.Close()
        if err != nil {
            fmt.Printf("fail to close file. %v\n", err)
        }
    }()

    uploadPartInput := &s3.UploadPartInput{
        Body:       file,
        Bucket:     aws.String("<your-bucket-name>"),
        Key:        aws.String("<your-object-key>"),
        PartNumber: aws.Int64(1),
        UploadId:   aws.String("<your-upload-id>"),
    }
    uploadPartOutput, err := svc.UploadPart(uploadPartInput)
    if err != nil {
        fmt.Printf("fail to upload part. %v\n", err)
    } else {
        fmt.Println(uploadPartOutput)
    }
}

通过UploadPartRequest操作获取对象：

UploadPartRequest操作首先生成一个"request.Request"对象，该对象是一个执行UploadPart操作的请求。通过调用Request对象的Send方法完成上传分片的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func UploadPartRequest(svc *s3.S3) {
    file, err := os.Open("<file-path>")
    if err != nil {
        fmt.Printf("Unable to open file:%v", err)
        os.Exit(1)
    }
    defer func() {
        err := file.Close()
        if err != nil {
            fmt.Printf("fail to close file. %v\n", err)
        }
    }()

    uploadPartInput := &s3.UploadPartInput{
        Body:       file,
        Bucket:     aws.String("<your-bucket-name>"),
        Key:        aws.String("<your-object-key>"),
        PartNumber: aws.Int64(1),
        UploadId:   aws.String("<your-upload-id>"),
    }
    req, uploadPartOutput := svc.UploadPartRequest(uploadPartInput)
    err = req.Send()
    if err != nil {
        fmt.Printf("fail to upload part. %v\n", err)
    } else {
        fmt.Println(uploadPartOutput)
    }
}

请求参数

UploadPartInput可设置的参数如下：

参数	类型	说明	是否必要
Body	io.ReadSeeker	对象的数据	是
Bucket	*string	执行分片上传的桶的名称	是
ContentLength	*int64	说明请求body的长度（单位：字节），该参数可以在body长度不能被自动识别的情况下设置	否
ContentMD5	*string	base64编码的128位MD5值，不包含请求头部的信息	否
Key	*string	上传文件到对象存储服务后对应的key	是
PartNumber	*int64	说明当前数据在文件中所属的分片，大于等于1，小于等于10000	是
UploadId	*string	通过CreateMultipartUpload操作获取的UploadId，与一个分片上传的对象对应	是

返回结果

UploadPartOutput返回的属性如下：

参数	类型	说明
ETag	*string	本次上传分片对应的Entity Tag

合并分片

功能说明

合并指定分片上传任务id对应任务中已上传的对象分片，使之成为一个完整的文件。

代码示例

func CompleteMultipartUpload(svc *s3.S3) {
    completeMultipartUploadInput := &s3.CompleteMultipartUploadInput{
        Bucket: aws.String("<your-bucket-name>"),
        Key:    aws.String("<your-object-key>"),
        MultipartUpload: &s3.CompletedMultipartUpload{
            Parts: []*s3.CompletedPart{
                {
                    ETag:       aws.String("<etag1>"),
                    PartNumber: aws.Int64(1),
                },
                {
                    ETag:       aws.String("<etag2>"),
                    PartNumber: aws.Int64(2),
                },
            },
        },
        UploadId: aws.String("<your-upload-id>"),
    }

    completeMultipartUploadOutput, err := svc.CompleteMultipartUpload(completeMultipartUploadInput)
    if err != nil {
        fmt.Printf("fail to complete multipart upload.%v\n", err)
    } else {
        fmt.Println(completeMultipartUploadOutput)
    }
}

通过CompleteMultipartUploadRequest操作获取对象：

CompleteMultipartUploadRequest操作首先生成一个"request.Request"对象，该对象是一个执行CompleteMultipartUpload操作的请求。通过调用Request对象的Send方法完成合并分片的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func CompleteMultipartUploadRequest(svc *s3.S3) {
    completeMultipartUploadInput := &s3.CompleteMultipartUploadInput{
        Bucket: aws.String("<your-bucket-name>"),
        Key:    aws.String("<your-object-key>"),
        MultipartUpload: &s3.CompletedMultipartUpload{
            Parts: []*s3.CompletedPart{
                {
                    ETag:       aws.String("<etag1>"),
                    PartNumber: aws.Int64(1),
                },
                {
                    ETag:       aws.String("<etag2>"),
                    PartNumber: aws.Int64(2),
                },
            },
        },
        UploadId: aws.String("<your-upload-id>"),
    }

    req, completeMultipartUploadOutput := svc.CompleteMultipartUploadRequest(completeMultipartUploadInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to complete multipart upload. %v\n", err)
    } else {
        fmt.Println(completeMultipartUploadOutput)
    }
}

请求参数

CompleteMultipartUploadInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	执行分片上传的桶的名称	是
Key	*string	上传文件到对象存储服务后对应的key	是
MultipartUpload	*CompletedMultipartUpload	包含了每个已上传的分片的ETag和PartNUmber等信息	否
UploadId	*string	通过CreateMultipartUpload操作获取的UploadId，与一个对象的分片上传对应	是

返回结果

CompleteMultipartUploadOutput返回的属性如下：

参数	类型	说明
Bucket	*string	执行分片上传的桶的名称
ETag	*string	本次上传对象后对应的Entity Tag
Key	*string	上传文件到对象存储服务后对应的key
Location	*string	合并生成对象的URI信息
VersionId	*string	上传对象后相应的版本ID

列举分片上传任务

功能说明

列举分片上传操作可以列出一个桶中正在进行的分片上传，这些分片上传的请求已经发起，但是还没完成或者被中止。ListMultipartUploads操作可以通过指定MaxUploads参数来设置返回分片上传信息的数量，MaxUploads参数的最大值和默认值均为1000。如果返回结果中的IsTruncated字分片为true，表示还有符合条件的分片上传信息没有列出，可以通过设置请求中的KeyMarker和UploadIdMarker参数，来列出符合筛选条件的正在上传的分片信息。

代码示例

func ListMultipartUploads(svc *s3.S3) {
    listMultipartUploadsInput := &s3.ListMultipartUploadsInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    listMultipartUploadsOutput, err := svc.ListMultipartUploads(listMultipartUploadsInput)
    if err != nil {
        fmt.Printf("fail to list multipart uploads. %v\n", err)
        return
    }
    fmt.Println(listMultipartUploadsOutput)
}

通过ListMultipartUploadsRequest操作：

ListMultipartUploadsRequest操作首先生成一个"request.Request"对象，该对象是一个执行ListMultipartUploads操作的请求。通过调用Request对象的Send方法来列出进行的分片上传信息。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func ListMultipartUploadsRequest(svc *s3.S3) {
    listMultipartUploadsInput := &s3.ListMultipartUploadsInput{
        Bucket: aws.String("<your-bucket-name>"),
    }
    req, listMultipartUploadsOutput := svc.ListMultipartUploadsRequest(listMultipartUploadsInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to list multipart uploads. %v\n", err)
    } else {
        fmt.Println(listMultipartUploadsOutput)
    }
}

请求参数

ListMultipartUploadsInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	执行本操作的桶名称	是
Delimiter	*string	与Prefix参数一起用于对对象key进行分组的字符。所有key包含指定的Prefix且第一次出现Delimiter字符之间的对象作为一组。如果没有指定Prefix参数，按Delimiter对所有对象key进行分割，多个对象分割后从对象key开始到第一个Delimiter之间相同的部分形成一组	否
KeyMarker	*string	和UploadIdMarker参数一起用于指定返回哪部分分片上传的信息。如果没有设置UploadIdMarker参数，则只返回对象key按照字典顺序排序后位于KeyMarker标识符之后的分片信息。如果设置了UploadIdMarker参数，则会返回对象key等于KeyMarker且UploadId大于UploadIdMarker的分片信息	否
MaxUploads	*int64	用于指定相应消息体中正在进行的分片上传信息的最大数量，最小值为1，默认值和最大值都是1000	否
Prefix	*string	与Delimiter参数一起用于对对象key进行分组的字符。所有key包含指定的Prefix且第一次出现Delimiter字符之间的对象作为一组	否
UploadIdMarker	*string	和KeyMarker参数一起用于指定返回哪部分分片上传的信息，仅当设置了KeyMarker参数的时候有效。设置后返回对象key等于KeyMarker且UploadId大于UploadIdMarker的分片信息	否

返回结果

ListMultipartUploadsOutput返回的属性如下：

参数	类型	说明
Bucket	*string	执行本操作的桶名称
CommonPrefixes	[]*CommonPrefix	当请求中设置了Delimiter和Prefix属性时，所有包含指定的Prefix且第一次出现Delimiter字符的对象key作为一组
Delimiter	*string	与请求中设置的Delimiter一致
IsTruncated	*bool	当为false时表示返回结果中包含了全部符合本次请求查询条件的上传分片信息，否则只返回了数量为MaxUploads个的分片信息
KeyMarker	*string	返回上传分片列表中的起始对象的key
MaxUploads	*int64	本次返回结果中包含的上传分片数量的最大值
NextKeyMarker	*string	当IsTruncated为true时，NextKeyMarker可以作为后续查询已初始化的上传分片请求中的KeyMarker的值
NextUploadIdMarker	*string	当IsTruncated为true时，NextKeyMarker可以作为后续查询已初始化的上传分片请求中的UploadIdMarker的值
Prefix	*string	限定返回分片中对应对象的key必须以Prefix作为前缀
UploadIdMarker	*string	返回上传分片列表中的起始UploadId
Uploads	[]*MultipartUpload	包含了零个或多个已初始化的上传分片信息的数组。数组中的每一项包含了分片初始化时间、分片上传操作发起者、对象key、对象拥有者、存储类型和UploadId等信息

列举已上传的分片

功能说明

列举已上传分片操作可以列出一个分片上传操作中已经上传完毕但是还未合并的分片信息。请求中需要提供object key和upload id，返回的结果最多包含1000个已上传的分片信息，默认返回1000个，可以通过设置MaxParts参数的值指定返回结果中分片信息的数量。如果已上传的分片信息的数量多于1000个，则返回结果中的IsTruncated字分片为true，可用通过设置PartNumberMarker参数获取PartNumber大于该参数的分片信息。

代码示例

func ListParts(svc *s3.S3) {
    listPartsInput := &s3.ListPartsInput{
        Bucket:   aws.String("<your-bucket-name>"),
        Key:      aws.String("<your-object-key>"),
        UploadId: aws.String("<your-upload-id>"),
    }
    listPartsOutput, err := svc.ListParts(listPartsInput)
    if err != nil {
        fmt.Printf("fail to list parts. %v\n", err)
        return
    }
    fmt.Println(listPartsOutput)
}

通过ListPartsRequest操作：

ListPartsRequest操作首先生成一个"request.Request"对象，该对象是一个执行ListParts操作的请求。通过调用Request对象的Send方法来列出一个分片上传操作中已经上传完毕的分片信息。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func ListPartsRequest(svc *s3.S3) {
    listPartsInput := &s3.ListPartsInput{
        Bucket:   aws.String("<your-bucket-name>"),
        Key:      aws.String("<your-object-key>"),
        UploadId: aws.String("<your-upload-id>"),
    }
    req, listPartsOutput := svc.ListPartsRequest(listPartsInput)

    err := req.Send()
    if err != nil {
        fmt.Printf("fail to list parts. %v\n", err)
    } else {
        fmt.Println(listPartsOutput)
    }
}

请求参数

ListPartsInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	执行本操作的桶名称	是
Key	*string	分片上传的对象的key	是
MaxParts	*int64	指定返回分片信息的数量，默认值和最大值均为1000	否
PartNumberMarker	*int64	用于指定返回part number大于PartNumberMarker的分片信息	否
UploadId	*string	指定返回该id所属的分片上传的分片信息	是

返回结果

ListPartsOutput返回的属性如下：

参数	类型	说明
Bucket	*string	执行本操作的桶名称
IsTruncated	*bool	当为false时表示返回结果中包含了全部符合本次请求查询条件的上传分片信息，否则只返回了数量为MaxParts个的分片信息
Key	*string	本次分片上传对象的名称
MaxParts	*int64	本次返回结果中包含的上传分片数量的最大值
NextPartNumberMarker	*int64	当IsTruncated为true时，NextPartNumberMarker可以作为后续查询已上传分片请求中的PartNumberMarker的值
Owner	*Owner	分片上传对象的拥有者信息，包含了用户名和Id等信息
PartNumberMarker	*int64	如果本次请求未能列出全部分片信息，该返回结果用于指定下次列举分片请求的起始位置
Parts	[]*Part	包含了已上传分片信息的数组，数组中的每一项包含了该分片的Entity tag、最后修改时间、PartNumber和大小等信息
StorageClass	*string	对象的存储类型
UploadId	*string	本次分片上传操作Id

复制分片

功能说明

复制分片操作可以从一个已存在的对象中拷贝指定分片的数据，当拷贝的对象大小超过5GB，必须使用复制分片操作完成对象的复。除了最后一个分片外，每个拷贝分片的大小范围是[5MB，5GB]。在一个在拷贝大对象之前，需要使用初始化分片上传操作获取一个upload id，在完成拷贝操作之后，需要使用CompleteMultipartUpload操作组装已拷贝的分片成为一个对象。

代码示例

var (
    sourceBucket      = "<source-bucket-name>"      //拷贝对象的来源
    key               = "<your-object-key>"         //拷贝对象的key
    destinationBucket = "<your-bucket-name>"        //目标桶名字
)

func UploadPartCopy(svc *s3.S3) {
    var MB int64
    MB = 1024 * 1024
    // 获取被拷贝对象大小
    headObjectOutput, err := svc.HeadObject(&s3.HeadObjectInput{
        Bucket: aws.String(sourceBucket),
        Key:    aws.String(key),
    })
    if err != nil {
        fmt.Printf("fail to head object. %v\n", err)
        return
    }
    objectSize := *headObjectOutput.ContentLength
    // UploadPartCopy操作的对象必须大于5MB
    if objectSize <= 5*MB {
        fmt.Printf("The size of the object must be bigger than 5MB.")
        return
    }
    // 发起一个分片上传请求，获取uploadId
    createMultipartUploadOutput, err := svc.CreateMultipartUpload(&s3.CreateMultipartUploadInput{
        Bucket: aws.String(destinationBucket),
        Key:    aws.String(key),
    })
    if err != nil {
        fmt.Printf("fail to create multipart upload. %v\n", err)
        return
    }
    uploadId := createMultipartUploadOutput.UploadId
    // 记录拷贝分片结果
    var uploadPartCopyResults map[int64]string
    uploadPartCopyResults = make(map[int64]string)
    // 拷贝分片
    var start, end, i int64
    fmt.Printf("object size: %v\n", objectSize)
    for i = 0; i*16*MB+i < objectSize; i++ {
        //每个分片大小为16MB
        start = i*16*MB + i
        if start+16*MB < objectSize {
            end = start + 16*MB
        } else {
            end = objectSize - 1
        }
        fmt.Printf("start: %v, end: %v.\n", start, end)
        if eTag, err := copyAUploadPart(svc, start, end, i+1, uploadId); err == nil {
            uploadPartCopyResults[i+1] = *eTag
        }
    }
    // 构建分片复制的part信息
    var partItems []*s3.CompletedPart
    for i, eTag := range uploadPartCopyResults {
        partItems = append(partItems, &s3.CompletedPart{
            ETag:       aws.String(eTag),
            PartNumber: aws.Int64(i),
        })
    }
    // 完成分片上传
    completeMultipartUploadOutput, err := svc.CompleteMultipartUpload(&s3.CompleteMultipartUploadInput{
        Bucket:          aws.String(destinationBucket),
        Key:             aws.String(key),
        UploadId:        uploadId,
        MultipartUpload: &s3.CompletedMultipartUpload{Parts: partItems},
    })
    if err != nil {
        fmt.Printf("Failed to CompleteMultipartUpload. %v", err)
        fmt.Println(completeMultipartUploadOutput)
    }
}

func copyAUploadPart(svc *s3.S3, start int64, end int64, partNumber int64, uploadId *string) (*string, error) {
    copySourceRange := "bytes=" + strconv.FormatInt(start, 10) + "-" + strconv.FormatInt(end, 10)
    uploadPartCopyInput := &s3.UploadPartCopyInput{
        Bucket:          aws.String(destinationBucket),
        CopySource:      aws.String(sourceBucket + "/" + key),
        CopySourceRange: aws.String(copySourceRange),
        Key:             aws.String(key),
        PartNumber:      aws.Int64(partNumber),
        UploadId:        uploadId,
    }
    uploadPartCopyOutput, err := svc.UploadPartCopy(uploadPartCopyInput)
    if err != nil {
        fmt.Printf("fail to copy upload part. %v\n", err)
        return nil, err
    }
    return uploadPartCopyOutput.CopyPartResult.ETag, nil
}

通过UploadPartCopyRequest操作：

UploadPartCopyRequest操作首先生成一个"request.Request"对象，该对象是一个执行UploadPartCopyRequest操作的请求。通过调用Request对象的Send方法来完成分片拷贝大对象的操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func UploadPartCopyRequest(svc *s3.S3) {
    // 发起一个分片上传请求，获取uploadId
    createMultipartUploadOutput, err := svc.CreateMultipartUpload(&s3.CreateMultipartUploadInput{
        Bucket: aws.String("<your-bucket-name>"),
        Key:    aws.String("<your-object-key>"),
    })
    if err != nil {
        fmt.Printf("fail to create multipart upload. %v\n", err)
        return
    }
    uploadId := createMultipartUploadOutput.UploadId
    // 分片复制
    uploadPartCopyInput := &s3.UploadPartCopyInput{
        Bucket:     aws.String("<destination-bucket-name>"),
        CopySource: aws.String("<source-bucket/object-Key>"),
        Key:        aws.String("<your-object-key>"),
        PartNumber: aws.Int64(1),
        UploadId:   uploadId,
    }
    req, uploadPartCopyOutput := svc.UploadPartCopyRequest(uploadPartCopyInput)

    err = req.Send()
    if err != nil {
        fmt.Printf("fail to copy upload part. %v\n", err)
    } else {
        fmt.Print(uploadPartCopyOutput)
    }
}

请求参数

UploadPartCopyInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	存放拷贝生成对象的桶名称	是
CopySource	*string	URL格式的拷贝对象数据来源，包含了桶名称和对象key的信息，二者之间使用正斜杆（/）分割，versionId可选参数用于指定原对象的版本。例如，"foo/boo?versionId=11111"表示拷贝foo桶中的boo对象，其版本id为11111。如果不指定versionId参数，则默认拷贝当前版本的对象数据	是
CopySourceIfMatch	*string	用于指定只有在被拷贝对象的ETag和该参数值匹配的情况下才进行拷贝操作	否
CopySourceIfModifiedSince	*time.Time	用于只有当被拷贝对象在指定时间后被修改的情况下才进行拷贝操作。	否
CopySourceIfNoneMatch	*string	用于指定只有在被拷贝对象的ETag和该参数值不匹配的情况下才进行拷贝操作	否
CopySourceIfUnmodifiedSince	*time.Time	用于仅当对象自指定时间以来未被修改的情况下才返回对象数据，否则返回412错误码	否
CopySourceRange	*string	指定本次分片拷贝的数据范围，必须是"bytes=first-last"的格式，例如"bytes=0-9"表示拷贝原对象中前10字节的数据，只有当拷贝的分片大小大于5MB的时候有效	否
Key	*string	拷贝生成对象的key	是
PartNumber	*int64	说明本次分片拷贝的数据在原对象中所属的部分	是
UploadId	*string	与本次拷贝操作相应的分片上传Id	是

返回结果

UploadPartCopyOutput返回的属性如下：

参数	类型	说明
CopyPartResult	*CopyPartResult	包含拷贝分片的Entity Tag和最后修改时间等信息

取消分片上传任务

功能说明

取消分片上传任务操作用于终止一个分片上传。当一个分片上传被中止后，不会再有数据通过与之相应的upload id上传，同时已经被上传的分片所占用的空间会被释放。执行取消分片上传任务操作后，正在上传的分片可能会上传成功也可能会被中止，所以必要的情况下需要执行多次取消分片上传任务操作去释放全部上传成功的分片所占用的空间。可以通过执行列举已上传分片操作来确认所有中止分片上传后所有已上传分片的空间是否被被释放。

代码示例

func AbortMultipartUpload(svc *s3.S3, bucket, key, uploadId string) {
    abortMultipartUploadInput := &s3.AbortMultipartUploadInput{
        Bucket:   aws.String("<your-bucket-name>"),
        Key:      aws.String("<your-object-key>"),
        UploadId: aws.String("<your-upload-id>"),
    }

    abortMultipartUploadOutput, err := svc.AbortMultipartUpload(abortMultipartUploadInput)
    if err != nil {
        fmt.Printf("fail to AbortMultipartUpload. %v\n", err)
        return
    }
    fmt.Println(abortMultipartUploadOutput)
}

通过AbortMultipartUploadRequest操作：

AbortMultipartUploadRequest操作首先生成一个"request.Request"对象，该对象是一个执行AbortMultipartUploadRequest操作的请求。通过调用Request对象的Send方法来中止一个分片上传操作。该方法可以生成定制化的请求，例如自定义请求头部请求超时重试设置。

func AbortMultipartUploadRequest(svc *s3.S3) {
    abortMultipartUploadInput := &s3.AbortMultipartUploadInput{
        Bucket:   aws.String("<your-bucket-name>"),
        Key:      aws.String("<your-object-key>"),
        UploadId: aws.String("<your-upload-id>"),
    }

    req, abortMultipartUploadOutput := svc.AbortMultipartUploadRequest(abortMultipartUploadInput)
    err := req.Send()
    if err != nil {
        fmt.Printf("fail to AbortMultipartUpload. %v\n", err)
    } else {
        fmt.Println(abortMultipartUploadOutput)
    }
}

请求参数

AbortMultipartUploadInput可设置的参数如下：

参数	类型	说明	是否必要
Bucket	*string	执行本操作的桶名称	是
Key	*string	分片上传的对象的key	是
UploadId	*string	指定需要终止的分片上传的id	是

活动

智算服务

应用商城

定价

合作伙伴

开发者

支持与服务

了解天翼云

媒体存储

媒体存储

初始化分片上传任务

功能说明

代码示例

请求参数

返回结果

上传分片

功能说明

代码示例

请求参数

返回结果

合并分片

功能说明

代码示例

请求参数

返回结果

列举分片上传任务

功能说明

代码示例

请求参数

返回结果

列举已上传的分片

功能说明

代码示例

请求参数

返回结果

复制分片

功能说明

代码示例

请求参数

返回结果

取消分片上传任务

功能说明

代码示例

请求参数