すべてのプロダクト
Search
ドキュメントセンター

Object Storage Service:マルチパートアップロード

最終更新日:Feb 23, 2024

サイズが5 GBを超える大きなオブジェクトをobject Storage Service (OSS) にアップロードすると、ネットワークの中断やプログラムのクラッシュにより、オブジェクトのアップロードに失敗することがあります。 複数回の再試行後にオブジェクトのアップロードに失敗した場合は、マルチパートアップロードを実行してラージオブジェクトをアップロードできます。 マルチパートアップロードを使用すると、アップロードするラージオブジェクトを複数のパーツに分割し、ネットワーク帯域幅とサーバーリソースに基づいてパーツを並行してアップロードできます。 このようにして、オブジェクトのアップロードに要する時間が短縮される。 パーツがアップロードされたら、CompleteMultipartUpload操作を呼び出して、パーツを完全なオブジェクトに結合する必要があります。

前提条件

シナリオ

  • 大きなオブジェクトの高速アップロード

    サイズが5 GBを超えるオブジェクトをアップロードする場合は、マルチパートアップロードを使用してオブジェクトを複数のパーツに分割し、パーツを並列にアップロードしてアップロードを高速化できます。

  • 不安定なネットワーク接続

    ネットワーク接続が不安定な場合は、マルチパートアップロードを使用することを推奨します。 特定のパーツのアップロードに失敗した場合は、失敗したパーツのみを再アップロードする必要があります。

  • 不明なオブジェクトサイズ

    アップロードするオブジェクトのサイズがわからない場合は、マルチパートアップロードを使用できます。 このケースは、ビデオ監視などの産業用途で一般的です。

処理中

image

上記のプロセスは、次の手順で構成されます。

説明

マルチパートアップロードタスクを完了するには、oss:PutObject権限が必要です。 マルチパートアップロードタスクは、マルチパートアップロードの開始、パートアップロード、およびパートの組み合わせの3つのステップで構成されます。 詳細については、「RAMユーザーへのカスタムポリシーのアタッチ」をご参照ください。

  1. アップロードするオブジェクトを特定のパーツサイズに基づいてパーツに分割します。

  2. InitiateMultipartUpload操作を呼び出して、マルチパートアップロードタスクを開始します。

  3. UploadPart操作を呼び出して、パーツをアップロードします。

    オブジェクトをパーツに分割した後、各パーツのpartNumberパラメーターを設定して、パーツの順序を指定します。 このようにして、パーツは並行してアップロードされます。 並行してアップロードを増やすと、必ずしもアップロードが速くなるとは限りません。 ネットワークの状態とデバイスのワークロードに基づいて、並列アップロードの数を指定することをお勧めします。

    マルチパートアップロードタスクをキャンセルするには、AbortMultipartUpload操作を呼び出します。 マルチパートアップロードタスクがキャンセルされると、アップロードされたパーツは削除されます。

  4. CompleteMultipartUpload操作を呼び出して、アップロードされたパーツをオブジェクトに結合します。

制限事項

項目

制限

オブジェクトサイズ

マルチパートアップロードは、サイズが最大48.8テラバイトのオブジェクトをサポートします。

部品の数

部品の数を1から10,000の範囲の値に設定できます。

パーツサイズ

最後の部品を除く部品のサイズは、100 KBから5 GBの範囲でなければなりません。 最後の部分のサイズは100 KB未満にすることができます。

1つのListPartsリクエストに対して返すことができるパーツの最大数

1回のListPartsリクエストで最大1,000個のパーツを返すことができます。

1つのListMultipartUploadsリクエストに対して返すことができるマルチパートアップロードタスクの最大数

1つのListMultipartUploadsリクエストに対して最大1,000のタスクを返すことができます。

使用上の注意

  • マルチパートアップロードを使用してオブジェクトをアップロードする場合、一度にアップロードできるオブジェクトは1つだけで、ディレクトリをアップロードできません。

  • PUTリクエスト料金の引き下げ

    多数のオブジェクトをアップロードし、オブジェクトのストレージクラスをDeep Cold Archiveに設定する場合は、高いPUTリクエスト料金が請求されます。 オブジェクトのアップロード時にオブジェクトのストレージクラスを標準に設定し、標準オブジェクトのストレージクラスをDeep Cold Archiveに変換するようにライフサイクルルールを設定することを推奨します。 これにより、PUTリクエスト料金が削減されます。

  • オブジェクトのアップロードのパフォーマンスの最適化

    名前にタイムスタンプや文字などの連続したプレフィックスが含まれているオブジェクトを多数アップロードすると、複数のオブジェクトインデックスが1つのパーティションに格納される可能性があります。 これらのオブジェクトを照会するために多数のリクエストが送信されると、レイテンシが増加します。 名前にシーケンシャルプレフィックスが含まれているオブジェクトを多数アップロードしないことをお勧めします。 詳細については、「OSSパフォーマンスとスケーラビリティのベストプラクティス」をご参照ください。

  • オブジェクトの上書き

    OSSで既存のオブジェクトと同じ名前のオブジェクトをアップロードすると、既存のオブジェクトはアップロードされたオブジェクトによって上書きされます。 次のいずれかの方法を使用して、オブジェクトが予期せず上書きされないようにします。

    • バージョン管理の有効化

      バケットのバージョン管理が有効になっている場合、上書きされたオブジェクトは以前のバージョンとして保存されます。 以前のバージョンを復元できます。 詳細については、「概要」をご参照ください。

    • アップロードリクエストにx-oss-forbid-overwriteヘッダーを含める

      アップロードリクエストにx-oss-forbid-overwriteヘッダーを含め、ヘッダーをtrueに設定します。 この方法では、既存のオブジェクトと同じ名前のオブジェクトをアップロードすると、アップロードは失敗し、FileAlreadyExistsエラーが返されます。 詳細については、「InitiateMultipartUpload」をご参照ください。

手順

OSS SDKの使用

次のサンプルコードは、一般的なプログラミング言語でOSS SDKを使用してマルチパートアップロードを実行する方法の例を示しています。 他のプログラミング言語でOSS SDKを使用してマルチパートアップロードを実行する方法については、「概要」をご参照ください。

