

# ACL によるアクセス管理
<a name="acls"></a>

 アクセスコントロールリスト (ACL) はリソースベースのオプションの 1 つであり、バケットとオブジェクトへのアクセスを管理するために使用できます。ACL を使用して、基本的な読み取り/書き込み許可を他の AWS アカウントに付与できます。ACL によるアクセス許可の管理にはいくつかの制限があります。

例えば、アクセス許可を付与できるのは他の AWS アカウント だけで、自分のアカウントのユーザーには付与できません。条件付きアクセス許可を付与することはできず、アクセス許可を明示的に拒否することもできません。ACL が適しているのは、特定のいくつかのシナリオです。例えば、バケット所有者が他の AWS アカウント にオブジェクトのアップロードを許可している場合、これらのオブジェクトへのアクセス許可を管理する方法は、オブジェクトを所有する AWS アカウント によるオブジェクト ACL を使用する以外にありません。

S3 オブジェクト所有権は、Amazon S3 バケットレベルの設定で、バケットにアップロードされる新しいオブジェクト所有権を制御し、ACL を無効にするのに使用できます。デフォルトでは、オブジェクト所有権はバケット所有者の強制設定に設定され、すべての ACL は無効になります。ACL を無効にすると、バケット所有者はバケット内のすべてのオブジェクトを所有し、アクセス管理ポリシーのみを使用してデータへのアクセスを管理します。

 Amazon S3 の最新のユースケースの大部分では ACL を使用する必要がなくなっています。オブジェクトごとに個別にアクセスを制御する必要がある状況を除き、ACL は無効にしておくことをお勧めします。ACL を無効にすると、誰がオブジェクトをバケットにアップロードしたかに関係なく、ポリシーを使用してバケット内のすべてのオブジェクトへのアクセスを制御できます。詳細については、「[オブジェクトの所有権の制御とバケットの ACL の無効化。](about-object-ownership.md)」を参照してください。

**重要**  
汎用バケットで S3 のオブジェクト所有者に [バケット所有者の強制] 設定を使用する場合は、ポリシーを使用して汎用バケットとその中のオブジェクトへのアクセスを許可する必要があります。バケット所有者強制設定が有効になっている場合、アクセスコントロールリスト (ACL) の設定または ACL の更新は失敗し、`AccessControlListNotSupported` エラーコードが返されます。ACL の読み取り要求は引き続きサポートされています。

ACL の詳細については、次のトピックを参照してください。

**Topics**
+ [アクセスコントロールリスト (ACL) の概要](acl-overview.md)
+ [ACL の設定](managing-acls.md)
+ [ACL のポリシーの例](example-bucket-policies-condition-keys.md)

# アクセスコントロールリスト (ACL) の概要
<a name="acl-overview"></a>

Amazon S3 のアクセスコントロールリスト (ACL) では、バケットとオブジェクトへのアクセスを管理できます。各バケットとオブジェクトには、サブリソースとして ACL がアタッチされています。これにより、アクセスが許可される AWS アカウントまたはグループと、アクセスの種類が定義されます。リソースに対するリクエストを受け取ると、Amazon S3 は該当する ACL を確認して、リクエスタに必要なアクセス許可があることを確かめます。

S3 オブジェクト所有権は、Amazon S3 バケットレベルの設定で、バケットにアップロードされる新しいオブジェクト所有権を制御し、ACL を無効にするのに使用できます。デフォルトでは、オブジェクト所有権はバケット所有者の強制設定に設定され、すべての ACL は無効になります。ACL を無効にすると、バケット所有者はバケット内のすべてのオブジェクトを所有し、アクセス管理ポリシーのみを使用してデータへのアクセスを管理します。

 Amazon S3 の最新のユースケースの大部分では ACL を使用する必要がなくなっています。オブジェクトごとに個別にアクセスを制御する必要がある状況を除き、ACL は無効にしておくことをお勧めします。ACL を無効にすると、誰がオブジェクトをバケットにアップロードしたかに関係なく、ポリシーを使用してバケット内のすべてのオブジェクトへのアクセスを制御できます。詳細については、「[オブジェクトの所有権の制御とバケットの ACL の無効化。](about-object-ownership.md)」を参照してください。

**重要**  
汎用バケットで S3 のオブジェクト所有者に [バケット所有者の強制] 設定を使用する場合は、ポリシーを使用して汎用バケットとその中のオブジェクトへのアクセスを許可する必要があります。バケット所有者強制設定が有効になっている場合、アクセスコントロールリスト (ACL) の設定または ACL の更新は失敗し、`AccessControlListNotSupported` エラーコードが返されます。ACL の読み取り要求は引き続きサポートされています。

バケットまたはオブジェクトを作成すると、Amazon S3 はリソースのフルコントロールをリソースの所有者に付与するデフォルトの ACL を作成します。これを、以下のバケット ACL のサンプルで示します (デフォルトのオブジェクト ACL は同じ構造です)。

**Example**  

```
 1. <?xml version="1.0" encoding="UTF-8"?>
 2. <AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
 3.   <Owner>
 4.     <ID>*** Owner-Canonical-User-ID ***</ID>
 5.   </Owner>
 6.   <AccessControlList>
 7.     <Grant>
 8.       <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 9.                xsi:type="Canonical User">
10.         <ID>*** Owner-Canonical-User-ID ***</ID>
11.       </Grantee>
12.       <Permission>FULL_CONTROL</Permission>
13.     </Grant>
14.   </AccessControlList>
15. </AccessControlPolicy>
```

