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

ツールを使用した自動パート分割

日常の開発、テスト、O&M、または手動アップロードには、グラフィカルツールまたはコマンドラインツールを使用します。これらのツールはパート分割ロジックを自動的に処理し、使いやすいです。

• グラフィカル管理ツール：ossbrowser

  ossbrowser 2.0 を使用してファイルをアップロードすると、マルチパートアップロードがデフォルトで有効になります。ossbrowser は、アップロードの進行状況とステータスを監視するための視覚的なインターフェイスを提供します。

• ossutil

  ossutil 2.0 の cp コマンドを使用してファイルをアップロードすると、100 MiB を超えるファイルに対してマルチパートアップロードが自動的に有効になり、大容量ファイルのアップロードの成功率と転送効率が向上します。マルチパートアップロードプロセスを手動で制御するには、initiate-multipart-upload、upload-part、および complete-multipart-upload コマンドを一緒に使用します。

  ossutil cp example.zip oss://example-bucket

SDK を使用したプログラムによる制御

各種言語の SDK はマルチパートアップロード操作をカプセル化しており、カスタムのパートサイズ、同時実行制御、エラー処理をサポートしています。以降のセクションでは、一般的な SDK のマルチパートアップロードの例を紹介します。他の言語の例については、SDK リファレンスのサンプルコードをご参照ください。

コードを実行する前に、適切な SDK をインストールし、アクセス認証情報を環境変数として設定してください。RAM ユーザーまたは RAM ロールを使用する場合は、必要な権限も付与する必要があります。詳細については、「API 権限」をご参照ください。

import com.aliyun.sdk.service.oss2.OSSClient;
import com.aliyun.sdk.service.oss2.credentials.CredentialsProvider;
import com.aliyun.sdk.service.oss2.credentials.StaticCredentialsProvider;
import com.aliyun.sdk.service.oss2.io.BoundedInputStream;
import com.aliyun.sdk.service.oss2.models.*;
import com.aliyun.sdk.service.oss2.transport.BinaryData;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * OSS マルチパートアップロードのサンプル。
 * 大容量ファイルのマルチパートアップロードを実装します。
 */
public class MultipartUpload {