com.aliyun.oss.ClientExceptionをインポートします。com.aliyun.oss.OSSをインポートします。impor t com.aliyun.oss.com mon.auth.*;
com.aliyun.oss.OSSClientBuilderをインポートします。com.aliyun.oss.OSSExceptionをインポートします。com.aliyun.oss.int ernal.Mimetypesをインポートします。com.aliyun.oss.mo delをインポートします。*;
java.io. ファイルをインポートします。java.io.FileInputStreamをインポートします。java.io.InputStreamをインポートします。java.util.ArrayListをインポートします。java.util.Listをインポートします。public classデモ {

    public static void main(String[] args) throws Exception {
        // この例では、中国 (杭州) リージョンのエンドポイントが使用されます。 実際のエンドポイントを指定します。 
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。 
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // バケットの名前を指定します。 例: examplebucket. 
        String bucketName = "examplebucket";
        // オブジェクトのフルパスを指定します。 例: exampledir/exampleobject.txt。 バケット名をフルパスに含めないでください。 
        文字列objectName = "exampledir/exampleobject.txt";
        // アップロードするローカルファイルのパスを指定します。 
        String filePath = "D :\\ localpath\\examplefile.txt";

        // Create an OSSClient instance. 
        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());
            // オブジェクトのwebページのキャッシュ動作を指定します。 
            // metadata.setCacheControl("no-cache");
            // オブジェクトのダウンロード時にオブジェクトの名前を指定します。 
            // metadata.setContentDisposition("attachment;filename=oss_MultipartUpload.txt");
            // オブジェクトのコンテンツのエンコード形式を指定します。 
            // metadata.setContentEncoding(OSSConstants.DEFAULT_CHARSET_NAME);
            // マルチパートアップロードタスクの開始時に、既存のオブジェクトが同じ名前のオブジェクトで上書きされるかどうかを指定します。 この例では、このパラメーターはtrueに設定されています。これは、アップロードするオブジェクトと同じ名前の既存のオブジェクトが上書きされないことを示します。 
            // metadata.setHeader("x-oss-forbid-overwrite", "true");
            // アップロードするオブジェクトの各部分の暗号化に使用するサーバー側の暗号化方法を指定します。 
            // metadata.setHeader(OSSHeaders.OSS_SERVER_SIDE_ENCRYPTION, ObjectMetadata.KMS_SERVER_SIDE_ENCRYPTION);
            // オブジェクトの暗号化に使用されるアルゴリズムを指定します。 このパラメーターを設定しない場合、オブジェクトはAES-256を使用して暗号化されます。 
            // metadata.setHeader(OSSHeaders.OSS_SERVER_SIDE_DATA_ENCRYPTION, ObjectMetadata.KMS_SERVER_SIDE_ENCRYPTION);
            // key Management Service (KMS) が管理するカスタマーマスターキー (CMK) のIDを指定します。 
            // metadata.setHeader(OSSHeaders.OSS_SERVER_SIDE_ENCRYPTION_KEY_ID、"9468da86-3509-4f8d-a61e-6eab1eac ****");
            // オブジェクトのストレージクラスを指定します。 
            // metadata.setHeader(OSSHeaders.OSS_STORAGE_CLASS、StorageClass.Standard);
            // オブジェクトのタグを指定します。 オブジェクトに対して一度に複数のタグを指定できます。 
            // metadata.setHeader(OSSHeaders.OSS_TAGGING, "a:1");
            // request.setObjectMetadata (メタデータ);

            // オブジェクトタイプに基づいてContentTypeを指定します。 このパラメーターを指定しない場合、ContentTypeフィールドのデフォルト値はapplication/oct-srreamです。 
            if (metadata.getContentType() == null) {
                metadata.setContentType(Mimetypes.getInstance().getMimetype(new File(filePath), objectName));
            }

            // マルチパートアップロードタスクを開始します。 
            InitiateMultipartUploadResult upresult = ossClient.initiateMultipartUpload(request);
            // アップロードIDを取得します。 
            String uploadId = upresult.getUploadId();
            // マルチパートアップロードタスクをキャンセルするか、アップロードIDに基づいてアップロードされたパーツをリストします。 
            // アップロードIDに基づいてマルチパートアップロードタスクをキャンセルする場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後にアップロードIDを取得します。  
            // アップロードIDに基づいてマルチパートアップロードタスクでアップロードされたパーツを一覧表示する場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後、CompleteMultipartUpload操作を呼び出してマルチパートアップロードタスクを完了する前に、アップロードIDを取得します。 
            // System.out.println(uploadId);

            // partETags is a set of PartETags. PartETagは、アップロードされたパーツのパーツ番号とETagで構成されます。 
            List<PartETag> partETags =  new ArrayList<PartETag>();
            // 各パーツのサイズを指定します。 部品サイズは、オブジェクトの部品数を計算するために使用されます。 単位:バイト 
            final long partSize = 1*1024 * 1024L; // パーツサイズを1 MBに設定します。 

            // アップロードされたデータのサイズに基づいて部品数を計算します。 次のコードでは、ローカルファイルを例として使用して、file. length() メソッドを使用してアップロードされたデータのサイズを取得する方法を示します。 
            final File sampleFile=新しいファイル (filePath);
            long fileLength = sampleFile.length();
            int partCount = (int) (fileLength / partSize);
            if (fileLength % partSize != 0) {
                partCount++;
            }
            // すべての部品をアップロードします。 
            for (int i = 0; i <recordCount; 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〜10,000の範囲の部品番号を有する。 指定した数値が範囲内にない場合、OSSはInvalidArgumentエラーコードを返します。 
                uploadPartRequest.setPartNumber( i + 1);
                // 部品は順番にアップロードされません。 パーツは、さまざまなOSSクライアントからアップロードできます。 OSSは、部品番号に基づいて部品をソートし、部品を結合して完全なオブジェクトを取得します。 
                UploadPartResult uploadPartResult = ossClient.uploadPart(uploadPartRequest);
                // 部品がアップロードされると、PartETagを含む結果が返されます。 The PartETag is stored in partETags. 
                partETags.add(uploadPartResult.getPartETag());
            }


            // CompleteMultipartUploadRequestオブジェクトを作成します。 
            // CompleteMultipartUpload操作を呼び出すときは、すべての有効なPartETagsを指定する必要があります。 OSSがpartETagsを受信すると、OSSはすべてのパーツを1つずつ検証します。 すべての部品が検証された後、OSSはこれらの部品を完全なオブジェクトに結合します。 
            CompleteMultipartUploadRequest completeMultipartUploadRequest =
                    new CompleteMultipartUploadRequest(bucketName, objectName, uploadId, partETags);

            // マルチパートアップロードタスクが完了したときにオブジェクトのアクセス制御リスト (ACL) を設定する方法の例を次のコードに示します。 
            // completeMultipartUploadRequest.setObjectACL(CannedAccessControlList.Private);
            // 現在のアップロードIDを使用してアップロードされたすべてのパーツを一覧表示するかどうかを指定します。 OSS SDK For Java 3.14.0以降の場合、CompleteMultipartUploadRequestのpartETagsをnullに設定できるのは、OSSサーバーにアップロードされたすべてのパーツをリストして、パーツを完全なオブジェクトに結合する場合のみです。 
            // Map<String, String> headers = new HashMap<String, String>();
            // リクエストでx-oss-complete-allをyesに設定した場合、現在のアップロードIDを使用してアップロードされたすべてのパーツが一覧表示され、パーツ番号でパーツが並べ替えられ、CompleteMultipartUpload操作が実行されます。 
            // リクエストでx-oss-complete-allをyesに設定した場合、リクエスト本文は指定できません。 リクエスト本文を指定すると、エラーが報告されます。 
            // headers.put("x-oss-complete-all","yes");
            // completeMultipartUploadRequest.setHeaders(headers);

            // マルチパートアップロードタスクを完了します。 
            CompleteMultipartUploadResult completeMultipartUploadResult = ossClient.completeMultipartUpload(completeMultipartUploadRequest);
            System.out.println(completeMultipartUploadResult.getETag());
        } catch (Exception e) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "しかし、何らかの理由でエラー応答で拒否されました。");
            System.out.println("エラーメッセージ:" + oe.getErrorMessage());
            System.out.println("エラーコード:" + oe.getErrorCode());
            System.out.println("リクエストID:" + oe.getRequestId());
            System.out.println("ホストID:" + oe.getHostId());
        } catch (ClientException e) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + 「ネットワークにアクセスできないなど」;
            System.out.println("エラーメッセージ:" + ce.getMessage());
        } 最後に{
            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';
}

