追加上傳 - Object Storage Service

追加上傳指的是在已上傳的Appendable類型Object後面直接追加內容。

前提條件

已建立儲存空間（Bucket）。詳情請參見控制台建立儲存空間。

背景資訊

通過簡單上傳產生的Object類型為Normal，通過分區上傳產生的Object類型為Multipart。這兩種類型Object在上傳結束之後內容是固定的，只能讀取，不能修改。如果Object內容發生了改變，只能重新上傳同名的Object來覆蓋之前的內容。

由於這一特性，如果通過上述方式上傳視頻監控、ApsaraVideo for Live等領域產生的即時視頻流，只能將視頻流按照一定規律切分成小塊然後不斷地上傳新的Object，在實際使用中存在以下缺點：

軟體架構比較複雜，需要考慮檔案分塊等細節問題。
需要有位置儲存中繼資料，比如已經產生的Object列表等，然後每次請求都重複讀取中繼資料來判斷是否有新的Object產生。這樣對伺服器的壓力很大，而且用戶端每次都需要發送兩次網路請求，延時上也會有一定的影響。
如果Object切分較小能有效降低資料延時，但是切分過多的Object會引發管理複雜的問題。如果Object切分較大，則資料延時又會明顯提升。

如果需要即時更新已上傳Object內容的視頻流，您需要先在本地進行視頻拼接，然後通過OSS提供的追加上傳（AppendObject）的方式上傳視頻，上傳後將產生Appendable類型的Object。Appendable類型Object後面允許直接追加內容，且每次追加上傳的資料都能夠即時可讀。

功能優勢

通過追加上傳，可在視頻資料產生之後即時將資料上傳至同一個Object，而用戶端只需要定時擷取該Object的長度，並與上次讀取的長度進行對比。如果發現有新的可讀資料，則觸發一次讀操作來擷取新上傳的資料部分即可。通過這種方式可以簡化架構，增強擴充性。

使用限制

大小限制
Object大小不能超過5 GB。
操作限制
- 不支援通過追加上傳的方式上傳冷歸檔、深度冷歸檔類型的Object。
- 不支援拷貝通過追加上傳方式上傳的Object，但允許修改Object本身的meta資訊。
- 追加上傳不支援上傳回調操作。

注意事項

當檔案不存在時，調用AppendObject介面會建立一個追加類型檔案。
當檔案已存在時：
- 如果檔案為追加類型檔案，且設定的追加位置和檔案當前長度相等，則直接在該檔案末尾追加內容。
- 如果檔案為追加類型檔案，但是設定的追加位置和檔案當前長度不相等，則拋出PositionNotEqualToLength異常。
- 如果檔案為非追加類型檔案時，例如通過簡單上傳的檔案類型為Normal的檔案，則拋出ObjectNotAppendable異常。

操作步驟

使用阿里雲SDK

以下僅列舉常見SDK的追加上傳的程式碼範例。關於其他SDK的追加上傳的程式碼範例，請參見SDK簡介。