    public static void main(String[] args) {
        // 環境変数からアクセス認証情報を取得します。
        String accessKeyId = System.getenv("OSS_ACCESS_KEY_ID");
        String accessKeySecret = System.getenv("OSS_ACCESS_KEY_SECRET");

        // OSS のリージョンとエンドポイントを設定します。
        String region = "cn-hangzhou";
        String endpoint = "oss-cn-hangzhou.aliyuncs.com";

        // バケットとファイル情報を設定します。
        String bucket = "example-bucket";
        String key = "dest.jpg";
        String filePath = "dest.jpg";

        // 認証情報プロバイダーを作成します。
        CredentialsProvider provider = new StaticCredentialsProvider(accessKeyId, accessKeySecret);

        // OSS クライアントを初期化します。
        OSSClient client = OSSClient.newBuilder()
                .credentialsProvider(provider)
                .region(region)
                .endpoint(endpoint)
                .build();

        try {
            // ステップ 1：マルチパートアップロードを初期化します。
            InitiateMultipartUploadResult initiateResult = client.initiateMultipartUpload(
                    InitiateMultipartUploadRequest.newBuilder()
                            .bucket(bucket)
                            .key(key)
                            .build());

            String uploadId = initiateResult.initiateMultipartUpload().uploadId();
            System.out.printf("マルチパートアップロードの初期化に成功しました。ステータスコード: %d, リクエスト ID: %s, アップロード ID: %s\n",
                    initiateResult.statusCode(), initiateResult.requestId(), uploadId);

            // ステップ 2：パートをアップロードします。
            File file = new File(filePath);
            long fileSize = file.length();
            long partSize = 100 * 1024; // パートあたり 100 KB。
            int partNumber = 1;
            List<Part> uploadParts = new ArrayList<>();

            for (long start = 0; start < fileSize; start += partSize) {
                long curPartSize = Math.min(partSize, fileSize - start);

                // ファイルパートを読み取り、アップロードします。
                try (InputStream is = new FileInputStream(file)) {
                    is.skip(start);
                    BoundedInputStream boundedInputStream = new BoundedInputStream(is, curPartSize);

                    // パートをアップロードします。
                    UploadPartResult partResult = client.uploadPart(UploadPartRequest.newBuilder()
                            .bucket(bucket)
                            .key(key)
                            .uploadId(uploadId)
                            .partNumber((long) partNumber)
                            .body(BinaryData.fromStream(boundedInputStream))
                            .build());

                    System.out.printf("ステータスコード: %d, リクエスト ID: %s, パート番号: %d, ETag: %s\n",
                            partResult.statusCode(), partResult.requestId(), partNumber, partResult.eTag());

                    uploadParts.add(Part.newBuilder()
                            .partNumber((long) partNumber)
                            .eTag(partResult.eTag())
                            .build());
                }
                partNumber++;
            }

            // ステップ 3：マルチパートアップロードを完了します。
            uploadParts.sort((p1, p2) -> p1.partNumber().compareTo(p2.partNumber()));

            CompleteMultipartUpload completeMultipartUpload = CompleteMultipartUpload.newBuilder()
                    .parts(uploadParts)
                    .build();

            CompleteMultipartUploadResult completeResult = client.completeMultipartUpload(
                    CompleteMultipartUploadRequest.newBuilder()
                            .bucket(bucket)
                            .key(key)
                            .uploadId(uploadId)
                            .completeMultipartUpload(completeMultipartUpload)
                            .build());

            System.out.printf("マルチパートアップロードが完了しました。ステータスコード: %d, リクエスト ID: %s, バケット: %s, キー: %s, ロケーション: %s, ETag: %s\n",
                    completeResult.statusCode(), completeResult.requestId(), 
                    completeResult.completeMultipartUpload().bucket(),
                    completeResult.completeMultipartUpload().key(), 
                    completeResult.completeMultipartUpload().location(),
                    completeResult.completeMultipartUpload().eTag());

        } catch (Exception e) {
            System.out.printf("エラー:\n%s", e);
            e.printStackTrace();
        } finally {
            // クライアントを閉じます。
            try {
                client.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
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;

/**
 * OSS マルチパートアップロードのサンプル (V1 SDK)。
 * 大容量ファイルのマルチパートアップロードを実装します。
 */
public class MultipartUpload {

    public static void main(String[] args) {
        // 環境変数からアクセス認証情報を取得します。
        String accessKeyId = System.getenv("OSS_ACCESS_KEY_ID");
        String accessKeySecret = System.getenv("OSS_ACCESS_KEY_SECRET");

        // OSS のリージョンとエンドポイントを設定します。
        String region = "cn-hangzhou";
        String endpoint = "oss-cn-hangzhou.aliyuncs.com";

        // バケットとファイル情報を設定します。
        String bucketName = "example-bucket";
        String objectName = "dest.jpg";
        String filePath = "dest.jpg";

        // 認証情報プロバイダーを作成します。
        DefaultCredentialProvider provider = new DefaultCredentialProvider(accessKeyId, accessKeySecret);

        // クライアントパラメータを設定します。
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);

        // OSS クライアントを初期化します。
        OSS ossClient = OSSClientBuilder.create()
                .credentialsProvider(provider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .endpoint(endpoint)
                .build();

        try {
            // ステップ 1：マルチパートアップロードを初期化します。
            InitiateMultipartUploadRequest initiateRequest = new InitiateMultipartUploadRequest(bucketName, objectName);
            InitiateMultipartUploadResult initiateResult = ossClient.initiateMultipartUpload(initiateRequest);
            String uploadId = initiateResult.getUploadId();
            System.out.printf("マルチパートアップロードの初期化に成功しました。アップロード ID: %s\n", uploadId);

            // ステップ 2：パートをアップロードします。
            File file = new File(filePath);
            long fileLength = file.length();
            long partSize = 100 * 1024L; // パートあたり 100 KB。

            // パート数を計算します。
            int partCount = (int) (fileLength / partSize);
            if (fileLength % partSize != 0) {
                partCount++;
            }

            // アップロードされたパートの ETag を保存します。
            List<PartETag> partETags = new ArrayList<>();

            // パートを走査してアップロードします。
            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);
                uploadPartRequest.setPartNumber(i + 1);
                uploadPartRequest.setPartSize(curPartSize);

                // ファイルパートを読み取り、アップロードします。
                try (InputStream instream = new FileInputStream(file)) {
                    instream.skip(startPos);
                    uploadPartRequest.setInputStream(instream);

                    UploadPartResult uploadPartResult = ossClient.uploadPart(uploadPartRequest);
                    partETags.add(uploadPartResult.getPartETag());

                    System.out.printf("パート %d/%d のアップロードに成功しました。ETag: %s\n",
                            i + 1, partCount, uploadPartResult.getPartETag().getETag());
                }
            }

            // ステップ 3：マルチパートアップロードを完了します。
            CompleteMultipartUploadRequest completeRequest = new CompleteMultipartUploadRequest(
                    bucketName, objectName, uploadId, partETags);
            CompleteMultipartUploadResult completeResult = ossClient.completeMultipartUpload(completeRequest);

            System.out.printf("マルチパートアップロードが完了しました。ETag: %s\n", completeResult.getETag());

        } catch (Exception e) {
            System.out.printf("エラー: %s\n", e.getMessage());
            e.printStackTrace();
        } finally {
            // クライアントを閉じます。
            ossClient.shutdown();
        }
    }
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# OSS Python SDK V2 を使用したマルチパートアップロードのサンプル。
# 大容量ファイルのマルチパートアップロードを実装します。

import alibabacloud_oss_v2 as oss
import os

def main():
    # 環境変数からアクセス認証情報を取得します。
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # SDK のデフォルト設定を読み込みます。
    config = oss.config.load_default()
    config.credentials_provider = credentials_provider

    # OSS のリージョンとエンドポイントを設定します。
    config.region = "cn-hangzhou"
    config.endpoint = "oss-cn-hangzhou.aliyuncs.com"

    # OSS クライアントを初期化します。
    client = oss.Client(config)

    # バケットとファイル情報を設定します。
    bucket = "example-bucket"
    key = "dest.jpg"
    file_path = "dest.jpg"

    try:
        # ステップ 1：マルチパートアップロードを初期化します。
        initiate_result = client.initiate_multipart_upload(
            oss.InitiateMultipartUploadRequest(
                bucket=bucket,
                key=key
            ))

        upload_id = initiate_result.upload_id
        print(f"マルチパートアップロードの初期化に成功しました。ステータスコード: {initiate_result.status_code}, "
              f"リクエスト ID: {initiate_result.request_id}, アップロード ID: {upload_id}")

        # ステップ 2：パートをアップロードします。
        file_size = os.path.getsize(file_path)
        part_size = 100 * 1024  # パートあたり 100 KB。
        part_number = 1
        upload_parts = []
        offset = 0

        with open(file_path, 'rb') as f:
            while offset < file_size:
                # 現在のパートのサイズを計算します。
                current_part_size = min(part_size, file_size - offset)
                
                # パートデータを読み取ります。
                f.seek(offset)
                part_data = f.read(current_part_size)

                # パートをアップロードします。
                part_result = client.upload_part(
                    oss.UploadPartRequest(
                        bucket=bucket,
                        key=key,
                        upload_id=upload_id,
                        part_number=part_number,
                        body=part_data
                    ))

                print(f"ステータスコード: {part_result.status_code}, リクエスト ID: {part_result.request_id}, "
                      f"パート番号: {part_number}, ETag: {part_result.etag}")

                # アップロードされたパートの情報を記録します。
                upload_parts.append(oss.UploadPart(
                    part_number=part_number,
                    etag=part_result.etag
                ))

                offset += current_part_size
                part_number += 1

        # ステップ 3：マルチパートアップロードを完了します。
        upload_parts.sort(key=lambda p: p.part_number)

        complete_result = client.complete_multipart_upload(
            oss.CompleteMultipartUploadRequest(
                bucket=bucket,
                key=key,
                upload_id=upload_id,
                complete_multipart_upload=oss.CompleteMultipartUpload(
                    parts=upload_parts
                )
            ))

        print(f"マルチパートアップロードが完了しました。ステータスコード: {complete_result.status_code}, "
              f"リクエスト ID: {complete_result.request_id}, "
              f"バケット: {complete_result.bucket}, "
              f"キー: {complete_result.key}, "
              f"ロケーション: {complete_result.location}, "
              f"ETag: {complete_result.etag}")

    except Exception as e:
        print(f"エラー: {e}")
        raise

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# OSS Python SDK V1 を使用したマルチパートアップロードのサンプル。
# 大容量ファイルのマルチパートアップロードを実装します。

import os
import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider
from oss2 import SizedFileAdapter
from oss2.models import PartInfo

def main():
    # 環境変数からアクセス認証情報を取得します。
    auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())

    # OSS のリージョンとエンドポイントを設定します。
    region = "cn-hangzhou"
    endpoint = "oss-cn-hangzhou.aliyuncs.com"

    # バケットとファイル情報を設定します。
    bucket_name = "example-bucket"
    key = "dest.jpg"
    file_path = "dest.jpg"

    # OSS バケットを初期化します。
    bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)