OSS\OssClientを使用します。OSS\Core\OssExceptionを使用します。OSS\Core\OssUtilを使用します。// 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。  
$accessKeyId = getenv("OSS_ACCESS_KEY_ID");
$accessKeySecret = getenv("OSS_ACCESS_KEY_SECRET");
// この例では、中国 (杭州) リージョンのエンドポイントが使用されます。 実際のエンドポイントを指定します。 
$end point = 'https:// oss-cn-hangzhou.aliyuncs.com ';
// バケットの名前を指定します。 例: examplebucket. 
$bucket= 'examplebucket';
// オブジェクトのフルパスを指定します。 バケット名をフルパスに含めないでください。 例: exampledir/exampleobject.txt。 
$object = 'exampledir/exampleobject.txt ';
// アップロードするローカルファイルのフルパスを指定します。 
$uploadFile = 'D :\\ localpath\\examplefile.txt ';
$initOptions=配列 (
    OssClient::OSS_HEADERS => 配列 (
        // オブジェクトのダウンロード時のwebページのキャッシュ動作を指定します。 
        // 'Cache-Control' => 'no-cache' 、
        // オブジェクトのダウンロード時にオブジェクトの名前を指定します。 
        // 'Content-Disposition' => 'attachment;filename=oss_download.jpg '、
        // オブジェクトのダウンロード時のオブジェクトのコンテンツエンコーディング形式を指定します。 
        // 'Content-Encoding' => 'utf-8' 、
        // リクエストの有効期間を指定します。 単位:ミリ秒。 
        // 'Expires' => 150、
        // マルチパートアップロードタスクの開始時に、マルチパートアップロードを使用してアップロードされたオブジェクトが、同じ名前の既存のオブジェクトを上書きするかどうかを指定します。 この例では、x-oss-forbid-overwriteパラメーターはtrueに設定されています。 この値は、既存のオブジェクトを同じ名前のオブジェクトで上書きできないことを示します。 
        // 'x-oss-forbid-overwrite' => 'true' 、
        // オブジェクトの各部分の暗号化に使用するサーバー側の暗号化方法を指定します。 
        // 'x-oss-server-side-encryption'=> 'KMS' 、
        // オブジェクトの暗号化に使用されるアルゴリズムを指定します。 
        // 'x-oss-server-side-data-encryption'=>'SM4' 、
        // KMSが管理するCMKのIDを指定します。 
        // 'x-oss-server-side-encryption-key-id' => '9468da86-3509-4f8d-a61e-6eab1eac **** '、
        // オブジェクトのストレージクラスを指定します。 
        // 'x-oss-storage-class' => 'Standard' 、
        // オブジェクトのタグを指定します。 オブジェクトに複数のタグを同時に指定できます。 
        // 'x-oss-tagging' => 'TagA=A&TagB=B' 、
    ),
);