Java

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.model.AppendObjectRequest;
import com.aliyun.oss.model.AppendObjectResult;
import com.aliyun.oss.model.ObjectMetadata;
import java.io.ByteArrayInputStream;

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完整路徑，完整路徑中不能包含Bucket名稱，例如exampledir/exampleobject.txt。
        String objectName = "exampledir/exampleobject.txt";
        String content1 = "Hello OSS A \n";
        String content2 = "Hello OSS B \n";
        String content3 = "Hello OSS C \n";

        // 建立OSSClient執行個體。
        OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);

        try {
            ObjectMetadata meta = new ObjectMetadata();
            // 指定上傳的內容類型。
            meta.setContentType("text/plain");
            // 指定該Object的網頁緩衝行為。
            //meta.setCacheControl("no-cache");
            // 指定該Object被下載時的名稱。
            //meta.setContentDisposition("attachment;filename=oss_download.txt");
            // 指定該Object的內容編碼格式。
            //meta.setContentEncoding(OSSConstants.DEFAULT_CHARSET_NAME);
            // 該要求標頭用於檢查訊息內容是否與發送時一致。
            //meta.setContentMD5("ohhnqLBJFiKkPSBO1eNaUA==");
            // 指定到期時間。
            //try {
            //    meta.setExpirationTime(DateUtil.parseRfc822Date("Wed, 08 Jul 2022 16:57:01 GMT"));
            //} catch (ParseException e) {
            //    e.printStackTrace();
            //}
            // 指定伺服器端加密方式。此處指定為OSS完全託管密鑰進行加密（SSE-OSS）。
            //meta.setServerSideEncryption(ObjectMetadata.AES_256_SERVER_SIDE_ENCRYPTION);
            // 指定Object的存取權限。此處指定為私人存取權限。
            //meta.setObjectAcl(CannedAccessControlList.Private);
            // 指定Object的儲存類型。
            //meta.setHeader(OSSHeaders.OSS_STORAGE_CLASS, StorageClass.Standard);
            // 建立AppendObject時可以添加x-oss-meta-*，繼續追加時不可以攜帶此參數。如果配置以x-oss-meta-*為首碼的參數，則該參數視為中繼資料。
            //meta.setHeader("x-oss-meta-author", "Alice");

            // 通過AppendObjectRequest設定多個參數。
            AppendObjectRequest appendObjectRequest = new AppendObjectRequest(bucketName, objectName, new ByteArrayInputStream(content1.getBytes()),meta);

            // 通過AppendObjectRequest設定單個參數。
            // 設定Bucket名稱。
            //appendObjectRequest.setBucketName(bucketName);
            // 設定Object名稱。
            //appendObjectRequest.setKey(objectName);
            // 設定待追加的內容。可選類型包括InputStream類型和File類型。此處為InputStream類型。
            //appendObjectRequest.setInputStream(new ByteArrayInputStream(content1.getBytes()));
            // 設定待追加的內容。可選類型包括InputStream類型和File類型。此處為File類型。
            //appendObjectRequest.setFile(new File("D:\\localpath\\examplefile.txt"));
            // 指定檔案的中繼資料，第一次追加時有效。
            //appendObjectRequest.setMetadata(meta);

            // 第一次追加。
            // 設定檔案的追加位置。
            appendObjectRequest.setPosition(0L);
            AppendObjectResult appendObjectResult = ossClient.appendObject(appendObjectRequest);
            // 檔案的64位CRC值。此值根據ECMA-182標準計算得出。
            System.out.println(appendObjectResult.getObjectCRC());

            // 第二次追加。
            // nextPosition表示下一次請求中應當提供的Position，即檔案當前的長度。
            appendObjectRequest.setPosition(appendObjectResult.getNextPosition());
            appendObjectRequest.setInputStream(new ByteArrayInputStream(content2.getBytes()));
            appendObjectResult = ossClient.appendObject(appendObjectRequest);

            // 第三次追加。
            appendObjectRequest.setPosition(appendObjectResult.getNextPosition());
            appendObjectRequest.setInputStream(new ByteArrayInputStream(content3.getBytes()));
            appendObjectResult = ossClient.appendObject(appendObjectRequest);
        } 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

 <?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\Credentials\EnvironmentVariableCredentialsProvider;
use OSS\OssClient;
use OSS\CoreOssException;

// 從環境變數中擷取訪問憑證。運行本程式碼範例之前，請確保已設定環境變數OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
$provider = new EnvironmentVariableCredentialsProvider();
// Endpoint以華東1（杭州）為例，其它Region請按實際情況填寫。
$endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// 填寫Bucket名稱。
$bucket= "examplebucket";
// 填寫不包含Bucket名稱在內的Object的完整路徑。
$object = "exampleobject.txt";
// 填寫本地檔案的完整路徑。如果未指定本地路徑，則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
$filePath = "D:\\localpath\\examplefilea.txt";
$filePath1 = "D:\\localpath\\examplefileb.txt";
$filePath2 = "D:\\localpath\\examplefilec.txt";

