在上传大文件（超过5 GB）到OSS的过程中，如果出现网络中断、程序异常退出等问题导致文件上传失败，您需要使用分片上传的方式上传大文件。分片上传通过将待上传的大文件分成多个较小的碎片（Part），充分利用网络带宽和服务器资源并发上传多个Part，加快上传完成时间，并在Part上传完成之后调用CompleteMultipartUpload接口将这些Part组合成一个完整的Object。
已创建存储空间（Bucket）。具体操作，请参见 创建存储空间 。
要分片上传，您必须有 oss:PutObject 权限。具体操作，请参见 RAM Policy常见示例 。
oss:PutObject
大文件加速上传
当文件大小超过5 GB时，使用分片上传可实现并行上传多个Part以加快上传速度。
网络环境较差
网络环境较差时，建议使用分片上传。当出现上传失败的时候，您仅需重传失败的Part。
文件大小不确定
可以在需要上传的文件大小还不确定的情况下开始上传，这种场景在视频监控等行业应用中比较常见。
流程说明如下：
如果您需要完成分片上传的完整流程，包括初始化分片上传，上传分片以及将分片合为完成的Object，您需要 oss:PutObject 权限。具体操作，请参见 为RAM用户授权自定义的权限策略 。
将待上传文件按照一定大小进行分片。
使用 InitiateMultipartUpload 接口初始化一个分片上传任务。
使用 UploadPart 接口上传分片。
文件切分成Part之后，文件顺序是通过上传过程中指定的 partNumber 来确定，所以您可以并发上传这些碎片。并发数并非越多越快，请结合自身网络状况和设备负载综合考虑。
partNumber
如果您希望终止上传任务，可调用 AbortMultipartUpload 接口，成功上传的Part会一并删除。
使用 CompleteMultipartUpload 接口将Part组合成一个Object。
限制项
规格
文件大小
不超过48.8 TB
Part数量
1~10, 000个
单个Part大小
最小值为100 KB，最大值为5 GB。最后一个Part的大小不要求大于100 KB。
单次ListParts请求返回的Part最大数量
1, 000个
单次ListMultipartUploads请求返回的Multipart Upload事件最大数量
通过分片上传的方式上传文件时，一次只能上传一个文件，且不支持上传目录。
降低PUT类请求费用
如果要上传的文件数量较多，直接指定上传的文件类型为深度冷归档类型会造成较高的 PUT类请求费用 。建议您先将文件的存储类型指定为标准存储进行上传，然后通过 生命周期规则 将其转储为深度冷归档类型，从而降低PUT类请求费用。
文件上传性能调优
如果您在上传大量文件时，在命名上使用了顺序前缀（如时间戳或字母顺序），可能会出现大量文件索引集中存储于存储空间中某个特定分区的情况。此时如果您的请求速率过大，会导致请求速率下降。建议您在上传大量文件时，不要使用顺序前缀的文件名。更多信息，请参见 OSS性能与扩展性最佳实践 。
文件覆盖
上传同名文件会覆盖OSS中已有文件。您可以通过以下方式防止文件被意外覆盖：
开启版本控制功能
开启版本控制功能后，被覆盖的文件会以历史版本的形式保存下来，您可以随时恢复历史版本文件。更多信息，请参见 版本控制介绍 。
在上传请求中携带禁止覆盖同名文件的参数
在上传请求的header中携带 x-oss-forbid-overwrite 参数，并指定其值为 true 。当您上传的文件在OSS中存在同名文件时，该文件会上传失败，并返回 FileAlreadyExists 错误。更多信息，请参见 InitiateMultipartUpload 。
true
FileAlreadyExists
以下仅列举常见SDK的分片上传的代码示例。关于其他SDK的分片上传的代码示例，请参见 SDK简介 。
import com.aliyun.oss.ClientException; import com.aliyun.oss.OSS; import com.aliyun.oss.common.auth.*; import com.aliyun.oss.OSSClientBuilder; import com.aliyun.oss.OSSException; import com.aliyun.oss.internal.Mimetypes; import com.aliyun.oss.model.*; import java.io.File; import java.io.FileInputStream; import java.io.InputStream; import java.util.ArrayList; import java.util.List; public class Demo { public static void main(String[] args) throws Exception { // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。 String endpoint = "https://oss-cn-hangzhou.aliyuncs.com"; // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。 EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider(); // 填写Bucket名称，例如examplebucket。 String bucketName = "examplebucket"; // 填写Object完整路径，例如exampledir/exampleobject.txt。Object完整路径中不能包含Bucket名称。 String objectName = "exampledir/exampleobject.txt"; // 待上传本地文件路径。 String filePath = "D:\\localpath\\examplefile.txt"; // 创建OSSClient实例。 OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider); try { // 创建InitiateMultipartUploadRequest对象。 InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest(bucketName, objectName); // 如果需要在初始化分片时设置请求头，请参考以下示例代码。 ObjectMetadata metadata = new ObjectMetadata(); // metadata.setHeader(OSSHeaders.OSS_STORAGE_CLASS, StorageClass.Standard.toString()); // 指定该Object的网页缓存行为。 // metadata.setCacheControl("no-cache"); // 指定该Object被下载时的名称。 // metadata.setContentDisposition("attachment;filename=oss_MultipartUpload.txt"); // 指定该Object的内容编码格式。 // metadata.setContentEncoding(OSSConstants.DEFAULT_CHARSET_NAME); // 指定初始化分片上传时是否覆盖同名Object。此处设置为true，表示禁止覆盖同名Object。 // metadata.setHeader("x-oss-forbid-overwrite", "true"); // 指定上传该Object的每个part时使用的服务器端加密方式。 // metadata.setHeader(OSSHeaders.OSS_SERVER_SIDE_ENCRYPTION, ObjectMetadata.KMS_SERVER_SIDE_ENCRYPTION); // 指定Object的加密算法。如果未指定此选项，表明Object使用AES256加密算法。 // metadata.setHeader(OSSHeaders.OSS_SERVER_SIDE_DATA_ENCRYPTION, ObjectMetadata.KMS_SERVER_SIDE_ENCRYPTION); // 指定KMS托管的用户主密钥。 // metadata.setHeader(OSSHeaders.OSS_SERVER_SIDE_ENCRYPTION_KEY_ID, "9468da86-3509-4f8d-a61e-6eab1eac****"); // 指定Object的存储类型。 // metadata.setHeader(OSSHeaders.OSS_STORAGE_CLASS, StorageClass.Standard); // 指定Object的对象标签，可同时设置多个标签。 // metadata.setHeader(OSSHeaders.OSS_TAGGING, "a:1"); // request.setObjectMetadata(metadata); // 根据文件自动设置ContentType。如果不设置，ContentType默认值为application/oct-srream。 if (metadata.getContentType() == null) { metadata.setContentType(Mimetypes.getInstance().getMimetype(new File(filePath), objectName)); // 初始化分片。 InitiateMultipartUploadResult upresult = ossClient.initiateMultipartUpload(request); // 返回uploadId。 String uploadId = upresult.getUploadId(); // 根据uploadId执行取消分片上传事件或者列举已上传分片的操作。 // 如果您需要根据您需要uploadId执行取消分片上传事件的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后获取uploadId。 // 如果您需要根据您需要uploadId执行列举已上传分片的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后，且在调用CompleteMultipartUpload完成分片上传之前获取uploadId。 // System.out.println(uploadId); // partETags是PartETag的集合。PartETag由分片的ETag和分片号组成。 List<PartETag> partETags = new ArrayList<PartETag>(); // 每个分片的大小，用于计算文件有多少个分片。单位为字节。 final long partSize = 1 * 1024 * 1024L; //1 MB。 // 根据上传的数据大小计算分片数。以本地文件为例，说明如何通过File.length()获取上传数据的大小。 final File sampleFile = new File(filePath); long fileLength = sampleFile.length(); int partCount = (int) (fileLength / partSize); if (fileLength % partSize != 0) { partCount++; // 遍历分片上传。 for (int i = 0; i < partCount; i++) { long startPos = i * partSize; long curPartSize = (i + 1 == partCount) ? (fileLength - startPos) : partSize; UploadPartRequest uploadPartRequest = new UploadPartRequest(); uploadPartRequest.setBucketName(bucketName); uploadPartRequest.setKey(objectName); uploadPartRequest.setUploadId(uploadId); // 设置上传的分片流。 // 以本地文件为例说明如何创建FIleInputstream，并通过InputStream.skip()方法跳过指定数据。 InputStream instream = new FileInputStream(sampleFile); instream.skip(startPos); uploadPartRequest.setInputStream(instream); // 设置分片大小。除了最后一个分片没有大小限制，其他的分片最小为100 KB。 uploadPartRequest.setPartSize(curPartSize); // 设置分片号。每一个上传的分片都有一个分片号，取值范围是1~10000，如果超出此范围，OSS将返回InvalidArgument错误码。 uploadPartRequest.setPartNumber( i + 1); // 每个分片不需要按顺序上传，甚至可以在不同客户端上传，OSS会按照分片号排序组成完整的文件。 UploadPartResult uploadPartResult = ossClient.uploadPart(uploadPartRequest); // 每次上传分片之后，OSS的返回结果包含PartETag。PartETag将被保存在partETags中。 partETags.add(uploadPartResult.getPartETag()); // 创建CompleteMultipartUploadRequest对象。 // 在执行完成分片上传操作时，需要提供所有有效的partETags。OSS收到提交的partETags后，会逐一验证每个分片的有效性。当所有的数据分片验证通过后，OSS将把这些分片组合成一个完整的文件。 CompleteMultipartUploadRequest completeMultipartUploadRequest = new CompleteMultipartUploadRequest(bucketName, objectName, uploadId, partETags); // 如果需要在完成分片上传的同时设置文件访问权限，请参考以下示例代码。 // completeMultipartUploadRequest.setObjectACL(CannedAccessControlList.Private); // 指定是否列举当前UploadId已上传的所有Part。仅在Java SDK为3.14.0及以上版本时，支持通过服务端List分片数据来合并完整文件时，将CompleteMultipartUploadRequest中的partETags设置为null。 // Map<String, String> headers = new HashMap<String, String>(); // 如果指定了x-oss-complete-all:yes，则OSS会列举当前UploadId已上传的所有Part，然后按照PartNumber的序号排序并执行CompleteMultipartUpload操作。 // 如果指定了x-oss-complete-all:yes，则不允许继续指定body，否则报错。 // headers.put("x-oss-complete-all","yes"); // completeMultipartUploadRequest.setHeaders(headers); // 完成分片上传。 CompleteMultipartUploadResult completeMultipartUploadResult = ossClient.completeMultipartUpload(completeMultipartUploadRequest); System.out.println(completeMultipartUploadResult.getETag()); } catch (OSSException oe) { System.out.println("Caught an OSSException, which means your request made it to OSS, " + "but was rejected with an error response for some reason."); System.out.println("Error Message:" + oe.getErrorMessage()); System.out.println("Error Code:" + oe.getErrorCode()); System.out.println("Request ID:" + oe.getRequestId()); System.out.println("Host ID:" + oe.getHostId()); } catch (ClientException ce) { System.out.println("Caught an ClientException, which means the client encountered " + "a serious internal problem while trying to communicate with OSS, " + "such as not being able to access the network."); System.out.println("Error Message:" + ce.getMessage()); } finally { if (ossClient != null) { ossClient.shutdown(); }
<?php if (is_file(__DIR__ . '/../autoload.php')) { require_once __DIR__ . '/../autoload.php'; if (is_file(__DIR__ . '/../vendor/autoload.php')) { require_once __DIR__ . '/../vendor/autoload.php'; use OSS\OssClient; use OSS\Core\OssException; use OSS\Core\OssUtil; // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。 $accessKeyId = getenv("OSS_ACCESS_KEY_ID"); $accessKeySecret = getenv("OSS_ACCESS_KEY_SECRET"); // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。 $endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'; // 填写Bucket名称，例如examplebucket。 $bucket= 'examplebucket'; //填写不包含Bucket名称在内的Object完整路径，例如exampledir/exampleobject.txt。 $object = 'exampledir/exampleobject.txt'; // 填写本地文件的完整路径。 $uploadFile = 'D:\\localpath\\examplefile.txt'; $initOptions = array( OssClient::OSS_HEADERS => array( // 指定该Object被下载时的网页缓存行为。 // 'Cache-Control' => 'no-cache', // 指定该Object被下载时的名称。 // 'Content-Disposition' => 'attachment;filename=oss_download.jpg', // 指定该Object被下载时的内容编码格式。 // 'Content-Encoding' => 'utf-8', // 指定过期时间，单位为毫秒。 // 'Expires' => 150, // 指定初始化分片上传时是否覆盖同名Object。此处设置为true，表示禁止覆盖同名Object。 //'x-oss-forbid-overwrite' => 'true', // 指定上传该Object的每个part时使用的服务器端加密方式。 // 'x-oss-server-side-encryption'=> 'KMS', // 指定Object的加密算法。 // 'x-oss-server-side-data-encryption'=>'SM4', // 指定KMS托管的用户主密钥。 //'x-oss-server-side-encryption-key-id' => '9468da86-3509-4f8d-a61e-6eab1eac****', // 指定Object的存储类型。 // 'x-oss-storage-class' => 'Standard', // 指定Object的对象标签，可同时设置多个标签。 // 'x-oss-tagging' => 'TagA=A&TagB=B', * 步骤1：初始化一个分片上传事件，并获取uploadId。 $ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint); //返回uploadId。uploadId是分片上传事件的唯一标识，您可以根据uploadId发起相关的操作，如取消分片上传、查询分片上传等。 $uploadId = $ossClient->initiateMultipartUpload($bucket, $object, $initOptions); print("initiateMultipartUpload OK" . "\n"); // 根据uploadId执行取消分片上传事件或者列举已上传分片的操作。 // 如果您需要根据您需要uploadId执行取消分片上传事件的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后获取uploadId。 // 如果您需要根据您需要uploadId执行列举已上传分片的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后，且在调用CompleteMultipartUpload完成分片上传之前获取uploadId。 //print("UploadId: " . $uploadId . "\n"); } catch(OssException $e) { printf($e->getMessage() . "\n"); return; * 步骤2：上传分片。 $partSize = 10 * 1024 * 1024; $uploadFileSize = sprintf('%u',filesize($uploadFile)); $pieces = $ossClient->generateMultiuploadParts($uploadFileSize, $partSize); $responseUploadPart = array(); $uploadPosition = 0; $isCheckMd5 = true; foreach ($pieces as $i => $piece) { $fromPos = $uploadPosition + (integer)$piece[$ossClient::OSS_SEEK_TO]; $toPos = (integer)$piece[$ossClient::OSS_LENGTH] + $fromPos - 1; $upOptions = array( // 上传文件。 $ossClient::OSS_FILE_UPLOAD => $uploadFile, // 设置分片号。 $ossClient::OSS_PART_NUM => ($i + 1), // 指定分片上传起始位置。 $ossClient::OSS_SEEK_TO => $fromPos, // 指定文件长度。 $ossClient::OSS_LENGTH => $toPos - $fromPos + 1, // 是否开启MD5校验，true为开启。 $ossClient::OSS_CHECK_MD5 => $isCheckMd5, // 开启MD5校验。 if ($isCheckMd5) { $contentMd5 = OssUtil::getMd5SumForFile($uploadFile, $fromPos, $toPos); $upOptions[$ossClient::OSS_CONTENT_MD5] = $contentMd5; try { // 上传分片。 $responseUploadPart[] = $ossClient->uploadPart($bucket, $object, $uploadId, $upOptions); printf("initiateMultipartUpload, uploadPart - part#{$i} OK\n"); } catch(OssException $e) { printf("initiateMultipartUpload, uploadPart - part#{$i} FAILED\n"); printf($e->getMessage() . "\n"); return; // $uploadParts是由每个分片的ETag和分片号（PartNumber）组成的数组。 $uploadParts = array(); foreach ($responseUploadPart as $i => $eTag) { $uploadParts[] = array( 'PartNumber' => ($i + 1), 'ETag' => $eTag, * 步骤3：完成上传。 $comOptions['headers'] = array( // 指定完成分片上传时是否覆盖同名Object。此处设置为true，表示禁止覆盖同名Object。 // 'x-oss-forbid-overwrite' => 'true', // 如果指定了x-oss-complete-all:yes，则OSS会列举当前uploadId已上传的所有Part，然后按照PartNumber的序号排序并执行CompleteMultipartUpload操作。 // 'x-oss-complete-all'=> 'yes' try { // 执行completeMultipartUpload操作时，需要提供所有有效的$uploadParts。OSS收到提交的$uploadParts后，会逐一验证每个分片的有效性。当所有的数据分片验证通过后，OSS将把这些分片组合成一个完整的文件。 $ossClient->completeMultipartUpload($bucket, $object, $uploadId, $uploadParts,$comOptions); printf( "Complete Multipart Upload OK\n"); } catch(OssException $e) { printf("Complete Multipart Upload FAILED\n"); printf($e->getMessage() . "\n"); return;
const OSS = require('ali-oss'); const path = require("path"); const client = new OSS({ // yourregion填写Bucket所在地域。以华东1（杭州）为例，Region填写为oss-cn-hangzhou。 region: 'yourregion', // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。 accessKeyId: process.env.OSS_ACCESS_KEY_ID, accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET, // 填写存储空间名称。 bucket: 'yourbucketname' const progress = (p, _checkpoint) => { // Object的上传进度。 console.log(p); // 分片上传的断点信息。 console.log(_checkpoint); const headers = { // 指定Object的存储类型。 'x-oss-storage-class': 'Standard', // 指定Object标签，可同时设置多个标签。 'x-oss-tagging': 'Tag1=1&Tag2=2', // 指定初始化分片上传时是否覆盖同名Object。此处设置为true，表示禁止覆盖同名Object。 'x-oss-forbid-overwrite': 'true' // 开始分片上传。 async function multipartUpload() { try { // 依次填写Object完整路径（例如exampledir/exampleobject.txt）和本地文件的完整路径（例如D:\\localpath\\examplefile.txt）。Object完整路径中不能包含Bucket名称。 // 如果本地文件的完整路径中未指定本地路径（例如examplefile.txt），则默认从示例程序所属项目对应本地路径中上传文件。 const result = await client.multipartUpload('exampledir/exampleobject.txt', path.normalize('D:\\localpath\\examplefile.txt'), { progress, // headers, // 指定meta参数，自定义Object的元信息。通过head接口可以获取到Object的meta数据。 meta: { year: 2020, people: 'test', console.log(result); // 填写Object完整路径，例如exampledir/exampleobject.txt。Object完整路径中不能包含Bucket名称。 const head = await client.head('exampledir/exampleobject.txt'); console.log(head); } catch (e) { // 捕获超时异常。 if (e.code === 'ConnectionTimeoutError') { console.log('TimeoutError'); // do ConnectionTimeoutError operation console.log(e); multipartUpload();
# -*- coding: utf-8 -*- import os from oss2 import SizedFileAdapter, determine_part_size from oss2.models import PartInfo import oss2 from oss2.credentials import EnvironmentVariableCredentialsProvider # 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。 auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider()) # Endpoint以华东1（杭州）为例，其他Region请按实际情况填写。 # 填写Bucket名称，例如examplebucket。 bucket = oss2.Bucket(auth, 'https://oss-cn-hangzhou.aliyuncs.com', 'examplebucket') # 填写不能包含Bucket名称在内的Object完整路径，例如exampledir/exampleobject.txt。 key = 'exampledir/exampleobject.txt' # 填写本地文件的完整路径，例如D:\\localpath\\examplefile.txt。 filename = 'D:\\localpath\\examplefile.txt' total_size = os.path.getsize(filename) # determine_part_size方法用于确定分片大小。 part_size = determine_part_size(total_size, preferred_size=100 * 1024) # 初始化分片。 # 如需在初始化分片时设置文件存储类型，请在init_multipart_upload中设置相关Headers，参考如下。 # headers = dict() # 指定该Object的网页缓存行为。 # headers['Cache-Control'] = 'no-cache' # 指定该Object被下载时的名称。 # headers['Content-Disposition'] = 'oss_MultipartUpload.txt' # 指定该Object的内容编码格式。 # headers['Content-Encoding'] = 'utf-8' # 指定过期时间，单位为毫秒。 # headers['Expires'] = '1000' # 指定初始化分片上传时是否覆盖同名Object。此处设置为true，表示禁止覆盖同名Object。 # headers['x-oss-forbid-overwrite'] = 'true' # 指定上传该Object的每个Part时使用的服务器端加密方式。 # headers[OSS_SERVER_SIDE_ENCRYPTION] = SERVER_SIDE_ENCRYPTION_KMS # 指定Object的加密算法。如果未指定此选项，表明Object使用AES256加密算法。 # headers[OSS_SERVER_SIDE_DATA_ENCRYPTION] = SERVER_SIDE_ENCRYPTION_KMS # 表示KMS托管的用户主密钥。 # headers[OSS_SERVER_SIDE_ENCRYPTION_KEY_ID] = '9468da86-3509-4f8d-a61e-6eab1eac****' # 指定Object的存储类型。 # headers['x-oss-storage-class'] = oss2.BUCKET_STORAGE_CLASS_STANDARD # 指定Object的对象标签，可同时设置多个标签。 # headers[OSS_OBJECT_TAGGING] = 'k1=v1&k2=v2&k3=v3' # upload_id = bucket.init_multipart_upload(key, headers=headers).upload_id upload_id = bucket.init_multipart_upload(key).upload_id # 根据upload_id执行取消分片上传事件或者列举已上传分片的操作。 # 如果您需要根据您需要uploadId执行取消分片上传事件的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后获取uploadId。 # 如果您需要根据您需要uploadId执行列举已上传分片的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后，且在调用CompleteMultipartUpload完成分片上传之前获取uploadId。 # print("UploadID:", upload_id) parts = [] # 逐个上传分片。 with open(filename, 'rb') as fileobj: part_number = 1 offset = 0 while offset < total_size: num_to_upload = min(part_size, total_size - offset) # 调用SizedFileAdapter(fileobj, size)方法会生成一个新的文件对象，重新计算起始追加位置。 result = bucket.upload_part(key, upload_id, part_number, SizedFileAdapter(fileobj, num_to_upload)) parts.append(PartInfo(part_number, result.etag)) offset += num_to_upload part_number += 1 # 完成分片上传。 # 如需在完成分片上传时设置相关Headers，请参考如下示例代码。 headers = dict() # 设置文件访问权限ACL。此处设置为OBJECT_ACL_PRIVATE，表示私有权限。 # headers["x-oss-object-acl"] = oss2.OBJECT_ACL_PRIVATE bucket.complete_multipart_upload(key, upload_id, parts, headers=headers) # bucket.complete_multipart_upload(key, upload_id, parts)
<!DOCTYPE html> <html lang="en"> <meta charset="UTF-8" /> <title>Document</title> </head> <button id="submit">上传</button> <input id="file" type="file" /> <!--导入sdk文件--> <script type="text/javascript" src="https://gosspublic.alicdn.com/aliyun-oss-sdk-6.18.0.min.js" ></script> <script type="text/javascript"> const client = new OSS({ // yourRegion填写Bucket所在地域。以华东1（杭州）为例，Region填写为oss-cn-hangzhou。 region: "yourRegion", // 从STS服务获取的临时访问密钥（AccessKey ID和AccessKey Secret）。 accessKeyId: "yourAccessKeyId", accessKeySecret: "yourAccessKeySecret", // 从STS服务获取的安全令牌（SecurityToken）。 stsToken: "yourSecurityToken", // 填写Bucket名称，例如examplebucket。 bucket: "examplebucket", const headers = { // 指定该Object被下载时的网页缓存行为。 "Cache-Control": "no-cache", // 指定该Object被下载时的名称。 "Content-Disposition": "example.txt", // 指定该Object被下载时的内容编码格式。 "Content-Encoding": "utf-8", // 指定过期时间，单位为毫秒。 Expires: "1000", // 指定Object的存储类型。 "x-oss-storage-class": "Standard", // 指定Object标签，可同时设置多个标签。 "x-oss-tagging": "Tag1=1&Tag2=2", // 指定初始化分片上传时是否覆盖同名Object。此处设置为true，表示禁止覆盖同名Object。 "x-oss-forbid-overwrite": "true", // 指定上传到examplebucket的Object名称，例如exampleobject.txt。 const name = "exampleobject.txt"; // 获取DOM。 const submit = document.getElementById("submit"); const options = { // 获取分片上传进度、断点和返回值。 progress: (p, cpt, res) => { console.log(p); // 设置并发上传的分片数量。 parallel: 4, // 设置分片大小。默认值为1 MB，最小值为100 KB。 partSize: 1024 * 1024, // headers, // 自定义元数据，通过HeadObject接口可以获取Object的元数据。 meta: { year: 2020, people: "test" }, mime: "text/plain", // 监听按钮。 submit.addEventListener("click", async () => { try { const data = document.getElementById("file").files[0]; // 分片上传。 const res = await client.multipartUpload(name, data, { ...options, // 设置上传回调。 // 如果不涉及回调服务器，请删除callback相关设置。 callback: { // 设置回调请求的服务器地址。 url: "http://examplebucket.aliyuncs.com:23450", // 设置回调请求消息头中Host的值，即您的服务器配置Host的值。 host: "yourHost", /* eslint no-template-curly-in-string: [0] */ // 设置发起回调时请求body的值。 body: "bucket=${bucket}&object=${object}&var1=${x:var1}", // 设置发起回调请求的Content-Type。 contentType: "application/x-www-form-urlencoded", customValue: { // 设置发起回调请求的自定义参数。 var1: "value1", var2: "value2", console.log(res); } catch (err) { console.log(err); </script> </body> </html>
using Aliyun.OSS; // yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1（杭州）为例，Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。 var endpoint = "yourEndpoint"; // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。 var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID"); var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET"); // 填写Bucket名称。 var bucketName = "examplebucket"; // 填写Object完整路径。Object完整路径中不能包含Bucket名称。 var objectName = "exampleobject.txt"; // 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件。 var localFilename = "D:\\localpath\\examplefile.txt"; // 创建OssClient实例。 var client = new OssClient(endpoint, accessKeyId, accessKeySecret); // 初始化分片上传，返回uploadId。 var uploadId = ""; // 定义上传的文件及所属Bucket的名称。您可以在InitiateMultipartUploadRequest中设置ObjectMeta，但不必指定其中的ContentLength。 var request = new InitiateMultipartUploadRequest(bucketName, objectName); var result = client.InitiateMultipartUpload(request); uploadId = result.UploadId; // 打印UploadId。 Console.WriteLine("Init multi part upload succeeded"); // 根据uploadId执行取消分片上传事件或者列举已上传分片的操作。 // 如果您需要根据您需要uploadId执行取消分片上传事件的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后获取uploadId。 // 如果您需要根据您需要uploadId执行列举已上传分片的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后，且在调用CompleteMultipartUpload完成分片上传之前获取uploadId。 Console.WriteLine("Upload Id:{0}", result.UploadId); catch (Exception ex) Console.WriteLine("Init multi part upload failed, {0}", ex.Message); // 计算分片总数。 var partSize = 100 * 1024; var fi = new FileInfo(localFilename); var fileSize = fi.Length; var partCount = fileSize / partSize; if (fileSize % partSize != 0) partCount++; // 开始分片上传。PartETags是保存PartETag的列表，OSS收到用户提交的分片列表后，会逐一验证每个分片数据的有效性。当所有的数据分片通过验证后，OSS会将这些分片组合成一个完整的文件。 var partETags = new List<PartETag>(); using (var fs = File.Open(localFilename, FileMode.Open)) for (var i = 0; i < partCount; i++) var skipBytes = (long)partSize * i; // 定位到本次上传的起始位置。 fs.Seek(skipBytes, 0); // 计算本次上传的分片大小，最后一片为剩余的数据大小。 var size = (partSize < fileSize - skipBytes) ? partSize : (fileSize - skipBytes); var request = new UploadPartRequest(bucketName, objectName, uploadId) InputStream = fs, PartSize = size, PartNumber = i + 1 // 调用UploadPart接口执行上传功能，返回结果中包含了这个数据片的ETag值。 var result = client.UploadPart(request); partETags.Add(result.PartETag); Console.WriteLine("finish {0}/{1}", partETags.Count, partCount); Console.WriteLine("Put multi part upload succeeded"); catch (Exception ex) Console.WriteLine("Put multi part upload failed, {0}", ex.Message); // 完成分片上传。 var completeMultipartUploadRequest = new CompleteMultipartUploadRequest(bucketName, objectName, uploadId); foreach (var partETag in partETags) completeMultipartUploadRequest.PartETags.Add(partETag); var result = client.CompleteMultipartUpload(completeMultipartUploadRequest); Console.WriteLine("complete multi part succeeded"); catch (Exception ex) Console.WriteLine("complete multi part failed, {0}", ex.Message); }
// 填写Bucket名称，例如examplebucket。 String bucketName = "examplebucket"; // 填写Object完整路径，例如exampledir/exampleobject.txt。Object完整路径中不能包含Bucket名称。 String objectName = "exampledir/exampleobject.txt"; // 填写本地文件完整路径，例如/storage/emulated/0/oss/examplefile.txt。 String localFilepath = "/storage/emulated/0/oss/examplefile.txt"; // 初始化分片上传。 InitiateMultipartUploadRequest init = new InitiateMultipartUploadRequest(bucketName, objectName); InitiateMultipartUploadResult initResult = oss.initMultipartUpload(init); // 返回uploadId。 String uploadId = initResult.getUploadId(); // 根据uploadId执行取消分片上传事件或者列举已上传分片的操作。 // 如果您需要根据您需要uploadId执行取消分片上传事件的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后获取uploadId。 // 如果您需要根据您需要uploadId执行列举已上传分片的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后，且在调用CompleteMultipartUpload完成分片上传之前获取uploadId。 // Log.d("uploadId", uploadId); // 设置单个Part的大小，单位为字节，取值范围为100 KB~5 GB。 int partCount = 100 * 1024; // 分片上传。 List<PartETag> partETags = new ArrayList<>(); for (int i = 1; i < 5; i++) { byte[] data = new byte[partCount]; RandomAccessFile raf = new RandomAccessFile(localFilepath, "r"); long skip = (i-1) * partCount; raf.seek(skip); raf.readFully(data, 0, partCount); UploadPartRequest uploadPart = new UploadPartRequest(); uploadPart.setBucketName(bucketName); uploadPart.setObjectKey(objectName); uploadPart.setUploadId(uploadId); // 设置分片号，从1开始标识。每一个上传的Part都有一个分片号，取值范围是1~10000。 uploadPart.setPartNumber(i); uploadPart.setPartContent(data); try { UploadPartResult result = oss.uploadPart(uploadPart); PartETag partETag = new PartETag(uploadPart.getPartNumber(), result.getETag()); partETags.add(partETag); } catch (ServiceException serviceException) { OSSLog.logError(serviceException.getErrorCode()); Collections.sort(partETags, new Comparator<PartETag>() { @Override public int compare(PartETag lhs, PartETag rhs) { if (lhs.getPartNumber() < rhs.getPartNumber()) { return -1; } else if (lhs.getPartNumber() > rhs.getPartNumber()) { return 1; } else { return 0; // 完成分片上传。 CompleteMultipartUploadRequest complete = new CompleteMultipartUploadRequest(bucketName, objectName, uploadId, partETags); // 上传回调。完成分片上传请求时可以设置CALLBACK_SERVER参数，请求完成后会向指定的Server Address发送回调请求。可通过返回结果的completeResult.getServerCallbackReturnBody()查看servercallback结果。 complete.setCallbackParam(new HashMap<String, String>() { put("callbackUrl", CALLBACK_SERVER); //修改为您的服务器地址。 put("callbackBody", "test"); CompleteMultipartUploadResult completeResult = oss.completeMultipartUpload(complete); OSSLog.logError("-------------- serverCallback: " + completeResult.getServerCallbackReturnBody());
package main import ( "fmt" "time" "github.com/aliyun/aliyun-oss-go-sdk/oss" func main() { // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。 provider, err := oss.NewEnvironmentVariableCredentialsProvider() if err != nil { fmt.Println("Error:", err) os.Exit(-1) // 创建OSSClient实例。 // yourEndpoint填写Bucket对应的Endpoint，以华东1（杭州）为例，填写为https://oss-cn-hangzhou.aliyuncs.com。其它Region请按实际情况填写。 client, err := oss.New("yourEndpoint", "", "", oss.SetCredentialsProvider(&provider)) if err != nil { fmt.Println("Error:", err) os.Exit(-1) // 填写存储空间名称。 bucketName := "examplebucket" // 填写Object完整路径。Object完整路径中不能包含Bucket名称。 objectName := "exampleobject.txt" // 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件。 locaFilename := "D:\\localpath\\examplefile.txt" bucket, err := client.Bucket(bucketName) if err != nil { fmt.Println("Error:", err) os.Exit(-1) // 将本地文件分片，且分片数量指定为3。 chunks, err := oss.SplitFileByPartNum(locaFilename, 3) if err != nil { fmt.Println("Error:", err) os.Exit(-1) fd, err := os.Open(locaFilename) if err != nil { fmt.Println("Error:", err) os.Exit(-1) defer fd.Close() // 指定过期时间。 expires := time.Date(2049, time.January, 10, 23, 0, 0, 0, time.UTC) // 如果需要在初始化分片时设置请求头，请参考以下示例代码。 options := []oss.Option{ oss.MetadataDirective(oss.MetaReplace), oss.Expires(expires), // 指定该Object被下载时的网页缓存行为。 // oss.CacheControl("no-cache"), // 指定该Object被下载时的名称。 // oss.ContentDisposition("attachment;filename=FileName.txt"), // 指定该Object的内容编码格式。 // oss.ContentEncoding("gzip"), // 指定对返回的Key进行编码，目前支持URL编码。 // oss.EncodingType("url"), // 指定Object的存储类型。 // oss.ObjectStorageClass(oss.StorageStandard), // 步骤1：初始化一个分片上传事件。 imur, err := bucket.InitiateMultipartUpload(objectName, options...) if err != nil { fmt.Println("Error:", err) os.Exit(-1) // 步骤2：上传分片。 var parts []oss.UploadPart for _, chunk := range chunks { fd.Seek(chunk.Offset, os.SEEK_SET) // 调用UploadPart方法上传每个分片。 part, err := bucket.UploadPart(imur, fd, chunk.Size, chunk.Number) if err != nil { fmt.Println("Error:", err) os.Exit(-1) parts = append(parts, part) // 指定Object的读写权限为私有，默认为继承Bucket的读写权限。 objectAcl := oss.ObjectACL(oss.ACLPrivate) // 步骤3：完成分片上传。 cmur, err := bucket.CompleteMultipartUpload(imur, parts, objectAcl) if err != nil { fmt.Println("Error:", err) os.Exit(-1) fmt.Println("cmur:", cmur) }
__block NSString * uploadId = nil; __block NSMutableArray * partInfos = [NSMutableArray new]; // 填写Bucket名称，例如examplebucket。 NSString * uploadToBucket = @"examplebucket"; // 填写Object完整路径，例如exampledir/exampleobject.txt。Object完整路径中不能包含Bucket名称。 NSString * uploadObjectkey = @"exampledir/exampleobject.txt"; // OSSInitMultipartUploadRequest用于指定上传文件的名称以及上传文件所属的存储空间的名称。 OSSInitMultipartUploadRequest * init = [OSSInitMultipartUploadRequest new]; init.bucketName = uploadToBucket; init.objectKey = uploadObjectkey; // init.contentType = @"application/octet-stream"; // multipartUploadInit返回的结果中包含UploadId，UploadId是分片上传的唯一标识。 OSSTask * initTask = [client multipartUploadInit:init]; [initTask waitUntilFinished]; if (!initTask.error) { OSSInitMultipartUploadResult * result = initTask.result; uploadId = result.uploadId; // 根据uploadId执行取消分片上传事件或者列举已上传分片的操作。 // 如果您需要根据您需要uploadId执行取消分片上传事件的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后获取uploadId。 // 如果您需要根据您需要uploadId执行列举已上传分片的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后，且在调用CompleteMultipartUpload完成分片上传之前获取uploadId。 //NSLog(@"UploadId": %@, uploadId); } else { NSLog(@"multipart upload failed, error: %@", initTask.error); return; // 指定要上传的文件。 NSString * filePath = @"<filepath>"; // 获取文件大小。 uint64_t fileSize = [[[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil] fileSize]; // 设置分片上传数量。 int chuckCount = 10; // 设置分片大小。 uint64_t offset = fileSize/chuckCount; for (int i = 1; i <= chuckCount; i++) { OSSUploadPartRequest * uploadPart = [OSSUploadPartRequest new]; uploadPart.bucketName = uploadToBucket; uploadPart.objectkey = uploadObjectkey; uploadPart.uploadId = uploadId; uploadPart.partNumber = i; // part number start from 1 NSFileHandle* readHandle = [NSFileHandle fileHandleForReadingAtPath:filePath]; [readHandle seekToFileOffset:offset * (i -1)]; NSData* data = [readHandle readDataOfLength:offset]; uploadPart.uploadPartData = data; OSSTask * uploadPartTask = [client uploadPart:uploadPart]; [uploadPartTask waitUntilFinished]; if (!uploadPartTask.error) { OSSUploadPartResult * result = uploadPartTask.result; uint64_t fileSize = [[[NSFileManager defaultManager] attributesOfItemAtPath:uploadPart.uploadPartFileURL.absoluteString error:nil] fileSize]; [partInfos addObject:[OSSPartInfo partInfoWithPartNum:i eTag:result.eTag size:fileSize]]; } else { NSLog(@"upload part error: %@", uploadPartTask.error); return; OSSCompleteMultipartUploadRequest * complete = [OSSCompleteMultipartUploadRequest new]; complete.bucketName = uploadToBucket; complete.objectKey = uploadObjectkey; complete.uploadId = uploadId; complete.partInfos = partInfos; OSSTask * completeTask = [client completeMultipartUpload:complete]; [[completeTask continueWithBlock:^id(OSSTask *task) { if (!task.error) { OSSCompleteMultipartUploadResult * result = task.result; // ... } else { // ... return nil; }] waitUntilFinished];
#include <alibabacloud/oss/OssClient.h> #include <fstream> int64_t getFileSize(const std::string& file) std::fstream f(file, std::ios::in | std::ios::binary); f.seekg(0, f.end); int64_t size = f.tellg(); f.close(); return size; using namespace AlibabaCloud::OSS; int main(void) /* 初始化OSS账号信息 */ std::string Endpoint = "yourEndpoint"; /* 填写Bucket名称，例如examplebucket */ std::string BucketName = "examplebucket"; /* 填写Object完整路径，完整路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。 */ std::string ObjectName = "exampledir/exampleobject.txt"; /* 初始化网络等资源 */ InitializeSdk(); ClientConfiguration conf; /* 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。*/ auto credentialsProvider = std::make_shared<EnvironmentVariableCredentialsProvider>(); OssClient client(Endpoint, credentialsProvider, conf); InitiateMultipartUploadRequest initUploadRequest(BucketName, ObjectName); /*（可选）请参见如下示例设置存储类型 */ //initUploadRequest.MetaData().addHeader("x-oss-storage-class", "Standard"); /* 初始化分片上传事件 */ auto uploadIdResult = client.InitiateMultipartUpload(initUploadRequest); /* 根据UploadId执行取消分片上传事件或者列举已上传分片的操作。*/ /* 如果您需要根据您需要UploadId执行取消分片上传事件的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后获取uploadId。*/ /* 如果您需要根据您需要UploadId执行列举已上传分片的操作，您需要在调用InitiateMultipartUpload完成初始化分片之后，且在调用CompleteMultipartUpload完成分片上传之前获取uploadId。*/ auto uploadId = uploadIdResult.result().UploadId(); std::string fileToUpload = "yourLocalFilename"; int64_t partSize = 100 * 1024; PartList partETagList; auto fileSize = getFileSize(fileToUpload); int partCount = static_cast<int>(fileSize / partSize); /* 计算分片个数 */ if (fileSize % partSize != 0) { partCount++; /* 对每一个分片进行上传 */ for (int i = 1; i <= partCount; i++) { auto skipBytes = partSize * (i - 1); auto size = (partSize < fileSize - skipBytes) ? partSize : (fileSize - skipBytes); std::shared_ptr<std::iostream> content = std::make_shared<std::fstream>(fileToUpload, std::ios::in|std::ios::binary); content->seekg(skipBytes, std::ios::beg); UploadPartRequest uploadPartRequest(BucketName, ObjectName, content); uploadPartRequest.setContentLength(size); uploadPartRequest.setUploadId(uploadId); uploadPartRequest.setPartNumber(i); auto uploadPartOutcome = client.UploadPart(uploadPartRequest); if (uploadPartOutcome.isSuccess()) { Part part(i, uploadPartOutcome.result().ETag()); partETagList.push_back(part); else { std::cout << "uploadPart fail" << ",code:" << uploadPartOutcome.error().Code() << ",message:" << uploadPartOutcome.error().Message() << ",requestId:" << uploadPartOutcome.error().RequestId() << std::endl; /* 完成分片上传 */ /* 在执行完成分片上传操作时，需要提供所有有效的partETags。OSS收到提交的partETags后，会逐一验证每个分片的有效性。当所有的数据分片验证通过后，OSS将把这些分片组合成一个完整的文件。*/ CompleteMultipartUploadRequest request(BucketName, ObjectName); request.setUploadId(uploadId); request.setPartList(partETagList); /*（可选）请参见如下示例设置读写权限ACL */ //request.setAcl(CannedAccessControlList::Private); auto outcome = client.CompleteMultipartUpload(request); if (!outcome.isSuccess()) { /* 异常处理 */ std::cout << "CompleteMultipartUpload fail" << ",code:" << outcome.error().Code() << ",message:" << outcome.error().Message() << ",requestId:" << outcome.error().RequestId() << std::endl; return -1; /* 释放网络等资源 */ ShutdownSdk(); return 0; }
#include "oss_api.h" #include "aos_http_io.h" #include <sys/stat.h> /* yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1（杭州）为例，Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。*/ const char *endpoint = "yourEndpoint"; /* 填写Bucket名称，例如examplebucket。*/ const char *bucket_name = "examplebucket"; /* 填写Object完整路径，完整路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。*/ const char *object_name = "exampledir/exampleobject.txt"; /* 填写本地文件的完整路径。*/ const char *local_filename = "yourLocalFilename"; void init_options(oss_request_options_t *options) options->config = oss_config_create(options->pool); /* 用char*类型的字符串初始化aos_string_t类型。*/ aos_str_set(&options->config->endpoint, endpoint); /* 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。*/ aos_str_set(&options->config->access_key_id, getenv("OSS_ACCESS_KEY_ID")); aos_str_set(&options->config->access_key_secret, getenv("OSS_ACCESS_KEY_SECRET")); /* 是否使用CNAME访问OSS服务。0表示不使用。*/ options->config->is_cname = 0; /* 设置网络相关参数，比如超时时间等。*/ options->ctl = aos_http_controller_create(options->pool, 0); int64_t get_file_size(const char *file_path) int64_t filesize = -1; struct stat statbuff; if(stat(file_path, &statbuff) < 0){ return filesize; } else { filesize = statbuff.st_size; return filesize; int main(int argc, char *argv[]) /* 在程序入口调用aos_http_io_initialize方法来初始化网络、内存等全局资源。*/ if (aos_http_io_initialize(NULL, 0) != AOSE_OK) { exit(1); /* 用于内存管理的内存池（pool），等价于apr_pool_t。其实现代码在apr库中。*/ aos_pool_t *pool; /* 重新创建一个内存池，第二个参数是NULL，表示没有继承其它内存池。*/ aos_pool_create(&pool, NULL); /* 创建并初始化options，该参数包括endpoint、access_key_id、acces_key_secret、is_cname、curl等全局配置信息。*/ oss_request_options_t *oss_client_options; /* 在内存池中分配内存给options。*/ oss_client_options = oss_request_options_create(pool); /* 初始化Client的选项oss_client_options。*/ init_options(oss_client_options); /* 初始化参数。*/ aos_string_t bucket; aos_string_t object; oss_upload_file_t *upload_file = NULL; aos_string_t upload_id; aos_table_t *headers = NULL; aos_table_t *complete_headers = NULL; aos_table_t *resp_headers = NULL; aos_status_t *resp_status = NULL; aos_str_set(&bucket, bucket_name); aos_str_set(&object, object_name); aos_str_null(&upload_id); headers = aos_table_make(pool, 1); complete_headers = aos_table_make(pool, 1); int part_num = 1; /* 初始化分片上传，获取一个上传ID(upload_id)。*/ resp_status = oss_init_multipart_upload(oss_client_options, &bucket, &object, &upload_id, headers, &resp_headers); /* 判断分片上传初始化是否成功。*/ if (aos_status_is_ok(resp_status)) { printf("Init multipart upload succeeded, upload_id:%.*s\n", upload_id.len, upload_id.data); } else { printf("Init multipart upload failed, upload_id:%.*s\n", upload_id.len, upload_id.data); /* 上传分片。*/ int64_t file_length = 0; int64_t pos = 0; aos_list_t complete_part_list; oss_complete_part_content_t* complete_content = NULL; char* part_num_str = NULL; char* etag = NULL; aos_list_init(&complete_part_list); file_length = get_file_size(local_filename); while(pos < file_length) { upload_file = oss_create_upload_file(pool); aos_str_set(&upload_file->filename, local_filename); upload_file->file_pos = pos; pos += 100 * 1024; upload_file->file_last = pos < file_length ? pos : file_length; resp_status = oss_upload_part_from_file(oss_client_options, &bucket, &object, &upload_id, part_num++, upload_file, &resp_headers); /* 保存分片号和ETag。*/ complete_content = oss_create_complete_part_content(pool); part_num_str = apr_psprintf(pool, "%d", part_num-1); aos_str_set(&complete_content->part_number, part_num_str); etag = apr_pstrdup(pool, (char*)apr_table_get(resp_headers, "ETag")); aos_str_set(&complete_content->etag, etag); aos_list_add_tail(&complete_content->node, &complete_part_list); if (aos_status_is_ok(resp_status)) { printf("Multipart upload part from file succeeded\n"); } else { printf("Multipart upload part from file failed\n"); /* 完成分片上传。*/ resp_status = oss_complete_multipart_upload(oss_client_options, &bucket, &object, &upload_id, &complete_part_list, complete_headers, &resp_headers); /* 判断分片上传是否完成。*/ if (aos_status_is_ok(resp_status)) { printf("Complete multipart upload from file succeeded, upload_id:%.*s\n", upload_id.len, upload_id.data); } else { printf("Complete multipart upload from file failed\n"); /* 释放内存池，相当于释放了请求过程中各资源分配的内存。*/ aos_pool_destroy(pool); /* 释放之前分配的全局资源。*/ aos_http_io_deinitialize(); return 0; }
关于使用ossutil分片上传具体操作， 请参见 cp（上传文件） 。
如果您的程序自定义要求较高，您可以直接发起REST API请求。直接发起REST API请求需要手动编写代码计算签名。更多信息，请参见 InitiateMultipartUpload 。
分片上传过程被中断后，已上传的Part会一直保存在Bucket中。如果您不再需要这些Part，请通过以下方式删除，以免产生额外的存储费用。
手动删除Part，请参见 删除碎片 。
通过生命周期规则自动删除Part，请参见 设置生命周期规则 。
如果您希望列举指定Upload ID所属的所有已经上传成功Part，请参见 ListParts 。
如果您希望列举已经初始化但还未完成（Complete）或者还未中止（Abort）的Multipart Upload事件，请参见 ListMultipartUploads 。
支持。
分片上传过程中断后，如果使用同一个Upload ID重新上传所有Part，则会覆盖之前上传的同名Part；如果使用新的Upload ID重新上传所有Part，旧的Upload ID中的分片会作为碎片继续保留。
Upload ID用于唯一标识分片上传事件。对于同一个Upload ID，分片号（PartNumber）用于标识该分片在整个文件内的相对位置。
Upload ID在分片上传过程中一直有效，如果上传终止或上传完成，Upload ID将失效。如果需要再次分片上传，您需要重新初始化生成一个新的Upload ID。
OSS不支持自动合并分片，您需要通过调用 CompleteMultipartUpload 手动合并分片。