サンプル ACL には、`Owner` の正規ユーザー ID を通じて所有者を識別する AWS アカウント エレメントが含まれています。正規ユーザー ID を見つける手順については、「[AWS アカウントの正規ユーザー ID の検索](#finding-canonical-id)」を参照してください。`Grant` エレメントは、被付与者 (AWS アカウント またはあらかじめ定義されたグループ) と付与されたアクセス許可を識別します。このデフォルトの ACL には、所有者に対する 1 つの `Grant` エレメントがあります。`Grant` エレメントを追加してアクセス許可を付与します。各許可は被付与者とアクセス許可を識別します。

**注記**  
1 つの ACL には最大 100 個の許可を指定することができます。

**Topics**
+ [被付与者とは](#specifying-grantee)
+ [付与できるアクセス許可](#permissions)
+ [一般的な Amazon S3 リクエストの `aclRequired` 値](#aclrequired-s3)
+ [サンプル ACL](#sample-acl)
+ [既定 ACL](#canned-acl)

## 被付与者とは
<a name="specifying-grantee"></a>

アクセス権限を付与する場合は、各被付与者を `type="value"` のペアとして指定します。`type` は以下のいずれかです。
+ `id` – 指定された値が AWS アカウントの正規ユーザー ID である場合
+ `uri` - 事前定義されたグループにアクセス許可を付与する場合

**警告**  
他の AWS アカウントに自分のリソースへのアクセスを許可した場合、その AWS アカウントはアカウント内のユーザーに許可を委任できることに注意してください。これは*クロスアカウントアクセス*と呼ばれています。クロスアカウントアクセスの使用については、「[IAM ユーザーガイド](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html)」の「*IAM ユーザーにアクセス許可を委任するロールの作成*」を参照してください。

### AWS アカウントの正規ユーザー ID の検索
<a name="finding-canonical-id"></a>

正規ユーザー ID は、AWS アカウントに関連付けられています。この ID は、次のような長い文字列です。

`79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be`

アカウントの正規ユーザー ID を検索する方法については、「**AWS Account Management リファレンスガイド」の「[AWS アカウント の正規ユーザー ID を検索する](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-identifiers.html#FindCanonicalId)」を参照してください。

また、AWS アカウントがアクセス許可を持つバケットまたはオブジェクトの ACL を読み取って、AWS アカウントの正規ユーザー ID を検索することもできます。許可リクエストによって個別の AWS アカウントに許可が付与された場合、ACL にはアカウントの正規ユーザー ID が含まれた許可エントリが追加されます。

**注記**  
バケットをパブリックにした場合 (非推奨)、認証されていないどのユーザーもバケットにオブジェクトをアップロードできます。これらの匿名ユーザーは AWS アカウントを持っていません。匿名ユーザーがバケットにオブジェクトをアップロードすると、Amazon S3 によって特殊な正規ユーザー ID (`65a011a29cdf8ec533ec3d1ccaae921c`) がそのオブジェクトの所有者として ACL で追加されます。詳細については、「[Amazon S3 のバケットとオブジェクトの所有権](access-policy-language-overview.md#about-resource-owner)」を参照してください。

### Amazon S3 の事前定義済みのグループ
<a name="specifying-grantee-predefined-groups"></a>

Amazon S3 には、事前定義済みの一連のグループがあります。グループにアカウントアクセスを許可するときは、正規ユーザー ID の代わりに Amazon S3 のいずれかの URI を指定します。Amazon S3 には、以下の事前に定義されたグループが用意されています。
+ ****Authenticated Users グループ**** – `http://acs.amazonaws.com/groups/global/AuthenticatedUsers` で表されます。

  このグループはすべて AWS アカウントを表しています。**このグループへのアクセス許可により、AWS アカウント がリソースにアクセスできます。**ただし、すべてのリクエストは署名(認証)されている必要があります。
**警告**  
**Authenticated Users グループ**にアクセスを許可すると、世界中の認証された AWS ユーザーがリソースにアクセスできます。
+ ****All Users グループ**** – `http://acs.amazonaws.com/groups/global/AllUsers` で表されます。

  **このグループへのアクセス許可により、世界中の誰でもリソースにアクセスすることが許可されます。**リクエストは署名(認証)済み、または署名なし(匿名)とすることができます。署名なしのリクエストでは、リクエストの Authentication ヘッダーが省略されます。
**警告**  
**All Users グループ**には、`WRITE`、`WRITE_ACP`、または `FULL_CONTROL` アクセス許可を一切付与しないことを強くお勧めします。例えば、`WRITE` アクセス許可は所有者以外のユーザーが既存のオブジェクトを上書きまたは削除することを許可しませんが、`WRITE` アクセス許可はすべてのユーザーがバケットにオブジェクトを格納することを許可し、この料金はお客様に請求されます。これらのアクセス許可の詳細については、次のセクション [付与できるアクセス許可](#permissions) を参照してください。
+ ****Log Delivery グループ**** – `http://acs.amazonaws.com/groups/s3/LogDelivery` で表されます。

  バケットに対する `WRITE` アクセス許可により、このグループはサーバーアクセスログ (「[サーバーアクセスログによるリクエストのログ記録](ServerLogs.md)」を参照) をバケットに書き込むことができます。

**注記**  
ACL を使用する場合、被付与者は AWS アカウントまたは事前定義済みのいずれかの Amazon S3 グループです。被付与者を IAM ユーザーとすることはできません。IAM 内の AWS ユーザーおよびアクセス許可の詳細については、「[AWS Identity and Access Management の使用](https://docs.aws.amazon.com/IAM/latest/UserGuide/)」を参照してください。

## 付与できるアクセス許可
<a name="permissions"></a>

以下の表に、Amazon S3 の ACL でサポートされている一連のアクセス許可を示します。ACL アクセス許可のセットは、オブジェクト ACL とバケット ACL で同じです。ただし、コンテキスト (バケット ACL かオブジェクト ACL か) に応じて、これらの ACL アクセス許可は特定のバケットまたはオブジェクトオペレーションのためのアクセス許可を付与します。この表では、アクセス許可の一覧と、オブジェクトとバケットにおけるその意味について説明しています。

Amazon S3 コンソールでの ACL アクセス権限の詳細については、「[ACL の設定](managing-acls.md)」を参照してください。


| アクセス許可 | バケット上で付与された場合 | オブジェクト上で付与された場合 | 
| --- | --- | --- | 
| READ | 被付与者がバケット内のオブジェクトをリストすることを許可します | 被付与者がオブジェクトデータとそのメタデータを読み込むことを許可します | 
| WRITE | 被付与者がバケット内に新しいオブジェクトを作成できるようにします。既存のオブジェクトのバケット所有者およびオブジェクト所有者には、これらのオブジェクトの削除と上書きも許可します。 | 該当しません | 
| READ\$1ACP | 被付与者がバケット ACL を読み込むことを許可します | 被付与者がオブジェクト ACL を読み込むことを許可します | 
| WRITE\$1ACP | 被付与者が該当するバケットの ACL を書き込むことを許可します | 被付与者が該当するオブジェクトの ACL を書き込むことを許可します | 
| FULL\$1CONTROL | バケットに対する READ、WRITE、READ\$1ACP、WRITE\$1ACP のアクセス許可を被付与者に付与します | オブジェクトに対する READ、READ\$1ACP、WRITE\$1ACP のアクセス許可を被付与者に付与します | 

**警告**  
S3 バケットとオブジェクトにアクセス許可を付与するときは注意が必要です。例えば、あるバケットに対する `WRITE` のアクセス権を付与すると、被付与者はそのバケットにオブジェクトを作成できます。アクセス許可を付与する前に、「[アクセスコントロールリスト (ACL) の概要](#acl-overview)」セクション全体を読むことを強くお勧めします。

### ACL アクセス許可とアクセスポリシーのアクセス許可のマッピング
<a name="acl-access-policy-permission-mapping"></a>

前の表に示したように、ACL で使用できるアクセス許可のセットは、アクセスポリシーで設定できるアクセス許可に比べると限定されています (「[Amazon S3 のポリシーアクション](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-actions)」を参照してください)。これらのアクセス許可はそれぞれ、Amazon S3 の 1 つ以上のオペレーションを許可します。

次の表は、ACL アクセス権限のそれぞれが、対応するアクセスポリシーのアクセス許可にどのようにマッピングされるかを示します。ご覧のように、アクセスポリシーでは ACL よりも多くのアクセス許可が付与されています。ACL は主に、ファイルシステムのアクセス許可と同様に、基本的な読み取り/書き込みアクセス許可を付与するために使用されます。ACL の使用が適している場合の詳細については、[Amazon S3 用 Identity and Access Management](security-iam.md) を参照してください。

Amazon S3 コンソールでの ACL アクセス権限の詳細については、[ACL の設定](managing-acls.md) を参照してください。


| ACL アクセス許可 | ACL アクセス許可がバケットに付与される場合の、対応するアクセスポリシーのアクセス許可  | ACL アクセス許可がオブジェクトに付与される場合の、対応するアクセスポリシーのアクセス許可 | 
| --- | --- | --- | 
| READ | s3:ListBucket、s3:ListBucketVersions、および s3:ListBucketMultipartUploads  | s3:GetObject および s3:GetObjectVersion | 
| WRITE |  `s3:PutObject` バケット所有者は、バケット内の任意のオブジェクトを作成、上書き、削除でき、オブジェクト所有者はそのオブジェクトに対する `FULL_CONTROL` を有します。 さらに、被付与者がバケット所有者であるときは、バケットの ACL で `WRITE` アクセス許可を付与すると、そのバケット内の任意のバージョンに対して `s3:DeleteObjectVersion` アクションを実行できるようになります。  | 該当しません | 
| READ\$1ACP | s3:GetBucketAcl  | s3:GetObjectAcl および s3:GetObjectVersionAcl | 
| WRITE\$1ACP | s3:PutBucketAcl | s3:PutObjectAcl および s3:PutObjectVersionAcl | 
| FULL\$1CONTROL | これは、READ、WRITE、READ\$1ACP、および WRITE\$1ACP ACL アクセス許可を付与するのと同等です。したがって、この ACL アクセス許可は、対応するアクセスポリシーのアクセス許可の組み合わせにマッピングされます。 | これは、READ、READ\$1ACP、および WRITE\$1ACP ACL アクセス許可を付与するのと同等です。したがって、この ACL アクセス許可は、対応するアクセスポリシーのアクセス許可の組み合わせにマッピングされます。 | 

### 条件キー
<a name="acl-specific-condition-keys"></a>

アクセスポリシー権限を付与する場合、条件キーを使用して、バケットポリシーを使用するオブジェクトの ACL の値を制限できます。以下のコンテキストキーは ACL に対応しています。これらのコンテキストキーを使用して、リクエストで特定の ACL の使用を強制することができます。
+ `s3:x-amz-grant-read` ‐ 読み取りアクセスが必要です。
+ `s3:x-amz-grant-write` ‐ 書き込みアクセスが必要です。
+ `s3:x-amz-grant-read-acp` ‐ バケットの ACL への読み取りアクセスが必要です。
+ `s3:x-amz-grant-write-acp` ‐ バケットの ACL への書き込みアクセスが必要です。
+ `s3:x-amz-grant-full-control` ‐ フルコントロールが必要です。
+ `s3:x-amz-acl` ‐ が必要です。[既定 ACL](#canned-acl)

ACL 固有のヘッダーを含むポリシーの例については、「[バケット所有者にフルコントロールを与えることを条件として s3:PutObject のアクセス許可を付与する](example-bucket-policies-condition-keys.md#grant-putobject-conditionally-1)」を参照してください。Amazon S3 固有の条件キーの完全なリストについては、「サービス認可リファレンス」の「[Actions, resources, and condition keys for Amazon S3](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html)」を参照してください。**

S3 リソースタイプ別の S3 API オペレーションへのアクセス許可の詳細については、「[Amazon S3 API オペレーションに必要なアクセス許可](using-with-s3-policy-actions.md)」を参照してください。

## 一般的な Amazon S3 リクエストの `aclRequired` 値
<a name="aclrequired-s3"></a>

承認に ACL を必要とした Amazon S3 リクエストを特定するには、Amazon S3 サーバーアクセスログまたは AWS CloudTrail の `aclRequired` 値を使用できます。CloudTrail または Amazon S3 サーバーアクセスログに表示される `aclRequired` 値は、呼び出されたオペレーションと、リクエスター、オブジェクト所有者、バケット所有者に関する特定の情報によって異なります。ACL が不要であったか、`bucket-owner-full-control` の既定 ACL を設定するか、リクエストがバケットポリシーで許可されている場合、`aclRequired` 値の文字列は Amazon S3 サーバーアクセスログでは「`-`」となり、CloudTrail では存在しません。

以下の表は、さまざまな Amazon S3 API オペレーションに対して CloudTrail または Amazon S3 サーバーアクセスログで期待される `aclRequired` 値を示しています。この情報から、どの Amazon S3 オペレーションが承認に関して ACL に依存しているかを理解できます。以下の表で、A、B、C は、リクエスター、オブジェクト所有者、バケット所有者と関連する各アカウントを表しています。アスタリスク (\$1) が付いているエントリは、A、B、C のうち、任意のアカウントを示します。

**注記**  
次の表の `PutObject` オペレーションは、特に明記しない限り、ACL を設定しないリクエストを示します。ただし、ACL が `bucket-owner-full-control` ACL である場合を除きます。`aclRequired` の値が NULL の場合、`aclRequired` は AWS CloudTrail ログに存在しないことを示します。

 次の表は、CloudTrail の `aclRequired` 値を示しています。


| オペレーション名 | リクエスタ | オブジェクト所有者 | バケット所有者  | バケットポリシーはアクセスを許可する | `aclRequired` 値 | Reason | 
| --- | --- | --- | --- | --- | --- | --- | 
| GetObject | A | A | A | はい/いいえ | null | 同一アカウントアクセス | 
| GetObject | A | B | A | はい/いいえ | null | 同一アカウントアクセス (バケット所有者の強制による) | 
| GetObject | A | A | B | はい | null | クロスアカウントアクセスがバケットポリシーで許可される | 
| GetObject | A | A | B | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| GetObject | A | A | B | はい | null | クロスアカウントアクセスがバケットポリシーで許可される | 
| GetObject | A | B | B | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| GetObject | A | B | C | はい | null | クロスアカウントアクセスがバケットポリシーで許可される | 
| GetObject | A | B | C | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| PutObject | A | 該当しない | A | はい/いいえ | null | 同一アカウントアクセス | 
| PutObject | A | 該当しない | B | はい | null | クロスアカウントアクセスがバケットポリシーで許可される | 
| PutObject | A | 該当しない | B | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| ACL による PutObject (bucket-owner-full-control を除く) | \$1 | 該当しない | \$1 | はい/いいえ | はい | リクエストは ACL を許可する | 
| ListObjects | A | 該当しない | A | はい/いいえ | null | 同一アカウントアクセス | 
| ListObjects | A | 該当しない | B | はい | null | クロスアカウントアクセスがバケットポリシーで許可される | 
| ListObjects | A | 該当しない | B | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| DeleteObject | A | 該当しない | A | はい/いいえ | null | 同一アカウントアクセス | 
| DeleteObject | A | 該当しない | B | はい | null | クロスアカウントアクセスがバケットポリシーで許可される | 
| DeleteObject | A | 該当しない | B | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| PutObjectAcl | \$1 | \$1 | \$1 | はい/いいえ | はい | リクエストは ACL を許可する | 
| PutBucketAcl | \$1 | 該当しない | \$1 | はい/いいえ | はい | リクエストは ACL を許可する | 

 

**注記**  
次の表の `REST.PUT.OBJECT` オペレーションは、特に明記しない限り、ACL を設定しないリクエストを示します。ただし、ACL が `bucket-owner-full-control` ACL である場合を除きます。`aclRequired` 値の文字列「`-`」は、Amazon S3 サーバーアクセスログの NULL 値を示します。

 次の表は、Amazon S3 サーバーアクセスログの `aclRequired` 値を示しています。


| オペレーション名 | リクエスタ | オブジェクト所有者 | バケット所有者  | バケットポリシーはアクセスを許可する | `aclRequired` 値 | Reason | 
| --- | --- | --- | --- | --- | --- | --- | 
| REST.GET.OBJECT | A | A | A | はい/いいえ | - | 同一アカウントアクセス | 
| REST.GET.OBJECT | A | B | A | はい/いいえ | - | 同一アカウントアクセス (バケット所有者の強制による) | 
| REST.GET.OBJECT | A | A | B | はい | - | クロスアカウントアクセスがバケットポリシーで許可される | 
| REST.GET.OBJECT | A | A | B | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| REST.GET.OBJECT | A | B | B | はい | - | クロスアカウントアクセスがバケットポリシーで許可される | 
| REST.GET.OBJECT | A | B | B | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| REST.GET.OBJECT | A | B | C | はい | - | クロスアカウントアクセスがバケットポリシーで許可される | 
| REST.GET.OBJECT | A | B | C | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| REST.PUT.OBJECT | A | 該当しない | A | はい/いいえ | - | 同一アカウントアクセス | 
| REST.PUT.OBJECT | A | 該当しない | B | はい | - | クロスアカウントアクセスがバケットポリシーで許可される | 
| REST.PUT.OBJECT | A | 該当しない | B | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| ACL による REST.PUT.OBJECT (bucket-owner-full-control を除く) | \$1 | 該当しない | \$1 | はい/いいえ | はい | リクエストは ACL を許可する | 
| REST.GET.BUCKET | A | 該当しない | A | はい/いいえ | - | 同一アカウントアクセス | 
| REST.GET.BUCKET | A | 該当しない | B | はい | - | クロスアカウントアクセスがバケットポリシーで許可される | 
| REST.GET.BUCKET | A | 該当しない | B | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| REST.DELETE.OBJECT | A | 該当しない | A | はい/いいえ | - | 同一アカウントアクセス | 
| REST.DELETE.OBJECT | A | 該当しない | B | はい | - | クロスアカウントアクセスがバケットポリシーで許可される | 
| REST.DELETE.OBJECT | A | 該当しない | B | いいえ | あり | クロスアカウントアクセスは ACL に依存する | 
| REST.PUT.ACL | \$1 | \$1 | \$1 | はい/いいえ | はい | リクエストは ACL を許可する | 

## サンプル ACL
<a name="sample-acl"></a>

バケットの以下のサンプル ACL は、リソース所有者と一連の許可を識別します。形式は Amazon S3 REST API の ACL の XML 表現です。バケット所有者はリソースに対する `FULL_CONTROL` が許可されます。また、この ACL には、正規ユーザー ID で示されている 2 つの AWS アカウントと、前のセクションで説明した事前定義済みの 2 つの Amazon S3 グループに対して、リソースへの許可がどのように付与されるかが示されています。

**Example**  

```
 1. <?xml version="1.0" encoding="UTF-8"?>
 2. <AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
 3.   <Owner>
 4.     <ID>Owner-canonical-user-ID</ID>
 5.   </Owner>
 6.   <AccessControlList>
 7.     <Grant>
 8.       <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
 9.         <ID>Owner-canonical-user-ID</ID>
10.       </Grantee>
11.       <Permission>FULL_CONTROL</Permission>
12.     </Grant>
13.     
14.     <Grant>
15.       <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
16.         <ID>user1-canonical-user-ID</ID>
17.       </Grantee>
18.       <Permission>WRITE</Permission>
19.     </Grant>
20. 
21.     <Grant>
22.       <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
23.         <ID>user2-canonical-user-ID</ID>
24.       </Grantee>
25.       <Permission>READ</Permission>
26.     </Grant>
27. 
28.     <Grant>
29.       <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="Group">
30.         <URI>http://acs.amazonaws.com/groups/global/AllUsers</URI> 
31.       </Grantee>
32.       <Permission>READ</Permission>
33.     </Grant>
34.     <Grant>
35.       <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="Group">
36.         <URI>http://acs.amazonaws.com/groups/s3/LogDelivery</URI>
37.       </Grantee>
38.       <Permission>WRITE</Permission>
39.     </Grant>
40. 
41.   </AccessControlList>
42. </AccessControlPolicy>
```

## 既定 ACL
<a name="canned-acl"></a>

Amazon S3 では、*既定 ACL* と呼ばれる事前定義済みの一連の許可がサポートされています。各既定 ACL には、あらかじめ定義された一連の被付与者とアクセス権限が含まれています。以下の表に、一連の既定 ACL と、関連するあらかじめ定義された許可を示します。


| 既定 ACL | Applies to | ACL に追加されるアクセス許可 | 
| --- | --- | --- | 
| private | バケットとオブジェクト | 所有者は FULL\$1CONTROL を取得します。他のユーザーにはアクセス許可は付与されません (デフォルト)。 | 
| public-read | バケットとオブジェクト | 所有者は FULL\$1CONTROL を取得します。AllUsers グループ ([被付与者とは](#specifying-grantee) を参照) は READ アクセス許可を取得します。 | 
| public-read-write | バケットとオブジェクト | 所有者は FULL\$1CONTROL を取得します。AllUsers グループは READ および WRITE アクセス許可を取得します。通常、これをバケットで付与することはお勧めしません。 | 
| aws-exec-read | バケットとオブジェクト | 所有者は FULL\$1CONTROL を取得します。Amazon EC2 には、Amazon S3 から Amazon マシンイメージ (AMI) バンドルを READ するための GET アクセスが許可されます。 | 
| authenticated-read | バケットとオブジェクト | 所有者は FULL\$1CONTROL を取得します。AuthenticatedUsers グループは READ アクセス許可を取得します。 | 
| bucket-owner-read | オブジェクト | オブジェクト所有者は FULL\$1CONTROL を取得します。バケット所有者は READ を取得します。バケットの作成時にこの既定 ACL を指定しても、Amazon S3 には無視されます。 | 
| bucket-owner-full-control | オブジェクト  | オブジェクト所有者とバケット所有者はオブジェクトに対する FULL\$1CONTROL を取得します。バケットの作成時にこの既定 ACL を指定しても、Amazon S3 には無視されます。 | 
| log-delivery-write | バケット  | LogDelivery グループはバケットに対する WRITE および READ\$1ACP アクセス許可を取得します。ログの詳細については、[サーバーアクセスログによるリクエストのログ記録](ServerLogs.md) を参照してください。 | 

**注記**  
リクエストではこれらの既定 ACL を 1 つのみ指定できます。

`x-amz-acl` リクエストヘッダーを使用して、リクエストに既定 ACL を指定します。Amazon S3 が既定 ACL を含むリクエストを受信すると、あらかじめ定義された許可がリソースの ACL に追加されます。

# ACL の設定
<a name="managing-acls"></a>

このセクションでは、アクセスコントロールリスト (ACL) を使用して S3 バケットとオブジェクトのアクセス許可を管理する方法について説明します。リソース ACL に許可を追加するには、AWS マネジメントコンソール、AWS Command Line Interface (CLI)、REST API、または AWS SDK を使用します。

バケットに対するアクセス許可とオブジェクトに対するアクセス許可は相互に独立しています。オブジェクトはバケットからアクセス許可を継承しません。例えば、バケットを作成してユーザーに書き込みアクセスを許可した場合、そのユーザーから明示的にアクセスが許可されない限り、そのユーザーのオブジェクトにアクセスできません。

他の AWS アカウント ユーザーまたは事前定義されたグループに許可を与えることができます。アクセス許可が付与されたユーザーまたはグループは、*被付与者*と呼ばれます。デフォルトでは、バケットを作成した AWS アカウントである所有者が、完全な許可を持っています。

ユーザーまたはグループに付与する各アクセス許可により、バケットに関連付けられたエントリが ACL に追加されます。ACL は、被付与者と付与されたアクセス許可を識別するリストを表示します。

S3 オブジェクト所有権は、Amazon S3 バケットレベルの設定で、バケットにアップロードされる新しいオブジェクト所有権を制御し、ACL を無効にするのに使用できます。デフォルトでは、オブジェクト所有権はバケット所有者の強制設定に設定され、すべての ACL は無効になります。ACL を無効にすると、バケット所有者はバケット内のすべてのオブジェクトを所有し、アクセス管理ポリシーのみを使用してデータへのアクセスを管理します。

 Amazon S3 の最新のユースケースの大部分では ACL を使用する必要がなくなっています。オブジェクトごとに個別にアクセスを制御する必要がある状況を除き、ACL は無効にしておくことをお勧めします。ACL を無効にすると、誰がオブジェクトをバケットにアップロードしたかに関係なく、ポリシーを使用してバケット内のすべてのオブジェクトへのアクセスを制御できます。詳細については、「[オブジェクトの所有権の制御とバケットの ACL の無効化。](about-object-ownership.md)」を参照してください。

**重要**  
汎用バケットで S3 のオブジェクト所有者に [バケット所有者の強制] 設定を使用する場合は、ポリシーを使用して汎用バケットとその中のオブジェクトへのアクセスを許可する必要があります。バケット所有者強制設定が有効になっている場合、アクセスコントロールリスト (ACL) の設定または ACL の更新は失敗し、`AccessControlListNotSupported` エラーコードが返されます。ACL の読み取り要求は引き続きサポートされています。

**警告**  
**すべてのユーザー (パブリックアクセス)**または**認証されたユーザーグループ (すべての AWS 認証ユーザー)** のグループへの書き込みアクセスを許可しないことを強くお勧めします。これらのグループに書き込みアクセスを許可した場合の影響の詳細については、[Amazon S3 の事前定義済みのグループ](acl-overview.md#specifying-grantee-predefined-groups) を参照してください。

## S3 コンソールを使用した、バケットの ACL アクセス権限の設定
<a name="set-bucket-permissions"></a>

コンソールには、重複した被付与者のアクセス権限がまとめて表示されます。ACL の全リストを表示するには、Amazon S3 REST API、AWS CLI、または AWS SDK を使用します。

次の表は、Amazon S3 コンソールでバケットに設定できる ACL アクセス権限を示しています。


**バケットの Amazon S3 コンソールの ACL アクセス権限**  

| コンソールのアクセス権限 | ACL アクセス許可 | アクセス | 
| --- | --- | --- | 
| オブジェクト − リスト | READ | 被付与者がバケット内のオブジェクトをリストすることを許可します。 | 
| オブジェクト − 書き込み | WRITE | 被付与者がバケット内に新しいオブジェクトを作成できるようにします。既存のオブジェクトのバケット所有者およびオブジェクト所有者については、これらのオブジェクトの削除と上書きも許可します。 | 
| バケット ACL − 読み取り | READ\$1ACP | 被付与者がバケット ACL を読み込むことを許可します。 | 
| バケット ACL − 書き込み | WRITE\$1ACP | 被付与者が該当するバケットの ACL を書き込むことを許可します。 | 
| 全員 (パブリックアクセス): オブジェクト − リスト | READ | バケット内のオブジェクトに対するパブリック読み取りアクセス権を付与します。リストアクセス権を [Everyone (public access)] (全員 (パブリックアクセス)) に付与すると、世界中のユーザーがバケット内のオブジェクトにアクセスできます。 | 
| 全員 (パブリックアクセス) : バケット ACL − 読み取り | READ\$1ACP | バケット ACL のパブリック読み取りアクセス権を付与します。[Everyone (public access)] (全員 (パブリックアクセス)) に読み取りアクセス権を付与すると、世界中のユーザーがバケット ACL にアクセスできます。 | 

ACL アクセス権限の詳細については、[アクセスコントロールリスト (ACL) の概要](acl-overview.md) を参照してください。

**重要**  
汎用バケットで S3 のオブジェクト所有者に [バケット所有者の強制] 設定を使用する場合は、ポリシーを使用して汎用バケットとその中のオブジェクトへのアクセスを許可する必要があります。バケット所有者強制設定が有効になっている場合、アクセスコントロールリスト (ACL) の設定または ACL の更新は失敗し、`AccessControlListNotSupported` エラーコードが返されます。ACL の読み取り要求は引き続きサポートされています。

**バケットに ACL アクセス許可を設定する**

1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。

1. 左のナビゲーションペインで、**[汎用バケット]** を選択します。

1. [**Buckets (バケット)**] リストで、アクセス許可を設定するバケットの名前を選択します。

1. [**Permissions**] を選択します。

1. [**アクセスコントロールリスト**] で、[**編集**] を選択します。

   バケットに対する次の ACL アクセス許可を編集できます。

**オブジェクト**
   + **List (リスト)** − 被付与者がバケット内のオブジェクトをリストすることを許可します
   + **Write** (書き込み) – 被付与者がバケット内に新しいオブジェクトを作成できるようにします。既存のオブジェクトのバケット所有者およびオブジェクト所有者については、これらのオブジェクトの削除と上書きも許可します。

     S3 コンソールでは、S3 ログデリバリーグループとバケット所有者 (AWS アカウント) にのみ書き込みアクセスを許可できます。他の被付与者には、書き込みアクセスを許可しないことを強くお勧めします。ただし、書き込みアクセスを許可する必要がある場合は、AWS CLI、AWS SDK、または REST API を使用できます。

**バケット ACL**
   + **Read (読み込み)** − 被付与者がバケット ACL を読み込むことを許可します
   + **Write (書き込み)** − 被付与者が該当するバケットの ACL を書き込むことを許可します

1. バケット所有者の許可を変更するには、**バケット所有者 (AWS アカウント)**の横で、次の ACL アクセス権限を消去または選択します。
   + [**Objects (オブジェクト)**] − [**List (リスト)**] または [**Write (書き込み)**]
   + [**Bucket ACL (バケット ACL)**] – [**Read (読み取り)**] または [**Write (書き込み)**]

   *所有者*とは、AWS アカウントのルートユーザーであり、AWS Identity and Access Management IAM ユーザーではありません。ルートユーザーの詳細については、「*IAM ユーザーガイド*」の「[AWS アカウントのルートユーザー](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html)」を参照してください。

1. 一般ユーザー (インターネット上のすべてのユーザー) のアクセス許可を付与または取り消すには、[**Everyone (public access) (全員 (パブリックアクセス))**] の横で、次の ACL アクセス許可をクリアまたは選択します。
   + [**Objects (オブジェクト)**] – [**List (リスト)**]
   + [**Bucket ACL (バケット ACL)**] – [**Read (読み取り)**]
**警告**  
[**全員**] グループに S3 バケットへのパブリックアクセスを付与するときは注意が必要です。このグループにアクセスを付与すると、世界中のすべてのユーザーがバケットにアクセスできます。種類にかかわらず、S3 バケットへのパブリック書き込みアクセスは一切付与しないことを強くお勧めします。

1. AWS アカウント があれば誰でも許可を付与するか取り消すために、**認証済みユーザーグループ (AWS アカウント があれば誰でも可)** の横で、次の ACL アクセス権限を消去または選択します。
   + [**Objects (オブジェクト)**] – [**List (リスト)**]
   + [**Bucket ACL (バケット ACL)**] – [**Read (読み取り)**]

1. Amazon S3 がバケットにサーバーアクセスログを書き込むアクセス許可を付与または取り消すには、[**S3 log delivery group (S3 ログ配信グループ)**] で、次の ACL アクセス許可をクリアまたは選択します。
   + [**Objects (オブジェクト)**] – [**List (リスト)**] または [**Write (書き込み)**] 
   + [**Bucket ACL (バケット ACL)**] – [**Read (読み取り)**] または [**Write (書き込み)**] 

     バケットがアクセスログを受け取るターゲットバケットとして設定されている場合、バケットのアクセス許可は [**ログ配信**] グループのバケットへの書き込みアクセスを許可する必要があります。バケット上のサーバアクセスログ記録を有効にすると、Amazon S3 コンソールは、[**Log Delivery (ログ配信)**] グループにログを受信することを選択したターゲットバケットへの書き込みアクセス権を付与します。サーバーアクセスログ記録の詳細については、「[Amazon S3 サーバーアクセスログを有効にします。](enable-server-access-logging.md)」を参照してください。

1. 別の AWS アカウントへの許可を付与するには、次の手順を実行します。

   1. [**Add grantee (被付与者の追加)**] を選択します。

   1. [**Grantee**] (被付与者) ボックスに、他の AWS アカウント の正規 ID を入力します。

   1. 次の ACL アクセス許可から選択します。
      + [**Objects (オブジェクト)**] – [**List (リスト)**] または [**Write (書き込み)**]
      + [**Bucket ACL (バケット ACL)**] – [**Read (読み取り)**] または [**Write (書き込み)**]
**警告**  
他の AWS アカウントに自分のリソースへのアクセスを許可した場合、その AWS アカウントはアカウント内のユーザーに許可を委任できることに注意してください。これは*クロスアカウントアクセス*と呼ばれています。クロスアカウントアクセスの使用については、[IAM ユーザーガイド](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html)の*IAM ユーザーにアクセス許可を委任するロールの作成*を参照してください。

1. 別の AWS アカウント へのアクセスを削除するには、**他の AWS アカウント へのアクセス**で、**削除**を選択します。

1. 変更を保存するには、[**変更の保存**] を選択します。

## S3 コンソールを使用した、オブジェクトの ACL アクセス権限の設定
<a name="set-object-permissions"></a>

コンソールには、重複した被付与者のアクセス権限がまとめて表示されます。ACL の全リストを表示するには、Amazon S3 REST API、AWS CLI、または AWS SDK を使用します。次の表に、Amazon S3 コンソールでオブジェクト用に設定できる ACL アクセス権限を示します。


**オブジェクト用の Amazon S3 コンソールの ACL アクセス権限**  

| コンソールのアクセス権限 | ACL アクセス許可 | アクセス | 
| --- | --- | --- | 
| オブジェクト − 読み取り | READ | 被付与者がオブジェクトデータとそのメタデータを読み込むことを許可します。 | 
| オブジェクト ACL − 読み取り | READ\$1ACP | 被付与者がオブジェクト ACL を読み込むことを許可します。 | 
| オブジェクト ACL − 書き込み | WRITE\$1ACP | 被付与者が該当するオブジェクトの ACL を書き込むことを許可します | 

ACL アクセス権限の詳細については、[アクセスコントロールリスト (ACL) の概要](acl-overview.md) を参照してください。

**重要**  
汎用バケットで S3 のオブジェクト所有者に [バケット所有者の強制] 設定を使用する場合は、ポリシーを使用して汎用バケットとその中のオブジェクトへのアクセスを許可する必要があります。バケット所有者強制設定が有効になっている場合、アクセスコントロールリスト (ACL) の設定または ACL の更新は失敗し、`AccessControlListNotSupported` エラーコードが返されます。ACL の読み取り要求は引き続きサポートされています。

**オブジェクトに ACL アクセス権限を設定する**

1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。

1. [**Buckets**] (バケット) リストで、オブジェクトが含まれるバケットの名前を選択します。

1. **オブジェクト**のリストで、アクセス許可を設定するオブジェクトの名前を選択します。

1. [**Permissions**] を選択します。

1. [アクセスコントロールリスト (ACL)] で、[**編集**] を選択します。

   オブジェクトに対する次の ACL アクセス許可を編集できます。

**オブジェクト**
   + **Read (読み込み)** − 被付与者がオブジェクトデータとそのメタデータを読み込むことを許可します

**オブジェクト ACL**
   + **読み込み (Read)** − 被付与者がオブジェクト ACL を読み込むことを許可します
   + **Write (書き込み)** − 被付与者が該当するオブジェクトの ACL を書き込むことを許可します S3 コンソールでは、バケット所有者 (AWS アカウント) にのみ書き込みアクセスを許可できます。他の被付与者には、書き込みアクセスを許可しないことを強くお勧めします。ただし、書き込みアクセスを許可する必要がある場合は、AWS CLI、AWS SDK、または REST API を使用できます。

1. 以下のオブジェクトのアクセス許可を管理できます。

   1. 

**オブジェクト所有者へのアクセス**

      *所有者*とは、AWS アカウントのルートユーザーであり、AWS Identity and Access Management IAM ユーザーではありません。ルートユーザーの詳細については、「*IAM ユーザーガイド*」の「[AWS アカウントのルートユーザー](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html)」を参照してください。

      所有者のオブジェクトアクセス許可を変更するには、**オブジェクト所有者へのアクセス**で、**お客様の AWS アカウント (所有者)** を選択します。

      変更するアクセス許可のチェックボックスをオンにして、[**保存**] を選択します。

   1. 

**その他の AWS アカウントのアクセス**

      別の AWS から AWS アカウント ユーザーに許可を与えるには、**他の AWS アカウント へのアクセス**で、**アカウントの追加**を選択します。[**Enter an ID**] (ID の入力) フィールドに、オブジェクトのアクセス許可を付与する AWS ユーザーの正規 ID を入力します。正規 ID の検索に関する詳細は、*Amazon Web Services 全般のリファレンス* の「[AWS アカウント 識別子](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html)」を参照してください。最大 99 人のユーザーを追加できます。

      ユーザーに付与するアクセス許可のチェックボックスをオンにして、[**保存**] を選択します。アクセス許可についての情報を表示するには、ヘルプアイコンを選択します。

   1. 

**パブリックアクセス**

      オブジェクトへのアクセスを一般のユーザー (世界中のすべてのユーザー) に許可するには、[**パブリックアクセス**] で [**全員**] を選択します。パブリックアクセス許可を付与すると、世界中の誰でもオブジェクトにアクセスできるようになります。

      付与するアクセス許可のチェックボックスをオンにして、[**保存**] を選択します。
**警告**  
[**Everyone (全員)**] グループに Amazon S3 オブジェクトへの匿名アクセスを付与するときは注意が必要です。このグループにアクセスを付与すると、世界中のすべてのユーザーがオブジェクトにアクセスできます。すべてのユーザーにアクセスを付与する必要がある場合は、[**Read objects (オブジェクトの読み取り)**] のみのアクセス許可を付与することを強くお勧めします。
[*全員*] グループにオブジェクト書き込み許可は付与**しない**ことを強くお勧めします。付与すると、すべてのユーザーに対して、オブジェクトの ACL アクセス許可を上書きすることが許可されます。

## AWS SDK の使用
<a name="acl-using-sdk"></a>

このセクションでは、バケットやオブジェクトでアクセスコントロールリスト (ACL) の付与を設定する方法の例を示します。

**重要**  
汎用バケットで S3 のオブジェクト所有者に [バケット所有者の強制] 設定を使用する場合は、ポリシーを使用して汎用バケットとその中のオブジェクトへのアクセスを許可する必要があります。バケット所有者強制設定が有効になっている場合、アクセスコントロールリスト (ACL) の設定または ACL の更新は失敗し、`AccessControlListNotSupported` エラーコードが返されます。ACL の読み取り要求は引き続きサポートされています。

------
#### [ Java ]

このセクションでは、バケットやオブジェクトでアクセスコントロールリスト (ACL) の付与を設定する方法の例を示します。最初の例では、既定 ACL を使用するバケット (「[既定 ACL](acl-overview.md#canned-acl)」を参照) を作成します。次に、カスタムアクセス許可の付与のリストを作成して、既定の ACL をカスタム付与を含む ACL で置き換えます。2 番目の例では、`AccessControlList.grantPermission()` メソッドを使用して ACL を変更する方法を示します。

**Example バケットを作成し、S3 ログ配信グループにアクセス許可を付与する既定 ACL を指定する**  
この例では、バケットを作成します。リクエストで既定の ACL を指定し、バケットにログを書き込むアクセス許可をログ配信グループに付与します。  

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
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.IOException;
import java.util.ArrayList;

public class CreateBucketWithACL {

    public static void main(String[] args) throws IOException {
        Regions clientRegion = Regions.DEFAULT_REGION;
        String bucketName = "*** Bucket name ***";
        String userEmailForReadPermission = "*** user@example.com ***";

        try {
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .withRegion(clientRegion)
                    .build();

            // Create a bucket with a canned ACL. This ACL will be replaced by the
            // setBucketAcl()
            // calls below. It is included here for demonstration purposes.
            CreateBucketRequest createBucketRequest = new CreateBucketRequest(bucketName, clientRegion.getName())
                    .withCannedAcl(CannedAccessControlList.LogDeliveryWrite);
            s3Client.createBucket(createBucketRequest);

            // Create a collection of grants to add to the bucket.
            ArrayList<Grant> grantCollection = new ArrayList<Grant>();

            // Grant the account owner full control.
            Grant grant1 = new Grant(new CanonicalGrantee(s3Client.getS3AccountOwner().getId()),
                    Permission.FullControl);
            grantCollection.add(grant1);

            // Grant the LogDelivery group permission to write to the bucket.
            Grant grant2 = new Grant(GroupGrantee.LogDelivery, Permission.Write);
            grantCollection.add(grant2);

            // Save grants by replacing all current ACL grants with the two we just created.
            AccessControlList bucketAcl = new AccessControlList();
            bucketAcl.grantAllPermissions(grantCollection.toArray(new Grant[0]));
            s3Client.setBucketAcl(bucketName, bucketAcl);

            // Retrieve the bucket's ACL, add another grant, and then save the new ACL.
            AccessControlList newBucketAcl = s3Client.getBucketAcl(bucketName);
            Grant grant3 = new Grant(new EmailAddressGrantee(userEmailForReadPermission), Permission.Read);
            newBucketAcl.grantAllPermissions(grant3);
            s3Client.setBucketAcl(bucketName, newBucketAcl);
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it and 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();
        }
    }
}
```

**Example 既存のオブジェクトの ACL を更新する**  
この例では、オブジェクトの ACL を更新します。この例では次のタスクを実行しています。  
+ オブジェクトの ACL を取得する
+ すべての既存のアクセス許可を削除して ACL をクリアする
+ 2 つのアクセス許可として、所有者へのフルアクセスと、メールアドレスで識別されたユーザーへの WRITE\$1ACP ([付与できるアクセス許可](acl-overview.md#permissions) を参照) を追加する
+ ACL をオブジェクトに保存する

```
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.AccessControlList;
import com.amazonaws.services.s3.model.CanonicalGrantee;
import com.amazonaws.services.s3.model.EmailAddressGrantee;
import com.amazonaws.services.s3.model.Permission;

import java.io.IOException;

public class ModifyACLExistingObject {

    public static void main(String[] args) throws IOException {
        Regions clientRegion = Regions.DEFAULT_REGION;
        String bucketName = "*** Bucket name ***";
        String keyName = "*** Key name ***";
        String emailGrantee = "*** user@example.com ***";

        try {
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .withCredentials(new ProfileCredentialsProvider())
                    .withRegion(clientRegion)
                    .build();

            // Get the existing object ACL that we want to modify.
            AccessControlList acl = s3Client.getObjectAcl(bucketName, keyName);

            // Clear the existing list of grants.
            acl.getGrantsAsList().clear();

            // Grant a sample set of permissions, using the existing ACL owner for Full
            // Control permissions.
            acl.grantPermission(new CanonicalGrantee(acl.getOwner().getId()), Permission.FullControl);
            acl.grantPermission(new EmailAddressGrantee(emailGrantee), Permission.WriteAcp);

            // Save the modified ACL back to the object.
            s3Client.setObjectAcl(bucketName, keyName, acl);
        } 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 ]

**Example バケットを作成し、S3 ログ配信グループにアクセス許可を付与する既定 ACL を指定する**  
この C\$1 の例では、バケットを作成します。リクエストで既定の ACL を指定し、バケットにログを書き込むアクセス許可をログ配信グループに付与します。  
 コード例を設定および実行する方法の詳細については、「*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.Model;
using System;
using System.Threading.Tasks;

namespace Amazon.DocSamples.S3
{
    class ManagingBucketACLTest
    {
        private const string newBucketName = "*** bucket name ***"; 
        // Specify your bucket region (an example region is shown).
        private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
        private static IAmazonS3 client;

        public static void Main()
        {
            client = new AmazonS3Client(bucketRegion);
            CreateBucketUseCannedACLAsync().Wait();
        }

        private static async Task CreateBucketUseCannedACLAsync()
        {
            try
            {
                // Add bucket (specify canned ACL).
                PutBucketRequest putBucketRequest = new PutBucketRequest()
                {
                    BucketName = newBucketName,
                    BucketRegion = S3Region.EUW1, // S3Region.US,
                                                  // Add canned ACL.
                    CannedACL = S3CannedACL.LogDeliveryWrite
                };
                PutBucketResponse putBucketResponse = await client.PutBucketAsync(putBucketRequest);

                // Retrieve bucket ACL.
                GetACLResponse getACLResponse = await client.GetACLAsync(new GetACLRequest
                {
                    BucketName = newBucketName
                });
            }
            catch (AmazonS3Exception amazonS3Exception)
            {
                Console.WriteLine("S3 error occurred. Exception: " + amazonS3Exception.ToString());
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception: " + e.ToString());
            }
        }
    }
}
```

**Example 既存のオブジェクトの ACL を更新する**  
この C\$1 の例では、既存のオブジェクトで ACL を更新します。この例では次のタスクを実行しています。  
+ オブジェクトの ACL を取得する。
+ すべての既存のアクセス許可を削除して ACL をクリアする。
+ 2 つのアクセス許可として、所有者へのフルアクセスと、メールアドレスで識別されたユーザーへの WRITE\$1ACP を追加する。
+ `PutAcl` リクエストを送信して ACL を保存する。
コード例を設定および実行する方法の詳細については、「*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.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Amazon.DocSamples.S3
{
    class ManagingObjectACLTest
    {
        private const string bucketName = "*** bucket name ***"; 
        private const string keyName = "*** object key name ***"; 
        private const string emailAddress = "*** email address ***";
        // Specify your bucket region (an example region is shown).
        private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
        private static IAmazonS3 client;
        public static void Main()
        {
            client = new AmazonS3Client(bucketRegion);
            TestObjectACLTestAsync().Wait();
        }
        private static async Task TestObjectACLTestAsync()
        {
            try
            {
                    // Retrieve the ACL for the object.
                    GetACLResponse aclResponse = await client.GetACLAsync(new GetACLRequest
                    {
                        BucketName = bucketName,
                        Key = keyName
                    });

                    S3AccessControlList acl = aclResponse.AccessControlList;

                    // Retrieve the owner (we use this to re-add permissions after we clear the ACL).
                    Owner owner = acl.Owner;

                    // Clear existing grants.
                    acl.Grants.Clear();

                    // Add a grant to reset the owner's full permission (the previous clear statement removed all permissions).
                    S3Grant fullControlGrant = new S3Grant
                    {
                        Grantee = new S3Grantee { CanonicalUser = owner.Id },
                        Permission = S3Permission.FULL_CONTROL
                        
                    };

                    // Describe the grant for the permission using an email address.
                    S3Grant grantUsingEmail = new S3Grant
                    {
                        Grantee = new S3Grantee { EmailAddress = emailAddress },
                        Permission = S3Permission.WRITE_ACP
                    };
                    acl.Grants.AddRange(new List<S3Grant> { fullControlGrant, grantUsingEmail });
 
                    // Set a new ACL.
                    PutACLResponse response = await client.PutACLAsync(new PutACLRequest
                    {
                        BucketName = bucketName,
                        Key = keyName,
                        AccessControlList = acl
                    });
            }
            catch (AmazonS3Exception amazonS3Exception)
            {
                Console.WriteLine("An AmazonS3Exception was thrown. Exception: " + amazonS3Exception.ToString());
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception: " + e.ToString());
            }
        }
    }
}
```

------

## REST API の使用
<a name="acl-using-rest-api"></a>

Amazon S3 API を使用して、バケットまたはオブジェクトの作成時に、ACL を設定できます。Amazon S3 では、既存のバケットまたはオブジェクトに ACL を設定する API も提供します。これらの API は ACL を設定する次のメソッドを提供します。
+ **リクエストヘッダーを使用した ACL の設定** − リソース (バケットまたはオブジェクト) を作成するリクエストを送るときに、リクエストヘッダーを使用して ACL を設定します。これらのヘッダーを使用して、既定 ACL を指定するか、許可を明示的に指定 (被付与者とアクセス許可を明示的に識別) します。
+ **リクエストボディを使用した ACL の設定** − 既存のリソースに ACL を設定するリクエストを送信するときに、リクエストのヘッダーまたはボディを使用して ACL を設定できます。

REST API での ACL の管理のサポートの詳細については、*Amazon Simple Storage Service API リファレンス*の以下のセクションを参照してください。
+  [GetBucketAcl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETacl.html) 
+  [PutBucketAcl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTacl.html) 
+  [GetObjectAcl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGETacl.html) 
+  [PutObjectAcl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUTacl.html) 
+  [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html) 
+  [:CreateBucket](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUT.html) 
+  [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html) 
+  [CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html) 

**重要**  
汎用バケットで S3 のオブジェクト所有者に [バケット所有者の強制] 設定を使用する場合は、ポリシーを使用して汎用バケットとその中のオブジェクトへのアクセスを許可する必要があります。バケット所有者強制設定が有効になっている場合、アクセスコントロールリスト (ACL) の設定または ACL の更新は失敗し、`AccessControlListNotSupported` エラーコードが返されます。ACL の読み取り要求は引き続きサポートされています。

### アクセスコントロールリスト (ACL) 固有の要求ヘッダー
<a name="acl-headers-rest-api"></a>

ヘッダーを使用して、アクセスコントロールリスト (ACL) ベースのアクセス許可を付与できます。デフォルトでは、すべてのオブジェクトがプライベートです。所有者だけがフルアクセスコントロールを持っています。新しいオブジェクトを追加するときに、個々の AWS アカウントに、または Amazon S3 であらかじめ定義されたグループに許可を付与できます。これらのアクセス許可は、オブジェクトのアクセスコントロールリスト (ACL) に追加されます。詳細については、[アクセスコントロールリスト (ACL) の概要](acl-overview.md) を参照してください。

この操作では、次の 2 つの方法のいずれかを使用してアクセス許可を付与できます。
+ **既定 ACL (`x-amz-acl`)** — Amazon S3 は、既定 ACL と呼ばれる、あらかじめ定義された一連の ACL をサポートしています。各既定 ACL には、あらかじめ定義された一連の被付与者とアクセス権限が含まれています。詳細については、[既定 ACL](acl-overview.md#canned-acl) を参照してください。
+ **アクセス許可** — 特定の AWS アカウント またはグループにアクセス許可を明示的に付与するには、次のヘッダーを使用します。各ヘッダーは、Amazon S3 が ACL でサポートする特定のアクセス許可にマッピングされます。詳細については、[アクセスコントロールリスト (ACL) の概要](acl-overview.md) を参照してください。ヘッダーでは、特定のアクセス許可を取得する被付与者のリストを指定します。
  + x−amz−grant−read
  + x−amz−grant−write
  + x−amz−grant−read−acp
  + x−amz−grant−write−acp
  + x−amz−grant−full−control

## AWS CLI の使用
<a name="using-acl-cli"></a>

AWS CLI を使用した ACL の管理の詳細については、*AWS CLI Command Reference* の [put−bucket−acl](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-acl.html) を参照してください。

**重要**  
汎用バケットで S3 のオブジェクト所有者に [バケット所有者の強制] 設定を使用する場合は、ポリシーを使用して汎用バケットとその中のオブジェクトへのアクセスを許可する必要があります。バケット所有者強制設定が有効になっている場合、アクセスコントロールリスト (ACL) の設定または ACL の更新は失敗し、`AccessControlListNotSupported` エラーコードが返されます。ACL の読み取り要求は引き続きサポートされています。

# ACL のポリシーの例
<a name="example-bucket-policies-condition-keys"></a>

バケットポリシーで条件キーを使用して、Amazon S3 へのアクセスをコントロールできます。

**Topics**
+ [バケット所有者にフルコントロールを与えることを条件として s3:PutObject のアクセス許可を付与する](#grant-putobject-conditionally-1)
+ [x-amz-acl ヘッダーの条件を使用した s3:PutObject アクセス許可の付与](#example-acl-header)

## バケット所有者にフルコントロールを与えることを条件として s3:PutObject のアクセス許可を付与する
<a name="grant-putobject-conditionally-1"></a>

[PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html) オペレーションでは、アクセスコントロールリスト (ACL) に固有のヘッダーを使用して、ACL に基づいてアクセス許可を付与することができます。バケット所有者は、これらのキーを使用して条件を設定し、ユーザーがオブジェクトをアップロードする場合に特定のアクセス許可を要求することができます。

例えば、アカウント A がバケット所有者であり、アカウント管理者がアカウント B のユーザー Dave に対して、オブジェクトをアップロードするアクセス許可を付与するとします。デフォルトでは、Dave がアップロードするオブジェクトはアカウント B に所有されるため、アカウント A にはそれらのオブジェクトに対するアクセス許可は付与されません。ただし、バケット所有者は請求書を支払うために、Dave がアップロードするオブジェクトに対する完全なアクセス許可を必要としています。この対処方法として、アカウント A の管理者は、明示的に完全なアクセス許可を付与するか、既定 ACL を使用する ACL 固有のヘッダーをリクエストに含むことを条件として、Dave に `s3:PutObject` のアクセス許可を付与できます。詳細については、[Put Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html) を参照してください。

### x−amz−full−control ヘッダーを必須にする
<a name="require-x-amz-full-control"></a>

リクエストで、バケット所有者へのフルコントロールのアクセス許可が含まれる `x-amz-full-control` ヘッダーを要求できます。以下のバケットポリシーは、`s3:PutObject` 条件キーを使用して、リクエストに `s3:x-amz-grant-full-control` ヘッダーを含めることを条件とする `x-amz-full-control` のアクセス許可をユーザー Dave に付与します。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "statement1",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::111122223333:user/Dave"
            },
            "Action": "s3:PutObject",
            "Resource": "arn:aws:s3:::awsexamplebucket1/*",
            "Condition": {
                "StringEquals": {
                    "s3:x-amz-grant-full-control": "id=AccountA-CanonicalUserID"
                }
            }
        }
    ]
}
```

------

**注記**  
この例では、クロスアカウントのアクセス許可を付与しています。ただし、許可を付与される Dave がバケットを所有している AWS アカウントに属している場合、この条件付き許可は不要になります。これは、ユーザーがアップロードするオブジェクトは Dave が属する親アカウントによって所有されるためです。

**明示的な拒否を追加する**  
前述のバケットポリシーでは、アカウント B のユーザー Dave に条件付きのアクセス許可が付与されます。ただし、このポリシーが有効であっても、Dave が他のポリシーに従って、条件なしで同じアクセス許可を取得する場合があります。例えば、Dave が属するグループに、条件なしで `s3:PutObject` のアクセス許可が付与される場合があります。このようなアクセス許可の抜け穴を避けるには、明示的な拒否を追加して、より厳格なアクセスポリシーを記述する必要があります。次の例では、バケット所有者に完全なアクセス許可を付与するヘッダーをリクエストに含めない場合、Dave に対してアップロードのアクセス許可を明示的に拒否します。明示的な拒否は、付与されている他のアクセス許可に常に優先されます。以下は、明示的な拒否が追加された、改訂済みアクセスポリシーの例です。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "statement1",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::111122223333:user/AccountBadmin"
            },
            "Action": "s3:PutObject",
            "Resource": "arn:aws:s3:::awsexamplebucket1/*",
            "Condition": {
                "StringEquals": {
                    "s3:x-amz-grant-full-control": "id=AccountA-CanonicalUserID"
                }
            }
        },
        {
            "Sid": "statement2",
            "Effect": "Deny",
            "Principal": {
                "AWS": "arn:aws:iam::111122223333:user/AccountBadmin"
            },
            "Action": "s3:PutObject",
            "Resource": "arn:aws:s3:::awsexamplebucket1/*",
            "Condition": {
                "StringNotEquals": {
                    "s3:x-amz-grant-full-control": "id=AccountA-CanonicalUserID"
                }
            }
        }
    ]
}
```

------

**AWS CLI でポリシーをテストする**  
2 つの AWS アカウントがある場合は、AWS Command Line Interface (AWS CLI) を使用してポリシーをテストできます。ポリシーをアタッチしたら、Dave の認証情報を使用し、次の AWS CLI `put-object` コマンドを実行してアクセス許可をテストします。Dave の認証情報は、`--profile` パラメータを追加して指定します。バケット所有者にフルコントロールのアクセス許可を付与するには、`--grant-full-control` パラメータを追加します。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)」を参照してください。**

```
aws s3api put-object --bucket examplebucket --key HappyFace.jpg --body c:\HappyFace.jpg --grant-full-control id="AccountA-CanonicalUserID" --profile AccountBUserProfile
```

### x−amz−acl ヘッダーを必須にする
<a name="require-x-amz-acl-header"></a>

バケット所有者にフルコントロールのアクセス許可を付与する既定 ACL が指定された `x-amz-acl` ヘッダーを要求できます。リクエストに `x-amz-acl` ヘッダーを含めることを義務付けるには、以下の例のように `Condition` ブロックのキーと値のペアを置き換え、`s3:x-amz-acl` 条件キーを指定します。

```
"Condition": {
    "StringEquals": {
        "s3:x-amz-acl": "bucket-owner-full-control"
    }
}
```

AWS CLI を使用してアクセス許可をテストするには、`--acl` パラメータを指定します。これにより、AWS CLI は送信するリクエストに `x-amz-acl` ヘッダーを追加します。

```
aws s3api put-object --bucket examplebucket --key HappyFace.jpg --body c:\HappyFace.jpg --acl "bucket-owner-full-control" --profile AccountBadmin
```

## x-amz-acl ヘッダーの条件を使用した s3:PutObject アクセス許可の付与
<a name="example-acl-header"></a>

以下のバケットポリシーは、オブジェクトをパブリックに読み取り可能にする `x-amz-acl` ヘッダーがリクエストに含まれている場合に、2 つの AWS アカウントに `s3:PutObject` の許可を付与します。`Condition` ブロックでは、`StringEquals` 条件を使用し、キーと値のペアとして `"s3:x-amz-acl":["public-read"]` を評価に使用できます。このキーと値のペアで、`s3:x-amz-acl` は、「`s3:`」というプレフィックスが示すとおり Amazon S3 固有のキーです。

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AddCannedAcl",
            "Effect": "Allow",
            "Principal": {
                "AWS": [
                    "arn:aws:iam::111122223333:root",
                    "arn:aws:iam::111122223333:root"
                ]
            },
            "Action": "s3:PutObject",
            "Resource": [
                "arn:aws:s3:::awsexamplebucket1/*"
            ],
            "Condition": {
                "StringEquals": {
                    "s3:x-amz-acl": [
                        "public-read"
                    ]
                }
            }
        }
    ]
}
```

------

**重要**  
すべての条件が、すべてのアクションに対して意味を成すわけではありません。例えば、Amazon S3 の `s3:LocationConstraint` のアクセス許可を付与するポリシーに条件として `s3:CreateBucket` を含めることは理にかなっています。ただし、この条件を `s3:GetObject` のアクセス許可を付与するポリシーに含めることは意味がありません。Amazon S3 では、このような Amazon S3 固有の条件を含むセマンティックエラーをテストすることができます。ただし、IAM ユーザーまたはロールのポリシーを作成し、意味的に無効な Amazon S3 条件を含めても、IAM は Amazon S3 条件を検証できないため、エラーは報告されません。