try{
    $config = array(
        "provider" => $provider,
        "endpoint" => $endpoint,
    );
    $ossClient = new OssClient($config);
    // 第一次追加上傳。第一次追加的位置是0，傳回值為下一次追加的位置。後續追加的位置是追加前檔案的長度。
    $position = $ossClient->appendFile($bucket, $object, $filePath, 0);
    $position = $ossClient->appendFile($bucket, $object, $filePath1, $position);
    $position = $ossClient->appendFile($bucket, $object, $filePath2, $position);
} catch(OssException $e) {
    printf(__FUNCTION__ . ": FAILED\n");
    printf($e->getMessage() . "\n");
    return;
}
print(__FUNCTION__ . ": OK" . "\n");

Node.js

const OSS = require('ali-oss')

const client = new OSS({
  // yourregion填寫Bucket所在地區。以華東1（杭州）為例，yourRegion填寫為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名稱，例如examplebucket。
  bucket: 'examplebucket',
});

const headers = {    
  // 指定Object的存取權限。
  'x-oss-object-acl': 'private',
  // 指定Object的儲存類型。
  'x-oss-storage-class': 'Standard',  
  // 指定伺服器端加密方式。此處指定為OSS完全託管密鑰進行加密（SSE-OSS）。
  'x-oss-server-side-encryption': 'AES256',  
};

async function append () {
  // 第一次追加上傳。傳回值為下一次追加的位置。
  // objectName表示不包含Bucket名稱在內的Object的完整路徑，例如destfolder/examplefile.txt。
  // localFile填寫包含尾碼在內的本地檔案完整路徑，例如/users/local/examplefile.txt。
  const result = await client.append('objectName', 'localFile'
  // 自訂headers和meta。
  //,{headers} 
  )

  // 第二次追加。後續追加的位置（position）是追加前檔案的長度（Content-Length）。
  result = await client.append('objectName', 'localFile', {
    position: result.nextAppendPosition
  })
}

append();

Python

# -*- coding: utf-8 -*-
import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider

# 從環境變數中擷取訪問憑證。運行本程式碼範例之前，請確保已設定環境變數OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
# yourEndpoint填寫Bucket所在地區對應的Endpoint。以華東1（杭州）為例，Endpoint填寫為https://oss-cn-hangzhou.aliyuncs.com。
# 填寫Bucket名稱。
bucket = oss2.Bucket(auth, 'https://oss-cn-hangzhou.aliyuncs.com', 'examplebucket')

# 如需在追加上傳時設定相關Headers，請參考如下範例程式碼。
# headers = dict()
# 指定該Object的網頁緩衝行為。
# headers['Cache-Control'] = 'no-cache'
# 指定該Object被下載時的名稱。
# headers['Content-Disposition'] = 'oss_MultipartUpload.txt'
# 指定該Object的內容編碼格式。
# headers['Content-Encoding'] = 'utf-8'
# 該要求標頭用於檢查訊息內容是否與發送時一致。
# headers['Content-MD5'] = 'ohhnqLBJFiKkPSBO1eNaUA=='
# 指定到期日期。
# headers['Expires'] = 'Wed, 08 Jul 2022 16:57:01 GMT'
# 指定Object的存取權限ACL。此處指定為OBJECT_ACL_PRIVATE，表示私人存取權限。
# headers['x-oss-object-acl'] = oss2.OBJECT_ACL_PRIVATE
# 指定追加上傳時是否覆蓋同名Object。
# headers['x-oss-forbid-overwrite'] = 'true'
# 指定伺服器端加密方式。此處指定為OSS完全託管密鑰進行加密（SSE-OSS）。
# headers[OSS_SERVER_SIDE_ENCRYPTION] = SERVER_SIDE_ENCRYPTION_AES256
# 指定Object的儲存類型。
# headers['x-oss-storage-class'] = oss2.BUCKET_STORAGE_CLASS_STANDARD
# 建立AppendObject時可以添加x-oss-meta-*，繼續追加時不可以攜帶此參數。如果配置以x-oss-meta-*為首碼的參數，則該參數視為中繼資料。
# headers['x-oss-meta-author'] = 'Alice'
# result = bucket.append_object(exampledir/exampleobject.txt, 0, 'content of first append', headers=headers)