/**
 * ステップ1: マルチパートアップロードタスクを開始し、アップロードIDを取得します。 
 * /
try {
    $ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint);
    // アップロードIDを取得します。 アップロードIDは、マルチパートアップロードタスクの一意の識別子です。 アップロードIDに基づいて、マルチパートアップロードタスクのキャンセルやクエリなどの関連操作を実行できます。 
    $uploadId = $ossClient->initiateMultipartUpload($bucket、$object、$initOptions);
    print("initiateMultipartUpload OK") 。 "\n");
    // マルチパートアップロードタスクをキャンセルするか、アップロードIDに基づいてアップロードされたパーツをリストします。 
    // アップロードIDに基づいてマルチパートアップロードタスクをキャンセルする場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後にアップロードIDを取得します。  
    // アップロードIDに基づいてマルチパートアップロードタスクでアップロードされたパーツを一覧表示する場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後、CompleteMultipartUpload操作を呼び出してマルチパートアップロードタスクを完了する前に、アップロードIDを取得します。 
    // print("UploadId: ") 。 $uploadId。 "\n");
} catch(OssException $e) {
    printf($e->getMessage()) 。 "\n");
    戻ります。}

/*
 * Step 2: Upload parts. 
 * /
$partSize = 10*1024*1024;
$uploadFileSize = sprintf('% u',filesize($uploadFile));
$pieces = $ossClient->generateMultiuploadParts($uploadFileSize、$partSize);
$responseUploadPart = array();
$uploadPosition = 0;
$isCheckMd5 = true;
foreach ($i => $pieceとして $pieces) {
    $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の値は、MD5検証が有効になっていることを示します。 
        $ossClient::OSS_CHECK_MD5 => $isCheckMd5,
    );
    // Enable MD5 verification. 
    if ($isCheckMd5) {
        $contentMd5 = OssUtil::getMd5SumForFile($uploadFile, $fromPos, $toPos);
        $upOptions[$ossClient::OSS_CONTENT_MD5] = $contentMd5;
    }
    try {
        // Upload the parts. 
        $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");
        戻る;
    }

}
// $uploadPartsパラメーターは、各パーツのETagパラメーターとPartNumberパラメーターで構成される配列です。 
$uploadParts = array();
foreach ($responseUploadPart as $i => $eTag) {
    $uploadParts[] = array(
        'PartNumber' => ($i + 1),
        'ETag' => $eTag,
    );
}
/**
 * ステップ3: マルチパートアップロードタスクを完了します。 
 * /
$comOptions ['header']=配列 (
    // マルチパートアップロードタスクが完了したときに、マルチパートアップロードを使用してアップロードされたオブジェクトが、同じ名前の既存のオブジェクトを上書きするかどうかを指定します。 この例では、x-oss-forbid-overwriteパラメーターはtrueに設定されています。 この値は、既存のオブジェクトを同じ名前のオブジェクトで上書きできないことを示します。 
    // 'x-oss-forbid-overwrite' => 'true' 、
    // x-oss-complete-allパラメーターをyesに設定すると、現在のアップロードIDを使用してアップロードされたすべてのパーツが一覧表示され、パーツ番号でパーツが並べ替えられ、CompleteMultipartUpload操作が実行されます。 
    // 'x-oss-complete-all'=> 'yes'
);

try {
    // CompleteMultipartUpload操作には、$uploadPartsパラメーターのすべての有効な値が必要です。 OSSが $uploadPartsパラメーターの値を受け取ると、OSSはすべてのパーツを1つずつ検証します。 すべての部品が検証された後、OSSはこれらの部品を完全なオブジェクトに結合します。 
    $ossClient->completeMultipartUpload($bucket、$object、$uploadId、$uploadParts、$comOptions);
    printf (「完全マルチパートアップロードOK\n」);
} catch(OssException $e) {
    printf("完全マルチパートアップロードFAILED\n");
    printf($e->getMessage()) 。 "\n");
    戻ります。}
           
const OSS = require('ali-OSS ');
const path = require("path");

const client = new OSS({
  // バケットが配置されているリージョンを指定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンを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) => {
  // オブジェクトのアップロードの進行状況を記録します。 
  console.log(p); 
  // マルチパートアップロードタスクに関するチェックポイント情報を記録します。 
  console.log(_checkpoint);
};

const headers = {  
  // オブジェクトのストレージクラスを指定します。 
  「x-oss-storage-classs」: 「標準」、 
  // オブジェクトのタグを指定します。 オブジェクトに複数のタグを指定できます。 
  'x-oss-tagging ': 'Tag1=1&Tag2=2' 、 
  // マルチパートアップロードタスクの初期化時に、同じ名前の既存のオブジェクトを上書きするかどうかを指定します。 この例では、このパラメーターはtrueに設定されています。これは、アップロードするオブジェクトと同じ名前の既存のオブジェクトが上書きされないことを示します。 
  'x-oss-forbid-overwrite': 'true'
}

// マルチパートアップロードタスクを開始します。 
async関数multipartUpload() {
  try {
    // オブジェクトのフルパスを指定します。 例: exampledir/exampleobject.txt。 次に、ローカルファイルのフルパスを指定します。 例: D :\\ localpath\\examplefile.txt。 バケット名をフルパスに含めないでください。 
    // デフォルトでは、ローカルパスを指定せずにこのパラメーターをexamplefile.txtなどのローカルファイル名に設定すると、サンプルプログラムが属するプロジェクトのローカルパスからローカルファイルがアップロードされます。 
    const result = await client.multipartUpload('exampledir/exampleobject.txt ', path.normalize('D :\\ localpath\\examplefile.txt')), {
      progress,
      // ヘッダー、
      // オブジェクトのメタデータを指定するメタパラメーターを設定します。 HeadObject操作を呼び出して、オブジェクトメタデータを取得できます。 
      meta: {
        年: 2020,
        人: 'test '、
      },
    });
    console.log (結果);
    // オブジェクトのフルパスを指定します。 例: exampledir/exampleobject.txt。 バケット名をフルパスに含めないでください。 
    const head = await client.head('exampledir/exampleobject.txt ');
    console.log(head);
  } catch (e) {
    // タイムアウト例外を処理します。 
    if (e.code === 'ConnectionTimeoutError') {
      console.log('TimeoutError');
      // ConnectionTimeoutError操作を行う
    }
    console.log(e);
  }
}

multipartUpload();
# -*-コーディング: utf-8 -*-
osのインポート
oss2インポートSizedFileAdapterから、determine_part_size
oss2.modelsからPartInfoをインポート
oss2のインポート
oss2.credentialsからEnvironmentVariableCredentialsProviderをインポート

# 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。 
auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
# この例では、中国 (杭州) リージョンのエンドポイントが使用されます。 実際のエンドポイントを指定します。 
# バケットの名前を指定します。 例: examplebucket. 
bucket = oss2.Bucket(auth, 'https:// oss-cn-hangzhou.aliyuncs.com ', 'examplebucket')
# オブジェクトのフルパスを指定します。 バケット名をフルパスに含めないでください。 例: exampledir/exampleobject.txt。 
key = 'exampledir/exampleobject.txt'
# アップロードするローカルファイルのフルパスを指定します。 例: D :\\ localpath\\examplefile.txt。 
filename = 'D :\\ localpath\\examplefile.txt'

total_size = os.path.getsize (ファイル名)
# determine_part_sizeメソッドを使用して、部品サイズを決定します。 
part_size = determine_part_size(total_size, preferred_size=100*1024)

# マルチパートアップロードタスクを開始します。 
# マルチパートアップロードタスクを開始するときにオブジェクトのストレージクラスを指定する場合は、init_multipart_uploadメソッドを使用するときに関連するヘッダーを設定します。 
# headers = dict()
# オブジェクトのwebページのキャッシュ動作を指定します。 
# headers['Cache-Control '] = 'no-cache'
# ダウンロード時のオブジェクトの名前を指定します。 
# headers['Content-Disposition'] = 'oss_MultipartUpload.txt'
# オブジェクトのコンテンツエンコーディング形式を指定します。 
# headers['Content-Encoding'] = 'utf-8'
# 有効期間を指定します。 単位:ミリ秒。 
# headers['Expires'] = '1000'
# マルチパートアップロードタスクの開始時に、マルチパートアップロードを実行してアップロードされたオブジェクトが、同じ名前の既存のオブジェクトを上書きするかどうかを指定します。 この例では、このパラメーターはtrueに設定されています。これは、同じ名前のオブジェクトを上書きできないことを示します。 
# headers['x-oss-forbid-overwrite'] = 'true'
# 各パーツの暗号化に使用するサーバー側の暗号化方法を指定します。 
# headers[OSS_SERVER_SIDE_ENCRYPTION] = SERVER_SIDE_ENCRYPTION_KMS
# オブジェクトの暗号化に使用するアルゴリズムを指定します。 このパラメーターを設定しない場合、オブジェクトはAES-256を使用して暗号化されます。 
# headers[OSS_SERVER_SIDE_DATA_ENCRYPTION] = SERVER_SIDE_ENCRYPTION_KMS
# Key Management Service (KMS) が管理するCustomer Master Key (CMK) のIDを指定します。 
# headers[OSS_SERVER_SIDE_ENCRYPTION_KEY_ID] = '9468da86-3509-4f8d-a61e-6eab1eac ****'
# オブジェクトのストレージクラスを指定します。 
# headers['x-oss-storage-classs'] = oss2.BUCKET_STORAGE_CLASS_STANDARD
# オブジェクトのタグを指定します。 オブジェクトに複数のタグを同時に指定できます。 
# headers[OSS_OBJECT_TAGGING] = 'k1=v1&k2=v2&k3=v3'
# upload_id = bucket.init_multipart_upload (キー、ヘッダー=ヘッダー) 。upload_id
upload_id = bucket.init_multipart_upload(key).upload_id
# マルチパートアップロードタスクをキャンセルするか、アップロードIDに基づいてアップロードされたパーツをリストします。 
# アップロードIDに基づいてマルチパートアップロードタスクをキャンセルする場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後にアップロードIDを取得します。 
# アップロードIDに基づいてマルチパートアップロードタスクでアップロードされたパーツを一覧表示する場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後、CompleteMultipartUpload操作を呼び出してマルチパートアップロードタスクを完了する前に、アップロードIDを取得します。 
# 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 = dict()
# オブジェクトのアクセス制御リスト (ACL) を指定します。 この例では、ACLはOBJECT_ACL_PRIVATEに設定され、オブジェクトのACLがプライベートであることを示します。 
# headers["x-oss-object-acl"] = oss2.OBJECT_ACL_PRIVATE
bucket.com plete_multipart_upload(key, upload_id, parts, headers=headers)
# <!DOCTYPE html> plete_multipart_upload(key、upload_id、parts) をbucket.comする
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title> ドキュメント </title>
  </head>

  <body>
    <button id="submit"> アップロード </button>
    <input id="file" type="file" />
    <!-- SDKファイルのインポート->
    <スクリプト
      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({
        // バケットが配置されているリージョンを指定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンをoss-cn-Hangzhouに設定します。 
        region: "yourRegion" 、
        // STSから取得した一時的なAccessKeyペアを指定します。 AccessKeyペアは、AccessKey IDとAccessKeyシークレットで構成されます。 
        accessKeyId: "yourAccessKeyId" 、
        accessKeySecret: "yourAccessKeySecret" 、
        // STSから取得したセキュリティトークンを指定します。 
        stsToken: "yourSecurityToken" 、
        // バケットの名前を指定します。 例: examplebucket. 
        bucket: "examplebucket" 、
      });

      const headers = {
        // オブジェクトのダウンロード時のwebページのキャッシュ動作を指定します。 
        "Cache-Control": "no-cache" 、
        // オブジェクトのダウンロード時にオブジェクトの名前を指定します。 
        "Content-Disposition": "example.txt" 、
        // オブジェクトのダウンロード時のオブジェクトのコンテンツエンコーディング形式を指定します。 
        "コンテンツエンコード": "utf-8" 、
        // リクエストの有効期間を指定します。 単位:ミリ秒。 
        有効期限: 「1000」、
        // オブジェクトのストレージクラスを指定します。 
        "x-oss-storage-class": "Standard" 、
        // オブジェクトに1つ以上のタグを指定します。 
        "x-oss-tagging": "Tag1=1&Tag2=2" 、
        // マルチパートアップロードタスクの初期化時に、既存のオブジェクトを同じ名前で上書きするかどうかを指定します。 この例では、x-oss-forbid-overwriteパラメーターはtrueに設定されています。 この値は、既存のオブジェクトを同じ名前のオブジェクトで上書きできないことを示します。 
        "x-oss-forbid-overwrite": "true" 、
      };

      // examplebucketバケットにアップロードされるオブジェクトの名前を指定します。 例: exampleobject.txt。 
      const name = "exampleobject.txt";
      // DOMを取得します。 
      const submit = document.getElementById("submit");
      const options = {
        // マルチパートアップロードタスクの進行状況、チェックポイント、および戻り値を照会します。 
        progress :( p, cpt, res) => {
          console.log(p);
        },
        // 並列にアップロードできるパーツの数を指定します。 
        パラレル: 4,
        // パーツサイズを指定します。 デフォルト値: 1 MB。 最小値: 100 KB。 
        partSize: 1024*1024、
        // ヘッダー、
        // オブジェクトのユーザーメタデータを指定します。 HeadObject操作を呼び出して、オブジェクトメタデータを照会できます。 
        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: {
              // コールバック要求を受信するサーバーのアドレスを指定します。 
              url: "http://examplebucket.aliyuncs.com:23450" 、
              // コールバック要求のHostヘッダーを指定します。 
              host: "yourHost" 、
              /* eslint no-template-curly-in-string: [0] * /
              // コールバック要求の本文の内容を指定します。 
              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>
Aliyun.OSSを使用した
;

// バケットが配置されているリージョンのエンドポイントを指定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントを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");
// バケットの名前を指定します。 
var bucketName = "examplebucket";
// オブジェクトのフルパスを指定します。 バケット名をフルパスに含めないでください。 
var objectName = "exampleobject.txt";
// アップロードするローカルファイルのフルパスを指定します。 デフォルトでは、ローカルファイルのフルパスを指定しない場合、サンプルプログラムが属するプロジェクトのパスからローカルファイルがアップロードされます。 
var localFilename = "D :\\ localpath\\examplefile.txt";
// OSSClientインスタンスを作成します。 
var client = new OssClient (エンドポイント、accessKeyId、accessKeySecret);

// マルチパートアップロードタスクを開始し、レスポンスでアップロードIDを取得します。 
var uploadId = "";
トライ
{
    // アップロードされたオブジェクトの名前とオブジェクトのバケットを指定します。 InitiateMultipartUploadRequestでオブジェクトメタデータを設定できます。 ただし、ContentLengthを指定する必要はありません。 
    var request = new InitiateMultipartUploadRequest(bucketName, objectName);
    var result = client.InitiateMultipartUpload(request);
    uploadId = result.UploadId;
    // アップロードIDを表示します。 
    Console.WriteLine("Init multi part upload succeeded");
    // マルチパートアップロードタスクをキャンセルするか、アップロードIDに基づいてアップロードされたパーツをリストします。 
    // アップロードIDに基づいてマルチパートアップロードタスクをキャンセルする場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後にアップロードIDを取得します。  
    // アップロードIDに基づいてマルチパートアップロードタスクでアップロードされたパーツを一覧表示する場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後、CompleteMultipartUpload操作を呼び出してマルチパートアップロードタスクを完了する前に、アップロードIDを取得します。 
    Console.WriteLine("Upload Id:{0}", result.UploadId);
}
キャッチ (例外ex)
{
    Console.WriteLine("Initマルチパートアップロードに失敗しました, {0}", 例: メッセージ);
}
// 部品の総数を計算します。 
var partSize = 100*1024;
var fi = new FileInfo(localFilename);
var fileSize = fi.Length;
var partCount = fileSize / partSize;
if (fileSize % partSize != 0)
{
    partCount ++;
}
// マルチパートアップロードタスクを開始します。 partETagsはPartETagsのリストです。 OSSがpartETagsを受信すると、OSSはすべてのパーツを1つずつ検証します。 すべての部品が検証された後、OSSはこれらの部品を完全なオブジェクトに結合します。 
var partETags = newリスト <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");
    }
}
キャッチ (例外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("完全なマルチパート成功");
}
キャッチ (例外ex)
{
    Console.WriteLine("complete multi part failed, {0}", ex.Message);
} 
// バケットの名前を指定します。 例: examplebucket. 
String bucketName = "examplebucket";
// オブジェクトのフルパスを指定します。 例: exampledir/exampleobject.txt。 バケット名をフルパスに含めないでください。 
文字列objectName = "exampledir/exampleobject.txt";
// ローカルファイルのフルパスを指定します。 例: /storage/emulated/0/oss/examplefile.txt 
文字列localFilepath = "/storage/emulated/0/oss/examplefile.txt";

// マルチパートアップロードタスクを開始します。 
InitiateMultipartUploadRequest init = new InitiateMultipartUploadRequest(bucketName, objectName);
InitiateMultipartUploadResult initResult = oss.initMultipartUpload(init);
// アップロードIDを取得します。 
文字列uploadId = initResult.getUploadId();
// マルチパートアップロードタスクをキャンセルするか、アップロードIDに基づいてアップロードされたパーツをリストします。 
// アップロードIDに基づいてマルチパートアップロードタスクをキャンセルする場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後にアップロードIDを取得します。  
// アップロードIDに基づいてマルチパートアップロードタスクでアップロードされたパーツを一覧表示する場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後、CompleteMultipartUpload操作を呼び出してマルチパートアップロードタスクを完了する前に、アップロードIDを取得します。 
// Log.d("uploadId", uploadId);

// パーツサイズを指定します。 単位:バイト 有効な値: 100 KB〜5 GB。 
int partCount = 100*1024;
// マルチパートアップロードタスクを開始します。 
リスト <PartETag> partETags = new ArrayList<>();
for (int i = 1; i < 5; i ++) {
    byte[] data = new byte[partCount];

    RandomAccessFile raf=新しいRandomAccessFile(localFilepath、"r");
    long skip = (i-1) * partCount;
    raf.seek (スキップ);
    raf.readFully (データ、0、partCount);

    UploadPartRequest uploadPart = new UploadPartRequest();
    uploadPart.setBucketName(bucketName);
    uploadPart.setObjectKey(objectName);
    uploadPart.setUploadId(uploadId);
    // 各パーツのパーツ番号を指定します。 番号は1から始まります。 各部品は部品番号を有する。 有効な値: 1 ~ 10000 
    uploadPart.setPartNumber(i); 
    uploadPart.setPartContent (データ);
    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>() {
    @オーバーライド
    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パラメーターを設定できます。 マルチパートアップロードタスクが完了すると、指定されたサーバーアドレスにコールバックリクエストが送信されます。 servercallbackの結果は、レスポンスのcompleteResult.getServerCallbackReturnBody() で表示できます。 
complete.setCallbackParam(new HashMap<String, String>() {
    {
        put("callbackUrl", CALLBACK_SERVER); // CALLBACK_SERVERパラメーターをサーバーアドレスに設定します。 
        put("callbackBody" 、"test");
    }
});
CompleteMultipartUploadResult completeResult = oss.com pleteMultipartUpload(complete);
OSSLog.logError("------------ serverCallback: " + completeResult.getServerCallbackReturnBody()); 
パッケージメイン

import (import (import)
    "fmt"
    "os"
    "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インスタンスを作成します。 
	// バケットが配置されているリージョンのエンドポイントを指定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントをhttps://oss-cn-hangzhou.aliyuncs.comに設定します。 実際のエンドポイントを指定します。 
	client, err := oss.New("yourEndpoint", ", " ", ", oss.SetCredentialsProvider(&provider))
if err! =nil {
fmt.Println("Error:", err)
os.Exit(-1)
}
    // バケットの名前を指定します。 
    bucketName := "examplebucket"
    // オブジェクトのフルパスを指定します。 バケット名をフルパスに含めないでください。 
    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),
        // オブジェクトのダウンロード時のwebページのキャッシュ動作を指定します。 
        // oss.CacheControl("no-cache") 、
        // ダウンロードされたときのオブジェクトの名前を指定します。 
        // oss.ContentDisposition("attachment;filename=FileName.txt") 、
        // オブジェクトのコンテンツエンコーディング形式を指定します。 
        // oss.ContentEncoding("gzip") 、
        // レスポンスでオブジェクト名のエンコードに使用されるメソッドを指定します。 URLエンコードのみがサポートされています。 
        // oss.EncodingType("url") 、
        // オブジェクトのストレージクラスを指定します。 
        // 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)
    }

    // オブジェクトのアクセス制御リスト (ACL) をprivateに設定します。 デフォルトでは、オブジェクトはバケットのACLを継承します。 
    objectAcl := oss.ObjectACL(oss. ACLDrivate)

    // ステップ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;
__ブロックNSMutableArray * partInfos = [NSMutableArray new];
// バケットの名前を指定します。 例: examplebucket. 
NSString * uploadToBucket = @ "examplebucket";
// オブジェクトのフルパスを指定します。 例: exampledir/exampleobject.txt。 バケット名をフルパスに含めないでください。 
NSString * uploadObjectkey = @ "exampledir/exampleobject.txt";
// OSSInitMultipartUploadRequestを使用して、アップロードされたオブジェクトの名前と、オブジェクトが格納されているバケットの名前を指定できます。 
OSSInitMultipartUploadRequest * init = [OSSInitMultipartUploadRequest new];
init.bucketName = uploadToBucket;
init.objectKey = uploadObjectkey;
// init.contentType = @ "application/octet-stream";
// multipartUploadInitへの応答には、アップロードIDが含まれます。 アップロードIDは、マルチパートアップロードタスクの一意のIDです。 
OSSTask * initTask = [client multipartUploadInit:init];
[initTask waitUntilFinished];
if (!initTask.error) {
    OSSInitMultipartUploadResult * result = initTask.result;
    uploadId = result.uploadId;
    // マルチパートアップロードタスクをキャンセルするか、アップロードIDに基づいてアップロードされたパーツをリストします。 
    // アップロードIDに基づいてマルチパートアップロードタスクをキャンセルする場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後にアップロードIDを取得します。 
    // アップロードIDに基づいてマルチパートアップロードタスクでアップロードされたパーツを一覧表示する場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後、CompleteMultipartUpload操作を呼び出してマルチパートアップロードタスクを完了する前に、アップロードIDを取得します。 
    // NSLog(@ "UploadId": %@, uploadId);
} else {
    NSLog(@ "マルチパートアップロードに失敗しました、エラー: % @" 、initTask.error);
    戻ります。}

// アップロードするオブジェクトを指定します。 
NSString * filePath = @ "<filepath>";
// オブジェクトのサイズを照会します。 
uint64_t fileSize = [[[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil] fileSize];
// 部品の数を指定します。 
int chuckCount = 10;
// 各パーツのサイズを指定します。 
uint64_tオフセット=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; // 部品番号は1から始まります

    NSFileHandle * readHandle = [NSFileHandleForReadingAtPath: filePath];
    [readHandle seekToFileOffset:offset * (i -1)];

    NSData * data = [readHandle readDataOfLength: オフセット];
    uploadPart.uploadPartData=データ;

    OSSTask * uploadPartTask = [クライアントuploadPart:uploadPart];

    [uploadPartTask waitUntilFinished];

    if (!uploadPartTask.error) {
        OSSUploadPartResult * result = uploadPartTask.result;
        uint64_t fileSize = [[[NSFileManager defaultManager] attributesOfItemAtPath:uploadPart.uploadPartFileURL.absoluteStringエラー: nil] fileSize];
        [partInfos addObject:[OSSPartInfo partInfoWithPartNum:i eTag:result.eTagサイズ: fileSize]];
    } else {
        NSLog(@ "upload part error: % @", uploadPartTask.error);
        戻る;
    }
}
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 {
        // ...
    }
    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();
    戻りサイズ;
}

名前空間listaCloud::OSSを使用します。int main(void)
{
    /* OSSへのアクセスに使用されるアカウントに関する情報を初期化します。 */
    
    std::string Endpoint = "yourEndpoint";
    /* バケットの名前を指定します。 例: examplebucket. */
    std::string BucketName = "examplebucket";
    /* オブジェクトのフルパスを指定します。 オブジェクトのフルパスにバケット名を含めないでください。 例: 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クライアント (Endpoint, credentialsProvider, conf);
  
    InitiateMultipartUploadRequest initUploadRequest(BucketName, ObjectName);
    /* (オプション) ストレージクラスを指定します。 */
    // initUploadRequest.MetaData().addHeader("x-oss-storage-class", "Standard");

    /* マルチパートアップロードタスクを開始します。 */
    auto uploadIdResult = client.InitiateMultipartUpload(initUploadRequest);
    /* マルチパートアップロードタスクをキャンセルするか、アップロードIDに基づいてアップロードされたパーツをリストします。 */
    /* アップロードIDに基づいてマルチパートアップロードタスクをキャンセルする場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後にアップロードIDを取得します。 */
    /* アップロードIDに基づいてマルチパートアップロードタスクでアップロードされたパーツを一覧表示する場合は、InitiateMultipartUpload操作を呼び出してマルチパートアップロードタスクを開始した後、CompleteMultipartUpload操作を呼び出してマルチパートアップロードタスクを完了する前に、アップロードIDを取得します。 */ 
    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 (サイズ);
        uploadPartRequest.setUploadId(uploadId);
        uploadPartRequest.setPartNumber(i);
        auto uploadPartOutcome = client.UploadPart(uploadPartRequest);
        if (uploadPartOutcome.isSuccess()) {
            パートパート (i, uploadPartOutcome.result().ETag());
            partETagList.push_back (部品);
        }
        else {
            std::cout << "uploadPart fail" <<
            ",code:" << uploadPartOutcome.error().Code() <<<
            ",message:" << uploadPartOutcome.error().Message() <<
            ",requestId:" << uploadPartOutcome.error().RequestId() << std::endl;
        }

    }

    /* マルチパートアップロードタスクを完了します。 */
    /* マルチパートアップロードタスクが完了したら、すべての有効なPartETagsを提供する必要があります。 OSSがPartETagsを受信すると、OSSはすべてのパーツを1つずつ検証します。 After part verification is successful, OSS combines these parts into a complete object. */
    CompleteMultipartUploadRequestリクエスト (BucketName, ObjectName);
    request.setUploadId(uploadId);
    request.setPartList(partETagList);
    /* (オプション) オブジェクトのACLを指定します。 */
    // request.setAcl(CannedAccessControlList:: プライベート);

    auto outcome = client.CompleteMultipartUpload (リクエスト);

    if (!outcome.isSuccess()) {
        /* 例外を処理します。 */
        std::cout << "CompleteMultipartUpload fail" <<
        ",code:" << outcome.error().Code() <<
        ",message:" << outcome.error().Message() <<
        ",requestId:" << outcome.error().RequestId() << std::endl;
        return -1;
    }

    /* ネットワークリソースなどのリソースを解放します。 */
    ShutdownSdk();
    0を返します。} 