    try:
        # ステップ 1：マルチパートアップロードを初期化します。
        upload_id = bucket.init_multipart_upload(key).upload_id
        print(f"マルチパートアップロードの初期化に成功しました。アップロード ID: {upload_id}")

        # ステップ 2：パートをアップロードします。
        file_size = os.path.getsize(file_path)
        part_size = 100 * 1024  # パートあたり 100 KB。
        part_number = 1
        parts = []
        offset = 0

        with open(file_path, 'rb') as fileobj:
            while offset < file_size:
                # 現在のパートのサイズを計算します。
                current_part_size = min(part_size, file_size - offset)

                # パートをアップロードします。
                result = bucket.upload_part(
                    key,
                    upload_id,
                    part_number,
                    SizedFileAdapter(fileobj, current_part_size)
                )

                print(f"パート番号: {part_number}, ETag: {result.etag}")

                # アップロードされたパートの情報を記録します。
                parts.append(PartInfo(part_number, result.etag))

                offset += current_part_size
                part_number += 1

        # ステップ 3：マルチパートアップロードを完了します。
        result = bucket.complete_multipart_upload(key, upload_id, parts)
        print(f"マルチパートアップロードが完了しました。ETag: {result.etag}")

    except Exception as e:
        print(f"エラー: {e}")
        raise

if __name__ == "__main__":
    main()

package main

// OSS Go SDK V2 を使用したマルチパートアップロードのサンプル。
// 大容量ファイルのマルチパートアップロードを実装します。

import (
	"context"
	"fmt"
	"io"
	"os"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
)

func main() {
	// 環境変数からアクセス認証情報を取得します。
	// OSS クライアントを設定し、認証情報プロバイダーとエンドポイントを設定します。
	config := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion("cn-hangzhou").
		WithEndpoint("oss-cn-hangzhou.aliyuncs.com")

	// OSS クライアントを初期化します。
	client := oss.NewClient(config)

	// バケットとファイル情報を設定します。
	bucket := "example-bucket"
	key := "dest.jpg"
	filePath := "dest.jpg"

	// ステップ 1：マルチパートアップロードを初期化します。
	initResult, err := client.InitiateMultipartUpload(context.TODO(), &oss.InitiateMultipartUploadRequest{
		Bucket: oss.Ptr(bucket),
		Key:    oss.Ptr(key),
	})
	if err != nil {
		fmt.Printf("エラー: %v\n", err)
		return
	}

	uploadId := *initResult.UploadId
	fmt.Printf("マルチパートアップロードの初期化に成功しました。アップロード ID: %s\n", uploadId)

	// ステップ 2：パートをアップロードします。
	file, err := os.Open(filePath)
	if err != nil {
		fmt.Printf("エラー: %v\n", err)
		return
	}
	defer file.Close()

	fileInfo, err := file.Stat()
	if err != nil {
		fmt.Printf("エラー: %v\n", err)
		return
	}

	fileSize := fileInfo.Size()
	partSize := int64(100 * 1024) // パートあたり 100 KB。
	partNumber := int32(1)
	var parts []oss.UploadPart

	for offset := int64(0); offset < fileSize; offset += partSize {
		// 現在のパートのサイズを計算します。
		currentPartSize := partSize
		if offset+partSize > fileSize {
			currentPartSize = fileSize - offset
		}

		// パートデータを読み取ります。
		file.Seek(offset, 0)
		partData := io.LimitReader(file, currentPartSize)

		// パートをアップロードします。
		partResult, err := client.UploadPart(context.TODO(), &oss.UploadPartRequest{
			Bucket:     oss.Ptr(bucket),
			Key:        oss.Ptr(key),
			UploadId:   oss.Ptr(uploadId),
			PartNumber: partNumber,
			Body:       partData,
		})
		if err != nil {
			fmt.Printf("エラー: %v\n", err)
			return
		}

		fmt.Printf("パート番号: %d, ETag: %s\n", partNumber, *partResult.ETag)

		// アップロードされたパートの情報を記録します。
		parts = append(parts, oss.UploadPart{
			PartNumber: partNumber,
			ETag:       partResult.ETag,
		})

		partNumber++
	}

	// ステップ 3：マルチパートアップロードを完了します。
	completeResult, err := client.CompleteMultipartUpload(context.TODO(), &oss.CompleteMultipartUploadRequest{
		Bucket:   oss.Ptr(bucket),
		Key:      oss.Ptr(key),
		UploadId: oss.Ptr(uploadId),
		CompleteMultipartUpload: &oss.CompleteMultipartUpload{
			Parts: parts,
		},
	})
	if err != nil {
		fmt.Printf("エラー: %v\n", err)
		return
	}

	fmt.Printf("マルチパートアップロードが完了しました。バケット: %s, キー: %s, ロケーション: %s, ETag: %s\n",
		*completeResult.Bucket, *completeResult.Key, *completeResult.Location, *completeResult.ETag)
}

package main

// OSS Go SDK V1 を使用したマルチパートアップロードのサンプル。
// 大容量ファイルのマルチパートアップロードを実装します。

import (
	"fmt"
	"os"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	// 環境変数からアクセス認証情報を取得します。
	provider, _ := oss.NewEnvironmentVariableCredentialsProvider()

	// OSS クライアントインスタンスを作成します。
	client, _ := oss.New(
		"oss-cn-hangzhou.aliyuncs.com",
		"",
		"",
		oss.SetCredentialsProvider(&provider),
		oss.AuthVersion(oss.AuthV4),
		oss.Region("cn-hangzhou"),
	)

	// バケットオブジェクトを取得します。
	bucket, _ := client.Bucket("example-bucket")

	// ファイル情報を設定します。
	key := "dest.jpg"
	filePath := "dest.jpg"

	// ステップ 1：マルチパートアップロードを初期化します。
	imur, err := bucket.InitiateMultipartUpload(key)
	if err != nil {
		fmt.Printf("エラー: %v\n", err)
		return
	}

	fmt.Printf("マルチパートアップロードの初期化に成功しました。アップロード ID: %s\n", imur.UploadID)

	// ステップ 2：パートをアップロードします。
	file, err := os.Open(filePath)
	if err != nil {
		fmt.Printf("エラー: %v\n", err)
		return
	}
	defer file.Close()

	fileInfo, err := file.Stat()
	if err != nil {
		fmt.Printf("エラー: %v\n", err)
		return
	}

	fileSize := fileInfo.Size()
	partSize := int64(100 * 1024) // パートあたり 100 KB。

	// ファイルをパートに分割します。
	chunks, err := oss.SplitFileByPartSize(filePath, partSize)
	if err != nil {
		fmt.Printf("エラー: %v\n", err)
		return
	}

	var parts []oss.UploadPart
	for _, chunk := range chunks {
		part, err := bucket.UploadPart(imur, file, chunk.Size, chunk.Number)
		if err != nil {
			fmt.Printf("エラー: %v\n", err)
			return
		}

		fmt.Printf("パート番号: %d, ETag: %s\n", chunk.Number, part.ETag)
		parts = append(parts, part)
	}

	// ステップ 3：マルチパートアップロードを完了します。
	_, err = bucket.CompleteMultipartUpload(imur, parts)
	if err != nil {
		fmt.Printf("エラー: %v\n", err)
		return
	}

	fmt.Printf("マルチパートアップロードが完了しました。ファイルサイズ: %d バイト\n", fileSize)
}

コンソールの使用

1. バケットリストに移動し、対象のバケットをクリックします。

2. オブジェクトリストで、パートをクリックしてパートを表示および削除します。

ライフサイクルルールの使用

ライフサイクルルールを設定して、期限切れのパートを自動的にクリーンアップします。これにより、手動でのメンテナンスが削減され、見落としを防ぐことができます。詳細については、「ライフサイクルルールを使用した期限切れパートのクリーンアップ」をご参照ください。

ツールの使用

• ossbrowser