# 設定首次上傳的追加位置（Position參數）為0。
# 填寫不能包含Bucket名稱在內的Object完整路徑，例如exampledir/exampleobject.txt。
result = bucket.append_object('exampledir/exampleobject.txt', 0, 'content of first append')
# 如果不是首次上傳，可以通過bucket.head_object方法或上次追加傳回值的next_position屬性，擷取追加位置。
bucket.append_object('<yourObjectName>', result.next_position, 'content of second append')

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名稱，例如examplebucket。
var bucketName = "examplebucket";
// 填寫Object完整路徑，完整路徑中不能包含Bucket名稱，例如exampledir/exampleobject.txt。
var objectName = "exampledir/exampleobject.txt";
// 填寫本地檔案完整路徑，例如D:\\localpath\\examplefile.txt。如果未指定本地路徑，則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
var localFilename = "D:\\localpath\\examplefile.txt";
// 建立OssClient執行個體。
var client = new OssClient(endpoint, accessKeyId, accessKeySecret);
// 第一次追加的位置是0，傳回值為下一次追加的位置。後續追加的位置是追加前檔案的長度。
long position = 0;
try
{
    var metadata = client.GetObjectMetadata(bucketName, objectName);
    position = metadata.ContentLength;
}
catch (Exception) { }
try
{
    using (var fs = File.Open(localFilename, FileMode.Open))
    {
        var request = new AppendObjectRequest(bucketName, objectName)
        {
            ObjectMetadata = new ObjectMetadata(),
            Content = fs,
            Position = position
        };
        // 追加檔案。
        var result = client.AppendObject(request);
        // 設定檔案的追加位置。
        position = result.NextAppendPosition;
        Console.WriteLine("Append object succeeded, next append position:{0}", position);
    }
    // 擷取追加位置，再次追加檔案。
    using (var fs = File.Open(localFilename, FileMode.Open))
    {
        var request = new AppendObjectRequest(bucketName, objectName)
        {
            ObjectMetadata = new ObjectMetadata(),
            Content = fs,
            Position = position
        };
        var result = client.AppendObject(request);
        position = result.NextAppendPosition;
        Console.WriteLine("Append object succeeded, next append position:{0}", position);
    }
}
catch (Exception ex)
{
    Console.WriteLine("Append object failed, {0}", ex.Message);
}

Android-Java

// 依次填寫Bucket名稱（例如examplebucket）、Object完整路徑（例如exampledir/exampleobject.txt）和本地檔案完整路徑（例如/storage/emulated/0/oss/examplefile.txt）。
// Object完整路徑中不能包含Bucket名稱。
AppendObjectRequest append = new AppendObjectRequest("examplebucket", "exampledir/exampleobject.txt", "/storage/emulated/0/oss/examplefile.txt");

ObjectMetadata metadata = new ObjectMetadata();
metadata.setContentType("text/plain");
append.setMetadata(metadata);

// 設定追加位置。
append.setPosition(0);

// 設定回調。
append.setProgressCallback(new OSSProgressCallback<AppendObjectRequest>() {
    @Override
    public void onProgress(AppendObjectRequest request, long currentSize, long totalSize) {
        Log.d("AppendObject", "currentSize: " + currentSize + " totalSize: " + totalSize);
    }
});
// 非同步追加上傳。
OSSAsyncTask task = oss.asyncAppendObject(append, new OSSCompletedCallback<AppendObjectRequest, AppendObjectResult>() {
    @Override
    public void onSuccess(AppendObjectRequest request, AppendObjectResult result) {
        Log.d("AppendObject", "AppendSuccess");
        Log.d("NextPosition", "" + result.getNextPosition());
    }

    @Override
    public void onFailure(AppendObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
        // 異常處理。
    }
});

package main

