# オブジェクトのアップロード
Amazon S3 にファイルをアップロードすると、S3 *オブジェクト*として保存されます。オブジェクトは、オブジェクトを記述するファイルデータとメタデータから構成されます。バケット内のオブジェクトの数に制限はありません。Amazon S3 バケットにファイルをアップロードするには、バケットに対する書き込みアクセス許可が必要です。アクセス許可の詳細については、[Amazon S3 用 Identity and Access Management](security-iam.md) を参照してください。
ファイルタイプ (イメージ、バックアップ、データ、ムービーなど) を問わず、各種のファイルを S3 バケットにアップロードできます。Amazon S3 コンソールを使用すると、アップロードできるファイルの最大サイズが 160 GB になります。160 GB を超えるファイルをアップロードするには、AWS Command Line Interface (AWS CLI)、AWS SDK、または Amazon S3 REST API を使用します。
バージョニングが有効なバケットに既に存在するキー名の付いたオブジェクトをアップロードした場合、Amazon S3 は既存のオブジェクトを置き換える代わりにオブジェクトの別バージョンを作成します。バージョニングを有効にする方法の詳細については、「[バケットでのバージョニングの有効化](manage-versioning-examples.md)」を参照してください。
アップロードするデータのサイズに応じて、Amazon S3 には以下のオプションが用意されています。
+ **AWS SDK、REST API、または AWS CLI** を使用して 1 回のオペレーションでオブジェクトをアップロードする — 1 回の `PUT` オペレーションでは、最大 5 GB の単一のオブジェクトをアップロードできます。
+ **Amazon S3 コンソールを使用して 1 つのオブジェクトをアップロードする**** — **Amazon S3 コンソールでは、最大 160 GB のオブジェクトをアップロードできます。
+ **AWS SDK、REST API、または AWS CLI を使用してオブジェクトをいくつかに分けてアップロードする**** — ** マルチパートアップロード API を使用すると、最大 50 TB のサイズの単一の大容量オブジェクトをアップロードできます。
マルチパートアップロード API オペレーションは大容量オブジェクトのアップロードを効率よく行えるように設計されています。1 つのオブジェクトをいくつかに分けてアップロードできます。オブジェクトのパートは、単独で、任意の順序で、または並行してアップロードできます。マルチパートアップロードは 5 MB～50 TB のオブジェクトで使用できます。詳細については、「[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md)」を参照してください。
5 TB を超えるファイルをアップロードするには、Java v1/v2、Python、または AWS CLI SDK で S3 Transfer Manager を使用します。最高のパフォーマンスを得るには、これらの SDK で最新の AWS 共通ランタイム (CRT) を使用します。これは、リソース使用率を向上させるために最適化されています。
メモリストリームから大きなオブジェクトをアップロードする場合、CRT は各パートを最大 5 GB までメモリにバッファリングし、割り当てられたメモリによって全体的なスループットを制限します。Java SDK の `maxNativeMemoryLimitInBytes` などの設定オプションを使用して CRT メモリ制限を調整できます。ディスクからのアップロードの場合、CRT は中間パートバッファリングではなく直接ディスクストリーミングに自動的に切り替え、メモリ使用量を改善します。この動作は大きなオブジェクトに対しては自動的に有効になりますが、AWS CLI の `should_stream` や Java SDK の `CRT_MEMORY_BUFFER_DISABLED` などのリクエストパラメータを介して小さなファイルに対して有効にすることもできます。
オブジェクトをアップロードすると、そのオブジェクトは、デフォルトでは Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) を使用して自動的に暗号化されます。ダウンロードすると、オブジェクトは復号化されます。詳細については、「[Amazon S3 バケット向けのサーバー側のデフォルトの暗号化動作の設定](bucket-encryption.md)」および「[暗号化によるデータの保護](UsingEncryption.md)」を参照してください。
オブジェクトをアップロードするときに、別の種類のデフォルト暗号化を使用する場合は、S3 `PUT` リクエストで AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS) を指定するか、SSE-KMS を使用してデータを暗号化するように送信先バケットのデフォルトの暗号化設定を設定することもできます。SSE-KMS に関する詳細は、「[AWS KMS (SSE−KMS) によるサーバー側の暗号化の指定](specifying-kms-encryption.md)」を参照してください。別のアカウントが所有している KMS キーを使用する場合は、そのキーを使用するアクセス許可が必要です。KMS キーのクロスアカウント権限の詳細については、**「AWS Key Management Service デベロッパーガイド」の「[他のアカウントで使用できる KMS キーを作成する](https://docs.aws.amazon.com//kms/latest/developerguide/key-policy-modifying-external-accounts.html#cross-account-console)」を参照してください。
Amazon S3 でアクセス拒否 (403 Forbidden) エラーが発生したとき、一般的な原因の詳細については「[Amazon S3 でのアクセス拒否 (403 Forbidden) エラーのトラブルシューティング](troubleshoot-403-errors.md) 」を参照してください。
## オブジェクトのアップロード
### S3 コンソールの使用
この手順では、コンソールを使用してオブジェクトおよびフォルダを Amazon S3 バケットにアップロードする方法について説明します。
オブジェクトをアップロードする場合、オブジェクトキー名はファイル名および任意のプレフィックスになります。Amazon S3 コンソールでは、フォルダを作成してオブジェクトを整理できます。Amazon S3 では、フォルダはオブジェクトキー名に表示されるプレフィックスとして表されます。Amazon S3 コンソールのフォルダに個々のオブジェクトをアップロードする場合、フォルダ名はオブジェクトキー名に含まれます。
例えば、「`sample1.jpg`」という名前のオブジェクトを「`backup`」という名前のフォルダにアップロードすると、キー名は「`backup/sample1.jpg`」になります。ただし、オブジェクトはコンソールの `sample1.jpg` フォルダ内で `backup` として表示されます。有効なキー名の詳細については、[オブジェクトメタデータの使用](UsingMetadata.md) を参照してください。
**注記**
Amazon S3 コンソールでオブジェクトの名前を変更したり、**ストレージクラス**、**暗号化**、または**メタデータ**などのプロパティを変更したりすると、新しいオブジェクトが作成され、古いオブジェクトが置き換えられます。S3 バージョニングが有効になっている場合は、オブジェクトの新しいバージョンが作成され、既存のオブジェクトが古いバージョンになります。また、プロパティを変更するロールは、新しいオブジェクト (またはオブジェクトのバージョン) の所有者になります。
フォルダをアップロードすると、Amazon S3 は、そのフォルダからすべてのファイルとサブフォルダをバケットにアップロードします。その後、アップロードしたファイルの名前とフォルダの名前を組み合わせたオブジェクトキー名が割り当てられます。例えば、`/images` と `sample1.jpg` の 2 つのファイルを含む `sample2.jpg` というフォルダをアップロードすると、Amazon S3 はファイルのアップロード後に、対応するキー名である `images/sample1.jpg` と `images/sample2.jpg` を割り当てます。キー名にはプレフィックスとしてフォルダ名が含まれています。Amazon S3 コンソールには、最後の `/` に続くキー名の部分のみが表示されます。例えば、`images` フォルダ内では `images/sample1.jpg` オブジェクトと `images/sample2.jpg` オブジェクトが `sample1.jpg` および `sample2.jpg` として表示されます。
**フォルダとファイルを S3 バケットにアップロードするには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. [**Buckets (バケット)**] リストで、フォルダやファイルのアップロード先のバケットの名前を選択します。
1. [**Upload (アップロード)**] を選択します。
1. [**Upload**] (アップロード) ウィンドウで、次のいずれかの操作を行います。
+ ファイルとフォルダを [**Upload**] (アップロード) ウィンドウにドラッグアンドドロップします。
+ **[ファイルの追加]** または **[フォルダの追加]** を選択し、アップロードするファイルまたはフォルダを選択して **[開く]** を選択します。
1. バージョニングを有効にするには、[**Destination**] (送信先) で [**Enable Bucket Versioning**] (バケットバージョニングを有効化) を選択します。
1. 追加のアップロードオプションを設定せずにリストされたファイルとフォルダをアップロードするには、ページの下部で [**Upload**] (アップロード) を選択します。
Amazon S3 はオブジェクトとフォルダをアップロードします。アップロードが完了すると、**[アップロード: ステータス]** ページに成功のメッセージが表示されます。
**追加のオブジェクトプロパティを設定するには**
1. アクセスコントロールリストの許可を変更するには、**[Permissions]** (許可) を選択します。
1. **[Access control list (ACL)]** (アクセスコントロールリスト (ACL) で、許可を編集します。
オブジェクトのアクセス許可については、[S3 コンソールを使用した、オブジェクトの ACL アクセス権限の設定](managing-acls.md#set-object-permissions) を参照してください。アップロードするすべてのファイルについて、オブジェクトの読み取りアクセスをパブリック (世界中のすべてのユーザー) に付与できます。ただし、パブリック読み取りアクセスのデフォルト設定を変更しないことをお勧めします。パブリック読み取りアクセス権限の付与は、バケットがウェブサイトなどに使用されるなど、ユースケースの小さいサブセットに適用されます。オブジェクトをアップロードした後で、オブジェクトの許可をいつでも変更できます。
1. その他の追加プロパティを設定するには、**[Properties]** (プロパティ) を選択します。
1. **[ストレージクラス]** で、アップロードするファイルのストレージクラスを選択します。
ストレージクラスの詳細については、[Amazon S3 ストレージクラスの理解と管理](storage-class-intro.md) を参照してください。
1. オブジェクトの暗号化設定を更新するには、[**Server−side encryption settings**] (サーバー側の暗号化設定) で、次の操作を行います。
1. **[Specify an encryption key]** (暗号化キーを指定する) を選択します。
1. **[暗号化設定]** で、**[デフォルトの暗号化にバケット設定を使用する]** または **[デフォルトの暗号化にバケット設定を上書きする]** を選択します。
1. **[デフォルトの暗号化にバケット設定を上書きする]** を選択した場合は、次の暗号化設定を設定する必要があります。
+ Amazon S3 管理のキーを使用してアップロードされたファイルを暗号化するには、**[Amazon S3 マネージドキー (SSE−S3)]** を選択します。
詳細については、「[Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3)](UsingServerSideEncryption.md)」を参照してください。
+ AWS Key Management Service (AWS KMS) に保存されているキーを使用してアップロード済みファイルを暗号化するには、**AWS Key Management Service キー (SSE−KMS)** を選択します。次に、**AWS KMS キー**について、以下のいずれかのオプションを選択します。
+ 使用可能な KMS キーのリストから選択するには、**[AWS KMS keys から選択する]** を選択し、使用可能なキーのリストから自分の **KMS** キーを選択します。
AWS マネージドキー (`aws/s3`) とカスタマーマネージドキーの両方がこのリストに表示されます。カスタマーマネージドキーの詳細については、*AWS Key Management Serviceデベロッパーガイド*の「[カスタマーキーと AWS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)」を参照してください。
+ KMS キー ARN を入力するには、**[AWS KMS key ARN を入力]** を選択し、表示されるフィールドに KMS キー ARN を入力します。
+ AWS KMS コンソールで新しいカスタマーマネージドキーを作成するには、**[KMS キーを作成]** を選択します。
AWS KMS key の作成の詳細については、**「AWS Key Management Service デベロッパーガイド」の「[キーの作成](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html)」を参照してください。
**重要**
バケットと同じ AWS リージョン で使用可能な KMS キーのみを使用できます。Amazon S3 コンソールには、バケットと同じリージョンで最初の 100 個の KMS キーしか表示されません。リストに存在しない KMS キーを使用するには、KMS キー ARN を入力する必要があります。別のアカウントが所有している KMS キーを使用する場合は、まずそのキーを使用するアクセス許可が必要であり、次に KMS キー ARN を入力する必要があります。
Amazon S3 では、対称暗号化 KMS キーのみがサポートされ、非対称暗号化 KMS キーはサポートされません。詳細については、*AWS Key Management Service デベロッパーガイド*の「[Identifying symmetric and asymmetric KMS keys](https://docs.aws.amazon.com//kms/latest/developerguide/find-symm-asymm.html)」(対称および非対称 KMS キーの識別) を参照してください。
1. 追加のチェックサムを使用するには、**[On]** (オン) を選択します。次に、**[Checksum function]** (チェックサム関数) で、使用する関数を選択します。Amazon S3 は、オブジェクト全体を受け取った後、チェックサム値を計算して保存します。**[Precalculated value]** (事前計算された値) ボックスを使用して、事前計算された値を指定できます。その場合、Amazon S3 は、指定した値と計算した値を比較します。2 つの値が一致しない場合、Amazon S3 はエラーを生成します。
追加のチェックサムを使用すると、データの検証に使用するチェックサムアルゴリズムを指定できます。追加のチェックサムの詳細については、「[Amazon S3 でのオブジェクトの整合性のチェック](checking-object-integrity.md)」を参照してください。
1. アップロードするすべてのオブジェクトにタグを追加するには、[**Add tag (タグの追加)**] を選択します。**[キー]** フィールドにタグ名を入力します。タグの値を入力します。
オブジェクトのタグ付けにより、ストレージを分類する方法が提供されます。各タグはキーと値のペアです。キーとタグ値は大文字と小文字が区別されます。オブジェクトごとに最大 10 個のタグを持つことができます。タグキーには最大 128 個の Unicode 文字、タグ値には最大 255 個の Unicode 文字を使用できます。オブジェクトタグの詳細については、[タグを使用したオブジェクトの分類](object-tagging.md)を参照してください。
1. メタデータを追加するには、[**Add metadata**] (メタデータの追加) を選択します。
1. [**Type**] (タイプ) で、[**System defined**] (システム定義) または [**User defined**] (ユーザー定義) を選択します。
システム定義のメタデータの場合は、**Content−Type** や **Content−Disposition** などの一般的な HTTP ヘッダーを選択できます。システム定義のメタデータのリストと値を追加できるかどうかについては、[システムで定義されたオブジェクトメタデータ](UsingMetadata.md#SysMetadata) を参照してください。プレフィックス `x-amz-meta-` で始まるメタデータはすべてユーザー定義のメタデータとして扱われます。ユーザー定義メタデータはオブジェクトと共に保存され、オブジェクトのダウンロード時に返されます。キーと値の両方が US−ASCII 標準に従っている必要があります。ユーザー定義メタデータのサイズは最大 2 KB です。システム定義メタデータとユーザー定義メタデータの詳細については、[オブジェクトメタデータの使用](UsingMetadata.md) を参照してください。
1. [**Key**] (キー) で、キーを選択します。
1. キーの値を入力します。
1. オブジェクトをアップロードするには、[**Upload**] (アップロード) を選択します。
Amazon S3 はオブジェクトをアップロードします。アップロードが完了すると、[**Upload: status**] (アップロード: ステータス) ページに成功のメッセージが表示されます。
1. [**終了**] を選択します。
### AWS CLI の使用
単一のオペレーションで、最大 5 GB のオブジェクトをアップロードする `PUT` リクエストを送信できます。詳細については、[https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html#examples](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html#examples)*AWS CLI コマンドリファレンス*での例を参照してください。
### REST API の使用
REST リクエストを送信してオブジェクトをアップロードできます。`PUT` リクエストを送信して 1 回のオペレーションでデータをアップロードできます。詳細については、「[PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)」を参照してください。
### AWS SDK の使用
AWS SDK を使用してオブジェクトをアップロードする方法の例については、「*Amazon Simple Storage Service API リファレンス*」の「[コードの例](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_PutObject_section.html)」を参照してください。
さまざまな AWS SDK の使用に関する一般的な情報については、「*Amazon Simple Storage Service API リファレンス*」の「[AWS SDK を使用した Amazon S3 での開発](https://docs.aws.amazon.com/AmazonS3/latest/API/sdk-general-information-section.html)」を参照してください。
## 同じキー名を持つオブジェクトのアップロードを禁止する
アップロード時の条件付き書き込みオペレーションを使用して、バケット内にオブジェクトが存在するかどうかを確認してからオブジェクトを作成できるようになりました。これにより、既存のデータの上書きを阻止できます。条件付き書き込みでは、アップロードする際にバケット内に同じキー名を持つ既存のオブジェクトが存在しないことを検証します。
条件付き書き込みは、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) リクエストまたは [CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html) リクエストに使用できます。
条件付きリクエストの詳細については、「[条件付きリクエストを使用して S3 オペレーションに前提条件を追加する](conditional-requests.md)」を参照してください。
# Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー
マルチパートアップロードを使用すると、単一のオブジェクトをパートのセットとして Amazon S3 にアップロードすることができます。各パートは、オブジェクトのデータの連続する部分です。これらのオブジェクトパートは、任意の順序で個別にアップロードできます。アップロードの場合、更新された AWS クライアントはオブジェクトのチェックサムを自動的に計算し、リクエストの一部としてオブジェクトのサイズとともに Amazon S3 に送信します。いずれかのパートの送信が失敗すると、他のパートに影響を与えることなくそのパートを再送することができます。オブジェクトのすべてのパートがアップロードされたら、Amazon S3 はこれらを組み立ててオブジェクトを作成します。100 MB 以上のオブジェクトは、単一のオペレーションでアップロードするのではなく、マルチパートアップロードを使用するのがベストプラクティスです。
マルチパートアップロードの使用には、次の利点があります。
+ **スループットの向上** − パートを並列にアップロードすることで、スループットを向上させることができます。
+ **ネットワーク問題からの迅速な回復** − パートサイズが小さいほど、ネットワークエラーにより失敗したアップロードを再開する際の影響を最小限に抑えることができます。
+ **オブジェクトのアップロードの一時停止と再開** – オブジェクトの複数のパートを徐々にアップロードできます。マルチパートアップロードを開始した後は終了期限がありません。マルチパートアップロードは明示的に完了または停止する必要があります。
+ **オブジェクトの最終的なサイズが不明な状態でアップロードを開始** – オブジェクトを作成しながらアップロードできます。
次の方法でマルチパートアップロードを使用することをお勧めします。
+ 安定した高帯域幅ネットワーク経由で大きなオブジェクトをアップロードする場合は、複数スレッドのパフォーマンスのために並行してオブジェクトパートをアップロードすることにより、マルチパートアップロードを使用して使用可能な帯域幅の使用を最大化します。
+ むらがあるネットワークでアップロードを実行する場合は、マルチパートアップロードを使用して、アップロードの再開を回避することで、ネットワークエラーに対する弾力性を高めます。マルチパートアップロードを使用するときには、アップロード中に中断されたパートのアップロードを再試行するだけで済みます。最初からオブジェクトのアップロードを再開する必要はありません。
**注記**
Amazon S3 Express One Zone ストレージクラスをディレクトリバケットで使用する方法の詳細については、「[S3 Express One Zone](directory-bucket-high-performance.md#s3-express-one-zone)」と「[ディレクトリバケットの使用](directory-buckets-overview.md)」を参照してください。S3 Express One Zone とディレクトリバケットでマルチパートアップロードを使用する方法の詳細については、「[ディレクトリバケットでのマルチパートアップロードの使用](s3-express-using-multipart-upload.md)」を参照してください。
## マルチパートアップロードのプロセス
マルチパートアップロードは 3 つのステップで構成されるプロセスです。アップロードを開始し、オブジェクトのパートをアップロードします。すべてのパートをアップロードし終わったら、マルチパートアップロードを完了します。Amazon S3 の側では、マルチパートアップロードの完了リクエストを受け取ると同時に、アップロードされたパートからオブジェクトを構築します。構築されたオブジェクトは、バケット内の他のオブジェクトと同じようにアクセスできます。
進行中のすべてのマルチパートアップロードをリストしたり、特定のマルチパートアップロードにおいてアップロードが完了したパートのリスト表示を取得したりできます。このようなオペレーションのそれぞれについて、このセクションで説明します。
**マルチパートアップロードの開始**
マルチパートアップロードを開始するリクエストを送信するときは、必ずチェックサムタイプを指定してください。その後、Amazon S3 は、マルチパートアップロードの一意の識別子であるアップロード ID を含むレスポンスを返します。このアップロード ID は、パートのアップロード、パートのリスト、アップロードの完了、アップロードの停止を行うときは常に必要になります。アップロードするオブジェクトの説明となるメタデータを指定する場合は、マルチパートアップロードの開始リクエストの中で指定する必要があります。匿名ユーザーはマルチパートアップロードを開始できません。
**パートのアップロード**
パートをアップロードするときは、アップロード ID に加えて、パート番号を指定する必要があります。1～10,000 の範囲で任意のパート番号を選択できます。パート番号によって、アップロードするオブジェクトに含まれるパートとその位置が一意に識別されます。選択するパート番号は、連続している必要はありません (例えば、1、5、14 など)。以前にアップロードしたパートと同じパート番号を使って新しいパートをアップロードした場合、以前のパートは上書きされることに注意してください。
パートをアップロードすると、Amazon S3 は各パートのチェックサム値を含むチェックサムアルゴリズムタイプをレスポンスのヘッダーとして返します。パートのアップロードごとに、パート番号と ETag 値を記録する必要があります。マルチパートアップロードを完了するためには、残りのリクエストにこれらの値を含める必要があります。各パートには、アップロード時に独自の ETag が設定されます。ただし、マルチパートアップロードが完了し、すべてのパートが統合されると、チェックサムのチェックサムとしてすべてのパートが 1 つの ETag に属することになります。
**重要**
マルチパートアップロードを開始して、1 つまたは複数のパートをアップロードした後は、マルチパートアップロードを完了するか停止しない限り、アップロードしたパートのストレージに対する課金を停止できません。マルチパートアップロードを*完了または停止した後*でのみ、Amazon S3 はパートのストレージを解放して、パートのストレージに対する課金を停止します。
マルチパートアップロードを停止した後は、再度同じアップロード ID を使ってパートをアップロードすることはできません。パートのアップロードが進行中だった場合、アップロードを停止した後も、パートのアップロードは成功または失敗する可能性があります。すべてのパートによって使用されているストレージをすべて解放するには、すべてのパートのアップロードが完了した後でマルチパートアップロードを停止する必要があります。
**マルチパートアップロードの完了**
マルチパートアップロードを完了すると、パート番号に基づいて昇順に連結されたオブジェクトが Amazon S3 によって作成されます。*マルチパートアップロードの開始*リクエストにオブジェクトメタデータが指定されている場合、Amazon S3 によってそのメタデータはオブジェクトに関連付けられます。*完了*リクエストが正常に処理されると、個々のパートはなくなります。
*マルチパートアップロードの完了*リクエストには、アップロード ID と、パート番号およびそれに対応する ETag 値のリストが含まれている必要があります。Amazon S3 からのレスポンスには、結合されるオブジェクトデータを一意に識別する ETag が含まれます。この ETag が、オブジェクトデータの MD5 ハッシュになるとは限りません。
マルチパートアップロード中にフルオブジェクトチェックサムを指定すると、AWS SDK はそのチェックサムを Amazon S3 に渡し、S3 はオブジェクトの整合性をサーバー側で検証して、受信した値と比較します。次に、値が一致すると、S3 はオブジェクトを保存します。2 つの値が一致しない場合、Amazon S3 は `BadDigest` エラーでリクエストに失敗します。オブジェクトのチェックサムはオブジェクトメタデータにも保存され、後でオブジェクトのデータ整合性を検証するために使用します。
**マルチパートアップロードのサンプル呼び出し**
この例では、100 GB ファイルのマルチパートアップロードを生成していると仮定します。この場合、プロセス全体に対して次の API コールが実行されます。合計 1,002 回の API コールが実行されます。
+ プロセスを開始する `[CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)` の呼び出し。
+ それぞれ 100 MB の一部をアップロードし、合計サイズは 100 GB となる、1,000 回の個別の `[UploadPart](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)` の呼び出し。
+ プロセスを完了するための `[CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)` 呼び出し。
**マルチパートアップロードのリスト化**
特定のマルチパートアップロードのパートや、進行中のすべてのマルチパートアップロードをリスト表示できます。パートのリストオペレーションでは、特定のマルチパートアップロードについて既にアップロードしたパートの情報が返されます。パートのリストリクエストを送信するたびに、指定したマルチパートアップロードのパート情報 (最大で 1,000 個のパート) が Amazon S3 から返されます。マルチパートアップロードに 1,000 個を超えるパートが含まれる場合、すべてのパートを取得するにはパートのリストリクエストを追加で送信する必要があります。返されるパートのリストには、アップロードが完了していないパートは含まれていないことに注意してください。*マルチパートアップロードの一覧表示*オペレーションを使用すると、進行中のマルチパートアップロードのリストを取得できます。
進行中のマルチパートアップロードとは、開始されているものの、まだ完了または停止されていないアップロードを意味します。各リクエストに最大 1,000 個のマルチパートアップロードが返されます。進行中のマルチパートアップロードが 1,000 個を超える場合、残りのマルチパートアップロードを取得するには、リクエストを追加で送信する必要があります。返されたリストは確認の目的でのみ使用してください。
**重要**
*マルチパートアップロードの完了*リクエストを送信するときに、このリストの結果を使用しないでください。代わりに、パートのアップロード時に指定したパート番号と、それに対応する、Amazon S3 から返される ETag 値の独自のリストを維持しておいてください。
## マルチパートアップロードオペレーションを使用したチェックサム
Amazon S3 にオブジェクトをアップロードするときに、使用する Amazon S3 のチェックサムアルゴリズムを指定できます。デフォルトでは、AWS SDK および S3 コンソールはすべてのオブジェクトアップロードにアルゴリズムを使用します。これは上書きできます。古い SDK を使用していて、アップロードされたオブジェクトに指定されたチェックサムがない場合、Amazon S3 は自動的に CRC-64/NVME (`CRC64NVME`) チェックサムアルゴリズムを使用します。(これは、効率的なデータ整合性の検証に推奨されるオプションでもあります。) CRC-64/NVME を使用する場合、Amazon S3 はマルチパートまたはシングルパートのアップロードの完了後に、フルオブジェクトのチェックサムを計算します。CRC-64/NVME チェックサムアルゴリズムは、オブジェクト全体の直接チェックサム、または個々のパートごとにチェックサムのチェックサムを計算するために使用されます。
マルチパートアップロードを使用してオブジェクトを S3 にアップロードすると、Amazon S3 は各パートまたはフルオブジェクトのチェックサム値を計算し、その値を保存します。S3 API または AWS SDK を使用して、次の方法でチェックサム値を取得できます。
+ 個々のパートには、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) または [https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html) を使用できます。まだ処理中のマルチパートアップロードの個々の部分のチェックサム値を取得したい場合は、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html) を使用できます。
+ オブジェクト全体に対しては、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) を使用できます。フルオブジェクトのチェックサムを使用してマルチパートアップロードを実行する場合は、フルオブジェクトのチェックサムタイプを指定して、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload) と [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload) を使用します。オブジェクト全体のチェックサム値を検証するか、マルチパートアップロードで使用されているチェックサムタイプを確認するには、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html) を使用します。
**重要**
**[チェックサム]** を含むマルチパートアップロードを使用している場合、各パートのアップロード (マルチパートアップロードに含まれる) のパート番号は、連続しており 1 から始まる必要があります。**[チェックサム]** を使用している場合、連続しないパート番号でマルチパートアップロードリクエストを完了しようとすると、Amazon S3 は `HTTP 500 Internal Server` エラーを生成します。
マルチパートアップロードオブジェクトでのチェックサムの動作の詳細については、「[Amazon S3 でのオブジェクトの整合性のチェック](checking-object-integrity.md)」を参照してください。
追加のチェックサムを含むマルチパートアップロードを使用してオブジェクトをアップロードする方法を示すエンドツーエンドの手順については、「[チュートリアル: マルチパートアップロードでオブジェクトをアップロードして、データ整合性を検証する](tutorial-s3-mpu-additional-checksums.md)」を参照してください。
## マルチパートアップロードの同時オペレーション
分散開発環境においては、アプリケーションから同じオブジェクトに対して複数の更新が同時に開始されることもありえます。同じオブジェクトキーを使ってアプリケーションから複数のマルチパートアップロードが開始される可能性もあります。そのようなアップロードごとに、アプリケーションからパートのアップロードが行われ、アップロードの完了リクエストが Amazon S3 に送信されて、オブジェクトが作成されます。バケットで S3 バージョニングが有効になっているときには、マルチパートアップロードを完了するたびに新しいバージョンが作成されます。バージョニングが有効なバケットで、同じオブジェクトキーを使用する複数のマルチパートアップロードを開始した場合、オブジェクトの最新バージョンは、どのアップロードが最後に開始されたか (`createdDate`） によって決まります。
例えば、オブジェクトの `CreateMultipartUpload` リクエストを午前 10 時に開始します。次に、同じオブジェクトに対する 2 番目の `CreateMultipartUpload` リクエストを午前 11 時に送信したとします。この場合は、2 番目のリクエストが最後に送信されたため、2 番目のリクエストの後に最初のアップロードが完了したとしても、午前 11 時 のリクエストでアップロードされたオブジェクトが最新バージョンになります。バージョニングが有効になっていないバケットの場合は、マルチパートアップロードの開始から完了までの間に受信された他の何らかのリクエストが優先される可能性もあります。
同時マルチパートアップロードリクエストが優先されるもう 1 つの例は、そのキーを使用してマルチパートアップロードを開始した後に、別のオペレーションでキーが削除される場合です。オペレーションを完了する前に、マルチパートアップロードの完了レスポンスによって、オブジェクトを確認できなくても、オブジェクト作成の成功が示される可能性があります。
## マルチパートアップロード中に同じキー名を持つオブジェクトのアップロードを禁止する
アップロード時の条件付き書き込みオペレーションを使用して、バケット内にオブジェクトが存在するかどうかを確認してからオブジェクトを作成できるようになりました。これにより、既存のデータの上書きを阻止できます。条件付き書き込みでは、アップロードする際にバケット内に同じキー名を持つ既存のオブジェクトが存在しないことを検証します。
条件付き書き込みは、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) リクエストまたは [CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html) リクエストに使用できます。
条件付きリクエストの詳細については、「[条件付きリクエストを使用して S3 オペレーションに前提条件を追加する](conditional-requests.md)」を参照してください。
## マルチパートアップロードと料金
マルチパートアップロードを開始すると、アップロードを完了または中止するまですべてのパートが Amazon S3 によって保持されます。マルチパートアップロードの実行期間を通して、アップロードとそれに関連するパートのために使用されるすべてのストレージ、帯域幅、リクエストに対して課金が行われます。
これらのパートは、パートのアップロード時に指定されたストレージクラスに従って課金されます。ただし、これらのパートが S3 Glacier Flexible Retrieval または S3 Glacier Deep Archive にアップロードされた場合、料金は請求されません。S3 Glacier Flexible Retrieval ストレージクラスへの PUT リクエストに対する処理中のマルチパートパートは、アップロードが完了するまで S3 Glacier Flexible Retrieval ステージングストレージとして S3 標準ストレージ料金で請求されます。さらに、`CreateMultipartUpload` と `UploadPart` の両方が S3 標準料金で請求されます。`CompleteMultipartUpload` リクエストのみが、S3 Glacier Flexible Retrieval 料金で請求されます。同様に、S3 Glacier Deep Archive ストレージクラスへの PUT の処理中のマルチパートパートは、アップロードが完了するまで S3 Glacier Flexible Retrieval ステージングストレージとして S3 標準ストレージ料金で請求されます。`CompleteMultipartUpload` リクエストのみが、S3 Glacier Deep Archive 料金で請求されます。
マルチパートアップロードを停止した場合、Amazon S3 はアップロードアーティファクトおよびアップロードしたすべてのパートを削除します。これらのアーティファクトについては請求されません。指定されたストレージクラスに関係なく、不完全なマルチパートアップロードの削除に伴う早期削除料金はありません。料金に関する詳細については、[[Amazon S3 の料金]](https://aws.amazon.com/s3/pricing/) を参照してください。
**注記**
ストレージコストを最小限に抑えるため、`AbortIncompleteMultipartUpload` アクションを使用して指定した日数が経過した後に不完全なマルチパートアップロードを削除するようにライフサイクルルールを設定することをお勧めします。不完全なマルチパートアップロードを削除するライフサイクルルールの作成の詳細については、「[不完全なマルチパートアップロードを中止するためのバケットライフサイクルポリシーの設定](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-abort-incomplete-mpu-lifecycle-config.html)」を参照してください。
## マルチパートアップロードの API サポート
*Amazon Simple Storage Service API リファレンス*の以下のセクションでは、マルチパートアップロードの REST API について説明しています。
AWS Lambda 関数を使用するマルチパートアップロードのチュートリアルについては、「[Uploading large objects to Amazon S3 using multipart upload and transfer acceleration](https://aws.amazon.com/blogs/compute/uploading-large-objects-to-amazon-s3-using-multipart-upload-and-transfer-acceleration/)」を参照してください。
+ [マルチパートアップロードの作成](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [Upload Part](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [パートのアップロード (コピー)](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [Complete Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [マルチパートアップロードの中止](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)
+ [パートのリスト](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)
+ [マルチパートアップロードのリスト](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)
## AWS Command Line Interfaceマルチパートアップロードの サポート
マルチパートアップロードのオペレーションについては、AWS Command Line Interface の以下のトピックを参照してください。
+ [Initiate Multipart Upload](https://docs.aws.amazon.com/cli/latest/reference/s3api/create-multipart-upload.html)
+ [Upload Part](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part.html)
+ [パートのアップロード (コピー)](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part-copy.html)
+ [Complete Multipart Upload](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html)
+ [マルチパートアップロードの中止](https://docs.aws.amazon.com/cli/latest/reference/s3api/abort-multipart-upload.html)
+ [パートのリスト](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html)
+ [マルチパートアップロードのリスト](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html)
## AWSマルチパートアップロードの SDK サポート
AWS SDK を使用して、オブジェクトを部分的にアップロードできます。API アクションでサポートされる AWS SDK のリストについては、次を参照してください。
+ [マルチパートアップロードの作成](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [Upload Part](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [パートのアップロード (コピー)](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [Complete Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [マルチパートアップロードの中止](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)
+ [パートのリスト](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)
+ [マルチパートアップロードのリスト](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)
## マルチパートアップロード API とアクセス許可
マルチパートアップロードオペレーションを使用するには、必要なアクセス権限を有している必要があります。マルチパートアップロードオペレーションを実行するためのアクセス許可を付与するには、アクセスコントロールリスト (ACL)、バケットポリシー、ユーザーポリシーを使用できます。ACL、バケットポリシー、またはユーザーポリシーを使用して割り当てることのできる、さまざまなマルチパートアップロードオペレーションに必要なアクセス許可を次の表に示します。
| アクション | 必要なアクセス許可 |
| --- | --- |
| マルチパートアップロードの作成 | マルチパートアップロードのリクエストを作成するには、オブジェクトに対して `s3:PutObject` アクションを実行するための許可が必要です。 バケット所有者は他のプリンシパルに対して `s3:PutObject` アクションの実行を許可できます。 |
| Initiate Multipart Upload | マルチパートアップロードを開始するには、オブジェクトに対して `s3:PutObject` アクションを実行するための許可が必要です。 バケット所有者は他のプリンシパルに対して `s3:PutObject` アクションの実行を許可できます。 |
| イニシエータ | マルチパートアップロード開始者を識別するコンテナエレメント。イニシエータが AWS アカウント である場合、このエレメントは所有者エレメントと同じ情報を提供します。イニシエータが IAM ユーザーである場合、このエレメントはユーザー ARN と表示名を提供します。 |
| Upload Part | パートをアップロードするには、オブジェクトに対して `s3:PutObject` アクションを実行するための許可が必要です。 マルチパートアップロードの開始者がオブジェクトのパートをアップロードできるようにするため、バケット所有者はその開始者に対しオブジェクトへの `s3:PutObject` アクションの実行を許可する必要があります。 |
| パートのアップロード (コピー) | パートをアップロードするには、オブジェクトに対して `s3:PutObject` アクションを実行するための許可が必要です。既存のオブジェクトからパートをアップロードするので、ソースオブジェクトに対して `s3:GetObject` を実行するための許可が必要です。 開始者がオブジェクトのパートをアップロードするには、バケット所有者が、開始者にそのオブジェクトでの `s3:PutObject` アクションの実行を許可する必要があります。 |
| Complete Multipart Upload | マルチパートアップロードを完了するには、オブジェクトに対して `s3:PutObject` アクションを実行するための許可が必要です。 マルチパートアップロードの開始者がオブジェクトのアップロードを完了できるようにするため、バケット所有者はその開始者に対しオブジェクトへの `s3:PutObject` アクションの実行を許可する必要があります。 |
| マルチパートアップロードの中止 | マルチパートアップロードを停止するには、`s3:AbortMultipartUpload` アクションを実行するための許可が必要です。 デフォルトでは、バケット所有者とマルチパートアップロードの開始者が、IAM と S3 バケットポリシーの一部として、このアクションの実行を許可されます。開始者が IAM ユーザーである場合、そのユーザーの AWS アカウント もそのマルチパートアップロードを停止できます。VPC エンドポイントポリシーでは、マルチパートアップロードのイニシエータは、`s3:AbortMultipartUpload` アクションを実行する許可を自動的に取得しません。 このようなデフォルト設定に加え、バケット所有者は他のプリンシパルに対してオブジェクトへの `s3:AbortMultipartUpload` アクションの実行を許可できます。バケット所有者は任意のプリンシパルに対し、`s3:AbortMultipartUpload` アクションを実行する権限を無効にすることができます。 |
| パートのリスト | マルチパートアップロードに含まれるパートをリストするには、`s3:ListMultipartUploadParts` アクションを実行するための許可が必要です。 デフォルトではバケット所有者が、バケットに対する任意のマルチパートアップロードについてパートのリストを許可されています。マルチパートアップロードの開始者は、特定のマルチパートアップロードについてパートのリストを許可されます。マルチパートアップロードの開始者が IAM ユーザーである場合、その IAM ユーザーを管理している AWS アカウント もそのアップロードのパートのリストへのアクセス許可を付与されます。 このようなデフォルト設定に加え、バケット所有者は他のプリンシパルに対してオブジェクトへの `s3:ListMultipartUploadParts` アクションの実行を許可できます。バケット所有者は任意のプリンシパルに対し、`s3:ListMultipartUploadParts` アクションを実行する権限を無効にすることもできます。 |
| マルチパートアップロードのリスト | バケットに対して進行中のマルチパートアップロードをリストするには、そのバケットに対して `s3:ListBucketMultipartUploads` アクションを実行するための許可が必要です。 デフォルト設定に加え、バケット所有者は他のプリンシパルに対してバケットへの `s3:ListBucketMultipartUploads` アクションの実行を許可できます。 |
| AWS KMS 暗号化および復号関連のアクセス許可 | AWS Key Management Service (AWS KMS) KMS キーを使用した暗号化を伴うマルチパートアップロードを実行するには、リクエスタに以下のアクセス許可が必要です。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/AmazonS3/latest/userguide/mpuoverview.html) マルチパートアップロードを完了する前に、暗号化されたファイル部分からデータを復号して読み取る必要があるため、Amazon S3 にはこれらの許可が必要です。また、オブジェクトのチェックサム値を取得するには、`kms:Decrypt` アクセス許可と、お客様が提供した暗号化キーによるサーバー側の暗号化も必要です。[https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html) API の使用時にこれらの必要なアクセス許可がない場合、オブジェクトはチェックサム値なしで作成されます。 IAM ユーザーまたはロールが KMS キーと同じ AWS アカウントにある場合、キーと IAM ポリシーの両方にアクセス許可があることを確認してください。IAM ユーザーまたはロールが KMS キーとは異なるアカウントに属している場合、キーポリシーと IAM ユーザーまたはロールの両方に対する許可が必要です。 |
| SSE-C (お客様が用意した暗号化キーによるサーバー側の暗号化) | [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html) API を使用する場合は、SSE-C (お客様が用意した暗号化キーによるサーバー側の暗号化) を指定する必要があります。指定しない場合、オブジェクトはチェックサムなしで作成され、チェックサム値は返されません。 |
ACL アクセス権限とアクセスポリシーのアクセス許可との関係については、[ACL アクセス許可とアクセスポリシーのアクセス許可のマッピング](acl-overview.md#acl-access-policy-permission-mapping) を参照してください。IAM ユーザー、グループ、ロール、ベストプラクティスの詳細については、「*IAM ユーザーガイド*」の「[IAM ID (ユーザー、グループ、ロール)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html)」を参照してください。
## マルチパートアップロードオペレーションを使用したチェックサム
実際のマルチパートアップロードを実行するために使用される Amazon S3 API は [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)、および [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html) の 3 つです。次の表は、各 API に提供する必要があるチェックサムヘッダーと値を示しています。
| チェックサムアルゴリズム | チェックサムタイプ | `CreateMultipartUpload` | `UploadPart` | `CompleteMultipartUpoad` |
| --- | --- | --- | --- | --- |
| CRC-64/NVME (`CRC64NVME`) | フルオブジェクト | 必要なヘッダー: `x-amz-checksum-algorithm` | オプションヘッダー: `x-amz-checksum-crc64nvme` | オプションヘッダー: `x-amz-checksum-algorithm` `x-amz-crc64` |
| CRC-32 (`CRC32`) CRC 32-C (`CRC32C`) | フルオブジェクト | 必要なヘッダー: `x-amz-checksum-algorithm` `x-amz-checksum-type` | オプションヘッダー: `x-amz-checksum-crc64nvme` | オプションヘッダー: `x-amz-checksum-algorithm` `x-amz-crc32` `x-amz-crc32c` |
| CRC-32 (`CRC32`) CRC-32C (`CRC32C`) SHA-1 (`SHA1`) SHA-256 (`SHA256`) | 複合 | 必要なヘッダー: `x-amz-checksum-algorithm` | 必要なヘッダー: `x-amz-checksum-crc32` `x-amz-checksum-crc32c` `x-amz-checksum-sha1` `x-amz-checksum-sha256` | 必要なヘッダー: すべてのパートレベルのチェックサムを `CompleteMultiPartUpload` リクエストに含める必要があります。 オプションヘッダー: `x-amz-crc32` `x-amz-crc32c` `x-amz-sha1` `x-amz-sha256` |
**Topics**
+ [
## マルチパートアップロードのプロセス
](#mpu-process)
+ [
## マルチパートアップロードオペレーションを使用したチェックサム
](#mpuchecksums)
+ [
## マルチパートアップロードの同時オペレーション
](#distributedmpupload)
+ [
## マルチパートアップロード中に同じキー名を持つオブジェクトのアップロードを禁止する
](#multipart-upload-objects-with-same-key-name)
+ [
## マルチパートアップロードと料金
](#mpuploadpricing)
+ [
## マルチパートアップロードの API サポート
](#apisupportformpu)
+ [
## AWS Command Line Interfaceマルチパートアップロードの サポート
](#clisupportformpu)
+ [
## AWSマルチパートアップロードの SDK サポート
](#sdksupportformpu)
+ [
## マルチパートアップロード API とアクセス許可
](#mpuAndPermissions)
+ [
## マルチパートアップロードオペレーションを使用したチェックサム
](#Checksums-mpu-operations)
+ [
# 不完全なマルチパートアップロードを削除するためのバケットライフサイクル設定の設定
](mpu-abort-incomplete-mpu-lifecycle-config.md)
+ [
# マルチパートアップロードを使用したオブジェクトのアップロード
](mpu-upload-object.md)
+ [
# 高レベルの .NET TransferUtility クラスを使用してディレクトリをアップロードする
](HLuploadDirDotNet.md)
+ [
# マルチパートアップロードのリスト化
](list-mpu.md)
+ [
# AWS SDK を使用したマルチパートアップロードの追跡
](track-mpu.md)
+ [
# マルチパートアップロードの中止
](abort-mpu.md)
+ [
# マルチパートアップロードを使用したオブジェクトのコピー
](CopyingObjectsMPUapi.md)
+ [
# チュートリアル: マルチパートアップロードでオブジェクトをアップロードして、データ整合性を検証する
](tutorial-s3-mpu-additional-checksums.md)
+ [
# Amazon S3 マルチパートアップロードの制限
](qfacts.md)
# 不完全なマルチパートアップロードを削除するためのバケットライフサイクル設定の設定
ベストプラクティスとして、ストレージコストを最小限に抑えるため、`AbortIncompleteMultipartUpload` アクションを使用してライフサイクルルールを設定することをお勧めします。マルチパートアップロードを中止する方法の詳細については、[マルチパートアップロードの中止](abort-mpu.md) を参照してください。
Amazon S3 は、バケットライフサイクルルールをサポートしています。このルールを使用すると、開始後指定された日数内に完了しないマルチパートアップロードを停止するよう Amazon S3 に指示できます。マルチパートアップロードが指定された時間内に完了しない場合、中止操作の対象となります。Amazon S3 は、マルチパートアップロードを中止し、マルチパートアップロードに関連付けられているすべてのパートを削除します。このルールは、既存のマルチパートアップロードと後で作成するマルチパートアップロードの両方に適用されます。
`AbortIncompleteMultipartUpload` アクションにルールを指定するライフサイクル設定の例を次に示します。
```
sample-rule
Enabled
7
```
この例のルールでは、`Prefix` エレメントの値 ([オブジェクトキー名のプレフィックス](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#keyprefix)) を指定しません。したがって、これはマルチパートアップロードを開始したバケット内のすべてのオブジェクトに適用されます。開始されてから 7 日以内に完了しなかったマルチパートアップロード、中止オペレーションのターゲットとなります。中止アクションは、完了したマルチパートアップロードに影響を与えません。
バケットライフサイクル設定についての詳細は、[オブジェクトのライフサイクルの管理](object-lifecycle-mgmt.md) を参照してください。
**注記**
マルチパートアップロードが、ルールで指定された日数内に完了した場合、`AbortIncompleteMultipartUpload` ライフサイクルアクションは適用されません (つまり Amazon S3 はアクションを実行しません)。また、このアクションはオブジェクトには適用されません。このライフサイクルアクションによって削除されるオブジェクトはありません。また、不完全なマルチパートアップロード部分を削除しても、S3 ライフサイクルの早期削除料金は発生しません。
## S3 コンソールの使用
未完了のマルチパートアップロードを自動的に管理するため、S3 コンソールを使用して、指定された日数後にバケットから未完了のマルチパートアップロードのバイトを失効させるライフサイクルポリシーを作成できます。次の手順は、7 日後に未完了のマルチパートアップロードを削除するためのライフサイクルルールを追加する方法を示しています。ライフサイクルルールの追加に関する詳細については、「[バケットに S3 ライフサイクル設定を設定する](how-to-set-lifecycle-configuration-intro.md)」を参照してください。
**7 日以上経過した未完了のマルチパートアップロードを中止するライフサイクルルールを追加するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. [**Buckets (バケット)**] リストで、ライフサイクルルールを作成するバケットの名前を選択します。
1. [**Management (管理)**] タブを選択して、[**Create lifecycle rule (ライフサイクルルールを作成する)**] を選択します。
1. [**Lifecycle rule name (ライフサイクルルール名)**] に、ルールの名前を入力します。
その名前はバケット内で一意である必要があります。
1. ライフサイクルルールのスコープを選択します。
+ 特定のプレフィックスを持つすべてのオブジェクトに対してライフサイクルルールを作成するには、**[1 つまたは複数のフィルタを使用してこのルールの適用範囲を制限]** を選択し、**[プレフィックス]** にプレフィックスを入力します。
+ このライフサイクルルールをバケット内のすべてのオブジェクトに作成するには、**[This rule applies to **all** objects in the bucket]** (このルールをバケット内のすべてのオブジェクトに適用する) を選択して、**[I acknowledge that this lifecycle rule will apply to all objects in the bucket]** (このライフサイクルルールがバケット内のすべてのオブジェクトに適用されることを了承します) を選択します。
1. **[Lifecycle rule actions]** (ライフサイクルルールアクション) で、**[Delete expired object delete markers or incomplete multipart uploads]** (期限切れのオブジェクト削除マーカーまたは未完了のマルチパートアップロードを削除) を選択します。
1. **[Delete expired object delete markers or incomplete multipart uploads]** (期限切れオブジェクト削除マーカーまたは未完了のマルチパートアップロードを削除する) で、**[Delete incomplete multipart uploads]** (未完了のマルチパートアップロードを削除) を選択します。
1. **[Number of days]** (日数) フィールドに、未完了のマルチパートアップロードを削除するまでの日数 (この例では 7 日) を入力します。
1. [**Create rule**] を選択してください。
## の使用AWS CLI
以下の `put-bucket-lifecycle-configuration` AWS Command Line Interface (AWS CLI) コマンドは、指定したバケットのライフサイクル設定を追加します。このコマンドを使用するには、`user input placeholders` を自分の情報に置き換えます。
```
aws s3api put-bucket-lifecycle-configuration \
--bucket amzn-s3-demo-bucket \
--lifecycle-configuration filename-containing-lifecycle-configuration
```
次の例は、AWS CLI を使用して未完了のマルチパートアップロードを中止するライフサイクルルールを追加する方法を示しています。これには、7 日以上経過した未完了のマルチパートアップロードを中止する JSON ライフサイクル設定の例が含まれています。
この例の CLI コマンドを使用するには、`user input placeholders` を自分の情報に置き換えてください。
**未完了のマルチパートアップロードを中止するためのライフサイクルルールを追加するには**
1. AWS CLI のセットアップ。手順については、「Amazon S3 API リファレンス」の「[Developing with Amazon S3 using the AWS CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/setup-aws-cli.html)」を参照してください。**
1. 次のサンプルライフサイクル設定をファイル (例、*`lifecycle.json`*``) に保存します。このサンプル設定では、空のプレフィックスが指定されているため、バケット内のすべてのオブジェクトに適用されます。設定がオブジェクトのサブセットに制限されるようにプレフィックスを指定できます。
```
{
"Rules": [
{
"ID": "Test Rule",
"Status": "Enabled",
"Filter": {
"Prefix": ""
},
"AbortIncompleteMultipartUpload": {
"DaysAfterInitiation": 7
}
}
]
}
```
1. 次の CLI コマンドを実行して、バケットにこのライフサイクル設定を指定します。
```
aws s3api put-bucket-lifecycle-configuration \
--bucket amzn-s3-demo-bucket \
--lifecycle-configuration file://lifecycle.json
```
1. ライフサイクル設定がバケットに設定されていることを確認するには、次の `get-bucket-lifecycle` コマンドを使用してライフサイクル設定を取得します。
```
aws s3api get-bucket-lifecycle \
--bucket amzn-s3-demo-bucket
```
1. ライフサイクル設定を削除するには、次の `delete-bucket-lifecycle` コマンドを使用します。
```
aws s3api delete-bucket-lifecycle \
--bucket amzn-s3-demo-bucket
```
# マルチパートアップロードを使用したオブジェクトのアップロード
マルチパートアップロードを使用して、プログラムで 1 つのオブジェクトを Amazon S3 にアップロードできます。各オブジェクトは一連のパートとしてアップロードされます。各パートは、オブジェクトのデータの連続する部分です。これらのオブジェクトパートは、任意の順序で個別にアップロードできます。いずれかのパートの送信が失敗すると、他のパートに影響を与えることなくそのパートを再送することができます。オブジェクトのすべてのパートがアップロードされたら、Amazon S3 はこれらのパートを組み立ててオブジェクトを作成します。匿名ユーザーはマルチパートアップロードを開始できません。
マルチパートアップロードで追加のチェックサムを含むオブジェクトをアップロードするエンドツーエンドの手順については、「[チュートリアル: マルチパートアップロードでオブジェクトをアップロードして、データ整合性を検証する](tutorial-s3-mpu-additional-checksums.md)」を参照してください。
次のセクションでは、AWS Command Line Interface、AWS SDK でマルチパートアップロードを使用する方法を示します。
## S3 コンソールの使用
ファイルタイプ (イメージ、バックアップ、データ、ムービーなど) を問わず、各種のファイルを S3 バケットにアップロードできます。Amazon S3 コンソールを使用すると、アップロードできるファイルの最大サイズが 160 GB になります。160 GB を超えるファイルをアップロードするには、AWS Command Line Interface (AWS CLI)、AWS SDK、または Amazon S3 REST API を使用します。
AWS マネジメントコンソール でオブジェクトをアップロードする手順については、「[オブジェクトのアップロード](upload-objects.md)」を参照してください。
## の使用AWS CLI
AWS CLI を使用したマルチパートアップロードの Amazon S3 オペレーションについては、以下で説明しています。
+ [Initiate Multipart Upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-multipart-upload.html)
+ [Upload Part](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part.html)
+ [パートのアップロード (コピー)](https://docs.aws.amazon.com/cli/latest/reference/s3api/upload-part-copy.html)
+ [Complete Multipart Upload](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html)
+ [マルチパートアップロードの中止](https://docs.aws.amazon.com/cli/latest/reference/s3api/abort-multipart-upload.html)
+ [パートのリスト](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html)
+ [マルチパートアップロードのリスト](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html)
## REST API の使用
*Amazon Simple Storage Service API リファレンス*の以下のセクションでは、マルチパートアップロードの REST API について説明しています。
+ [Initiate Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ [ パートのアップロード](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)
+ [ マルチパートアップロードの完了](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ [マルチパートアップロードの中止](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadAbort.html)
+ [パートのリスト](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListParts.html)
+ [マルチパートアップロードのリスト](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListMPUpload.html)
## AWS SDK (高レベル API) の使用
一部の AWS SDK は、マルチパートアップロードを完了するために必要なさまざまな API オペレーションを 1 つのオペレーションに結合することで、マルチパートアップロードを簡素化する高レベル API を公開しています。詳細については、「[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md)」を参照してください。
マルチパートアップロードを一時停止して再開する場合、アップロード中にパートサイズを変更する場合、またはデータのサイズが事前にわからない場合は、低レベル API メソッドを使用します。マルチパートアップロード用の低レベル API メソッドは、追加の機能も提供します。詳細については、「[AWS SDK の使用 (低レベル API)](#mpu-upload-low-level)」を参照してください。
------
#### [ Java ]
AWS SDK for Java を使用してマルチパートアップロードを実行する方法の例については、「*Amazon S3 API リファレンス*」の「[Upload or download large files to and from Amazon S3 using an AWS SDK](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_Scenario_UsingLargeFiles_section.html)」を参照してください。
------
#### [ .NET ]
S3 バケットにファイルをアップロードするには、`TransferUtility` クラスを使用します。ファイルからデータをアップロードする場合は、オブジェクトのキー名を指定する必要があります。指定しないと、API ではキー名としてファイル名を使用します。ストリームからデータをアップロードする場合は、オブジェクトのキー名を指定する必要があります。
高度なアップロードオプション (パートのサイズ、複数のパーツを同時にアップロードする際のスレッド数、メタデータ、ストレージクラス、ACL など) を設定するには、`TransferUtilityUploadRequest` クラスを使用します。
**注記**
データのソースにストリームを使っている場合、`TransferUtility` クラスは同時アップロードを実行しません。
次の C\$1 の例では、ファイルを複数のパートに分割して Amazon S3 バケットにアップロードします。さまざまな `TransferUtility.Upload` オーバーロードを使用してファイルをアップロードする方法を示します。後続のアップロード呼び出しが行われるたびに、前のアップロードが置き換えられます。コード例を設定および実行する方法の詳細については、「*AWS SDK for .NET デベロッパーガイド*」の「[AWS SDK for .NET の開始方法](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html)」 を参照してください。
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadFileMPUHighLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
private const string keyName = "*** provide a name for the uploaded object ***";
private const string filePath = "*** provide the full path name of the file to upload ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
UploadFileAsync().Wait();
}
private static async Task UploadFileAsync()
{
try
{
var fileTransferUtility =
new TransferUtility(s3Client);
// Option 1. Upload a file. The file name is used as the object key name.
await fileTransferUtility.UploadAsync(filePath, bucketName);
Console.WriteLine("Upload 1 completed");
// Option 2. Specify object key name explicitly.
await fileTransferUtility.UploadAsync(filePath, bucketName, keyName);
Console.WriteLine("Upload 2 completed");
// Option 3. Upload data from a type of System.IO.Stream.
using (var fileToUpload =
new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
await fileTransferUtility.UploadAsync(fileToUpload,
bucketName, keyName);
}
Console.WriteLine("Upload 3 completed");
// Option 4. Specify advanced settings.
var fileTransferUtilityRequest = new TransferUtilityUploadRequest
{
BucketName = bucketName,
FilePath = filePath,
StorageClass = S3StorageClass.StandardInfrequentAccess,
PartSize = 6291456, // 6 MB.
Key = keyName,
CannedACL = S3CannedACL.PublicRead
};
fileTransferUtilityRequest.Metadata.Add("param1", "Value1");
fileTransferUtilityRequest.Metadata.Add("param2", "Value2");
await fileTransferUtility.UploadAsync(fileTransferUtilityRequest);
Console.WriteLine("Upload 4 completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
------
#### [ JavaScript ]
**Example**
サイズの大きいファイルをアップロードします。
```
import { S3Client } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
import {
ProgressBar,
logger,
} from "@aws-doc-sdk-examples/lib/utils/util-log.js";
const twentyFiveMB = 25 * 1024 * 1024;
export const createString = (size = twentyFiveMB) => {
return "x".repeat(size);
};
/**
* Create a 25MB file and upload it in parts to the specified
* Amazon S3 bucket.
* @param {{ bucketName: string, key: string }}
*/
export const main = async ({ bucketName, key }) => {
const str = createString();
const buffer = Buffer.from(str, "utf8");
const progressBar = new ProgressBar({
description: `Uploading "${key}" to "${bucketName}"`,
barLength: 30,
});
try {
const upload = new Upload({
client: new S3Client({}),
params: {
Bucket: bucketName,
Key: key,
Body: buffer,
},
});
upload.on("httpUploadProgress", ({ loaded, total }) => {
progressBar.update({ current: loaded, total });
});
await upload.done();
} catch (caught) {
if (caught instanceof Error && caught.name === "AbortError") {
logger.error(`Multipart upload was aborted. ${caught.message}`);
} else {
throw caught;
}
}
};
```
**Example**
サイズの大きいファイルをダウンロードします。
```
import { fileURLToPath } from "node:url";
import { GetObjectCommand, NoSuchKey, S3Client } from "@aws-sdk/client-s3";
import { createWriteStream, rmSync } from "node:fs";
const s3Client = new S3Client({});
const oneMB = 1024 * 1024;
export const getObjectRange = ({ bucket, key, start, end }) => {
const command = new GetObjectCommand({
Bucket: bucket,
Key: key,
Range: `bytes=${start}-${end}`,
});
return s3Client.send(command);
};
/**
* @param {string | undefined} contentRange
*/
export const getRangeAndLength = (contentRange) => {
const [range, length] = contentRange.split("/");
const [start, end] = range.split("-");
return {
start: Number.parseInt(start),
end: Number.parseInt(end),
length: Number.parseInt(length),
};
};
export const isComplete = ({ end, length }) => end === length - 1;
const downloadInChunks = async ({ bucket, key }) => {
const writeStream = createWriteStream(
fileURLToPath(new URL(`./${key}`, import.meta.url)),
).on("error", (err) => console.error(err));
let rangeAndLength = { start: -1, end: -1, length: -1 };
while (!isComplete(rangeAndLength)) {
const { end } = rangeAndLength;
const nextRange = { start: end + 1, end: end + oneMB };
const { ContentRange, Body } = await getObjectRange({
bucket,
key,
...nextRange,
});
console.log(`Downloaded bytes ${nextRange.start} to ${nextRange.end}`);
writeStream.write(await Body.transformToByteArray());
rangeAndLength = getRangeAndLength(ContentRange);
}
};
/**
* Download a large object from and Amazon S3 bucket.
*
* When downloading a large file, you might want to break it down into
* smaller pieces. Amazon S3 accepts a Range header to specify the start
* and end of the byte range to be downloaded.
*
* @param {{ bucketName: string, key: string }}
*/
export const main = async ({ bucketName, key }) => {
try {
await downloadInChunks({
bucket: bucketName,
key: key,
});
} catch (caught) {
if (caught instanceof NoSuchKey) {
console.error(`Failed to download object. No such key "${key}".`);
rmSync(key);
}
}
};
```
------
#### [ Go ]
マルチパートアップロードの Go コード例の詳細については、「[Upload or download large files to and from Amazon S3 using an AWS SDK](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_Scenario_UsingLargeFiles_section.html)」を参照してください。
**Example**
アップロードマネージャーを使用してデータを分割し、同時にアップロードすることで、大きなオブジェクトをアップロードすることができます。
```
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"log"
"os"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/aws-sdk-go-v2/service/s3/types"
"github.com/aws/smithy-go"
)
// BucketBasics encapsulates the Amazon Simple Storage Service (Amazon S3) actions
// used in the examples.
// It contains S3Client, an Amazon S3 service client that is used to perform bucket
// and object actions.
type BucketBasics struct {
S3Client *s3.Client
}
```
```
// UploadLargeObject uses an upload manager to upload data to an object in a bucket.
// The upload manager breaks large data into parts and uploads the parts concurrently.
func (basics BucketBasics) UploadLargeObject(ctx context.Context, bucketName string, objectKey string, largeObject []byte) error {
largeBuffer := bytes.NewReader(largeObject)
var partMiBs int64 = 10
uploader := manager.NewUploader(basics.S3Client, func(u *manager.Uploader) {
u.PartSize = partMiBs * 1024 * 1024
})
_, err := uploader.Upload(ctx, &s3.PutObjectInput{
Bucket: aws.String(bucketName),
Key: aws.String(objectKey),
Body: largeBuffer,
})
if err != nil {
var apiErr smithy.APIError
if errors.As(err, &apiErr) && apiErr.ErrorCode() == "EntityTooLarge" {
log.Printf("Error while uploading object to %s. The object is too large.\n"+
"The maximum size for a multipart upload is 5TB.", bucketName)
} else {
log.Printf("Couldn't upload large object to %v:%v. Here's why: %v\n",
bucketName, objectKey, err)
}
} else {
err = s3.NewObjectExistsWaiter(basics.S3Client).Wait(
ctx, &s3.HeadObjectInput{Bucket: aws.String(bucketName), Key: aws.String(objectKey)}, time.Minute)
if err != nil {
log.Printf("Failed attempt to wait for object %s to exist.\n", objectKey)
}
}
return err
}
```
**Example**
ダウンロードマネージャーを使用して、データを分割して取得し、同時にダウンロードすることで、大きなオブジェクトをダウンロードすることができます。
```
// DownloadLargeObject uses a download manager to download an object from a bucket.
// The download manager gets the data in parts and writes them to a buffer until all of
// the data has been downloaded.
func (basics BucketBasics) DownloadLargeObject(ctx context.Context, bucketName string, objectKey string) ([]byte, error) {
var partMiBs int64 = 10
downloader := manager.NewDownloader(basics.S3Client, func(d *manager.Downloader) {
d.PartSize = partMiBs * 1024 * 1024
})
buffer := manager.NewWriteAtBuffer([]byte{})
_, err := downloader.Download(ctx, buffer, &s3.GetObjectInput{
Bucket: aws.String(bucketName),
Key: aws.String(objectKey),
})
if err != nil {
log.Printf("Couldn't download large object from %v:%v. Here's why: %v\n",
bucketName, objectKey, err)
}
return buffer.Bytes(), err
}
```
------
#### [ PHP ]
このトピックでは、マルチパートファイルのアップロードの `Aws\S3\Model\MultipartUpload\UploadBuilder` からの高レベルの AWS SDK for PHP クラスを使用する方法について説明します。AWS SDK for Ruby API の詳細については、[AWS SDK for Ruby - バージョン 2](https://docs.aws.amazon.com/sdkforruby/api/index.html) を参照してください。
以下の PHP サンプルは、ファイルを Amazon S3 バケットにアップロードします。この例では、`MultipartUploader` オブジェクトのパラメータを設定する方法を示します。
```
require 'vendor/autoload.php';
use Aws\Exception\MultipartUploadException;
use Aws\S3\MultipartUploader;
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Prepare the upload parameters.
$uploader = new MultipartUploader($s3, '/path/to/large/file.zip', [
'bucket' => $bucket,
'key' => $keyname
]);
// Perform the upload.
try {
$result = $uploader->upload();
echo "Upload complete: {$result['ObjectURL']}" . PHP_EOL;
} catch (MultipartUploadException $e) {
echo $e->getMessage() . PHP_EOL;
}
```
------
#### [ Python ]
次の例では、高レベルマルチパートアップロード Python API (`TransferManager` クラス) を使用して、オブジェクトをロードします。
```
import sys
import threading
import boto3
from boto3.s3.transfer import TransferConfig
MB = 1024 * 1024
s3 = boto3.resource("s3")
class TransferCallback:
"""
Handle callbacks from the transfer manager.
The transfer manager periodically calls the __call__ method throughout
the upload and download process so that it can take action, such as
displaying progress to the user and collecting data about the transfer.
"""
def __init__(self, target_size):
self._target_size = target_size
self._total_transferred = 0
self._lock = threading.Lock()
self.thread_info = {}
def __call__(self, bytes_transferred):
"""
The callback method that is called by the transfer manager.
Display progress during file transfer and collect per-thread transfer
data. This method can be called by multiple threads, so shared instance
data is protected by a thread lock.
"""
thread = threading.current_thread()
with self._lock:
self._total_transferred += bytes_transferred
if thread.ident not in self.thread_info.keys():
self.thread_info[thread.ident] = bytes_transferred
else:
self.thread_info[thread.ident] += bytes_transferred
target = self._target_size * MB
sys.stdout.write(
f"\r{self._total_transferred} of {target} transferred "
f"({(self._total_transferred / target) * 100:.2f}%)."
)
sys.stdout.flush()
def upload_with_default_configuration(
local_file_path, bucket_name, object_key, file_size_mb
):
"""
Upload a file from a local folder to an Amazon S3 bucket, using the default
configuration.
"""
transfer_callback = TransferCallback(file_size_mb)
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, Callback=transfer_callback
)
return transfer_callback.thread_info
def upload_with_chunksize_and_meta(
local_file_path, bucket_name, object_key, file_size_mb, metadata=None
):
"""
Upload a file from a local folder to an Amazon S3 bucket, setting a
multipart chunk size and adding metadata to the Amazon S3 object.
The multipart chunk size controls the size of the chunks of data that are
sent in the request. A smaller chunk size typically results in the transfer
manager using more threads for the upload.
The metadata is a set of key-value pairs that are stored with the object
in Amazon S3.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_chunksize=1 * MB)
extra_args = {"Metadata": metadata} if metadata else None
s3.Bucket(bucket_name).upload_file(
local_file_path,
object_key,
Config=config,
ExtraArgs=extra_args,
Callback=transfer_callback,
)
return transfer_callback.thread_info
def upload_with_high_threshold(local_file_path, bucket_name, object_key, file_size_mb):
"""
Upload a file from a local folder to an Amazon S3 bucket, setting a
multipart threshold larger than the size of the file.
Setting a multipart threshold larger than the size of the file results
in the transfer manager sending the file as a standard upload instead of
a multipart upload.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_threshold=file_size_mb * 2 * MB)
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def upload_with_sse(
local_file_path, bucket_name, object_key, file_size_mb, sse_key=None
):
"""
Upload a file from a local folder to an Amazon S3 bucket, adding server-side
encryption with customer-provided encryption keys to the object.
When this kind of encryption is specified, Amazon S3 encrypts the object
at rest and allows downloads only when the expected encryption key is
provided in the download request.
"""
transfer_callback = TransferCallback(file_size_mb)
if sse_key:
extra_args = {"SSECustomerAlgorithm": "AES256", "SSECustomerKey": sse_key}
else:
extra_args = None
s3.Bucket(bucket_name).upload_file(
local_file_path, object_key, ExtraArgs=extra_args, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_default_configuration(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, using the
default configuration.
"""
transfer_callback = TransferCallback(file_size_mb)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_single_thread(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, using a
single thread.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(use_threads=False)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_high_threshold(
bucket_name, object_key, download_file_path, file_size_mb
):
"""
Download a file from an Amazon S3 bucket to a local folder, setting a
multipart threshold larger than the size of the file.
Setting a multipart threshold larger than the size of the file results
in the transfer manager sending the file as a standard download instead
of a multipart download.
"""
transfer_callback = TransferCallback(file_size_mb)
config = TransferConfig(multipart_threshold=file_size_mb * 2 * MB)
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, Config=config, Callback=transfer_callback
)
return transfer_callback.thread_info
def download_with_sse(
bucket_name, object_key, download_file_path, file_size_mb, sse_key
):
"""
Download a file from an Amazon S3 bucket to a local folder, adding a
customer-provided encryption key to the request.
When this kind of encryption is specified, Amazon S3 encrypts the object
at rest and allows downloads only when the expected encryption key is
provided in the download request.
"""
transfer_callback = TransferCallback(file_size_mb)
if sse_key:
extra_args = {"SSECustomerAlgorithm": "AES256", "SSECustomerKey": sse_key}
else:
extra_args = None
s3.Bucket(bucket_name).Object(object_key).download_file(
download_file_path, ExtraArgs=extra_args, Callback=transfer_callback
)
return transfer_callback.thread_info
```
------
## AWS SDK の使用 (低レベル API)
AWS SDK は、Amazon S3 REST API に非常によく似たマルチパートアップロード用の下位 API を公開しています ([Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md) を参照)。マルチパートアップロードを一時停止して再開する必要がある場合やアップロード中にパートサイズを変更する場合、またはアップロードデータのサイズが事前にわからない場合は、低レベル API を使用します。これらの要件がない場合は、高レベル API ([AWS SDK (高レベル API) の使用](#multipart-upload-high-level) を参照) を使用します。
------
#### [ Java ]
次の例では、低レベル Java クラスを使用してファイルをアップロードする方法を示します。以下のステップが実行されます。
+ `AmazonS3Client.initiateMultipartUpload()` メソッドを使用してマルチパートアップロードを開始し、`InitiateMultipartUploadRequest` オブジェクトを渡します。
+ `AmazonS3Client.initiateMultipartUpload()` メソッドが返すアップロード ID を保存します。以降、マルチパートアップロードオペレーションのたびに、このアップロード ID を指定する必要があります。
+ オブジェクトのパートをアップロードします。パートごとに、`AmazonS3Client.uploadPart()` メソッドを呼び出します。`UploadPartRequest` オブジェクトを使用して、パートアップロード情報を指定します。
+ 各パートで、リストの `AmazonS3Client.uploadPart()` メソッドのレスポンスから ETag を保存します。ETag 値を使用して、マルチパートアップロードを完了します。
+ `AmazonS3Client.completeMultipartUpload()` メソッドを呼び出して、マルチパートアップロードを完了します。
**Example**
作業サンプルの作成およびテストの手順については、「AWS SDK for Java のデベロッパーガイド」の「[使用開始](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html)」を参照してください。
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class LowLevelMultipartUpload {
public static void main(String[] args) throws IOException {
Regions clientRegion = Regions.DEFAULT_REGION;
String bucketName = "*** Bucket name ***";
String keyName = "*** Key name ***";
String filePath = "*** Path to file to upload ***";
File file = new File(filePath);
long contentLength = file.length();
long partSize = 5 * 1024 * 1024; // Set part size to 5 MB.
try {
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withRegion(clientRegion)
.withCredentials(new ProfileCredentialsProvider())
.build();
// Create a list of ETag objects. You retrieve ETags for each object part
// uploaded,
// then, after each individual part has been uploaded, pass the list of ETags to
// the request to complete the upload.
List partETags = new ArrayList();
// Initiate the multipart upload.
InitiateMultipartUploadRequest initRequest = new InitiateMultipartUploadRequest(bucketName, keyName);
InitiateMultipartUploadResult initResponse = s3Client.initiateMultipartUpload(initRequest);
// Upload the file parts.
long filePosition = 0;
for (int i = 1; filePosition < contentLength; i++) {
// Because the last part could be less than 5 MB, adjust the part size as
// needed.
partSize = Math.min(partSize, (contentLength - filePosition));
// Create the request to upload a part.
UploadPartRequest uploadRequest = new UploadPartRequest()
.withBucketName(bucketName)
.withKey(keyName)
.withUploadId(initResponse.getUploadId())
.withPartNumber(i)
.withFileOffset(filePosition)
.withFile(file)
.withPartSize(partSize);
// Upload the part and add the response's ETag to our list.
UploadPartResult uploadResult = s3Client.uploadPart(uploadRequest);
partETags.add(uploadResult.getPartETag());
filePosition += partSize;
}
// Complete the multipart upload.
CompleteMultipartUploadRequest compRequest = new CompleteMultipartUploadRequest(bucketName, keyName,
initResponse.getUploadId(), partETags);
s3Client.completeMultipartUpload(compRequest);
} catch (AmazonServiceException e) {
// The call was transmitted successfully, but Amazon S3 couldn't process
// it, so it returned an error response.
e.printStackTrace();
} catch (SdkClientException e) {
// Amazon S3 couldn't be contacted for a response, or the client
// couldn't parse the response from Amazon S3.
e.printStackTrace();
}
}
}
```
------
#### [ .NET ]
次の C\$1 の例では、低レベルの SDK for .NET マルチパートアップロード API を使用して S3 バケットにファイルをアップロードする方法を示します。Amazon S3 のマルチパートアップロードの詳細については、[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md) を参照してください。
**注記**
SDK for .NET API を使用して大きなオブジェクトをアップロードする場合、リクエストストリームへのデータの書き込み中に、タイムアウトが発生することがあります。`UploadPartRequest` を使用して、明示的なタイムアウトを設定できます。
次 C\$1 の例では、低レベルのマルチパートアップロード API を使用して S3 バケットにファイルをアップロードします。コード例を設定および実行する方法の詳細については、「*AWS SDK for .NET デベロッパーガイド*」の「[AWS SDK for .NET の開始方法](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html)」 を参照してください。
```
using Amazon;
using Amazon.Runtime;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadFileMPULowLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
private const string keyName = "*** provide a name for the uploaded object ***";
private const string filePath = "*** provide the full path name of the file to upload ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
Console.WriteLine("Uploading an object");
UploadObjectAsync().Wait();
}
private static async Task UploadObjectAsync()
{
// Create list to store upload part responses.
List uploadResponses = new List();
// Setup information required to initiate the multipart upload.
InitiateMultipartUploadRequest initiateRequest = new InitiateMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName
};
// Initiate the upload.
InitiateMultipartUploadResponse initResponse =
await s3Client.InitiateMultipartUploadAsync(initiateRequest);
// Upload parts.
long contentLength = new FileInfo(filePath).Length;
long partSize = 5 * (long)Math.Pow(2, 20); // 5 MB
try
{
Console.WriteLine("Uploading parts");
long filePosition = 0;
for (int i = 1; filePosition < contentLength; i++)
{
UploadPartRequest uploadRequest = new UploadPartRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId,
PartNumber = i,
PartSize = partSize,
FilePosition = filePosition,
FilePath = filePath
};
// Track upload progress.
uploadRequest.StreamTransferProgress +=
new EventHandler(UploadPartProgressEventCallback);
// Upload a part and add the response to our list.
uploadResponses.Add(await s3Client.UploadPartAsync(uploadRequest));
filePosition += partSize;
}
// Setup to complete the upload.
CompleteMultipartUploadRequest completeRequest = new CompleteMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
completeRequest.AddPartETags(uploadResponses);
// Complete the upload.
CompleteMultipartUploadResponse completeUploadResponse =
await s3Client.CompleteMultipartUploadAsync(completeRequest);
}
catch (Exception exception)
{
Console.WriteLine("An AmazonS3Exception was thrown: { 0}", exception.Message);
// Abort the upload.
AbortMultipartUploadRequest abortMPURequest = new AbortMultipartUploadRequest
{
BucketName = bucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
await s3Client.AbortMultipartUploadAsync(abortMPURequest);
}
}
public static void UploadPartProgressEventCallback(object sender, StreamTransferProgressArgs e)
{
// Process event.
Console.WriteLine("{0}/{1}", e.TransferredBytes, e.TotalBytes);
}
}
}
```
------
#### [ PHP ]
このトピックガイドでは、`uploadPart` のバージョン 3 から低レベルの AWS SDK for PHP メソッドを使用してファイルを複数のパートに分割してアップロードする方法について説明します。AWS SDK for Ruby API の詳細については、[AWS SDK for Ruby - バージョン 2](https://docs.aws.amazon.com/sdkforruby/api/index.html) を参照してください。
次の PHP の例では、下位の PHP API マルチパートアップロードを使用して、Amazon S3 バケットにファイルをアップロードします。
```
require 'vendor/autoload.php';
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$filename = '*** Path to and Name of the File to Upload ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
$result = $s3->createMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'StorageClass' => 'REDUCED_REDUNDANCY',
'Metadata' => [
'param1' => 'value 1',
'param2' => 'value 2',
'param3' => 'value 3'
]
]);
$uploadId = $result['UploadId'];
// Upload the file in parts.
try {
$file = fopen($filename, 'r');
$partNumber = 1;
while (!feof($file)) {
$result = $s3->uploadPart([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
'PartNumber' => $partNumber,
'Body' => fread($file, 5 * 1024 * 1024),
]);
$parts['Parts'][$partNumber] = [
'PartNumber' => $partNumber,
'ETag' => $result['ETag'],
];
$partNumber++;
echo "Uploading part $partNumber of $filename." . PHP_EOL;
}
fclose($file);
} catch (S3Exception $e) {
$result = $s3->abortMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId
]);
echo "Upload of $filename failed." . PHP_EOL;
}
// Complete the multipart upload.
$result = $s3->completeMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
'MultipartUpload' => $parts,
]);
$url = $result['Location'];
echo "Uploaded $filename to $url." . PHP_EOL;
```
------
## の使用AWS SDK for Ruby
AWS SDK for Ruby バージョン 3 では、2 つの方法で Amazon S3 マルチパートアップロードがサポートされています。1 つ目のオプションとして、マネージドファイルアップロードを使用できます。詳細については、*AWS 開発者ブログ*の [Amazon S3 にファイルをアップロードする](https://aws.amazon.com/blogs/developer/uploading-files-to-amazon-s3/)を参照してください。マネージドファイルアップロードは、バケットにファイルをアップロードするための推奨される方法です。これらのアップロードには次の利点があります。
+ 15 MB より大きなオブジェクトのマルチパートアップロードを管理します。
+ エンコードの問題を回避するために、バイナリモードでファイルを正しく開きます。
+ 大きなオブジェクトの複数パートを並行してアップロードするために、複数のスレッドを使用します。
次に示すマルチパートアップロードクライアントオペレーションを直接使用することもできます。
+ [create\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#create_multipart_upload-instance_method) – マルチパートアップロードを開始し、アップロード ID を返します。
+ [upload\$1part](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#upload_part-instance_method) – マルチパートアップロードでパートをアップロードします。
+ [upload\$1part\$1copy](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#upload_part_copy-instance_method) – データソースとして既存のオブジェクトからデータをコピーすることで、パートをアップロードします。
+ [complete\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#complete_multipart_upload-instance_method) – 以前にアップロードしたパートを組み合わせることで、マルチパートアップロードを完了します。
+ [abort\$1multipart\$1upload](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#abort_multipart_upload-instance_method) – マルチパートアップロードを停止します。
# 高レベルの .NET TransferUtility クラスを使用してディレクトリをアップロードする
ディレクトリ全体をアップロードするには、`TransferUtility` クラスを使用できます。デフォルトでは、API でアップロードされるのは、指定したディレクトリのルートにあるファイルのみです。ただし、すべてのサブディレクトリでファイルを再帰的にアップロードするように指定できます。
フィルタ基準に基づいて指定したディレクトリのファイルを選択するには、フィルタ式を指定します。例えば、ディレクトリから `PDF` ファイルのみをアップロードするには、`"*.pdf"` フィルタ式を指定します。
ディレクトリからファイルをアップロードする場合は、結果のオブジェクトのキー名を指定しません。キー名は、元のファイルパスを使用して Amazon S3 で作成されます。例えば、以下の構造の `c:\myfolder` ディレクトリがあるとします。
**Example**
```
1. C:\myfolder
2. \a.txt
3. \b.pdf
4. \media\
5. An.mp3
```
このディレクトリをアップロードすると、Amazon S3 では次のキー名が使用されます。
**Example**
```
1. a.txt
2. b.pdf
3. media/An.mp3
```
**Example**
以下の C\$1 コード例では、ディレクトリを Amazon S3 バケットにアップロードしています。さまざまな `TransferUtility.UploadDirectory` オーバーロードを使用してディレクトリをアップロードする方法を示します。後続のアップロード呼び出しが行われるたびに、前のアップロードが置き換えられます。コード例を設定および実行する方法の詳細については、「*AWS SDK for .NET デベロッパーガイド*」の「[AWS SDK for .NET の開始方法](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html)」 を参照してください。
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.IO;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class UploadDirMPUHighLevelAPITest
{
private const string existingBucketName = "*** bucket name ***";
private const string directoryPath = @"*** directory path ***";
// The example uploads only .txt files.
private const string wildCard = "*.txt";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
UploadDirAsync().Wait();
}
private static async Task UploadDirAsync()
{
try
{
var directoryTransferUtility =
new TransferUtility(s3Client);
// 1. Upload a directory.
await directoryTransferUtility.UploadDirectoryAsync(directoryPath,
existingBucketName);
Console.WriteLine("Upload statement 1 completed");
// 2. Upload only the .txt files from a directory
// and search recursively.
await directoryTransferUtility.UploadDirectoryAsync(
directoryPath,
existingBucketName,
wildCard,
SearchOption.AllDirectories);
Console.WriteLine("Upload statement 2 completed");
// 3. The same as Step 2 and some optional configuration.
// Search recursively for .txt files to upload.
var request = new TransferUtilityUploadDirectoryRequest
{
BucketName = existingBucketName,
Directory = directoryPath,
SearchOption = SearchOption.AllDirectories,
SearchPattern = wildCard
};
await directoryTransferUtility.UploadDirectoryAsync(request);
Console.WriteLine("Upload statement 3 completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine(
"Error encountered ***. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine(
"Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
# マルチパートアップロードのリスト化
AWS CLI、REST API、AWS SDK を使用して、Amazon S3 で進行中のマルチパートアップロードのリストを取得できます。マルチパートアップロードを使用して、プログラムで 1 つのオブジェクトを Amazon S3 にアップロードできます。マルチパートアップロードでは、オブジェクトのデータの一部を一度に移動することで、オブジェクトを Amazon S3 に移動させます。マルチパートアップロードに関する一般的な情報については、「[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md)」を参照してください。
マルチパートアップロードで追加のチェックサムを含むオブジェクトをアップロードするエンドツーエンドの手順については、「[チュートリアル: マルチパートアップロードでオブジェクトをアップロードして、データ整合性を検証する](tutorial-s3-mpu-additional-checksums.md)」を参照してください。
次のセクションでは、AWS Command Line Interface、Amazon S3 REST API、および AWS SDK を使用して、進行中のマルチパートアップロードを一覧表示する方法を示します。
## AWS CLI を使用したマルチパートアップロードのリスト化
マルチパートアップロードのオペレーションについては、AWS Command Line Interface の以下のセクションを参照してください。
+ [list−parts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-parts.html) － 特定のマルチパートアップロードでアップロードされた部分を一覧表示します。
+ [list−multipart−uploads](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-multipart-uploads.html) － 進行中のマルチパートアップロードを一覧表示します。
# REST API を使用したマルチパートアップロードのリスト化
*Amazon Simple Storage Service API リファレンス*の以下のセクションでは、マルチパートアップロードをリスト化するための REST API について説明します。
+ [ListParts](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html) － 特定のマルチパートアップロードでアップロードされた部分を一覧表示します。
+ [ListMultipartUploads](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html) － 進行中のマルチパートアップロードを一覧表示します。
## AWS SDK (低レベル API) を使用したマルチパートアップロードのリスト化
------
#### [ Java ]
AWS SDK for Java を使用して、バケットで進行中のすべてのマルチパートアップロードを一覧表示するには、低レベル API クラスを使用して以下を実行します。
**低レベル API のマルチパートアップロードのリスト化プロセス**
| | |
| --- |--- |
| 1 | `ListMultipartUploadsRequest` クラスのインスタンスを作成し、バケット名を指定します。 |
| 2 | S3Client `listMultipartUploads` メソッドを実行します。このメソッドは、進行中のマルチパートアップロードに関する情報を提供する `ListMultipartUploadsResponse` クラスのインスタンスを返します。 |
AWS SDK for Java を使用してマルチパートアップロードを一覧表示する方法の例については、「*Amazon S3 API リファレンス*」の「[List multipart uploads](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_ListMultipartUploads_section.html)」を参照してください。
------
#### [ .NET ]
特定のバケットですべての進行中のマルチパートアップロードを一覧表示するには、SDK for .NET の低レベルのマルチパートアップロード API の `ListMultipartUploadsRequest` クラスを使用します。`AmazonS3Client.ListMultipartUploads` メソッドは、`ListMultipartUploadsResponse` クラスのインスタンスを返し、進行中のマルチパートアップロードに関する情報を提供します。
進行中のマルチパートアップロードとは、マルチパートアップロードの開始リクエストによって開始されてから、まだ完了または中止されていないマルチパートアップロードです。Amazon S3 マルチパートアップロードの詳細については、[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md) を参照してください。
次の C\$1 の例では、SDK for .NET を使用してバケットで進行中のマルチパートアップロードを一覧表示する方法を示します。コード例を設定および実行する方法の詳細については、「*AWS SDK for .NET デベロッパーガイド*」の「[AWS SDK for .NET の開始方法](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html)」 を参照してください。
```
ListMultipartUploadsRequest request = new ListMultipartUploadsRequest
{
BucketName = bucketName // Bucket receiving the uploads.
};
ListMultipartUploadsResponse response = await AmazonS3Client.ListMultipartUploadsAsync(request);
```
------
#### [ PHP ]
このトピックでは、バージョン 3 の AWS SDK for PHP の低レベル API クラスを使用して、バケットで進行中のすべてのマルチパートアップロードを一覧表示する方法を示します。AWS SDK for Ruby API の詳細については、[AWS SDK for Ruby - バージョン 2](https://docs.aws.amazon.com/sdkforruby/api/index.html) を参照してください。
次の PHP の例では、バケットで進行中のすべてのマルチパートアップロードを一覧表示します。
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Retrieve a list of the current multipart uploads.
$result = $s3->listMultipartUploads([
'Bucket' => $bucket
]);
// Write the list of uploads to the page.
print_r($result->toArray());
```
------
# AWS SDK を使用したマルチパートアップロードの追跡
リッスンインターフェイスを使用して、オブジェクトの Amazon S3 へのアップロードの進行状況を追跡できます。高レベルのマルチパートアップロード API は、`ProgressListener` と呼ばれるリッスンインターフェイスを提供します。進行状況に関するイベントが定期的に発生し、バイトが転送されたことをリスナーに通知します。マルチパートアップロードに関する一般的な情報については、「[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md)」を参照してください。
マルチパートアップロードで追加のチェックサムを含むオブジェクトをアップロードするエンドツーエンドの手順については、「[チュートリアル: マルチパートアップロードでオブジェクトをアップロードして、データ整合性を検証する](tutorial-s3-mpu-additional-checksums.md)」を参照してください。
次のセクションでは、AWS SDK を使用してマルチパートアップロードを追跡する方法を示します。
------
#### [ Java ]
**Example**
以下の Java コードは、ファイルをアップロードし、`ExecutionInterceptor` を使用してアップロードの進行状況を追跡します。作業サンプルの作成方法およびテスト方法については、「AWS SDK for Java 2.x のデベロッパーガイド」の「[開始方法](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html)」を参照してください。
```
import java.nio.file.Paths;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.interceptor.Context;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.interceptor.ExecutionInterceptor;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
public class TrackMPUProgressUsingHighLevelAPI {
static class ProgressListener implements ExecutionInterceptor {
private long transferredBytes = 0;
@Override
public void beforeTransmission(Context.BeforeTransmission context, ExecutionAttributes executionAttributes) {
if (context.httpRequest().firstMatchingHeader("Content-Length").isPresent()) {
String contentLength = context.httpRequest().firstMatchingHeader("Content-Length").get();
long partSize = Long.parseLong(contentLength);
transferredBytes += partSize;
System.out.println("Transferred bytes: " + transferredBytes);
}
}
}
public static void main(String[] args) throws Exception {
String existingBucketName = "*** Provide bucket name ***";
String keyName = "*** Provide object key ***";
String filePath = "*** file to upload ***";
S3AsyncClient s3Client = S3AsyncClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create())
.overrideConfiguration(c -> c.addExecutionInterceptor(new ProgressListener()))
.build();
// For more advanced uploads, you can create a request object
// and supply additional request parameters (ex: progress listeners,
// canned ACLs, etc.)
PutObjectRequest request = PutObjectRequest.builder()
.bucket(existingBucketName)
.key(keyName)
.build();
AsyncRequestBody requestBody = AsyncRequestBody.fromFile(Paths.get(filePath));
// You can ask the upload for its progress, or you can
// add a ProgressListener to your request to receive notifications
// when bytes are transferred.
// S3AsyncClient processes all transfers asynchronously,
// so this call will return immediately.
var upload = s3Client.putObject(request, requestBody);
try {
// You can block and wait for the upload to finish
upload.join();
} catch (Exception exception) {
System.out.println("Unable to upload file, upload aborted.");
exception.printStackTrace();
} finally {
s3Client.close();
}
}
}
```
------
#### [ .NET ]
次の C\$1 の例では、`TransferUtility` クラスを使用して S3 バケットにファイルをアップロードし、アップロードの進行状況を追跡します。コード例を設定および実行する方法の詳細については、「*AWS SDK for .NET デベロッパーガイド*」の「[AWS SDK for .NET の開始方法](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html)」 を参照してください。
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class TrackMPUUsingHighLevelAPITest
{
private const string bucketName = "*** provide the bucket name ***";
private const string keyName = "*** provide the name for the uploaded object ***";
private const string filePath = " *** provide the full path name of the file to upload **";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
TrackMPUAsync().Wait();
}
private static async Task TrackMPUAsync()
{
try
{
var fileTransferUtility = new TransferUtility(s3Client);
// Use TransferUtilityUploadRequest to configure options.
// In this example we subscribe to an event.
var uploadRequest =
new TransferUtilityUploadRequest
{
BucketName = bucketName,
FilePath = filePath,
Key = keyName
};
uploadRequest.UploadProgressEvent +=
new EventHandler
(uploadRequest_UploadPartProgressEvent);
await fileTransferUtility.UploadAsync(uploadRequest);
Console.WriteLine("Upload completed");
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
static void uploadRequest_UploadPartProgressEvent(object sender, UploadProgressArgs e)
{
// Process event.
Console.WriteLine("{0}/{1}", e.TransferredBytes, e.TotalBytes);
}
}
}
```
------
# マルチパートアップロードの中止
マルチパートアップロードを開始したら、パートをアップロードし始めます。Amazon S3 はこれらのパートを保存し、すべてのパートをアップロードしてマルチパートアップロードを完了するリクエストを送信した後にのみオブジェクトを作成します。マルチパートアップロードの完了リクエストを受け取ると、Amazon S3 はパートを組み立ててオブジェクトを作成します。マルチパートアップロードの完了リクエストが正常に送信されなかった場合、S3 はパートを組み立てず、オブジェクトも作成しません。パートのアップロード後にマルチパートアップロードを完了しない場合は、マルチパートアップロードを中止する必要があります。
アップロードされたパートに関連のあるすべてのストレージに対して料金が請求されます。常にマルチパートアップロードを完了させるか、マルチパートアップロードを停止してアップロードされたパートを削除することをお勧めします。料金の詳細については、「[マルチパートアップロードと料金](mpuoverview.md#mpuploadpricing)」を参照してください。
バケットライフサイクル設定を使用して、完了しないマルチパートアップロードを中止することもできます。詳細については、「[不完全なマルチパートアップロードを削除するためのバケットライフサイクル設定の設定](mpu-abort-incomplete-mpu-lifecycle-config.md)」を参照してください。
次のセクションでは、AWS Command Line Interface、REST API、および AWS SDK を使用して、Amazon S3 で進行中のマルチパートアップロードを停止する方法を示します。
## の使用AWS CLI
AWS CLI を使用してマルチパートアップロードを中止する方法の詳細については、*AWS CLI コマンドリファレンス*の [abort−multipart−upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/abort-multipart-upload.html) を参照してください。
## REST API の使用
REST API を使用してマルチパートアップロードを中止する方法の詳細については、*Amazon Simple Storage Service API リファレンス*の [AbortMultiPartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html) を参照してください。
## AWS SDK (高レベル API) の使用
------
#### [ Java ]
AWS SDK for Java を使用して進行中のマルチパートアップロードを停止する場合、指定した日付より前に開始され、まだ進行中のアップロードを中止できます。アップロードを開始すると、そのアップロードを完了または中止するまで進行中とみなされます。
マルチパートアップロードを停止するには、次の手順を実行します。
| | |
| --- |--- |
| 1 | S3Client インスタンスを作成します。 |
| 2 | バケット名やその他の必須パラメータを渡して、クライアントの中止方法を使用します。 |
**注記**
特定のマルチパートアップロードを中止することもできます。詳細については、「[AWS SDK の使用 (低レベル API)](#abort-mpu-low-level)」を参照してください。
AWS SDK for Java を使用してマルチパートアップロードを中止する方法の例については、「*Amazon S3 API リファレンス*」の「[Cancel a multipart upload](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_AbortMultipartUpload_section.html)」を参照してください。
------
#### [ .NET ]
次の C\$1 の例では、1 週間以上前に特定のバケットで開始された進行中のマルチパートアップロードをすべて中止します。コード例を設定および実行する方法の詳細については、「*AWS SDK for .NET デベロッパーガイド*」の「[AWS SDK for .NET の開始方法](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html)」 を参照してください。
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using System;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class AbortMPUUsingHighLevelAPITest
{
private const string bucketName = "*** provide bucket name ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
AbortMPUAsync().Wait();
}
private static async Task AbortMPUAsync()
{
try
{
var transferUtility = new TransferUtility(s3Client);
// Abort all in-progress uploads initiated before the specified date.
await transferUtility.AbortMultipartUploadsAsync(
bucketName, DateTime.Now.AddDays(-7));
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
**注記**
特定のマルチパートアップロードを中止することもできます。詳細については、[AWS SDK の使用 (低レベル API)](#abort-mpu-low-level) を参照してください。
------
## AWS SDK の使用 (低レベル API)
`AmazonS3.abortMultipartUpload` メソッドを呼び出すと、進行中のマルチパートアップロードを中止できます。このメソッドは、Amazon S3 にアップロードされたすべてのパートを削除し、リソースを解放します。アップロード ID、バケット名、およびキー名を指定する必要があります。以下の Java コードの例では、進行中のマルチパートアップロードを中止する方法を示します。
マルチパートアップロードを中止するには、アップロード ID とアップロードで使用しているバケット名とキー名を指定します。マルチパートアップロードを中止した後は、同じアップロード ID を使用して追加のパートをアップロードすることはできません。Amazon S3 マルチパートアップロードの詳細については、[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md) を参照してください。
------
#### [ Java ]
AWS SDK for Java を使用して、特定の進行中のマルチパートアップロードを停止する場合は、低レベル API を使用して、バケット名、オブジェクトキー、アップロード ID を指定することでアップロードを中止できます。
**注記**
特定のマルチパートアップロードを中止するのではなく、特定の時刻より前に開始され、まだ進行中のマルチパートアップロードをすべて中止することができます。このクリーンアップオペレーションは、開始したが完了または中止していない古いマルチパートアップロードを中止する場合に役に立ちます。詳細については、「[AWS SDK (高レベル API) の使用](#abort-mpu-high-level)」を参照してください。
AWS SDK for Java を使用して特定のマルチパートアップロードを中止する方法の例については、「*Amazon S3 API リファレンス*」の「[Cancel a multipart upload](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_AbortMultipartUpload_section.html)」を参照してください。
------
#### [ .NET ]
次の C\$1 の例は、マルチパートアップロードを中止する方法を示しています。次のコードを含む完全な C\$1 のサンプルについては、[AWS SDK の使用 (低レベル API)](mpu-upload-object.md#mpu-upload-low-level) を参照してください。
```
AbortMultipartUploadRequest abortMPURequest = new AbortMultipartUploadRequest
{
BucketName = existingBucketName,
Key = keyName,
UploadId = initResponse.UploadId
};
await AmazonS3Client.AbortMultipartUploadAsync(abortMPURequest);
```
特定の時刻までに開始されたすべての進行中のマルチパートアップロードを中止することもできます。このクリーンアップオペレーションは、完了または中止していないマルチパートアップロードを中止する場合に役立ちます。詳細については、[AWS SDK (高レベル API) の使用](#abort-mpu-high-level) を参照してください。
------
#### [ PHP ]
この例では、バージョン 3 の AWS SDK for PHP のクラスを使用して、進行中のマルチパートアップロードを中止する方法を示します。AWS SDK for Ruby API の詳細については、[AWS SDK for Ruby - バージョン 2](https://docs.aws.amazon.com/sdkforruby/api/index.html) を参照してください。`abortMultipartUpload()` メソッドの例です。
AWS SDK for Ruby API の詳細については、[AWS SDK for Ruby - バージョン 2](https://docs.aws.amazon.com/sdkforruby/api/index.html) を参照してください。
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$uploadId = '*** Upload ID of upload to Abort ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Abort the multipart upload.
$s3->abortMultipartUpload([
'Bucket' => $bucket,
'Key' => $keyname,
'UploadId' => $uploadId,
]);
```
------
# マルチパートアップロードを使用したオブジェクトのコピー
マルチパートアップロードを使用すると、オブジェクトをパートのセットとしてコピーすることができます。このセクションの例は、Multipart Upload API を使用して 5 GB よりも大きいオブジェクトをコピーする方法を示しています。マルチパートアップロードの詳細については、「[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md)」を参照してください。
マルチパートアップロード API を使用せずに、1 回のオペレーションで 5 GB 未満のオブジェクトをコピーできます。AWS マネジメントコンソール、AWS CLI、REST API、または AWS SDK を使用して、5 GB 未満のオブジェクトをコピーできます。詳細については、「[オブジェクトのコピー、移動、名前の変更](copy-object.md)」を参照してください。
マルチパートアップロードで追加のチェックサムを含むオブジェクトをアップロードするエンドツーエンドの手順については、「[チュートリアル: マルチパートアップロードでオブジェクトをアップロードして、データ整合性を検証する](tutorial-s3-mpu-additional-checksums.md)」を参照してください。
次のセクションでは、REST API または AWS SDK を使用してマルチパートアップロードでオブジェクトをコピーする方法を示します。
## REST API の使用
*Amazon Simple Storage Service API リファレンス*の以下のセクションでは、マルチパートアップロードの REST API について説明しています。既存のオブジェクトをコピーするには、UploadPart (Copy) API を使用し、リクエストに `x-amz-copy-source` リクエストヘッダーを追加してコピー元オブジェクトを指定します。
+ [Initiate Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ [Upload Part](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)
+ [パートのアップロード (コピー)](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)
+ [Complete Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ [マルチパートアップロードの中止](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadAbort.html)
+ [パートのリスト](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListParts.html)
+ [マルチパートアップロードのリスト](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadListMPUpload.html)
これらの API を使用して独自の REST リクエストを作成するか、提供されている SDK のいずれかを使用できます。AWS CLI でマルチパートアップロードを使用する方法の詳細については、[の使用AWS CLI](mpu-upload-object.md#UsingCLImpUpload) を参照してください。SDK の詳細については、「[AWSマルチパートアップロードの SDK サポート](mpuoverview.md#sdksupportformpu)」を参照してください。
## AWS SDK の使用
低レベル API を使用してオブジェクトをコピーするには、次の手順を実行します。
+ `AmazonS3Client.initiateMultipartUpload()` メソッドを呼び出して、マルチパートアップロードを開始します。
+ `AmazonS3Client.initiateMultipartUpload()` メソッドから返されたレスポンスオブジェクトのアップロード ID を保存します。このアップロード ID は、パートのアップロードオペレーションごとに指定します。
+ すべてのパートをコピーします。コピーする必要があるパートごとに、`CopyPartRequest` クラスの新しいインスタンスを作成します。パート情報として、送信元と送信先のバケット名、送信元と送信先のオブジェクトキー、アップロード ID、パートの最初と最後のバイトの場所、パート番号などを指定します。
+ `AmazonS3Client.copyPart()` メソッド呼び出しのレスポンスを保存します。各レスポンスには、アップロードしたパートの `ETag` 値とパート番号が含まれています。この情報は、マルチパートアップロードを完了するために必要です。
+ `AmazonS3Client.completeMultipartUpload()` メソッドを呼び出してコピーオペレーションを完了します。
------
#### [ Java ]
AWS SDK for Java でマルチパートアップロードを使用してオブジェクトをコピーする方法の例については、「*Amazon S3 API リファレンス*」の「[Copy part of an object from another object](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_UploadPartCopy_section.html)」を参照してください。
------
#### [ .NET ]
次の C\$1 の例では、SDK for .NET を使用して 5 GB を超える Amazon S3 オブジェクトをコピー元からコピー先 (あるバケットから別のバケットなど) にコピーする方法を示します。5 GB 未満のオブジェクトをコピーするには、1 回のオペレーションでコピーする手順を使用します ([AWS SDK の使用](copy-object.md#CopyingObjectsUsingSDKs) を参照)。Amazon S3 マルチパートアップロードの詳細については、[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md) を参照してください。
この例では、SDK for .NET マルチパートアップロード API を使用して、5 GB を超える Amazon S3 オブジェクトを S3 バケットから別のバケットにコピーする方法を示します。
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class CopyObjectUsingMPUapiTest
{
private const string sourceBucket = "*** provide the name of the bucket with source object ***";
private const string targetBucket = "*** provide the name of the bucket to copy the object to ***";
private const string sourceObjectKey = "*** provide the name of object to copy ***";
private const string targetObjectKey = "*** provide the name of the object copy ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
public static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
Console.WriteLine("Copying an object");
MPUCopyObjectAsync().Wait();
}
private static async Task MPUCopyObjectAsync()
{
// Create a list to store the upload part responses.
List uploadResponses = new List();
List copyResponses = new List();
// Setup information required to initiate the multipart upload.
InitiateMultipartUploadRequest initiateRequest =
new InitiateMultipartUploadRequest
{
BucketName = targetBucket,
Key = targetObjectKey
};
// Initiate the upload.
InitiateMultipartUploadResponse initResponse =
await s3Client.InitiateMultipartUploadAsync(initiateRequest);
// Save the upload ID.
String uploadId = initResponse.UploadId;
try
{
// Get the size of the object.
GetObjectMetadataRequest metadataRequest = new GetObjectMetadataRequest
{
BucketName = sourceBucket,
Key = sourceObjectKey
};
GetObjectMetadataResponse metadataResponse =
await s3Client.GetObjectMetadataAsync(metadataRequest);
long objectSize = metadataResponse.ContentLength; // Length in bytes.
// Copy the parts.
long partSize = 5 * (long)Math.Pow(2, 20); // Part size is 5 MB.
long bytePosition = 0;
for (int i = 1; bytePosition < objectSize; i++)
{
CopyPartRequest copyRequest = new CopyPartRequest
{
DestinationBucket = targetBucket,
DestinationKey = targetObjectKey,
SourceBucket = sourceBucket,
SourceKey = sourceObjectKey,
UploadId = uploadId,
FirstByte = bytePosition,
LastByte = bytePosition + partSize - 1 >= objectSize ? objectSize - 1 : bytePosition + partSize - 1,
PartNumber = i
};
copyResponses.Add(await s3Client.CopyPartAsync(copyRequest));
bytePosition += partSize;
}
// Set up to complete the copy.
CompleteMultipartUploadRequest completeRequest =
new CompleteMultipartUploadRequest
{
BucketName = targetBucket,
Key = targetObjectKey,
UploadId = initResponse.UploadId
};
completeRequest.AddPartETags(copyResponses);
// Complete the copy.
CompleteMultipartUploadResponse completeUploadResponse =
await s3Client.CompleteMultipartUploadAsync(completeRequest);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
------
# チュートリアル: マルチパートアップロードでオブジェクトをアップロードして、データ整合性を検証する
マルチパートアップロードを使用すると、単一のオブジェクトをパートのセットとしてアップロードすることができます。各パートは、オブジェクトのデータの連続する部分です。これらのオブジェクトパートは、任意の順序で個別にアップロードできます。いずれかのパートの送信が失敗すると、他のパートに影響を与えることなくそのパートを再送することができます。オブジェクトのすべてのパートがアップロードされたら、Amazon S3 はこれらのパートを組み立ててオブジェクトを作成します。通常、オブジェクトサイズが 100 MB 以上の場合は、単一のオペレーションでオブジェクトをアップロードする代わりに、マルチパートアップロードを使用することを考慮してください。マルチパートアップロードの詳細については、「[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md)」を参照してください。マルチパートアップロードに関する制限については、「[Amazon S3 マルチパートアップロードの制限](qfacts.md)」を参照してください。
チェックサムを使用して、コピー時にアセットが変更されていないことを確認できます。チェックサムを実行するには、アルゴリズムを使用してファイル内のバイトごとに順番に反復処理を行います。Amazon S3 は、データの整合性をチェックするための複数のチェックサムオプションを提供しています。耐久性のベストプラクティスとして、このような整合性チェックを実行し、すべてのバイトが変更されずに転送されることを確認することをお勧めします。Amazon S3 は、SHA-1、SHA-256、CRC32、CRC32C のアルゴリズムもサポートしています。Amazon S3 は、このようなアルゴリズムの 1 つまたは複数使用して、追加のチェックサム値を計算し、オブジェクトメタデータの一部として保存します。チェックサムの詳細については、「[Amazon S3 でのオブジェクトの整合性のチェック](checking-object-integrity.md)」を参照してください。
**目的**
このチュートリアルでは、AWS コマンドラインインターフェイス (AWS CLI) を介してマルチパートアップロードと追加の SHA-256 チェックサムを使って、オブジェクトを Amazon S3 にアップロードする方法を説明します。アップロードしたオブジェクトの MD5 ハッシュと SHA-256 チェックサムを計算することで、オブジェクトのデータ整合性を確認する方法についても説明します。
**Topics**
+ [
## 前提条件
](#mpu-prerequisites)
+ [
## ステップ 1: サイズが大きいファイルを作成する
](#create-large-file-step1)
+ [
## ステップ 2: ファイルを複数のファイルに分割する
](#split-large-file-step2)
+ [
## ステップ 3: 追加のチェックサムを使用してマルチパートアップロードを作成する
](#create-multipart-upload-step3)
+ [
## ステップ 4: マルチパートアップロードのパートをアップロードする
](#upload-parts-step4)
+ [
## ステップ 5: マルチパートアップロードのすべてのパートを一覧表示する
](#list-parts-step5)
+ [
## ステップ 6: マルチアップロードを完了する
](#complete-multipart-upload-step6)
+ [
## ステップ 7: オブジェクトがバケットにアップロードされていることを確認する
](#confirm-upload-step7)
+ [
## ステップ 8: MD5 チェックサムを使用してオブジェクトの整合性を検証する
](#verify-object-integrity-step8)
+ [
## ステップ 9: 追加のチェックサムを使用してオブジェクトの整合性を検証する
](#verify-object-integrity-sha256-step9)
+ [
## ステップ 10: リソースをクリーンアップする
](#clean-up-step10)
## 前提条件
+ このチュートリアルを開始する前に、アップロード先の Amazon S3 バケットにアクセスできることを確認してください。詳細については、「[汎用バケットの作成](create-bucket-overview.md)」を参照してください。
+ AWS CLI がインストールされて、設定されている必要があります。AWS CLI をまだインストールしていない場合は、「AWS Command Line Interface ユーザーガイド」の「[AWS CLI の最新バージョンをインストールまたは更新する](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html)」を参照してください。**
+ 別の方法として、AWS CloudShell を使用してコンソールから AWS CLI コマンドを実行することもできます。AWS CloudShell は、AWS マネジメントコンソールから直接起動できる、ブラウザベースの事前認証済みシェルです。詳細については、「AWS CloudShell ユーザーガイド」の「[CloudShell とは](https://docs.aws.amazon.com//cloudshell/latest/userguide/welcome.html)」と「[AWS CloudShell の使用開始](https://docs.aws.amazon.com//cloudshell/latest/userguide/getting-started.html)」を参照してください。**
## ステップ 1: サイズが大きいファイルを作成する
アップロードするファイルが既にある場合は、このチュートリアルでそのファイルを使用できます。ない場合は、次の手順で 15 MB のファイルを作成します。マルチパートアップロードに関する制限については、「[Amazon S3 マルチパートアップロードの制限](qfacts.md)」を参照してください。
**サイズが大きいファイルを作成するには**
使用しているオペレーティングシステムに応じて、次のいずれかのコマンドを使用してファイルを作成します。
**Linux または macOS**
15 MB のファイルを作成するには、ローカルターミナルを開いて、次のコマンドを実行します。
```
dd if=/dev/urandom of=census-data.bin bs=1M count=15
```
このコマンドは、ランダムなバイトが入力された、サイズが 15 MB の `census-data.bin` という名前のファイルを作成します。
**Server**
15 MB のファイルを作成するには、ローカルターミナルを開いて、次のコマンドを実行します。
```
fsutil file createnew census-data.bin 15728640
```
このコマンドは、サイズが 15 MB (15,728,640 バイト) の任意のデータが入力された、`census-data.bin` という名前のファイルを作成します。
## ステップ 2: ファイルを複数のファイルに分割する
マルチパートアップロードを実行するには、サイズの大きいファイルを小さいサイズのパートに分割する必要があります。その後、マルチパートアップロードプロセスを使用して、小さいサイズのパートをアップロードできます。このステップでは、[ステップ 1](#create-large-file-step1) で作成したサイズの大きいファイルを小さいパートに分割する方法を説明します。次の例では、`census-data.bin` という名前の 15 MB のファイルを使用します。
**サイズの大きいファイルをパートに分割するには**
**Linux または macOS**
サイズの大きいファイルを 5 MB のパートに分割するには、`split` コマンドを使用します。ターミナルを開いて、次のコマンドを実行します。
```
split -b 5M -d census-data.bin census-part
```
このコマンドは、`census-data.bin` を `census-part**` という名前の 5 MB のパートに分割します。`**` は `00` から始まる数値のサフィックスです。
**Server**
サイズの大きいファイルを分割するには、PowerShell を使用します。[PowerShell](https://learn.microsoft.com/en-us/powershell/) を開いて、次のスクリプトを実行します。
```
$inputFile = "census-data.bin"
$outputFilePrefix = "census-part"
$chunkSize = 5MB
$fs = [System.IO.File]::OpenRead($inputFile)
$buffer = New-Object byte[] $chunkSize
$fileNumber = 0
while ($fs.Position -lt $fs.Length) {
$bytesRead = $fs.Read($buffer, 0, $chunkSize)
$outputFile = "{0}{1:D2}" -f $outputFilePrefix, $fileNumber
$fileStream = [System.IO.File]::Create($outputFile)
$fileStream.Write($buffer, 0, $bytesRead)
$fileStream.Close()
$fileNumber++
}
$fs.Close()
```
この PowerShell スクリプトは、サイズの大きいファイルを 5 MB のチャンクで読み取り、各チャンクを数値のサフィックス付きの新しいファイルに書き込みます。
適切なコマンドを実行後、コマンドを実行したディレクトリに複数のパートがあるのを確認できるはずです。各パートには、次の例のとおり、パート番号に対応するサフィックスが付けられています。
```
census-part00 census-part01 census-part02
```
## ステップ 3: 追加のチェックサムを使用してマルチパートアップロードを作成する
マルチパートアップロードプロセスを開始するには、マルチパートアップロードリクエストを作成する必要があります。このステップでは、マルチパートアップロードを開始し、データの整合性に関する追加のチェックサムを指定します。次の例では、SHA-256 チェックサムを使用しています。アップロードするオブジェクトの説明となるメタデータを指定する場合は、マルチパートアップロードの開始リクエストの中で指定する必要があります。
**注記**
このチュートリアルでは、このステップと以降のステップで SHA-256 の追加アルゴリズムを使用します。このようなステップでは、必要に応じて、CRC32、CRC32C、または SHA-1 などの追加のチェックサムを使用できます。別のアルゴリズムを使用する場合は、このチュートリアルのステップ全体で、同じアルゴリズムを使用する必要があります。
**マルチパートアップロードを開始するには**
ターミナルで、次の `create-multipart-upload` コマンドを使用してバケットのマルチパートアップロードを開始します。`amzn-s3-demo-bucket1` を実際のバケット名に置き換えます。`census_data_file` も選択したファイル名に置き換えます。このファイル名は、アップロードが完了するとオブジェクトキーになります。
```
aws s3api create-multipart-upload --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --checksum-algorithm sha256
```
リクエストが正常に完了すると、次のような JSON 出力が表示されます。
```
{
"ServerSideEncryption": "AES256",
"ChecksumAlgorithm": "SHA256",
"Bucket": "amzn-s3-demo-bucket1",
"Key": "census_data_file",
"UploadId": "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz"
}
```
**注記**
リクエストを送信すると、アップロード ID を含むレスポンスが Amazon S3 から返されます。アップロード ID はマルチパートアップロードの一意の識別子です。パートのアップロード、パートのリスト、アップロードの完了、アップロードの停止を行うときは常に、このアップロード ID を指定する必要があります。`UploadId`、`Key`、`Bucket` の値は、後半のステップで使用する必要があるため、必ず保存します。
追加のチェックサムがあるマルチパートアップロードを使用する場合、マルチパート番号には連続するパート番号を使用する必要があります。連続していないパート番号を使用すると、`complete-multipart-upload` リクエストで HTTP `500 Internal Server Error` が発生する可能性があります。
## ステップ 4: マルチパートアップロードのパートをアップロードする
このステップでは、マルチパートアップロードのパートを S3 バケットにアップロードします。`upload-part` コマンドを使用して、各パートを個別にアップロードします。このプロセスでは、アップロード ID、パート番号、パートごとにアップロードするファイルを指定する必要があります。
**パートをアップロードするには**
1. パートをアップロードする際は、アップロード ID 以外にも、`--part-number` 引数を使用して、パート番号を指定する必要があります。1～10,000 の範囲で任意のパート番号を選択できます。パート番号によって、アップロードするオブジェクトに含まれるパートとその位置が一意に識別されます。選択するパート番号は、連続している必要があります (1、2、3 など)。以前にアップロードしたパートと同じパート番号を使って新しいパートをアップロードした場合、以前のパートは上書きされます。
1. `upload-part` コマンドを使用して、マルチパートアップロードの各パートを個別にアップロードします。`--upload-id` は、[ステップ 3](#create-multipart-upload-step3) で `create-multipart-upload` コマンドを使って作成した出力と同じものです。データの最初のパートをアップロードするには、次のコマンドを使用します。
```
aws s3api upload-part --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --part-number 1 --body census-part00 --upload-id "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz" --checksum-algorithm SHA256
```
各 `upload-part` コマンドが完了すると、次の例のような出力が表示されるはずです。
```
{
"ServerSideEncryption": "AES256",
"ETag": "\"e611693805e812ef37f96c9937605e69\"",
"ChecksumSHA256": "QLl8R4i4+SaJlrl8ZIcutc5TbZtwt2NwB8lTXkd3GH0="
}
```
1. 以降のパートについては、順番にパート番号を増分します。
```
aws s3api upload-part --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --part-number --body --upload-id "" --checksum-algorithm SHA256
```
例えば、2 番目のパートをアップロードするには、次のコマンドを使用します。
```
aws s3api upload-part --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --part-number 2 --body census-part01 --upload-id "cNV6KCSNANFZapz1LUGPC5XwUVi1n6yUoIeSP138sNOKPeMhpKQRrbT9k0ePmgoOTCj9K83T4e2Gb5hQvNoNpCKqyb8m3.oyYgQNZD6FNJLBZluOIUyRE.qM5yhDTdhz" --checksum-algorithm SHA256
```
Amazon S3 は、エンティティタグ (ETag) と、アップロードされた各パートの追加チェックサムをレスポンスのヘッダーとして返します。
1. オブジェクトのすべてのパートのアップロードが完了するまで、`upload-part` コマンドを引き続き使用します。
## ステップ 5: マルチパートアップロードのすべてのパートを一覧表示する
マルチパートアップロードを完了するには、特定のマルチパートアップロードでアップロードされたすべてのパートの一覧が必要です。`list-parts` コマンドからの出力は、バケット名、キー、アップロード ID、パート番号、ETag、追加のチェックサムなどの情報を提供します。この出力をファイルに保存して、マルチパートアップロードプロセスの完了に向けた次のステップで使用できるようにすると便利です。次の方法を使用して、`parts.json` という名前の JSON 出力ファイルを作成できます。
**すべてのパートを一覧表示するファイルを作成するには**
1. アップロードしたすべてのパートの詳細を含む JSON ファイルを生成するには、次の `list-parts` コマンドを使用します。***amzn-s3-demo-bucket1*** は実際のバケット名、**** は、[ステップ 3](#create-multipart-upload-step3) で取得したアップロード ID に置き換えます。`list-parts` コマンドの詳細については、「AWS Command Line Interface ユーザーガイド」の「[https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-parts.html)」を参照してください。**
```
aws s3api list-parts --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --upload-id --query '{Parts: Parts[*].{PartNumber: PartNumber, ETag: ETag, ChecksumSHA256: ChecksumSHA256}}' --output json > parts.json
```
`parts.json` という名前の新しいファイルが生成されます。このファイルには、アップロードしたすべてのパートの JSON 形式の情報が含まれています。`parts.json` ファイルには、マルチパートアップロードプロセスを完了するために必要な、パート番号や対応する ETag 値など、マルチパートアップロードの各パートについての重要な情報が含まれています。
1. 任意のテキストエディタを使用するか、ターミナルで `parts.json` を開きます。以下は出力の例です。
```
{
"Parts": [
{
"PartNumber": 1,
"ETag": "\"3c3097f89e2a2fece47ac54b243c9d97\"",
"ChecksumSHA256": "fTPVHfyNHdv5VkR4S3EewdyioXECv7JBxN+d4FXYYTw="
},
{
"PartNumber": 2,
"ETag": "\"03c71cc160261b20ab74f6d2c476b450\"",
"ChecksumSHA256": "VDWTa8enjOvULBAO3W2a6C+5/7ZnNjrnLApa1QVc3FE="
},
{
"PartNumber": 3,
"ETag": "\"81ae0937404429a97967dffa7eb4affb\"",
"ChecksumSHA256": "cVVkXehUlzcwrBrXgPIM+EKQXPUvWist8mlUTCs4bg8="
}
]
}
```
## ステップ 6: マルチアップロードを完了する
マルチパートアップロードのすべてのパートをアップロードして一覧表示した後の最後のステップは、マルチパートアップロードを完了することです。このステップでは、アップロードしたすべてのパートを S3 バケット内の単一のオブジェクトにマージします。
**注記**
リクエストに `--checksum-sha256` を含めることで、`complete-multipart-upload` を呼び出す前にオブジェクトのチェックサムを計算できます。チェックサムが一致しない場合、リクエストは Amazon S3 で失敗します。詳細については、*AWS Command Line Interface ユーザーガイド*の [https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/complete-multipart-upload.html) を参照してください。
**マルチパートアップロードを完了するには**
マルチパートアップロードを最終化するには、`complete-multipart-upload` コマンドを使用します。このコマンドには、[ステップ 5](#list-parts-step5) で作成した `parts.json` ファイル、バケット名、アップロード ID が必要です。**<*amzn-s3-demo-bucket1*>** は実際のバケット名、**** は `parts.json` のアップロード ID に置き換えます。
```
aws s3api complete-multipart-upload --multipart-upload file://parts.json --bucket amzn-s3-demo-bucket1 --key 'census_data_file' --upload-id
```
以下は出力の例です。
```
{
"ServerSideEncryption": "AES256",
"Location": "https://amzn-s3-demo-bucket1.s3.us-east-2.amazonaws.com/census_data_file",
"Bucket": "amzn-s3-demo-bucket1",
"Key": "census_data_file",
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ChecksumSHA256": "aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=-3"
}
```
**注記**
この時点では、個別のパートファイルの削除は行いません。マージ後のオブジェクトの整合性を検証するためにチェックサムを実行するには、個別のパートが必要です。
## ステップ 7: オブジェクトがバケットにアップロードされていることを確認する
マルチパートアップロードが完了したら、オブジェクトが S3 バケットに正常にアップロードされたことを確認できます。バケット内のオブジェクトを一覧表示して、新しくアップロードされたファイルが存在することを確認するには、 `list-objects-v2` コマンドを使用します。
**アップロードしたオブジェクトを一覧表示するには**
バケット内のオブジェクトを一覧表示するには、`list-objects-v2` コマンドを使用します。次の ***amzn-s3-demo-bucket1*** は、実際のバケット名に置き換えます。
```
aws s3api list-objects-v2 --bucket amzn-s3-demo-bucket1
```
このコマンドは、バケット内のオブジェクトの一覧を返します。オブジェクトの一覧で、アップロードしたファイル (`census_data_file` など) を検索します。
詳細については、「AWS Command Line Interface ユーザーガイド」の「[`list-objects-v2` コマンドの例](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-objects-v2.html)」セクションを参照してください。**
## ステップ 8: MD5 チェックサムを使用してオブジェクトの整合性を検証する
オブジェクトをアップロードする際に、Amazon S3 が使用するチェックサムのアルゴリズムを指定できます。デフォルトでは、Amazon S3 は複数のバイトの MD5 ダイジェストをオブジェクトの ETag として保存します。マルチパートアップロードの場合、ETag はオブジェクト全体のチェックサムではなく、個別のパートのチェックサムの複合体です。
**MD5 チェックサムを使用してオブジェクトの整合性を検証するには**
1. アップロードしたオブジェクトの ETag を取得するには、次のとおり `head-object` リクエストを実行します。
```
aws s3api head-object --bucket amzn-s3-demo-bucket1 --key census_data_file
```
以下は出力の例です。
```
{
"AcceptRanges": "bytes",
"LastModified": "2024-07-26T19:04:13+00:00",
"ContentLength": 16106127360,
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ContentType": "binary/octet-stream",
"ServerSideEncryption": "AES256",
"Metadata": {}
}
```
この ETag の末尾には「-3」が追加されています。これは、このオブジェクトがマルチパートアップロードを使用して 3 つのパートでアップロードされたことを意味します。
1. 次に、`md5sum` コマンドを使用して各パートの MD5 チェックサムを計算します。パートファイルへの適切なパスを指定する必要があります。
```
md5sum census-part*
```
以下は出力の例です。
```
e611693805e812ef37f96c9937605e69 census-part00
63d2d5da159178785bfd6b6a5c635854 census-part01
95b87c7db852451bb38b3b44a4e6d310 census-part02
```
1. このステップでは、MD5 ハッシュを手動で単一の文字列にまとめます。次に、以下のコマンドを実行して、文字列をバイナリに変換し、バイナリ値の MD5 チェックサムを計算します。
```
echo "e611693805e812ef37f96c9937605e6963d2d5da159178785bfd6b6a5c63585495b87c7db852451bb38b3b44a4e6d310" | xxd -r -p | md5sum
```
以下は出力の例です。
```
f453c6dccca969c457efdf9b1361e291 -
```
このハッシュ値は、`census_data_file` オブジェクトの整合性を検証する [ステップ 1](#create-large-file-step1) の元の ETag 値のハッシュ値と一致する必要があります。
追加のチェックサムを使用するように Amazon S3 に指示すると、Amazon S3 は各パートのチェックサム値を計算し、その値を保存します。マルチパートアップロード処理中の個別のパートのチェックサム値を取得する場合は、`list-parts` を使用できます。
マルチパートアップロードオブジェクトでのチェックサムの動作の詳細については、「[Amazon S3 でのオブジェクトの整合性のチェック](checking-object-integrity.md)」を参照してください。
## ステップ 9: 追加のチェックサムを使用してオブジェクトの整合性を検証する
このチュートリアルでは、オブジェクトの整合性を検証するための追加のチェックサムとして、このステップで SHA-256 を使用します。別の追加のチェックサムを使用した場合は、代わりにそのチェックサム値を使用します。
**SHA256 チェックサムを使用してオブジェクトの整合性を検証するには**
1. ターミナルで `--checksum-mode enabled` 引数を含む次のコマンドを実行して、オブジェクトの `ChecksumSHA256` 値を表示します。
```
aws s3api head-object --bucket amzn-s3-demo-bucket1 --key census_data_file --checksum-mode enabled
```
以下は出力の例です。
```
{
"AcceptRanges": "bytes",
"LastModified": "2024-07-26T19:04:13+00:00",
"ContentLength": 16106127360,
"ChecksumSHA256": "aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=-3",
"ETag": "\"f453c6dccca969c457efdf9b1361e291-3\"",
"ContentType": "binary/octet-stream",
"ServerSideEncryption": "AES256",
"Metadata": {}
}
```
1. 次のコマンドを使用して、個別のパートの `ChecksumSHA256` 値を base64 にデコードし、`outfile` という名前のバイナリファイルに保存します。これらの値は `parts.json` ファイルにあります。base64 文字列の例を実際の `ChecksumSHA256` 値に置き換えます。
```
echo "QLl8R4i4+SaJlrl8ZIcutc5TbZtwt2NwB8lTXkd3GH0=" | base64 --decode >> outfile
echo "xCdgs1K5Bm4jWETYw/CmGYr+m6O2DcGfpckx5NVokvE=" | base64 --decode >> outfile
echo "f5wsfsa5bB+yXuwzqG1Bst91uYneqGD3CCidpb54mAo=" | base64 --decode >> outfile
```
1. 次のコマンドを実行して、`outfile` の SHA256 チェックサムを計算します。
```
sha256sum outfile
```
以下は出力の例です。
```
688f04a24b42768b6353c06ae3a0eb3c2c50086b8670f221279d67a16b3a86f9 outfile
```
次のステップでは、ハッシュ値を取得して、バイナリ値に変換します。このバイナリ値は、[ステップ 1](#create-large-file-step1) のチェックサムの `ChecksumSHA256` 値と一致する必要があります。
1. [ステップ 3](#create-multipart-upload-step3) の SHA256 チェックサムをバイナリに変換し、これを base64 にエンコードして、[ステップ 1](#create-large-file-step1) の `ChecksumSHA256` 値と一致することを検証します。
```
echo "688f04a24b42768b6353c06ae3a0eb3c2c50086b8670f221279d67a16b3a86f9" | xxd -r -p | base64
```
以下は出力の例です。
```
aI8EoktCdotjU8Bq46DrPCxQCGuGcPIhJ51noWs6hvk=
```
この出力は、base64 出力が `head-object` コマンド出力からの `ChecksumSHA256` 値と一致することを確認します。この出力がチェックサム値と一致すれば、このオブジェクトは有効です。
**重要**
追加のチェックサムを使用するように Amazon S3 に指示すると、Amazon S3 は各パートのチェックサム値を計算し、その値を保存します。
マルチパートアップロード処理中の個別のパートのチェックサム値を取得する場合は、`list-parts` コマンドを使用できます。
## ステップ 10: リソースをクリーンアップする
このチュートリアルで作成したファイルをクリーンアップする場合は、次の方法を使用します。S3 バケットにアップロードしたファイルを削除する手順については、「[Amazon S3 オブジェクトの削除](DeletingObjects.md)」を参照してください。
**[ステップ 1](#create-large-file-step1) で作成したローカルファイルを削除する:**
マルチパートアップロードのために作成したファイルを削除するには、作業ディレクトリから次のコマンドを実行します。
```
rm census-data.bin census-part* outfile parts.json
```
# Amazon S3 マルチパートアップロードの制限
マルチパートアップロードを使用すると、単一のオブジェクトをパートのセットとしてアップロードすることができます。各パートは、オブジェクトのデータの連続する部分です。オブジェクトのすべてのパートがアップロードされたら、Amazon S3 はこれらのパートを組み立ててオブジェクトを作成します。通常、オブジェクトサイズが 100 MB 以上の場合は、単一のオペレーションでオブジェクトをアップロードする代わりに、マルチパートアップロードを使用することを考慮してください。マルチパートアップロードの詳細については、「[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md)」を参照してください。
次の表は、マルチパートアップロードの主な仕様をまとめたものです。これには、オブジェクトの最大サイズ、パーツの最大数、パーツの最大サイズなどが含まれます。マルチパートアップロードの最後のパートには、最小サイズの制限はありません。
| 項目 | 仕様 |
| --- | --- |
| 最大オブジェクトサイズ | 48.8 TiB |
| アップロードあたりの最大パート数 | 10,000 |
| パート番号 | 1～10,000 |
| パートサイズ | 5 MiB から 5 GiB。マルチパートアップロードの最後のパートには、最小サイズの制限はありません。 |
| パートのリストリクエストで返されるパートの最大数 | 1,000 |
| マルチパートアップロードのリストリクエストで返されるマルチパートアップロードの最大数 | 1,000 |