  バケットのオブジェクトリストページで、パートをクリックしてパートを表示および削除します。

• ossutil

  abort-multipart-upload コマンドを使用して、マルチパートアップロードをキャンセルし、対応するパートデータを削除します。以下にコマンドの例を示します：

  ossutil api abort-multipart-upload --bucket example-bucket --key dest.jpg --upload-id D9F4****************************

SDK の使用

AbortMultipartUpload 操作を呼び出して、マルチパートアップロードをキャンセルし、対応するパートデータを削除します。以降のセクションでは、一般的な SDK を使用してマルチパートアップロードをキャンセルするサンプルコードを記載しています。他の言語の例については、SDK リファレンスのサンプルコードをご参照ください。

コードを実行する前に、適切な SDK をインストールし、アクセス認証情報を環境変数として設定してください。RAM ユーザーまたは RAM ロールを使用する場合は、必要な権限も付与する必要があります。詳細については、「API 権限」をご参照ください。

import com.aliyun.sdk.service.oss2.OSSClient;
import com.aliyun.sdk.service.oss2.credentials.CredentialsProvider;
import com.aliyun.sdk.service.oss2.credentials.StaticCredentialsProvider;
import com.aliyun.sdk.service.oss2.models.AbortMultipartUploadRequest;
import com.aliyun.sdk.service.oss2.models.AbortMultipartUploadResult;

/**
 * OSS マルチパートアップロードをキャンセルするサンプル。
 * マルチパートアップロードをキャンセルする方法を示します。
 */
public class AbortMultipartUpload {