import (
	"log"
	"strings"
	"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 {
		log.Fatalf("Failed to create credentials provider: %v", err)
	}

	// 建立OSSClient執行個體。
	// yourEndpoint填寫Bucket對應的Endpoint，以華東1（杭州）為例，填寫為https://oss-cn-hangzhou.aliyuncs.com。其它Region請按實際情況填寫。
	endpoint := "https://oss-cn-hangzhou.aliyuncs.com" // 請替換為實際的Endpoint
	client, err := oss.New(endpoint, "", "", oss.SetCredentialsProvider(&provider))
	if err != nil {
		log.Fatalf("Failed to create OSS client: %v", err)
	}

	// 填寫Bucket名稱，例如examplebucket。
	bucketName := "examplebucket" // 請替換為實際的Bucket名稱
	bucket, err := client.Bucket(bucketName)
	if err != nil {
		log.Fatalf("Failed to get bucket: %v", err)
	}

	// 填寫不包含Bucket名稱在內的Object的完整路徑，例如appendobject.txt。
	objectName := "appendobject.txt"
	var nextPos int64 = 0

	// 指定到期時間。
	expires := time.Date(2025, time.December, 10, 23, 0, 0, 0, time.UTC)
	options := []oss.Option{
		oss.Expires(expires),
	}

	// 第一次追加上傳的位置是0，傳回值為下一次追加的位置。
	appendValue1 := "YourObjectAppendValue1"
	nextPos, err = bucket.AppendObject(objectName, strings.NewReader(appendValue1), nextPos, options...)
	if err != nil {
		log.Fatalf("Failed to append first value: %v", err)
	}

	// 第二次追加上傳。
	appendValue2 := "YourObjectAppendValue2"
	nextPos, err = bucket.AppendObject(objectName, strings.NewReader(appendValue2), nextPos)
	if err != nil {
		log.Fatalf("Failed to append second value: %v", err)
	}

	log.Println("Append uploads completed successfully.")
}

Object C

OSSAppendObjectRequest * append = [OSSAppendObjectRequest new];
// 配置以下必要欄位，其中bucketName為儲存空間名稱；objectKey等同於objectName，表示追加上傳檔案到OSS時需要指定包含檔案尾碼在內的完整路徑，例如abc/efg/123.jpg。
append.bucketName = @"<bucketName>";
append.objectKey = @"<objectKey>";
// 指定首次進行追加上傳的位置。
append.appendPosition = 0; 
NSString * docDir = [self getDocumentDirectory];
append.uploadingFileURL = [NSURL fileURLWithPath:@"<filepath>"];
// 以下為可選欄位。
append.uploadProgress = ^(int64_t bytesSent, int64_t totalByteSent, int64_t totalBytesExpectedToSend) {
    NSLog(@"%lld, %lld, %lld", bytesSent, totalByteSent, totalBytesExpectedToSend);
};
// append.contentType = @"";
// append.contentMd5 = @"";
// append.contentEncoding = @"";
// append.contentDisposition = @"";
OSSTask * appendTask = [client appendObject:append];
[appendTask continueWithBlock:^id(OSSTask *task) {
    NSLog(@"objectKey: %@", append.objectKey);
    if (!task.error) {
        NSLog(@"append object success!");
        OSSAppendObjectResult * result = task.result;
        NSString * etag = result.eTag;
        long nextPosition = result.xOssNextAppendPosition;
    } else {
        NSLog(@"append object failed, error: %@" , task.error);
    }
    return nil;
}];

C++

#include <alibabacloud/oss/OssClient.h>
using namespace AlibabaCloud::OSS;