#include "oss_api.h"
# 「aos_http_io.h」を含める
# include <sys/stat.h>
/* バケットが配置されているリージョンのエンドポイントを指定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントをhttps://oss-cn-hangzhou.aliyuncs.comに設定します。 * /
const char * endpoint = "yourEndpoint";

/* バケットの名前を指定します。 例: examplebucket. * /
const char * bucket_name = "examplebucket";
/* オブジェクトのフルパスを指定します。 バケット名をフルパスに含めないでください。 例: exampledir/exampleobject.txt。 * /
const char * object_name = "exampledir/exampleobject.txt";
/* ローカルファイルのフルパスを指定します。 * /
const char * local_filename = "yourLocalFilename";
void init_options(oss_request_options_t * オプション)
{
    options->config = oss_config_create(options->pool);
    /* char * stringを使用して、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は、CNAMEが使用されないことを示す。 */
    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;
    }
    ファイルサイズを返します。}
int main(int argc, char * argv[])
{
    /* main() でaos_http_io_initializeメソッドを呼び出して、ネットワークリソースやメモリリソースなどのグローバルリソースを初期化します。 */
    if (aos_http_io_initialize(NULL, 0))! =AOSE_OK) {
        exit(1);
    }
    /* メモリを管理するためのメモリプールを作成します。 aos_pool_tはapr_pool_tと同じです。 メモリプールの作成に使用されるコードは、APRライブラリに含まれています。 */
    aos_pool_t *pool;
    /* メモリプールを作成します。 2番目のパラメーターの値はNULLです。 この値は、プールが他のメモリプールを継承しないことを示します。 */
    aos_pool_create(&pool, NULL);
    /* Create and initialize options. このパラメーターには、エンドポイント、access_key_id、access_key_secret、is_cname、curlなどのグローバル構成情報が含まれます。 */
    oss_request_options_t *oss_client_options;
    /* メモリプール内のメモリリソースをオプションに割り当てます。 */
    oss_client_options = oss_request_options_create(pool);
    /* 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 (プール、1);
    int part_num = 1;
    /* マルチパートアップロードタスクを開始し、アップロード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;
        aos_list_for_each_entry(oss_list_part_content_t、part_content、&amp; params-&gt; part_list、node){

        /* 部品番号とETagsを保存します。 */
        complete_content = oss_create_complete_part_content(pool);
        part_num_str = apr_psprintf (プール、"% d" 、part_num-1);
        aos_str_set(&complete_content->part_number, part_num_str);
        etag = apr_pstrdup (プール、
        (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();
    0を返します。} 

ossutilの使用

ossutilを使用してマルチパートアップロードを実行できます。 詳しくは、「オブジェクトのアップロード」をご参照ください。

OSS APIの使用

ビジネスで高度なカスタマイズが必要な場合は、RESTful APIを直接呼び出すことができます。 APIを直接呼び出すには、コードに署名計算を含める必要があります。 詳細については、「InitiateMultipartUpload」をご参照ください。

よくある質問

パーツを削除するには?

マルチパートアップロードタスクが中断された場合、アップロードされたパーツはバケットに保存されます。 部品が不要になった場合は、次のいずれかの方法で部品を削除して、不要なストレージコストを防ぐことができます。

  • 手動でパーツを削除します。 詳細については、「パーツの削除」をご参照ください。

  • 部品を自動的に削除するライフサイクルルールを設定します。 詳細については、「ライフサイクルルールの設定」をご参照ください。

部品をリストする方法は?

  • 特定のアップロードIDを使用してアップロードされたパーツを一覧表示する場合は、ListParts操作を呼び出すことができます。 詳細については、「ListParts」をご参照ください。

  • 開始されたが完了またはキャンセルされていないマルチパートアップロードタスクを一覧表示する場合は、ListMultipartUploads操作を呼び出すことができます。 詳細については、「ListMultipartUploads」をご参照ください。

マルチパートアップロードを使用して、暗号化および圧縮されたローカルファイルをOSSにアップロードできますか?

はい。マルチパートアップロードを使用して、暗号化および圧縮されたローカルファイルをOSSにアップロードできます。

マルチパートアップロードタスクが中断された後にパーツを再アップロードすると、アップロードされたパーツは上書きされますか?

マルチパートアップロードタスクが中断された後、元のアップロードIDを使用してすべてのパーツを再アップロードすると、同じ名前のアップロードされたパーツが上書きされます。 新しいアップロードIDを使用してすべてのパーツを再アップロードすると、元のアップロードIDを持つアップロードされたパーツが保持されます。

マルチパートアップロードのアップロードIDとは何ですか?

アップロードIDは、マルチパートアップロードタスクを一意に識別します。 部品番号は、同じアップロードIDを共有する部品の相対位置を識別します。

マルチパートアップロードタスク中にアップロードIDはどのくらい有効ですか?

アップロードIDは、マルチパートアップロードプロセス全体で引き続き有効です。 アップロードタスクがキャンセルまたは完了した場合、アップロードIDは無効になります。 別のマルチパートアップロードタスクを実行する場合は、マルチパートアップロードタスクを再開して新しいアップロードIDを生成する必要があります。

OSSは部品の自動結合をサポートしていますか?

いいえ、OSSはパーツの自動組み合わせをサポートしていません。 CompleteMultipartUpload操作を呼び出して、パーツをオブジェクトに手動で結合する必要があります。