    public static void main(String[] args) {
        // 環境変数からアクセス認証情報を取得します。
        String accessKeyId = System.getenv("OSS_ACCESS_KEY_ID");
        String accessKeySecret = System.getenv("OSS_ACCESS_KEY_SECRET");

        // OSS のリージョンとエンドポイントを設定します。
        String region = "cn-hangzhou";
        String endpoint = "oss-cn-hangzhou.aliyuncs.com";

        // バケットとファイル情報を設定します。
        String bucket = "example-bucket";
        String key = "dest.jpg";
        String uploadId = "D9F4****************************";

        // 認証情報プロバイダーを作成します。
        CredentialsProvider provider = new StaticCredentialsProvider(accessKeyId, accessKeySecret);

        // OSS クライアントを初期化します。
        OSSClient client = OSSClient.newBuilder()
                .credentialsProvider(provider)
                .region(region)
                .endpoint(endpoint)
                .build();

        try {
            // マルチパートアップロードをキャンセルします。
            AbortMultipartUploadResult result = client.abortMultipartUpload(
                    AbortMultipartUploadRequest.newBuilder()
                            .bucket(bucket)
                            .key(key)
                            .uploadId(uploadId)
                            .build());

            System.out.printf("マルチパートアップロードのキャンセルに成功しました。ステータスコード: %d, リクエスト ID: %s\n",
                    result.statusCode(), result.requestId());

        } catch (Exception e) {
            System.out.printf("エラー: %s\n", e.getMessage());
            e.printStackTrace();
        } finally {
            // クライアントを閉じます。
            try {
                client.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.*;

/**
 * OSS マルチパートアップロードをキャンセルするサンプル (V1 SDK)。
 * マルチパートアップロードをキャンセルする方法を示します。
 */
public class AbortMultipartUpload {

    public static void main(String[] args) {
        // 環境変数からアクセス認証情報を取得します。
        String accessKeyId = System.getenv("OSS_ACCESS_KEY_ID");
        String accessKeySecret = System.getenv("OSS_ACCESS_KEY_SECRET");

        // OSS のリージョンとエンドポイントを設定します。
        String region = "cn-hangzhou";
        String endpoint = "oss-cn-hangzhou.aliyuncs.com";

        // バケットとファイル情報を設定します。
        String bucketName = "example-bucket";
        String objectName = "dest.jpg";
        String uploadId = "D9F4****************************";

        // 認証情報プロバイダーを作成します。
        DefaultCredentialProvider provider = new DefaultCredentialProvider(accessKeyId, accessKeySecret);

        // クライアントパラメータを設定します。
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);

        // OSS クライアントを初期化します。
        OSS ossClient = OSSClientBuilder.create()
                .credentialsProvider(provider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .endpoint(endpoint)
                .build();

        try {
            // マルチパートアップロードをキャンセルします。
            AbortMultipartUploadRequest abortMultipartUploadRequest =
                    new AbortMultipartUploadRequest(bucketName, objectName, uploadId);
            ossClient.abortMultipartUpload(abortMultipartUploadRequest);

            System.out.printf("マルチパートアップロードのキャンセルに成功しました。アップロード ID: %s\n", uploadId);

        } catch (Exception e) {
            System.out.printf("エラー: %s\n", e.getMessage());
            e.printStackTrace();
        } finally {
            // クライアントを閉じます。
            ossClient.shutdown();
        }
    }
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# OSS Python SDK V2 を使用してマルチパートアップロードをキャンセルするサンプル。
# マルチパートアップロードをキャンセルし、アップロードされたパートを削除します。

import alibabacloud_oss_v2 as oss

def main():
    # 環境変数からアクセス認証情報を取得します。
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # SDK のデフォルト設定を読み込みます。
    config = oss.config.load_default()
    config.credentials_provider = credentials_provider

    # OSS のリージョンとエンドポイントを設定します。
    config.region = "cn-hangzhou"
    config.endpoint = "oss-cn-hangzhou.aliyuncs.com"

    # OSS クライアントを初期化します。
    client = oss.Client(config)

    # バケットとファイル情報を設定します。
    bucket = "example-bucket"
    key = "dest.jpg"
    upload_id = "D9F4****************************"

    # マルチパートアップロードをキャンセルします。
    result = client.abort_multipart_upload(
        oss.AbortMultipartUploadRequest(
            bucket=bucket,
            key=key,
            upload_id=upload_id
        ))

    print(f"マルチパートアップロードのキャンセルに成功しました。ステータスコード: {result.status_code}, リクエスト ID: {result.request_id}")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# OSS Python SDK V1 を使用してマルチパートアップロードをキャンセルするサンプル。

import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider

def main():
    # 環境変数からアクセス認証情報を取得します。
    auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
    
    # OSS のリージョンとエンドポイントを設定します。
    region = "cn-hangzhou"
    endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
    
    # バケットとファイル情報を設定します。
    bucket_name = "example-bucket"
    key = "dest.jpg"
    upload_id = "D9F4****************************"
    
    # OSS クライアントを初期化します。
    bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
    
    # マルチパートアップロードをキャンセルします。
    bucket.abort_multipart_upload(key, upload_id)
    
    print(f"マルチパートアップロードのキャンセルに成功しました。アップロード ID: {upload_id}")

if __name__ == "__main__":
    main()

package main

// OSS Go SDK V2 を使用してマルチパートアップロードをキャンセルするサンプル。

import (
	"context"
	"fmt"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
)

func main() {
	// 環境変数からアクセス認証情報を取得します。
	// OSS クライアントを設定し、認証情報プロバイダーとエンドポイントを設定します。
	config := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion("cn-hangzhou").
		WithEndpoint("oss-cn-hangzhou.aliyuncs.com")

	// OSS クライアントを初期化します。
	client := oss.NewClient(config)

	// バケットとファイル情報を設定します。
	bucket := "example-bucket"
	key := "dest.jpg"
	uploadId := "D9F4****************************"

	// マルチパートアップロードをキャンセルします。
	client.AbortMultipartUpload(context.TODO(), &oss.AbortMultipartUploadRequest{
		Bucket:   oss.Ptr(bucket),
		Key:      oss.Ptr(key),
		UploadId: oss.Ptr(uploadId),
	})

	fmt.Printf("マルチパートアップロードのキャンセルに成功しました。アップロード ID: %s\n", uploadId)
}

package main

// OSS Go SDK V1 を使用してマルチパートアップロードをキャンセルするサンプル。

import (
	"fmt"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	// 環境変数からアクセス認証情報を取得します。
	provider, _ := oss.NewEnvironmentVariableCredentialsProvider()

	// OSS クライアントインスタンスを作成します。
	client, _ := oss.New(
		"oss-cn-hangzhou.aliyuncs.com",
		"",
		"",
		oss.SetCredentialsProvider(&provider),
		oss.AuthVersion(oss.AuthV4),
		oss.Region("cn-hangzhou"),
	)

	// バケットオブジェクトを取得します。
	bucket, _ := client.Bucket("example-bucket")

	// ファイル情報を設定します。
	key := "dest.jpg"
	uploadId := "D9F4****************************"

	// InitiateMultipartUploadResult オブジェクトを作成します。
	imur := oss.InitiateMultipartUploadResult{
		UploadID: uploadId,
		Key:      key,
	}

	// マルチパートアップロードをキャンセルします。
	bucket.AbortMultipartUpload(imur)

	fmt.Printf("マルチパートアップロードのキャンセルに成功しました。アップロード ID: %s\n", uploadId)
}

ベストプラクティス

• パフォーマンスの最適化：アップロード速度と安定性の向上

  • 同時パート数の制御：ネットワーク帯域幅とデバイスの負荷に基づいて、適切な同時パート数を決定します。同時接続が多すぎるとシステム負荷が増加し、ネットワーク輻輳を引き起こす可能性があります。一方、少なすぎるとネットワークリソースを十分に活用できません。

  • 名前の連続したプレフィックスを避ける：多数のファイルをアップロードする場合、ファイル名にタイムスタンプなどの連続したプレフィックスを使用しないでください。これにより、リクエストが特定のパーティションに集中するのを防ぎ、ホットスポット問題を引き起こして全体的なアップロードパフォーマンスに影響を与えるのを回避します。詳細については、「OSS パフォーマンスのベストプラクティス」をご参照ください。

• 信頼性の確保：再開可能なアップロードの実装

  マルチパートアップロードは有効期限がなく、一時停止および再開操作をサポートします。UploadId をタスク識別子として使用します。単一のパートのアップロードに失敗した場合、ファイル全体を最初から再アップロードするのではなく、そのパートのみを再アップロードするだけで済みます。これにより、転送効率が大幅に向上します。

• コストの最適化：ディープコールドアーカイブのアップロード戦略の最適化

  ディープコールドアーカイブのコストを最適化するには、まずファイルを標準オブジェクトとしてアップロードし、その後ライフサイクルルールを使用してそれらを移行します。これにより、直接アップロードの高いリクエストごとの PUT 料金を回避できます。

リスク防止

• データセキュリティ：ファイルの上書き防止

  アップロードリクエストヘッダーで、x-oss-forbid-overwrite パラメーターを true に設定して、同じ名前のファイルが上書きされるのを防ぎ、データ損失を回避します。バージョン管理を有効にして、履歴バージョンを保持することもできます。