int main(void)
{
    /* 初始化OSS帳號資訊。*/
            
    /* 填寫Bucket所在地區對應的Endpoint。以華東1（杭州）為例，Endpoint填寫為https://oss-cn-hangzhou.aliyuncs.com。*/
    std::string Endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
    /* 填寫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);

    auto meta = ObjectMetaData();
    meta.setContentType("text/plain");

    /* 第一次追加的位置是0，傳回值為下一次追加的位置。後續追加的位置是追加前檔案的長度。*/
    std::shared_ptr<std::iostream> content1 = std::make_shared<std::stringstream>();
    *content1 <<"Thank you for using Aliyun Object Storage Service!";
    AppendObjectRequest request(BucketName, ObjectName, content1, meta);
    request.setPosition(0L);

    /* 第一次追加檔案。*/
    auto result = client.AppendObject(request);

    if (!result.isSuccess()) {
        /* 異常處理。*/
        std::cout << "AppendObject fail" <<
        ",code:" << result.error().Code() <<
        ",message:" << result.error().Message() <<
        ",requestId:" << result.error().RequestId() << std::endl;
        return -1;
    }

    std::shared_ptr<std::iostream> content2 = std::make_shared<std::stringstream>();
    *content2 <<"Thank you for using Aliyun Object Storage Service!";
    auto position = result.result().Length();
    AppendObjectRequest appendObjectRequest(BucketName, ObjectName, content2);
    appendObjectRequest.setPosition(position);

    /* 第二次追加檔案。*/
    auto outcome = client.AppendObject(appendObjectRequest);

    if (!outcome.isSuccess()) {
        /* 異常處理。*/
        std::cout << "AppendObject 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"
/* 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 *object_content = "More than just cloud.";
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。0表示不使用。*/
    options->config->is_cname = 0;
    /* 用於設定網路相關參數，比如逾時時間等。*/
    options->ctl = aos_http_controller_create(options->pool, 0);
}
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;
    aos_list_t buffer;
    int64_t position = 0;
    char *next_append_position = NULL;
    aos_buf_t *content = NULL;
    aos_table_t *headers1 = NULL;
    aos_table_t *headers2 = 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);
    headers1 = aos_table_make(pool, 0);
    /* 擷取起始追加位置。*/
    resp_status = oss_head_object(oss_client_options, &bucket, &object, headers1, &resp_headers);
    if (aos_status_is_ok(resp_status)) {
        next_append_position = (char*)(apr_table_get(resp_headers, "x-oss-next-append-position"));
        position = atoi(next_append_position);
    }
    /* 追加檔案。*/
    headers2 = aos_table_make(pool, 0);
    aos_list_init(&buffer);
    content = aos_buf_pack(pool, object_content, strlen(object_content));
    aos_list_add_tail(&content->node, &buffer);
    resp_status = oss_append_object_from_buffer(oss_client_options, &bucket, &object, position, &buffer, headers2, &resp_headers);
    if (aos_status_is_ok(resp_status)) {
        printf("append object from buffer succeeded\n");
    } else {
        printf("append object from buffer failed\n");
    }
    /* 釋放記憶體池，相當於釋放了請求過程中各資源分派的記憶體。*/
    aos_pool_destroy(pool);
    /* 釋放之前分配的全域資源。*/
    aos_http_io_deinitialize();
    return 0;
}

Ruby

require 'aliyun/oss'

client = Aliyun::OSS::Client.new(
  # Endpoint以華東1（杭州）為例，其它Region請按實際情況填寫。
  endpoint: 'https://oss-cn-hangzhou.aliyuncs.com',
  # 從環境變數中擷取訪問憑證。運行本程式碼範例之前，請確保已設定環境變數OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
  access_key_id: ENV['OSS_ACCESS_KEY_ID'],
  access_key_secret: ENV['OSS_ACCESS_KEY_SECRET']
)

# 填寫Bucket名稱，例如examplebucket。
bucket = client.get_bucket('examplebucket')
# my-object填寫Object完整路徑，完整路徑中不能包含Bucket名稱。
bucket.append_object('my-object', 0)

# 向檔案末尾追加內容。
next_pos = bucket.append_object('my-object', 0) do |stream|
  100.times { |i| stream << i.to_s }
end
next_pos = bucket.append_object('my-object', next_pos, :file => 'local-file-1')
next_pos = bucket.append_object('my-object', next_pos, :file => 'local-file-2')

使用命令列工具ossutil

關於使用ossutil追加上傳的具體操作，請參見appendfromfile（追加上傳）。

使用REST API

如果您的程式自訂要求較高，您可以直接發起REST API請求。直接發起REST API請求需要手動編寫代碼計算簽名。更多資訊，請參見AppendObject。

常見問題

追加上傳有檔案類型限制嗎？

沒有。追加上傳時只識別二進位流，對於檔案類型無要求。