翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# の開始方法AWS Config
AWS Configは、 内のAWSリソースの設定の詳細ビューを提供しますAWS アカウント。を使用するとAWS Config、AWSリソース間の設定や関係の変更を確認し、リソース設定履歴を調べ、ルールを使用してコンプライアンスを判断できます。詳細については、[「 とはAWS Config](https://docs.aws.amazon.com/config/latest/developerguide/WhatIsConfig.html)」および[AWS Config「 の仕組み](https://docs.aws.amazon.com/config/latest/developerguide/how-does-config-work.html)」を参照してください。
## にサインアップするAWS
**Topics**
+ [にサインアップするAWS アカウント](#sign-up-for-aws)
+ [管理アクセスを持つユーザーを作成する](#create-an-admin)
### にサインアップするAWS アカウント
がない場合はAWS アカウント、次の手順を実行して作成します。
**にサインアップするにはAWS アカウント**
1. [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup) を開きます。
1. オンラインの手順に従います。
サインアップ手順の一環として、電話またはテキストメッセージを受け取り、電話キーパッドで検証コードを入力します。
にサインアップするとAWS アカウント、 *AWS アカウントのルートユーザー* が作成されます。ルートユーザーには、アカウントのすべてのAWS のサービスとリソースへのアクセス権があります。セキュリティベストプラクティスとして、ユーザーに管理アクセス権を割り当て、[ルートユーザーアクセスが必要なタスク](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)の実行にはルートユーザーのみを使用するようにしてください。
AWSサインアッププロセスが完了すると、 から確認メールが送信されます。[https://aws.amazon.com/](https://aws.amazon.com/) の **[マイアカウント]** をクリックして、いつでもアカウントの現在のアクティビティを表示し、アカウントを管理することができます。
### 管理アクセスを持つユーザーを作成する
にサインアップしたらAWS アカウント、日常的なタスクにルートユーザーを使用しないようにAWS アカウントのルートユーザー、 を保護しAWS IAM アイデンティティセンター、 を有効にして管理ユーザーを作成します。
**を保護するAWS アカウントのルートユーザー**
1. **ルートユーザー**を選択し、AWS アカウント E メールアドレスを入力して、アカウント所有者[AWS マネジメントコンソール](https://console.aws.amazon.com/)として にサインインします。次のページでパスワードを入力します。
ルートユーザーを使用してサインインする方法については、「*AWS サインインユーザーガイド*」の「[ルートユーザーとしてサインインする](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)」を参照してください。
1. ルートユーザーの多要素認証 (MFA) を有効にします。
手順については、*IAM* [ユーザーガイドのAWS アカウント「ルートユーザー (コンソール) の仮想 MFA デバイス](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)を有効にする」を参照してください。
**管理アクセスを持つユーザーを作成する**
1. IAM アイデンティティセンターを有効にします。
手順については、「AWS IAM アイデンティティセンターユーザーガイド」の「[AWS IAM アイデンティティセンターの有効化](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)」を参照してください。
1. IAM アイデンティティセンターで、ユーザーに管理アクセスを付与します。
を ID ソースIAM アイデンティティセンターディレクトリとして使用する方法のチュートリアルについては、「 *AWS IAM アイデンティティセンターユーザーガイド*」の[「デフォルトを使用してユーザーアクセスを設定するIAM アイデンティティセンターディレクトリ](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)」を参照してください。
**管理アクセス権を持つユーザーとしてサインインする**
+ IAM アイデンティティセンターのユーザーとしてサインインするには、IAM アイデンティティセンターのユーザーの作成時に E メールアドレスに送信されたサインイン URL を使用します。
IAM Identity Center ユーザーを使用してサインインする方法については、*AWS サインイン「 ユーザーガイド*[」のAWS「 アクセスポータルにサインイン](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)する」を参照してください。
**追加のユーザーにアクセス権を割り当てる**
1. IAM アイデンティティセンターで、最小特権のアクセス許可を適用するというベストプラクティスに従ったアクセス許可セットを作成します。
手順については、「*AWS IAM アイデンティティセンターユーザーガイド*」の「[アクセス許可セットを作成する](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)」を参照してください。
1. グループにユーザーを割り当て、そのグループにシングルサインオンアクセス権を割り当てます。
手順については、「*AWS IAM アイデンティティセンターユーザーガイド*」の「[グループの追加](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)」を参照してください。
## の使用を開始する方法AWS Config
にサインアップしたらAWS アカウント、AWS マネジメントコンソール、AWS CLI、またはAWS SDKs AWS Configを使用して の使用を開始できます。
**Topics**
+ [コンソールAWS Configでのセットアップ](https://docs.aws.amazon.com/config/latest/developerguide/gs-console.html)
+ [AWS Configを使用した のセットアップAWS CLI](https://docs.aws.amazon.com/config/latest/developerguide/gs-cli.html)
+ [AWS SDK でのAWS Configサービスの使用](https://docs.aws.amazon.com/config/latest/developerguide/sdk-general-information-section.html)
# コンソールによる AWS Config の設定
AWS マネジメントコンソール では、AWS Config のセットアップを迅速かつ効率的に行えます。
## 設定
**コンソールで AWS Config を設定するには**
1. AWS マネジメントコンソール にサインインして、AWS Config コンソール ([https://console.aws.amazon.com/config/home](https://console.aws.amazon.com/config/home)) を開きます。
1. AWS Config コンソールを初めて開く場合や新しいリージョンで AWS Config を設定する場合、AWS Config コンソールページは次のように表示されます。
![\[AWS Config コンソールページのイメージは、AWS Config サービスの概要を示し、AWS リソースの設定変更の記録と評価におけるそのロールを強調しています。\]](http://docs.aws.amazon.com/ja_jp/config/latest/developerguide/images/welcome.png)
1. **[1-click setup]** (1-click セットアップ) を選択して、AWS ベストプラクティスに基づいて AWS Config を起動します。また、「**使用開始**」を選択して、より詳細なセットアッププロセスに進むこともできます。
**Topics**
+ [設定](#gs-console-setting-up.title)
+ [ワンクリックセットアップ](1-click-setup.md)
+ [手動セットアップ](manual-setup.title.md)
# のワンクリックセットアップ AWS Config
AWS Config **ワンクリック設定**は、手動選択の数を減らすことで、 AWS Config コンソールのお客様の開始プロセスを簡素化するのに役立ちます。セットアッププロセスのすべての手動選択を確認するには、「[「手動セットアップ](https://docs.aws.amazon.com/config/latest/developerguide/detailed-setup.html)」を参照してください。
**ワンクリック設定を使用してコンソール AWS Config で を設定するには ******
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/config/home](https://console.aws.amazon.com/config/home) で AWS Config コンソールを開きます。
1. **[1-click setup]** (ワンクリックセットアップ) を選択します。
セットアップページには 3 つのステップが含まれていますが、**[1-click setup]** (ワンクリックセットアップ) ワークフローでは、自動的にステップ 3 (レビュー) に誘導されます。次に、その手順の内訳を示します。
+ **設定**: AWS Config コンソールがリソースとロールを記録する方法を選択し、設定履歴と設定スナップショットファイルの送信先を選択します。
+ **ルール**: サポート AWS リージョン AWS Config ルールでは、このステップを使用して、アカウントに追加できる初期管理ルールを設定できます。設定後、 AWS Config は選択したルールに照らして AWS リソースを評価します。追加のルールの作成や、既存のルールの更新は、設定後にアカウントで行うことができます。
+ **確認**: 設定の詳細を確認します。
## ステップ 1: 設定
### 記録方法
**カスタマイズ可能なオーバーライドを使用してすべてのリソースタイプ**を記録するオプションが選択されます。 AWS Config は、このリージョンで現在および将来サポートされているすべてのリソースタイプを記録します。詳細については、[[サポートされるリソースタイプ]](https://docs.aws.amazon.com/config/latest/developerguide/resource-config-reference.html) を参照してください。
+ **デフォルト設定**
デフォルトの記録頻度は **[連続]** に設定されています。つまり、 は、変更が発生するたびに設定の変更を継続的に AWS Config 記録します。
AWS Config は、記録頻度を**日**次に設定するオプションもサポートしています。設定した後、このオプションを選択した場合、以前に記録された CI と異なる場合にのみ、過去 24 時間におけるリソースの最新の状態を表す設定項目 (CI) を、受け取ります。詳細については、「[Recording Frequency](https://docs.aws.amazon.com/config/latest/developerguide/select-resources.html#select-resources-recording-frequency)」を参照してください。
**注記**
AWS Firewall Manager は、リソースをモニタリングするために継続的な記録に依存します。Firewall Manager を使用している場合、記録頻度を連続に設定することをお勧めします。
+ **オーバーライド設定 - *オプション***
設定した後、オプションで特定のリソースタイプの記録頻度を上書きしたり、特定のリソースタイプを記録から除外したりできます。デフォルト設定を上書きするには、 AWS Config コンソールの左側のナビゲーションで**設定**を選択し、**編集**を選択します。
#### リソースを記録する際の考慮事項
** AWS Config 評価の数が多い**
AWS Config での最初の月の記録中に、後続の月と比較して、アカウントのアクティビティが増加することがあります。最初のブートストラッププロセス中に、 は、 が記録 AWS Config するように選択したアカウント内のすべてのリソースで評価 AWS Config を実行します。
一時的なワークロードを実行している場合、これらの一時リソースの作成と削除に関連する設定の変更を記録するため、 AWS Config のアクティビティが増加する可能性があります。一時的なワークロード**とは、必要なときにロードされて実行されるコンピューティングリソースを一時的に使用することです。例には、Amazon Elastic Compute Cloud (Amazon EC2) スポットインスタンス、Amazon EMR ジョブ、 AWS Auto Scalingがあります。一時的なワークロードの実行によるアクティビティの増加を避けたい場合は、これらのリソースタイプを記録から除外するよう設定レコーダーを設定するか、または AWS Config をオフにした別のアカウントでこの種のワークロードを実行し、設定の記録とルール評価の増加を回避することができます。
**グローバルリソースタイプ \$1 Aurora グローバルクラスターは、最初は記録に含められます**
`AWS::RDS::GlobalCluster` リソースタイプは、設定レコーダーが有効になっているサポートされているすべての AWS Config リージョンに記録されます。
有効なすべてのリージョンで `AWS::RDS::GlobalCluster` を記録しない場合、設定後にこのリソースタイプを記録から除外できます。左のナビゲーションバーで、**[設定]** を選択し、**[編集]** を選択します。**[編集]** から、**[記録方法]** セクションの **[オーバーライド設定]** を選択し、`AWS::RDS::GlobalCluster` を選択してから、[記録から除外] のオーバーライドを選択します。
**グローバルリソースタイプ \$1 IAM リソースタイプは、最初は記録から除外されます。**
コスト削減のため、「グローバルに記録されたすべての IAM リソースタイプ」は、最初は記録から除外されます。このバンドルには、IAM ユーザー、グループ、ロール、およびカスタマー管理ポリシーが含まれます。**[削除]** を選択してオーバーライドを削除し、これらのリソースを記録に含めます。
さらに、グローバル IAM リソースタイプ (`AWS::IAM::User`、`AWS::IAM::Group`、`AWS::IAM::Role`、および `AWS::IAM::Policy`) は、2022 年 2 月より後に AWS Config がサポートされるリージョンでは記録できません。これらのリージョンのリストについては、[AWS 「リソースの記録 \$1 グローバルリソース](https://docs.aws.amazon.com/config/latest/developerguide/select-resources.html#select-resources-all)」を参照してください。
### データガバナンス
このセクションでは、7 年間 (2557 日) データを保持するデフォルトの AWS Config データ保持期間が選択されています。
**既存の AWS Config サービスにリンクされたロールを使用する**オプションが選択され、 が**AWS Config ロール**に設定されます。サービスにリンクされたロールは によって事前定義 AWS Config されており、サービスが他の サービスを呼び出すために必要なすべてのアクセス許可が含まれています AWS 。
### 配信方法
このセクションでは、**アカウントからバケットを選択する**オプションが選択されています。この選択は、デフォルトで `config-bucket-accountid` 形式で名前が付けられたアカウントのバケットとなります。例えば、`config-bucket-012345678901`。その形式でバケットを作成していない場合は、自動的に作成されます。独自のバケットを作成する場合、「Amazon Simple Storage Service ユーザーガイド**」の「[バケットの作成](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html)」を参照してください。
S3 バケットの詳細については、「Amazon Simple Storage Service ユーザーガイド**」の「[バケットの概要](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html)」を参照してください。
## ステップ 2: ルール
**AWS マネージド型ルール**については、このステップではルールは選択されていません。アカウントの設定が完了した後にルールを作成および更新することをお勧めします。
## ステップ 3: 確認
AWS Config セットアップの詳細を確認します。戻って各セクションの変更を編集できます。**確認**を選択して設定を完了します AWS Config。
# の手動セットアップ AWS Config
**開始方法**ワークフローでは、セットアッププロセスのすべての手動選択を確認して、 AWS Config コンソールの使用を開始できます。簡単な開始プロセスについては、「[ワンクリックセットアップ](https://docs.aws.amazon.com/config/latest/developerguide/1-click-setup.html)」を参照してください。
****開始**方法を使用して コンソール AWS Config で を設定するには**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/config/home](https://console.aws.amazon.com/config/home) で AWS Config コンソールを開きます。
1. **[開始する]** を選択します。
セットアップページには 3 つのステップがあります。以下に、**[Get started]** (使用開始) を選択した後の手順の内訳を示します。
+ **設定**: AWS Config コンソールがリソースとロールを記録する方法を選択し、設定履歴と設定スナップショットファイルの送信先を選択します。
+ **ルール**: サポート AWS リージョン AWS Config ルールの場合、このステップを使用して、アカウントに追加できる初期管理ルールを設定できます。設定後、 AWS Config は選択したルールに照らして AWS リソースを評価します。追加のルールを作成したり、既存のルールを更新したり、設定後にアカウントで更新できます。
+ **確認**: 設定の詳細を確認します。
## ステップ 1: 設定
### 記録方法
**[記録方法]** セクションで、記録方法を選択します。 AWS Config 記録する AWS リソースを指定できます。
------
#### [ All resource types with customizable overrides ]
このリージョンで現在および将来サポートされているすべてのリソースタイプの設定変更を記録する AWS Config ように を設定します。特定のリソースタイプの記録頻度をオーバーライドしたり、特定のリソースタイプを記録から除外したりできます。詳細については、[[サポートされるリソースタイプ]](https://docs.aws.amazon.com/config/latest/developerguide/resource-config-reference.html) を参照してください。
+ **デフォルト設定**
現在および将来サポートされるすべてのリソースタイプについて、デフォルトの記録頻度を設定します。詳細については、「[Recording Frequency](https://docs.aws.amazon.com/config/latest/developerguide/select-resources.html#select-resources-recording-frequency)」を参照してください。
+ 継続的な記録 – は、変更が発生するたびに設定の変更を継続的に記録 AWS Config します。
+ 日時記録 - 以前に記録された CI と異なる場合にのみ、過去 24 時間におけるリソースの最新の状態を表す設定項目 (CI) を、受け取ります。
**注記**
AWS Firewall Manager は、リソースをモニタリングするために継続的な記録に依存します。Firewall Manager を使用している場合、記録頻度を連続に設定することをお勧めします。
+ **上書き設定**
特定のリソースタイプの記録頻度を上書きしたり、特定のリソースタイプを記録から除外したりします。リソースタイプの記録頻度を変更するか、またはリソースタイプの記録を停止した場合、既に記録されている設定項目は変更されません。
------
#### [ Specific resource types ]
指定したリソースタイプのみの設定変更を記録する AWS Config ように を設定します。
+ **特定のリソースタイプ**
記録するリソースタイプとその頻度を選択します。詳細については、「[Recording Frequency](https://docs.aws.amazon.com/config/latest/developerguide/select-resources.html#select-resources-recording-frequency)」を参照してください。
+ 継続的な記録 – は、変更が発生するたびに設定の変更を継続的に記録 AWS Config します。
+ 日時記録 - 以前に記録された CI と異なる場合にのみ、過去 24 時間におけるリソースの最新の状態を表す設定項目 (CI) を、受け取ります。
**注記**
AWS Firewall Manager は、リソースをモニタリングするために継続的な記録に依存します。Firewall Manager を使用している場合、記録頻度を連続に設定することをお勧めします。
リソースタイプの記録頻度を変更するか、またはリソースタイプの記録を停止した場合、既に記録されている設定項目は変更されません。
------
#### リソースを記録する際の考慮事項
** AWS Config 評価の数が多い**
AWS Config での最初の月の記録中に、後続の月と比較して、アカウントのアクティビティが増加することがあります。最初のブートストラッププロセス中に、 は、 が記録 AWS Config するために選択したアカウント内のすべてのリソースで評価 AWS Config を実行します。
一時的なワークロードを実行している場合、これらの一時リソースの作成と削除に関連する設定の変更を記録するため、 AWS Config のアクティビティが増加する可能性があります。一時的なワークロード**とは、必要なときにロードされて実行されるコンピューティングリソースを一時的に使用することです。例としては、Amazon Elastic Compute Cloud (Amazon EC2) スポットインスタンス、Amazon EMR ジョブ、 AWS Auto Scalingなどがあります。一時的なワークロードの実行によるアクティビティの増加を避けたい場合は、これらのリソースタイプを記録から除外するよう設定レコーダーを設定するか、または AWS Config をオフにした別のアカウントでこの種のワークロードを実行し、設定の記録とルール評価の増加を回避することができます。
------
#### [ Considerations: All resource types with customizable overrides ]
**グローバルに記録するリソースタイプ \$1 Aurora グローバルクラスターは、最初は記録に含められます**
`AWS::RDS::GlobalCluster` リソースタイプは、設定レコーダーが有効になっているサポートされているすべての AWS Config リージョンに記録されます。
すべての有効なリージョンで `AWS::RDS::GlobalCluster` を記録しない場合、「AWS RDS GlobalCluster」を選択し、「記録から除外する」というオーバーライドを選択します。
**グローバルリソースタイプ \$1 IAM リソースタイプは、最初は記録から除外されます。**
コスト削減のため、グローバル IAM リソースタイプは、最初は記録から除外されます。このバンドルには、IAM ユーザー、グループ、ロール、およびカスタマー管理ポリシーが含まれます。**[削除]** を選択してオーバーライドを削除し、これらのリソースを記録に含めます。
さらに、グローバル IAM リソースタイプ (`AWS::IAM::User`、`AWS::IAM::Group`、`AWS::IAM::Role`、および `AWS::IAM::Policy`) は、2022 年 2 月 AWS Config 以降に でサポートされているリージョンでは記録できません。これらのリージョンのリストについては、[AWS 「リソースの記録 \$1 グローバルリソース](https://docs.aws.amazon.com/config/latest/developerguide/select-resources.html#select-resources-all)」を参照してください。
**制限**
最大 100 の頻度のオーバーライドと 600 の除外のオーバーライドを追加できます。
次のリソースタイプに日次記録を指定することはできません。
+ `AWS::Config::ResourceCompliance`
+ `AWS::Config::ConformancePackCompliance`
+ `AWS::Config::ConfigurationRecorder`
------
#### [ Considerations: Specific resource types ]
**利用可能なリージョン**
が追跡 AWS Config するリソースタイプを指定する前に、[Resource Coverage by Region Availability](https://docs.aws.amazon.com/config/latest/developerguide/what-is-resource-config-coverage.html) をチェックして、リソースタイプがセットアップした AWS リージョンでサポートされているかどうかを確認します AWS Config。リソースタイプが少なくとも 1 つのリージョン AWS Config で でサポートされている場合は、指定したリソースタイプがセットアップしたリージョンでサポートされていない場合でも AWS Config、 でサポートされているすべての AWS リージョンでそのリソースタイプの記録を有効にできます AWS Config。
**制限**
すべてのリソースタイプが同じ頻度であれば制限はありません。少なくとも 1 つのリソースタイプが継続に設定されている場合、日次の頻度で最大 100 のリソースタイプを追加できます。
次のリソースタイプに日次頻度はサポートされていません。
+ `AWS::Config::ResourceCompliance`
+ `AWS::Config::ConformancePackCompliance`
+ `AWS::Config::ConfigurationRecorder`
------
### データガバナンス
+ **データ保持期間**では、デフォルトの保持期間を選択して AWS Config データを 7 年間 (2557) 保持するか、 によって記録された項目のカスタム保持期間を設定します AWS Config。
AWS Config では、 の保持期間を指定してデータを削除できます`ConfigurationItems`。保持期間を指定すると、 AWS Config は `ConfigurationItems` を指定された期間保持します。最小 30 日から最大 7 年 (2557 日) の期間を選択できます。 は、指定した保持期間より古いデータ AWS Config を削除します。
+ **の IAM ロール AWS Config**では、アカウントから既存の AWS Config サービスにリンクされたロールまたは IAM ロールを選択します。
+ サービスにリンクされたロールは によって事前定義 AWS Config されており、サービスが他の AWS サービスを呼び出すために必要なすべてのアクセス許可が含まれています。
**注記**
**推奨: サービスにリンクされたロールを使用する**
サービスにリンクされたロールを使用することをお勧めします。サービスにリンクされたロールは、 AWS Config が予想どおりに実行するのに必要なすべてのアクセス許可を追加します。
+ それ以外の場合は、既存のロールとアクセス許可ポリシーの 1 つから IAM ロールを選択します。
**注記**
**ポリシーとコンプライアンスの結果**
で管理される [IAM ポリシー](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html)やその他のポリシーは、 AWS Config がリソースの設定変更を記録するアクセス許可を持っているかどうかに影響を与える可能性があります。 [AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies.html)また、ルールはリソースの設定を直接評価し、評価の実行時にこれらのポリシーを考慮しません。適用されるポリシーが、意図する AWS Configの使用方法と合致していることを確認してください。
**IAM ロール再利用時に最小限のアクティビティ許可を維持する**
や AWS Configなどの AWS Security Hub CSPM を使用する AWS サービスを使用し AWS Control Tower、IAM ロールがすでに作成されている場合は、セットアップ AWS Config 時に使用する IAM ロールが既存の IAM ロールと同じ最小限のアクセス許可を保持していることを確認してください。これを実行して、他の AWS サービスが期待どおりに実行されるようにする必要があります。
たとえば、 に S3 オブジェクト AWS Config の読み取りを許可する IAM ロール AWS Control Tower がある場合、セットアップ時に使用する IAM ロールに同じアクセス許可が付与されていることを確認してください AWS Config。そうしないと、 AWS Control Tower の動作に支障をきたす可能性があります。
### 配信方法
+ **[Delivery method]** (配信方法) では、 AWS Config から設定履歴と設定スナップショットのファイルを送信する先の S3 バケットを選択します。
+ **[Create a bucket]** (バケットの作成) — **[S3 bucket name]** (S3 バケット名) に S3 バケットの名前を入力します。
Amazon S3 の既存のバケット名と重複しないように一意の名前を入力する必要があります。一意の名前にする 1 つの方法としては、組織の名前などをプレフィックスとして含めます。バケット名を作成後に変更することはできません。詳細については、「Amazon Simple Storage Service ユーザーガイド**」の「[バケットの制約と制限](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html)」を参照してください。
+ **[Choose a bucket from your account]** (アカウントからバケットを選択) – **[S3 bucket name]** (S3 バケット名) で目的のバケットを選択します。
+ **[Choose a bucket from another account]** (別のアカウントからバケットを選択) — **[S3 bucket name]** (S3 バケット名) にバケット名を入力します。
**注記**
**バケットのアクセス許可**
別のアカウントからバケットを選択する場合、そのバケットにはアクセス許可を付与するポリシーが必要です AWS Config。詳細については、「[AWS Config 配信チャネルの Amazon S3 バケットのアクセス許可](s3-bucket-policy.md)」を参照してください。
+ **Amazon SNS トピック**で、**設定変更と通知を Amazon SNS トピックにストリーム**して、設定履歴配信、設定スナップショット配信、コンプライアンスなどの通知 AWS Config を送信するようにします。
+ Amazon SNS AWS Config トピックにストリーミングすることを選択した場合は、ターゲットトピックを選択します。
+ **[Create a topic]** (トピックの作成) — **[Topic Name]** (トピック名) に SNS トピックの名前を入力します。
+ **[Choose a topic from your account]** (アカウントからトピックを選択) — **[Topic Name]** (トピック名) で目的のトピックを選択します。
+ **[Choose a topic from another account]** (別のアカウントからトピックを選択) – **[Topic ARN]** (トピック ARN) にトピックの Amazon リソースネーム (ARN) を入力します。別のアカウントからトピックを選択する場合、そのトピックにはアクセス許可を付与するポリシーが必要です AWS Config。詳細については、「[Amazon SNS トピックへのアクセス許可](sns-topic-policy.md)」を参照してください。
**注記**
**Amazon SNS トピックのリージョン**
Amazon SNS トピックは、設定したリージョンと同じリージョンに存在する必要があります AWS Config。
## ステップ 2: ルール
ルールをサポートするリージョン AWS Config で を設定する場合は、**次へ** を選択します。
## ステップ 3: 確認
AWS Config セットアップの詳細を確認します。戻って各セクションの変更を編集できます。**確認** を選択してセットアップを完了します AWS Config。
## 詳細情報
アカウント内の既存のリソースの検索とリソースの設定の理解については、「[Looking up Resources](https://docs.aws.amazon.com/config/latest/developerguide/looking-up-discovered-resources.html)」、「[Viewing Compliance Informance](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config_view-compliance.html)」、「[Viewing Compliance Informance](https://docs.aws.amazon.com/config/latest/developerguide/view-manage-resource-console.html)」を参照してください。
Amazon Simple Queue Service を使用して、プログラムで AWS リソースをモニタリングすることもできます。詳細については、「[Amazon SQS による AWS リソース変更のモニタリング](monitor-resource-changes.md)」を参照してください。
# AWS CLI を使用した AWS Config のセットアップ
AWS CLI は、AWS サービスを管理するための統合ツールです。ダウンロードおよび設定用の単一のツールのみを使用して、コマンドラインから複数の AWS サービスを制御し、スクリプトを使用してそれらを自動化できます。AWS CLI の詳細と AWS CLI ツールのインストール手順については、「AWS Command Line Interface ユーザーガイド**」の次のリソースを参照してください。
+ [AWS Command Line Interface ユーザーガイド](https://docs.aws.amazon.com/cli/latest/userguide/)
+ [ のセットアップAWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html)
必要に応じて、「`aws configure`」と入力し、AWS CLI が AWS Config を利用できる AWS リージョンを使用するように設定します。
## 設定
AWS Config で AWS CLI を設定するには以下のトピックを参照してください。
**Topics**
+ [設定](#gs-cli-setting-up.title)
+ [前提条件](gs-cli-prereq.md)
+ [AWS Config の起動](gs-cli-subscribe.md)
+ [セットアップの確認](gs-cli-verify-subscribe.md)
# AWS Config で をセットアップするための前提条件 AWS CLI
AWS で を設定する前に AWS CLI、前提条件として Amazon S3 バケット、Amazon SNS トピック、およびポリシーがアタッチされた IAM ロールを作成する必要があります。その後、 を使用して AWS CLI バケット、トピック、ロールを指定できます AWS Config。次の手順に従って、 AWS Configの前提条件をセットアップします。
**Topics**
+ [ステップ 1: Amazon S3 バケットを作成する](#gs-cli-create-s3bucket)
+ [ステップ 2: Amazon SNS トピックを作成する](#gs-cli-create-snstopic)
+ [ステップ 3: IAM ロールを作成する](#gs-cli-create-iamrole)
## ステップ 1: Amazon S3 バケットを作成する
アカウントに Amazon S3 バケットが既にあり、それを使用する場合は、このステップをスキップして [ステップ 2: Amazon SNS トピックを作成する](#gs-cli-create-snstopic) に進んでください。
### S3 コンソールの使用
**バケットを作成するには**
1. Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。
1. **[バケットを作成]** を選択します。
1. **[バケット名]** に、バケットの DNS に準拠する名前を入力します。
バケット名には次の条件があります。
+ すべての Amazon S3 で一意にする。
+ 3～63 文字で指定する。
+ 大文字を含めないでください。
+ 先頭の文字には小文字の英文字または数字を使用する。
バケットを作成したら、その名前を変更することはできません。バケット名は、Amazon S3 の既存のバケット名と重複しないように指定してください。バケットの命名ルールと変換の詳細については、「*Amazon Simple Storage Service デベロッパーガイド*」の「[バケットの制約と制限](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html)」を参照してください。
**重要**
バケット名に機密情報を含めないでください。バケット名は、バケット内のオブジェクトを参照する URL に表示されます。
1. **リージョン**で、バケットを配置する AWS リージョンを選択します。
レイテンシーとコストを最小化するため、さらに規制条件に対応するために、最寄りのリージョンを選択します。明示的に別のリージョンに移動する場合を除き、特定のリージョンに保管されたオブジェクトは、そのリージョンから移動されることはありません。Amazon S3 AWS Regions のリストについては、の[AWS 「サービスエンドポイント](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)」を参照してください*Amazon Web Services 全般のリファレンス*。
1. **ブロックパブリックアクセスのバケット設定** で、バケットに適用するパブリックアクセスブロック設定を選択します。
パブリックウェブサイトをホスティングする場合など、ユースケースでオフにする必要のある設定が 1 つ以上あることがわかっている場合を除いて、すべての設定を有効にしておくことをお勧めします。バケットに対して有効にしたパブリックアクセスブロック設定は、バケットに作成するすべてのアクセスポイントに対しても有効になります。パブリックアクセスのブロックの詳細については、「*Amazon Simple Storage Service デベロッパーガイド*」の「[Amazon S3 パブリックアクセスブロックの使用](https://docs.aws.amazon.com/AmazonS3/latest/dev/access-control-block-public-access.html)」を参照してください。
1. (オプション) S3 オブジェクトロックを有効にする場合:
1. [**詳細設定**] を選択し、表示されるメッセージを読みます。
**重要**
バケットに対する S3 オブジェクトロックは、バケットの作成時にのみ有効にできます。バケットに対してオブジェクトロックを有効にした場合、後で無効にすることはできません。バケットに対してオブジェクトロックを有効にすると、バージョニングも有効になります。バケットに対してオブジェクトロックを有効にした後、バケット内のオブジェクトを保護するには、オブジェクトロック設定を定義する必要があります。オブジェクトの保護の設定の詳細については、「[Amazon S3 コンソールを使用した S3 オブジェクトロックの設定](https://docs.aws.amazon.com//AmazonS3/latest/dev/object-lock-console.html)」を参照してください。
1. オブジェクトロックを有効にする場合は、テキストボックスに「*enable*」と入力し、**[確認]** を選択します。
S3 オブジェクトロック機能の詳細については、「*Amazon Simple Storage Service デベロッパーガイド*」の「[Amazon S3 オブジェクトロックを使用したオブジェクトのロック](https://docs.aws.amazon.com//AmazonS3/latest/dev/object-lock.html)」を参照してください。
1. **[バケットを作成]** を選択します。
### AWS SDKsの使用
AWS SDKs を使用してバケットを作成する場合は、クライアントを作成し、クライアントを使用してバケットを作成するリクエストを送信する必要があります。ベストプラクティスとして、クライアントとバケットを同じ AWS リージョンで作成する必要があります。クライアントまたはバケットの作成時にリージョンを指定しない場合、Amazon S3 ではデフォルトのリージョンである米国東部 (バージニア北部) が使用されます。
デュアルスタックエンドポイントにアクセスするクライアントを作成するには、 を指定する必要があります AWS リージョン。詳細については、[Amazon S3 デュアルスタックのエンドポイント](https://docs.aws.amazon.com//AmazonS3/latest/dev/dual-stack-endpoints.html#dual-stack-endpoints-description)を参照してください。利用可能な のリストについては AWS リージョン、『』の[「リージョンとエンドポイント](https://docs.aws.amazon.com/general/latest/gr/s3.html)」を参照してください*AWS 全般のリファレンス*。
クライアントを作成すると、リージョンはリージョン固有のエンドポイントにマッピングされます。クライアントは、このエンドポイントを使用して Amazon S3 と通信します。`s3..amazonaws.com`。リージョンがローンチされたのが 2019 年 3 月 20 日以降である場合は、クライアントとバケットは同じリージョン内にある必要があります。2019 年 3 月 20 日以前にローンチされたリージョンの場合は、米国東部 (バージニア北部) のリージョンでクライアントを使用することによりバケットを作成できます。詳細については、「[レガシーエンドポイント](https://docs.aws.amazon.com//AmazonS3/latest/dev/VirtualHosting.html#s3-legacy-endpoints)」を参照してください。
これらの AWS SDK コード例は、次のタスクを実行します。
+ ** AWS リージョンを明示的に指定してクライアントを作成する** - この例では、クライアントは `s3.us-west-2.amazonaws.com` エンドポイントを使用して Amazon S3 と通信します。任意の AWS リージョンを指定できます。のリストについては AWS リージョン、*AWS 「 全般のリファレンス*」の[「リージョンとエンドポイント](https://docs.aws.amazon.com/general/latest/gr/s3.html)」を参照してください。
+ **バケット名のみを指定してバケット作成リクエストを送信する** - クライアントが Amazon S3 にリクエストを送信し、クライアントが作成されたリージョンにバケットを作成します。
+ **バケットの場所情報を取得する** — Amazon S3 が、バケットの場所情報を、そのバケットに関連付けられている*場所*のサブリソースに保存します。
次のサンプルコードは、`CreateBucket` を使用する方法を説明しています。
------
#### [ .NET ]
**SDK for .NET (v4)**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/S3#code-examples)での設定と実行の方法を確認してください。
```
///
/// Shows how to create a new Amazon S3 bucket.
///
/// The name of the bucket to create.
/// A boolean value representing the success or failure of
/// the bucket creation process.
public async Task CreateBucketAsync(string bucketName)
{
try
{
var request = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true,
};
var response = await _amazonS3.PutBucketAsync(request);
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
catch (AmazonS3Exception ex)
{
Console.WriteLine($"Error creating bucket: '{ex.Message}'");
return false;
}
}
```
+ API の詳細については、「*AWS SDK for .NET API リファレンス*」の「[CreateBucket](https://docs.aws.amazon.com/goto/DotNetSDKV4/s3-2006-03-01/CreateBucket)」を参照してください。
**SDK for .NET**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/S3#code-examples)での設定と実行の方法を確認してください。
オブジェクトロックを有効にしてバケットを作成します。
```
///
/// Create a new Amazon S3 bucket with object lock actions.
///
/// The name of the bucket to create.
/// True to enable object lock on the bucket.
/// True if successful.
public async Task CreateBucketWithObjectLock(string bucketName, bool enableObjectLock)
{
Console.WriteLine($"\tCreating bucket {bucketName} with object lock {enableObjectLock}.");
try
{
var request = new PutBucketRequest
{
BucketName = bucketName,
UseClientRegion = true,
ObjectLockEnabledForBucket = enableObjectLock,
};
var response = await _amazonS3.PutBucketAsync(request);
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
catch (AmazonS3Exception ex)
{
Console.WriteLine($"Error creating bucket: '{ex.Message}'");
return false;
}
}
```
+ API の詳細については、「*AWS SDK for .NET API リファレンス*」の「[CreateBucket](https://docs.aws.amazon.com/goto/DotNetSDKV3/s3-2006-03-01/CreateBucket)」を参照してください。
------
#### [ Bash ]
**AWS CLI Bash スクリプトを使用する**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/s3#code-examples)での設定と実行の方法を確認してください。
```
###############################################################################
# function iecho
#
# This function enables the script to display the specified text only if
# the global variable $VERBOSE is set to true.
###############################################################################
function iecho() {
if [[ $VERBOSE == true ]]; then
echo "$@"
fi
}
###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
printf "%s\n" "$*" 1>&2
}
###############################################################################
# function create-bucket
#
# This function creates the specified bucket in the specified AWS Region, unless
# it already exists.
#
# Parameters:
# -b bucket_name -- The name of the bucket to create.
# -r region_code -- The code for an AWS Region in which to
# create the bucket.
#
# Returns:
# The URL of the bucket that was created.
# And:
# 0 - If successful.
# 1 - If it fails.
###############################################################################
function create_bucket() {
local bucket_name region_code response
local option OPTARG # Required to use getopts command in a function.
# bashsupport disable=BP5008
function usage() {
echo "function create_bucket"
echo "Creates an Amazon S3 bucket. You must supply a bucket name:"
echo " -b bucket_name The name of the bucket. It must be globally unique."
echo " [-r region_code] The code for an AWS Region in which the bucket is created."
echo ""
}
# Retrieve the calling parameters.
while getopts "b:r:h" option; do
case "${option}" in
b) bucket_name="${OPTARG}" ;;
r) region_code="${OPTARG}" ;;
h)
usage
return 0
;;
\?)
echo "Invalid parameter"
usage
return 1
;;
esac
done
if [[ -z "$bucket_name" ]]; then
errecho "ERROR: You must provide a bucket name with the -b parameter."
usage
return 1
fi
local bucket_config_arg
# A location constraint for "us-east-1" returns an error.
if [[ -n "$region_code" ]] && [[ "$region_code" != "us-east-1" ]]; then
bucket_config_arg="--create-bucket-configuration LocationConstraint=$region_code"
fi
iecho "Parameters:\n"
iecho " Bucket name: $bucket_name"
iecho " Region code: $region_code"
iecho ""
# If the bucket already exists, we don't want to try to create it.
if (bucket_exists "$bucket_name"); then
errecho "ERROR: A bucket with that name already exists. Try again."
return 1
fi
# shellcheck disable=SC2086
response=$(aws s3api create-bucket \
--bucket "$bucket_name" \
$bucket_config_arg)
# shellcheck disable=SC2181
if [[ ${?} -ne 0 ]]; then
errecho "ERROR: AWS reports create-bucket operation failed.\n$response"
return 1
fi
}
```
+ API の詳細については、「*AWS CLI コマンドリファレンス*」の「[CreateBucket](https://docs.aws.amazon.com/goto/aws-cli/s3-2006-03-01/CreateBucket)」を参照してください。
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3#code-examples)での設定と実行の方法を確認してください。
```
bool AwsDoc::S3::createBucket(const Aws::String &bucketName,
const Aws::S3::S3ClientConfiguration &clientConfig) {
Aws::S3::S3Client client(clientConfig);
Aws::S3::Model::CreateBucketRequest request;
request.SetBucket(bucketName);
if (clientConfig.region != "us-east-1") {
Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
createBucketConfig.SetLocationConstraint(
Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(
clientConfig.region));
request.SetCreateBucketConfiguration(createBucketConfig);
}
Aws::S3::Model::CreateBucketOutcome outcome = client.CreateBucket(request);
if (!outcome.IsSuccess()) {
auto err = outcome.GetError();
std::cerr << "Error: createBucket: " <<
err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
} else {
std::cout << "Created bucket " << bucketName <<
" in the specified AWS Region." << std::endl;
}
return outcome.IsSuccess();
}
```
+ API の詳細については、「*AWS SDK for C\$1\$1 API リファレンス*」の「[CreateBucket](https://docs.aws.amazon.com/goto/SdkForCpp/s3-2006-03-01/CreateBucket)」を参照してください。
------
#### [ CLI ]
**AWS CLI**
**例 1: バケットを作成するには**
次の `create-bucket` の例は、`amzn-s3-demo-bucket` という名前のバケットを作成します。
```
aws s3api create-bucket \
--bucket amzn-s3-demo-bucket \
--region us-east-1
```
出力:
```
{
"Location": "/amzn-s3-demo-bucket"
}
```
詳細については、「*Amazon S3 ユーザーガイド*」の「[バケットの作成](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html)」を参照してください。
**例 2: 所有者の強制を使用してバケットを作成するには**
次の `create-bucket` の例は、S3 オブジェクトの所有権のバケット所有者の強制設定を使用して、`amzn-s3-demo-bucket` という名前のバケットを作成します。
```
aws s3api create-bucket \
--bucket amzn-s3-demo-bucket \
--region us-east-1 \
--object-ownership BucketOwnerEnforced
```
出力:
```
{
"Location": "/amzn-s3-demo-bucket"
}
```
詳細については、*Amazon S3 ユーザーガイド*の[オブジェクトの所有権のコントロールと ACL の無効化](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html)を参照してください。
**例 3: ``us-east-1`` リージョンの外にバケットを作成するには**
次の `create-bucket` の例は、`eu-west-1` リージョンに `amzn-s3-demo-bucket` という名前のバケットを作成します。`us-east-1` の外にある目的のリージョンにバケットを作成するには、適切な `LocationConstraint` を指定する必要があります。
```
aws s3api create-bucket \
--bucket amzn-s3-demo-bucket \
--region eu-west-1 \
--create-bucket-configuration LocationConstraint=eu-west-1
```
出力:
```
{
"Location": "http://amzn-s3-demo-bucket.s3.amazonaws.com/"
}
```
詳細については、「*Amazon S3 ユーザーガイド*」の「[バケットの作成](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html)」を参照してください。
+ API の詳細については、「*AWS CLI コマンドリファレンス*」の「[CreateBucket](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-bucket.html)」を参照してください。
------
#### [ Go ]
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/s3#code-examples)での設定と実行の方法を確認してください。
デフォルト設定を使用してバケットを作成します。
```
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
}
// CreateBucket creates a bucket with the specified name in the specified Region.
func (basics BucketBasics) CreateBucket(ctx context.Context, name string, region string) error {
_, err := basics.S3Client.CreateBucket(ctx, &s3.CreateBucketInput{
Bucket: aws.String(name),
CreateBucketConfiguration: &types.CreateBucketConfiguration{
LocationConstraint: types.BucketLocationConstraint(region),
},
})
if err != nil {
var owned *types.BucketAlreadyOwnedByYou
var exists *types.BucketAlreadyExists
if errors.As(err, &owned) {
log.Printf("You already own bucket %s.\n", name)
err = owned
} else if errors.As(err, &exists) {
log.Printf("Bucket %s already exists.\n", name)
err = exists
}
} else {
err = s3.NewBucketExistsWaiter(basics.S3Client).Wait(
ctx, &s3.HeadBucketInput{Bucket: aws.String(name)}, time.Minute)
if err != nil {
log.Printf("Failed attempt to wait for bucket %s to exist.\n", name)
}
}
return err
}
```
オブジェクトロックを使用してバケットを作成し、作成が完了するまで待ちます。
```
import (
"bytes"
"context"
"errors"
"fmt"
"log"
"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"
)
// S3Actions wraps S3 service actions.
type S3Actions struct {
S3Client *s3.Client
S3Manager *manager.Uploader
}
// CreateBucketWithLock creates a new S3 bucket with optional object locking enabled
// and waits for the bucket to exist before returning.
func (actor S3Actions) CreateBucketWithLock(ctx context.Context, bucket string, region string, enableObjectLock bool) (string, error) {
input := &s3.CreateBucketInput{
Bucket: aws.String(bucket),
CreateBucketConfiguration: &types.CreateBucketConfiguration{
LocationConstraint: types.BucketLocationConstraint(region),
},
}
if enableObjectLock {
input.ObjectLockEnabledForBucket = aws.Bool(true)
}
_, err := actor.S3Client.CreateBucket(ctx, input)
if err != nil {
var owned *types.BucketAlreadyOwnedByYou
var exists *types.BucketAlreadyExists
if errors.As(err, &owned) {
log.Printf("You already own bucket %s.\n", bucket)
err = owned
} else if errors.As(err, &exists) {
log.Printf("Bucket %s already exists.\n", bucket)
err = exists
}
} else {
err = s3.NewBucketExistsWaiter(actor.S3Client).Wait(
ctx, &s3.HeadBucketInput{Bucket: aws.String(bucket)}, time.Minute)
if err != nil {
log.Printf("Failed attempt to wait for bucket %s to exist.\n", bucket)
}
}
return bucket, err
}
```
+ API の詳細については、「*AWS SDK for Go API リファレンス*」の「[CreateBucket](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/s3#Client.CreateBucket)」を参照してください。
------
#### [ Java ]
**SDK for Java 2.x**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/s3#code-examples)での設定と実行の方法を確認してください。
バケットを作成します。
```
/**
* Creates an S3 bucket asynchronously.
*
* @param bucketName the name of the S3 bucket to create
* @return a {@link CompletableFuture} that completes when the bucket is created and ready
* @throws RuntimeException if there is a failure while creating the bucket
*/
public CompletableFuture createBucketAsync(String bucketName) {
CreateBucketRequest bucketRequest = CreateBucketRequest.builder()
.bucket(bucketName)
.build();
CompletableFuture response = getAsyncClient().createBucket(bucketRequest);
return response.thenCompose(resp -> {
S3AsyncWaiter s3Waiter = getAsyncClient().waiter();
HeadBucketRequest bucketRequestWait = HeadBucketRequest.builder()
.bucket(bucketName)
.build();
CompletableFuture> waiterResponseFuture =
s3Waiter.waitUntilBucketExists(bucketRequestWait);
return waiterResponseFuture.thenAccept(waiterResponse -> {
waiterResponse.matched().response().ifPresent(headBucketResponse -> {
logger.info(bucketName + " is ready");
});
});
}).whenComplete((resp, ex) -> {
if (ex != null) {
throw new RuntimeException("Failed to create bucket", ex);
}
});
}
```
オブジェクトロックを有効にしてバケットを作成します。
```
// Create a new Amazon S3 bucket with object lock options.
public void createBucketWithLockOptions(boolean enableObjectLock, String bucketName) {
S3Waiter s3Waiter = getClient().waiter();
CreateBucketRequest bucketRequest = CreateBucketRequest.builder()
.bucket(bucketName)
.objectLockEnabledForBucket(enableObjectLock)
.build();
getClient().createBucket(bucketRequest);
HeadBucketRequest bucketRequestWait = HeadBucketRequest.builder()
.bucket(bucketName)
.build();
// Wait until the bucket is created and print out the response.
s3Waiter.waitUntilBucketExists(bucketRequestWait);
System.out.println(bucketName + " is ready");
}
```
+ API の詳細については、「*AWS SDK for Java 2.x API リファレンス*」の「[CreateBucket](https://docs.aws.amazon.com/goto/SdkForJavaV2/s3-2006-03-01/CreateBucket)」を参照してください。
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/s3#code-examples)での設定と実行の方法を確認してください。
バケットを作成します。
```
import {
BucketAlreadyExists,
BucketAlreadyOwnedByYou,
CreateBucketCommand,
S3Client,
waitUntilBucketExists,
} from "@aws-sdk/client-s3";
/**
* Create an Amazon S3 bucket.
* @param {{ bucketName: string }} config
*/
export const main = async ({ bucketName }) => {
const client = new S3Client({});
try {
const { Location } = await client.send(
new CreateBucketCommand({
// The name of the bucket. Bucket names are unique and have several other constraints.
// See https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html
Bucket: bucketName,
}),
);
await waitUntilBucketExists({ client }, { Bucket: bucketName });
console.log(`Bucket created with location ${Location}`);
} catch (caught) {
if (caught instanceof BucketAlreadyExists) {
console.error(
`The bucket "${bucketName}" already exists in another AWS account. Bucket names must be globally unique.`,
);
}
// WARNING: If you try to create a bucket in the North Virginia region,
// and you already own a bucket in that region with the same name, this
// error will not be thrown. Instead, the call will return successfully
// and the ACL on that bucket will be reset.
else if (caught instanceof BucketAlreadyOwnedByYou) {
console.error(
`The bucket "${bucketName}" already exists in this AWS account.`,
);
} else {
throw caught;
}
}
};
```
+ 詳細については、「[AWS SDK for JavaScript デベロッパーガイド](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/s3-example-creating-buckets.html#s3-example-creating-buckets-new-bucket-2)」を参照してください。
+ API の詳細については、「*AWS SDK for JavaScript API リファレンス*」の「[CreateBucket](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/CreateBucketCommand)」を参照してください。
------
#### [ Kotlin ]
**SDK for Kotlin**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/s3#code-examples)での設定と実行の方法を確認してください。
```
suspend fun createNewBucket(bucketName: String) {
val request =
CreateBucketRequest {
bucket = bucketName
}
S3Client.fromEnvironment { region = "us-east-1" }.use { s3 ->
s3.createBucket(request)
println("$bucketName is ready")
}
}
```
+ API の詳細については、「*AWS SDK for Kotlin API リファレンス*」の「[CreateBucket](https://sdk.amazonaws.com/kotlin/api/latest/index.html)」を参照してください。
------
#### [ PHP ]
**SDK for PHP**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples)での設定と実行の方法を確認してください。
バケットを作成します。
```
$s3client = new Aws\S3\S3Client(['region' => 'us-west-2']);
try {
$this->s3client->createBucket([
'Bucket' => $this->bucketName,
'CreateBucketConfiguration' => ['LocationConstraint' => $region],
]);
echo "Created bucket named: $this->bucketName \n";
} catch (Exception $exception) {
echo "Failed to create bucket $this->bucketName with error: " . $exception->getMessage();
exit("Please fix error with bucket creation before continuing.");
}
```
+ API の詳細については、「*AWS SDK for PHP API リファレンス*」の「[CreateBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CreateBucket)」を参照してください。
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/s3/s3_basics#code-examples)での設定と実行の方法を確認してください。
デフォルトの設定でバケットを作成します。
```
class BucketWrapper:
"""Encapsulates S3 bucket actions."""
def __init__(self, bucket):
"""
:param bucket: A Boto3 Bucket resource. This is a high-level resource in Boto3
that wraps bucket actions in a class-like structure.
"""
self.bucket = bucket
self.name = bucket.name
def create(self, region_override=None):
"""
Create an Amazon S3 bucket in the default Region for the account or in the
specified Region.
:param region_override: The Region in which to create the bucket. If this is
not specified, the Region configured in your shared
credentials is used.
"""
if region_override is not None:
region = region_override
else:
region = self.bucket.meta.client.meta.region_name
try:
self.bucket.create(CreateBucketConfiguration={"LocationConstraint": region})
self.bucket.wait_until_exists()
logger.info("Created bucket '%s' in region=%s", self.bucket.name, region)
except ClientError as error:
logger.exception(
"Couldn't create bucket named '%s' in region=%s.",
self.bucket.name,
region,
)
raise error
```
ライフサイクル設定を使用してバージョン対応バケットを作成します。
```
def create_versioned_bucket(bucket_name, prefix):
"""
Creates an Amazon S3 bucket, enables it for versioning, and configures a lifecycle
that expires noncurrent object versions after 7 days.
Adding a lifecycle configuration to a versioned bucket is a best practice.
It helps prevent objects in the bucket from accumulating a large number of
noncurrent versions, which can slow down request performance.
Usage is shown in the usage_demo_single_object function at the end of this module.
:param bucket_name: The name of the bucket to create.
:param prefix: Identifies which objects are automatically expired under the
configured lifecycle rules.
:return: The newly created bucket.
"""
try:
bucket = s3.create_bucket(
Bucket=bucket_name,
CreateBucketConfiguration={
"LocationConstraint": s3.meta.client.meta.region_name
},
)
logger.info("Created bucket %s.", bucket.name)
except ClientError as error:
if error.response["Error"]["Code"] == "BucketAlreadyOwnedByYou":
logger.warning("Bucket %s already exists! Using it.", bucket_name)
bucket = s3.Bucket(bucket_name)
else:
logger.exception("Couldn't create bucket %s.", bucket_name)
raise
try:
bucket.Versioning().enable()
logger.info("Enabled versioning on bucket %s.", bucket.name)
except ClientError:
logger.exception("Couldn't enable versioning on bucket %s.", bucket.name)
raise
try:
expiration = 7
bucket.LifecycleConfiguration().put(
LifecycleConfiguration={
"Rules": [
{
"Status": "Enabled",
"Prefix": prefix,
"NoncurrentVersionExpiration": {"NoncurrentDays": expiration},
}
]
}
)
logger.info(
"Configured lifecycle to expire noncurrent versions after %s days "
"on bucket %s.",
expiration,
bucket.name,
)
except ClientError as error:
logger.warning(
"Couldn't configure lifecycle on bucket %s because %s. "
"Continuing anyway.",
bucket.name,
error,
)
return bucket
```
+ API の詳細については、「*AWS SDK for Python (Boto3) API リファレンス*」の「[CreateBucket](https://docs.aws.amazon.com/goto/boto3/s3-2006-03-01/CreateBucket)」を参照してください。
------
#### [ Ruby ]
**SDK for Ruby**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/s3#code-examples)での設定と実行の方法を確認してください。
```
require 'aws-sdk-s3'
# Wraps Amazon S3 bucket actions.
class BucketCreateWrapper
attr_reader :bucket
# @param bucket [Aws::S3::Bucket] An Amazon S3 bucket initialized with a name. This is a client-side object until
# create is called.
def initialize(bucket)
@bucket = bucket
end
# Creates an Amazon S3 bucket in the specified AWS Region.
#
# @param region [String] The Region where the bucket is created.
# @return [Boolean] True when the bucket is created; otherwise, false.
def create?(region)
@bucket.create(create_bucket_configuration: { location_constraint: region })
true
rescue Aws::Errors::ServiceError => e
puts "Couldn't create bucket. Here's why: #{e.message}"
false
end
# Gets the Region where the bucket is located.
#
# @return [String] The location of the bucket.
def location
if @bucket.nil?
'None. You must create a bucket before you can get its location!'
else
@bucket.client.get_bucket_location(bucket: @bucket.name).location_constraint
end
rescue Aws::Errors::ServiceError => e
"Couldn't get the location of #{@bucket.name}. Here's why: #{e.message}"
end
end
# Example usage:
def run_demo
region = "us-west-2"
wrapper = BucketCreateWrapper.new(Aws::S3::Bucket.new("amzn-s3-demo-bucket-#{Random.uuid}"))
return unless wrapper.create?(region)
puts "Created bucket #{wrapper.bucket.name}."
puts "Your bucket's region is: #{wrapper.location}"
end
run_demo if $PROGRAM_NAME == __FILE__
```
+ API の詳細については、「*AWS SDK for Ruby API リファレンス*」の「[CreateBucket](https://docs.aws.amazon.com/goto/SdkForRubyV3/s3-2006-03-01/CreateBucket)」を参照してください。
------
#### [ Rust ]
**SDK for Rust**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/s3#code-examples)での設定と実行の方法を確認してください。
```
pub async fn create_bucket(
client: &aws_sdk_s3::Client,
bucket_name: &str,
region: &aws_config::Region,
) -> Result, S3ExampleError> {
let constraint = aws_sdk_s3::types::BucketLocationConstraint::from(region.to_string().as_str());
let cfg = aws_sdk_s3::types::CreateBucketConfiguration::builder()
.location_constraint(constraint)
.build();
let create = client
.create_bucket()
.create_bucket_configuration(cfg)
.bucket(bucket_name)
.send()
.await;
// BucketAlreadyExists and BucketAlreadyOwnedByYou are not problems for this task.
create.map(Some).or_else(|err| {
if err
.as_service_error()
.map(|se| se.is_bucket_already_exists() || se.is_bucket_already_owned_by_you())
== Some(true)
{
Ok(None)
} else {
Err(S3ExampleError::from(err))
}
})
}
```
+ API の詳細については、「*AWS SDK for Rust API リファレンス*」の「[CreateBucket](https://docs.rs/aws-sdk-s3/latest/aws_sdk_s3/client/struct.Client.html#method.create_bucket)」を参照してください。
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/s3#code-examples)での設定と実行の方法を確認してください。
```
TRY.
" determine our region from our session
DATA(lv_region) = CONV /aws1/s3_bucketlocationcnstrnt( lo_session->get_region( ) ).
DATA lo_constraint TYPE REF TO /aws1/cl_s3_createbucketconf.
" When in the us-east-1 region, you must not specify a constraint
" In all other regions, specify the region as the constraint
IF lv_region = 'us-east-1'.
CLEAR lo_constraint.
ELSE.
lo_constraint = NEW /aws1/cl_s3_createbucketconf( lv_region ).
ENDIF.
lo_s3->createbucket(
iv_bucket = iv_bucket_name
io_createbucketconfiguration = lo_constraint ).
MESSAGE 'S3 bucket created.' TYPE 'I'.
CATCH /aws1/cx_s3_bucketalrdyexists.
MESSAGE 'Bucket name already exists.' TYPE 'E'.
CATCH /aws1/cx_s3_bktalrdyownedbyyou.
MESSAGE 'Bucket already exists and is owned by you.' TYPE 'E'.
ENDTRY.
```
+ API の詳細については、「*AWS SDK for SAP ABAP API リファレンス*」の「[CreateBucket](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)」を参照してください。
------
#### [ Swift ]
**SDK for Swift**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/s3/basics#code-examples)での設定と実行の方法を確認してください。
```
import AWSS3
public func createBucket(name: String) async throws {
var input = CreateBucketInput(
bucket: name
)
// For regions other than "us-east-1", you must set the locationConstraint in the createBucketConfiguration.
// For more information, see LocationConstraint in the S3 API guide.
// https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html#API_CreateBucket_RequestBody
if let region = configuration.region {
if region != "us-east-1" {
input.createBucketConfiguration = S3ClientTypes.CreateBucketConfiguration(locationConstraint: S3ClientTypes.BucketLocationConstraint(rawValue: region))
}
}
do {
_ = try await client.createBucket(input: input)
}
catch let error as BucketAlreadyOwnedByYou {
print("The bucket '\(name)' already exists and is owned by you. You may wish to ignore this exception.")
throw error
}
catch {
print("ERROR: ", dump(error, name: "Creating a bucket"))
throw error
}
}
```
+ API の詳細については、「*AWS SDK for Swift API リファレンス*」の「[CreateBucket](https://sdk.amazonaws.com/swift/api/awss3/latest/documentation/awss3/s3client/createbucket(input:))」を参照してください。
------
**注記**
別のアカウントの Amazon S3 バケットを使用することもできますが、 AWS Configに対してアクセス許可を付与するバケットポリシーの作成が必要になる場合があります。Amazon S3 バケットへのアクセス許可を付与する方法については、[AWS Config 配信チャネルの Amazon S3 バケットのアクセス許可](s3-bucket-policy.md) と [ステップ 2: Amazon SNS トピックを作成する](#gs-cli-create-snstopic) を順に参照してください。
## ステップ 2: Amazon SNS トピックを作成する
アカウントに Amazon SNS トピックが既にあり、それを使用する場合は、このステップをスキップして「[ステップ 3: IAM ロールを作成する](#gs-cli-create-iamrole)」に進んでください。
### SNS コンソールの使用
**Amazon SNS トピックを作成するには**
1. Amazon SNS コンソール ([https://console.aws.amazon.com/sns/v3/home](https://console.aws.amazon.com/sns/v3/home)) を開きます。
1. 次のいずれかを行います。
+ AWS アカウント 以前に でトピックを作成したことがない場合は、ホームページで Amazon SNS の説明をお読みください。
+ AWS アカウント 以前に でトピックが作成されている場合は、ナビゲーションパネルで**トピック**を選択します。
1. [**トピック**] ページで、[**トピックの作成**] を選択します。
1. [**サブスクリプションの作成**] ページで [**詳細**] セクションで、以下を実行します。
1. [**タイプ**] で、トピックタイプ (**標準**または**FIFO**) を選択します。
1. トピックの**名前**を入力します。[FIFO トピック](https://docs.aws.amazon.com/sns/latest/dg/sns-fifo-topics.html)で、名前の末尾に **.fifo** を追加します。
1. (オプション) トピックの**表示名**を入力します。
1. (オプション) FIFO トピックで、[**コンテンツベースのメッセージ重複排除**] を選択して、デフォルトのメッセージの重複排除を有効にします。詳細については、「[FIFO トピックのメッセージ重複除外](https://docs.aws.amazon.com/sns/latest/dg/fifo-message-dedup.html)」を参照してください。
1. (オプション) [**暗号化**] セクションを展開し、以下の操作を実行します。詳細については、「[保管時の暗号化](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html)」を参照してください。
1. [**暗号化の有効化**] を選択します。
1. カスタマーマスターキー (CMK) を指定します。詳細については、[重要な用語](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms)を参照してください。
CMK タイプごとに、[**説明**]、[**アカウント**]、および [**CMK ARN**] が表示されます。
**重要**
CMK の所有者ではない場合、または `kms:ListAliases` および `kms:DescribeKey` アクセス権限がないアカウントでログインしている場合、Amazon SNS コンソールで CMK に関する情報は表示できません。
CMK の所有者に、これらのアクセス権限を付与するよう依頼します。詳細については、「*AWS Key Management Service デベロッパーガイド*」の「[AWS KMS API アクセス権限: アクションとリソースのリファレンス](https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html)」を参照してください。
+ Amazon SNS **(デフォルト) alias/aws/sns** の AWS マネージド CMK がデフォルトで選択されています。
**注記**
以下に留意してください。
AWS マネジメントコンソール を使用してトピックの Amazon SNS の AWS マネージド CMK を初めて指定すると、 は Amazon SNS の AWS マネージド CMK AWS KMS を作成します。
または、SSE が有効になっているトピックで `Publish`アクションを初めて使用すると、 は Amazon SNS の AWS マネージド CMK AWS KMS を作成します。
+ からカスタム CMK を使用するには AWS アカウント、**カスタマーマスターキー (CMK)** フィールドを選択し、リストからカスタム CMK を選択します。
**注記**
カスタム CMK の作成手順については、「*AWS Key Management Service デベロッパーガイド*」の「[キーの作成](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html)」を参照してください。
+ AWS アカウント または別の AWS アカウントからカスタム CMK ARN を使用するには、**カスタマーマスターキー (CMK)** フィールドに入力します。
1. (オプション) デフォルトでは、トピックの所有者のみがトピックを発行またはサブスクライブできます。追加のアクセス許可を設定するには、**[アクセスポリシー]** セクションを展開します。詳細については、「[Amazon SNS におけるアイデンティティとアクセス管理](https://docs.aws.amazon.com/sns/latest/dg/sns-authentication-and-access-control.html)」および「[Amazon SNS のアクセス制御のケース例](https://docs.aws.amazon.com/sns/latest/dg/sns-access-policy-use-cases.html)」を参照してください。
**注記**
コンソールを使用してトピックを作成すると、デフォルトのポリシーでは `aws:SourceOwner` 条件キーが使用されます。このキーは `aws:SourceAccount` に類似しています。
1. (オプション) 失敗したメッセージ配信試行を Amazon SNS で再試行する方法を設定するには、**[配信再試行ポリシー (HTTP/S)]** セクションを展開します。詳細については、「[Amazon SNS メッセージ配信の再試行](https://docs.aws.amazon.com/sns/latest/dg/sns-message-delivery-retries.html)」を参照してください。
1. (オプション) CloudWatch へのメッセージの配信を Amazon SNS でログに記録する方法を設定するには、**[配信ステータスのログ記録]** セクションを展開します。詳細については、「[メッセージの配信ステータスの Amazon SNS アプリケーション属性を使用する](https://docs.aws.amazon.com/sns/latest/dg/sns-topic-attributes.html)」を参照してください。
1. (オプション) トピックにメタデータタグを追加するには、**[タグ]** セクションを展開し、**[キー]** と **[値]** (オプション) に入力し、**[タグの追加]** を選択します。詳細については、「[Amazon SNS トピックのタグ付け](https://docs.aws.amazon.com/sns/latest/dg/sns-tags.html)」を参照してください。
1. **[トピックの作成]** を選択します。
トピックが作成され、***[MyTopic]*** ページが表示されます。
トピックの**名前**、**ARN**、(オプション) **表示名**、および**トピックの所有者**の AWS アカウント ID が **[詳細]** セクションに表示されます。
1. トピック ARN をクリップボードにコピーします。例:
```
arn:aws:sns:us-east-2:123456789012:MyTopic
```
**E メールアドレスを Amazon SNS トピックにサブスクライブするには**
1. Amazon SNS コンソール[https://console.aws.amazon.com/sns/v3/home](https://console.aws.amazon.com/sns/v3/home)を開いてください。
1. 左のナビゲーションペインで、**[サブスクリプション]** を選択します。
1. **[サブスクリプション]** ページで **[サブスクリプションの作成]** を選択します。
1. **[サブスクリプションの作成]** ページの **[詳細]** セクションで、以下を実行します。
1. **[トピック ARN]** は、トピックの Amazon リソースネーム (ARN) を選択します。
1. **[プロトコル]** でエンドポイントタイプを選択します。使用可能なエンドポイントタイプは次のとおりです。
+ [HTTP/HTTPS](https://docs.aws.amazon.com/sns/latest/dg/sns-http-https-endpoint-as-subscriber.html)
+ [Email/Email-JSON](https://docs.aws.amazon.com/sns/latest/dg/sns-email-notifications.html)
+ [Amazon Data Firehose](https://docs.aws.amazon.com/sns/latest/dg/sns-firehose-as-subscriber.html)
+ [Amazon SQS](https://docs.aws.amazon.com/sns/latest/dg/sns-sqs-as-subscriber.html)
**注記**
[SNS FIFO トピック](https://docs.aws.amazon.com/sns/latest/dg/sns-fifo-topics.html)にサブスクライブするには、このオプションを選択します。
+ [AWS Lambda](https://docs.aws.amazon.com/sns/latest/dg/sns-lambda-as-subscriber.html)
+ [プラットフォームアプリケーションエンドポイント](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-application-as-subscriber.html)
+ [SMS](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html)
1. **[エンドポイント]** に、エンドポイント値 (E メールアドレスや Amazon SQS キューの ARN など) を入力します。
1. Firehose エンドポイントのみ: **[サブスクリプションロール ARN]** で、Firehose 配信ストリームに書き込むために作成した IAM ロールの ARN を指定します。詳細については、「[Prerequisites for subscribing Firehose delivery streams to Amazon SNS topics](https://docs.aws.amazon.com/sns/latest/dg/prereqs-kinesis-data-firehose.html)」を参照してください。
1. (オプション) Firehose、Amazon SQS、HTTP/S エンドポイントは、raw メッセージ配信を有効にすることもできます。詳細については、「[Amazon SNS raw メッセージ配信](https://docs.aws.amazon.com/sns/latest/dg/sns-large-payload-raw-message-delivery.html)」を参照してください。
1. (オプション) フィルターポリシーを設定するには、**[サブスクリプションのフィルターポリシー]** セクションを展開します。詳細については、「[Amazon SNS サブスクリプションフィルターポリシー](https://docs.aws.amazon.com/sns/latest/dg/sns-subscription-filter-policies.html)」を参照してください。
1. (オプション) サブスクリプションのデッドレターキューを設定するには、**Redrive ポリシー (デッドレターキュー)** を展開します。詳細については、「[Amazon SNS デッドレターキュー (DLQ)](https://docs.aws.amazon.com/sns/latest/dg/sns-dead-letter-queues.html)」を参照してください。
1. **[サブスクリプションの作成]** を選択します。
コンソールがサブスクリプションを作成し、サブスクリプションの **[詳細]** ページを開きます。
### AWS SDKsの使用
AWS SDK を使用するには、認証情報を使用して設定する必要があります。詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルと認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html)」を参照してください。
次のサンプルコードは、`CreateTopic` を使用する方法を説明しています。
------
#### [ .NET ]
**SDK for .NET**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SNS#code-examples)での設定と実行の方法を確認してください。
トピックを作成して、個別の名前を付けます。
```
using System;
using System.Threading.Tasks;
using Amazon.SimpleNotificationService;
using Amazon.SimpleNotificationService.Model;
///
/// This example shows how to use Amazon Simple Notification Service
/// (Amazon SNS) to add a new Amazon SNS topic.
///
public class CreateSNSTopic
{
public static async Task Main()
{
string topicName = "ExampleSNSTopic";
IAmazonSimpleNotificationService client = new AmazonSimpleNotificationServiceClient();
var topicArn = await CreateSNSTopicAsync(client, topicName);
Console.WriteLine($"New topic ARN: {topicArn}");
}
///
/// Creates a new SNS topic using the supplied topic name.
///
/// The initialized SNS client object used to
/// create the new topic.
/// A string representing the topic name.
/// The Amazon Resource Name (ARN) of the created topic.
public static async Task CreateSNSTopicAsync(IAmazonSimpleNotificationService client, string topicName)
{
var request = new CreateTopicRequest
{
Name = topicName,
};
var response = await client.CreateTopicAsync(request);
return response.TopicArn;
}
}
```
名前と特定の FIFO および重複除外属性を使用して新しいトピックを作成します。
```
///
/// Create a new topic with a name and specific FIFO and de-duplication attributes.
///
/// The name for the topic.
/// True to use a FIFO topic.
/// True to use content-based de-duplication.
/// The ARN of the new topic.
public async Task CreateTopicWithName(string topicName, bool useFifoTopic, bool useContentBasedDeduplication)
{
var createTopicRequest = new CreateTopicRequest()
{
Name = topicName,
};
if (useFifoTopic)
{
// Update the name if it is not correct for a FIFO topic.
if (!topicName.EndsWith(".fifo"))
{
createTopicRequest.Name = topicName + ".fifo";
}
// Add the attributes from the method parameters.
createTopicRequest.Attributes = new Dictionary
{
{ "FifoTopic", "true" }
};
if (useContentBasedDeduplication)
{
createTopicRequest.Attributes.Add("ContentBasedDeduplication", "true");
}
}
var createResponse = await _amazonSNSClient.CreateTopicAsync(createTopicRequest);
return createResponse.TopicArn;
}
```
+ API の詳細については、「*AWS SDK for .NET API リファレンス*」の「[CreateTopic](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/CreateTopic)」を参照してください。
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sns#code-examples)での設定と実行の方法を確認してください。
```
//! Create an Amazon Simple Notification Service (Amazon SNS) topic.
/*!
\param topicName: An Amazon SNS topic name.
\param topicARNResult: String to return the Amazon Resource Name (ARN) for the topic.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SNS::createTopic(const Aws::String &topicName,
Aws::String &topicARNResult,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SNS::SNSClient snsClient(clientConfiguration);
Aws::SNS::Model::CreateTopicRequest request;
request.SetName(topicName);
const Aws::SNS::Model::CreateTopicOutcome outcome = snsClient.CreateTopic(request);
if (outcome.IsSuccess()) {
topicARNResult = outcome.GetResult().GetTopicArn();
std::cout << "Successfully created an Amazon SNS topic " << topicName
<< " with topic ARN '" << topicARNResult
<< "'." << std::endl;
}
else {
std::cerr << "Error creating topic " << topicName << ":" <<
outcome.GetError().GetMessage() << std::endl;
topicARNResult.clear();
}
return outcome.IsSuccess();
}
```
+ API の詳細については、「*AWS SDK for C\$1\$1 API リファレンス*」の「[CreateTopic](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/CreateTopic)」を参照してください。
------
#### [ CLI ]
**AWS CLI**
**SNS トピックを作成するには**
次の `create-topic` の例では、`my-topic` という名前の SNS トピックを作成します。
```
aws sns create-topic \
--name my-topic
```
出力:
```
{
"ResponseMetadata": {
"RequestId": "1469e8d7-1642-564e-b85d-a19b4b341f83"
},
"TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}
```
詳細については、[AWS 「 コマンドラインインターフェイスユーザーガイド」のAmazon SQS および Amazon SNS での](https://docs.aws.amazon.com/cli/latest/userguide/cli-sqs-queue-sns-topic.html)コマンドラインインターフェイスの使用」を参照してください。 *AWS *
+ API の詳細については、「*AWS CLI コマンドリファレンス*」の「[CreateTopic](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/create-topic.html)」を参照してください。
------
#### [ Go ]
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/workflows/topics_and_queues#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"encoding/json"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/sns"
"github.com/aws/aws-sdk-go-v2/service/sns/types"
)
// SnsActions encapsulates the Amazon Simple Notification Service (Amazon SNS) actions
// used in the examples.
type SnsActions struct {
SnsClient *sns.Client
}
// CreateTopic creates an Amazon SNS topic with the specified name. You can optionally
// specify that the topic is created as a FIFO topic and whether it uses content-based
// deduplication instead of ID-based deduplication.
func (actor SnsActions) CreateTopic(ctx context.Context, topicName string, isFifoTopic bool, contentBasedDeduplication bool) (string, error) {
var topicArn string
topicAttributes := map[string]string{}
if isFifoTopic {
topicAttributes["FifoTopic"] = "true"
}
if contentBasedDeduplication {
topicAttributes["ContentBasedDeduplication"] = "true"
}
topic, err := actor.SnsClient.CreateTopic(ctx, &sns.CreateTopicInput{
Name: aws.String(topicName),
Attributes: topicAttributes,
})
if err != nil {
log.Printf("Couldn't create topic %v. Here's why: %v\n", topicName, err)
} else {
topicArn = *topic.TopicArn
}
return topicArn, err
}
```
+ API の詳細については、「*AWS SDK for Go API リファレンス*」の「[CreateTopic](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.CreateTopic)」を参照してください。
------
#### [ Java ]
**SDK for Java 2.x**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/sns#code-examples)での設定と実行の方法を確認してください。
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.CreateTopicRequest;
import software.amazon.awssdk.services.sns.model.CreateTopicResponse;
import software.amazon.awssdk.services.sns.model.SnsException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class CreateTopic {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
topicName - The name of the topic to create (for example, mytopic).
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String topicName = args[0];
System.out.println("Creating a topic with name: " + topicName);
SnsClient snsClient = SnsClient.builder()
.region(Region.US_EAST_1)
.build();
String arnVal = createSNSTopic(snsClient, topicName);
System.out.println("The topic ARN is" + arnVal);
snsClient.close();
}
public static String createSNSTopic(SnsClient snsClient, String topicName) {
CreateTopicResponse result;
try {
CreateTopicRequest request = CreateTopicRequest.builder()
.name(topicName)
.build();
result = snsClient.createTopic(request);
return result.topicArn();
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return "";
}
}
```
+ API の詳細については、「*AWS SDK for Java 2.x API リファレンス*」の「[CreateTopic](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/CreateTopic)」を参照してください。
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples)での設定と実行の方法を確認してください。
別のモジュールでクライアントを作成し、エクスポートします。
```
import { SNSClient } from "@aws-sdk/client-sns";
// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```
SDK モジュールとクライアントモジュールをインポートし、API を呼び出します。
```
import { CreateTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string} topicName - The name of the topic to create.
*/
export const createTopic = async (topicName = "TOPIC_NAME") => {
const response = await snsClient.send(
new CreateTopicCommand({ Name: topicName }),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '087b8ad2-4593-50c4-a496-d7e90b82cf3e',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME'
// }
return response;
};
```
+ 詳細については、「[AWS SDK for JavaScript デベロッパーガイド](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topics-createtopic)」を参照してください。
+ API の詳細については、「*AWS SDK for JavaScript API リファレンス*」の「[CreateTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/CreateTopicCommand)」を参照してください。
------
#### [ Kotlin ]
**SDK for Kotlin**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/sns#code-examples)での設定と実行の方法を確認してください。
```
suspend fun createSNSTopic(topicName: String): String {
val request =
CreateTopicRequest {
name = topicName
}
SnsClient.fromEnvironment { region = "us-east-1" }.use { snsClient ->
val result = snsClient.createTopic(request)
return result.topicArn.toString()
}
}
```
+ API の詳細については、「*AWS SDK for Kotlin API リファレンス*」の「[CreateTopic](https://sdk.amazonaws.com/kotlin/api/latest/index.html)」を参照してください。
------
#### [ PHP ]
**SDK for PHP**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/sns#code-examples)での設定と実行の方法を確認してください。
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Create a Simple Notification Service topics in your AWS account at the requested region.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$topicname = 'myTopic';
try {
$result = $SnSclient->createTopic([
'Name' => $topicname,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ 詳細については、「[AWS SDK for PHP デベロッパーガイド](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-managing-topics.html#create-a-topic)」を参照してください。
+ API の詳細については、「AWS SDK for PHP API リファレンス**」の「[CreateTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CreateTopic)」を参照してください。
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/sns#code-examples)での設定と実行の方法を確認してください。
```
class SnsWrapper:
"""Encapsulates Amazon SNS topic and subscription functions."""
def __init__(self, sns_resource):
"""
:param sns_resource: A Boto3 Amazon SNS resource.
"""
self.sns_resource = sns_resource
def create_topic(self, name):
"""
Creates a notification topic.
:param name: The name of the topic to create.
:return: The newly created topic.
"""
try:
topic = self.sns_resource.create_topic(Name=name)
logger.info("Created topic %s with ARN %s.", name, topic.arn)
except ClientError:
logger.exception("Couldn't create topic %s.", name)
raise
else:
return topic
```
```
class SnsWrapper:
"""Wrapper class for managing Amazon SNS operations."""
def __init__(self, sns_client: Any) -> None:
"""
Initialize the SnsWrapper.
:param sns_client: A Boto3 Amazon SNS client.
"""
self.sns_client = sns_client
@classmethod
def from_client(cls) -> 'SnsWrapper':
"""
Create an SnsWrapper instance using a default boto3 client.
:return: An instance of this class.
"""
sns_client = boto3.client('sns')
return cls(sns_client)
def create_topic(
self,
topic_name: str,
is_fifo: bool = False,
content_based_deduplication: bool = False
) -> str:
"""
Create an SNS topic.
:param topic_name: The name of the topic to create.
:param is_fifo: Whether to create a FIFO topic.
:param content_based_deduplication: Whether to use content-based deduplication for FIFO topics.
:return: The ARN of the created topic.
:raises ClientError: If the topic creation fails.
"""
try:
# Add .fifo suffix for FIFO topics
if is_fifo and not topic_name.endswith('.fifo'):
topic_name += '.fifo'
attributes = {}
if is_fifo:
attributes['FifoTopic'] = 'true'
if content_based_deduplication:
attributes['ContentBasedDeduplication'] = 'true'
response = self.sns_client.create_topic(
Name=topic_name,
Attributes=attributes
)
topic_arn = response['TopicArn']
logger.info(f"Created topic: {topic_name} with ARN: {topic_arn}")
return topic_arn
except ClientError as e:
error_code = e.response.get('Error', {}).get('Code', 'Unknown')
logger.error(f"Error creating topic {topic_name}: {error_code} - {e}")
raise
```
+ API の詳細については、「*AWS SDK for Python (Boto3) API リファレンス*」の「[CreateTopic](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/CreateTopic)」を参照してください。
------
#### [ Ruby ]
**SDK for Ruby**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/sns#code-examples)での設定と実行の方法を確認してください。
```
# This class demonstrates how to create an Amazon Simple Notification Service (SNS) topic.
class SNSTopicCreator
# Initializes an SNS client.
#
# Utilizes the default AWS configuration for region and credentials.
def initialize
@sns_client = Aws::SNS::Client.new
end
# Attempts to create an SNS topic with the specified name.
#
# @param topic_name [String] The name of the SNS topic to create.
# @return [Boolean] true if the topic was successfully created, false otherwise.
def create_topic(topic_name)
@sns_client.create_topic(name: topic_name)
puts "The topic '#{topic_name}' was successfully created."
true
rescue Aws::SNS::Errors::ServiceError => e
# Handles SNS service errors gracefully.
puts "Error while creating the topic named '#{topic_name}': #{e.message}"
false
end
end
# Example usage:
if $PROGRAM_NAME == __FILE__
topic_name = 'YourTopicName' # Replace with your topic name
sns_topic_creator = SNSTopicCreator.new
puts "Creating the topic '#{topic_name}'..."
unless sns_topic_creator.create_topic(topic_name)
puts 'The topic was not created. Stopping program.'
exit 1
end
end
```
+ 詳細については、「[AWS SDK for Ruby デベロッパーガイド](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/sns-example-create-topic.html)」を参照してください。
+ API の詳細については、「AWS SDK for Ruby API リファレンス**」の「[CreateTopic](https://docs.aws.amazon.com/goto/SdkForRubyV3/sns-2010-03-31/CreateTopic)」を参照してください。
------
#### [ Rust ]
**SDK for Rust**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/sns#code-examples)での設定と実行の方法を確認してください。
```
async fn make_topic(client: &Client, topic_name: &str) -> Result<(), Error> {
let resp = client.create_topic().name(topic_name).send().await?;
println!(
"Created topic with ARN: {}",
resp.topic_arn().unwrap_or_default()
);
Ok(())
}
```
+ API の詳細については、「*AWS SDK for Rust API リファレンス*」の「[CreateTopic](https://docs.rs/aws-sdk-sns/latest/aws_sdk_sns/client/struct.Client.html#method.create_topic)」を参照してください。
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/sns#code-examples)での設定と実行の方法を確認してください。
```
TRY.
oo_result = lo_sns->createtopic( iv_name = iv_topic_name ). " oo_result is returned for testing purposes. "
MESSAGE 'SNS topic created' TYPE 'I'.
CATCH /aws1/cx_snstopiclimitexcdex.
MESSAGE 'Unable to create more topics. You have reached the maximum number of topics allowed.' TYPE 'E'.
ENDTRY.
```
+ API の詳細については、「*AWS SDK for SAP ABAP API リファレンス*」の「[CreateTopic](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)」を参照してください。
------
#### [ Swift ]
**SDK for Swift**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/sns#code-examples)での設定と実行の方法を確認してください。
```
import AWSSNS
let config = try await SNSClient.SNSClientConfiguration(region: region)
let snsClient = SNSClient(config: config)
let output = try await snsClient.createTopic(
input: CreateTopicInput(name: name)
)
guard let arn = output.topicArn else {
print("No topic ARN returned by Amazon SNS.")
return
}
```
+ API の詳細については、「*AWS SDK for Swift API リファレンス*」の「[CreateTopic](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/createtopic(input:))」を参照してください。
------
**注記**
別のアカウントの Amazon SNS トピックを使用することもできますが、その場合は、 AWS Configに対するアクセス許可を付与するトピックポリシーの作成が必要になる場合があります。Amazon SNS トピックへのアクセス許可を付与する方法については、[Amazon SNS トピックへのアクセス許可](sns-topic-policy.md) と [ステップ 3: IAM ロールを作成する](#gs-cli-create-iamrole) を順に参照してください。
## ステップ 3: IAM ロールを作成する
**重要**
**(推奨) AWS Config サービスにリンクされたロールを使用する**
AWS Config サービスにリンクされたロール を使用することをお勧めします`AWSServiceRoleForConfig`。サービスにリンクされたロールは事前定義されており、 が他の を呼び出す AWS Config ために必要なすべてのアクセス許可が含まれています AWS のサービス。 AWS Config サービスにリンクされたロールは、サービスにリンクされた設定レコーダーに必要です。
詳細については、「[AWS Configのサービスにリンクされたロールの使用](https://docs.aws.amazon.com/config/latest/developerguide/using-service-linked-roles.html)」を参照してください。
### IAM コンソールの使用
IAM コンソールを使用して、Amazon S3 バケットへのアクセス、Amazon SNS トピックへのアクセス、サポートされている AWS リソースの設定詳細を取得するアクセス AWS Config 許可を付与する IAM ロールを作成できます。コンソールを使用して IAM ロールを作成すると、 AWS Config はロールに必要なアクセス許可を自動的に適用します。
**注記**
を使用する AWS サービス AWS Config ( AWS Security Hub や AWS Control Tower など) を使用していて、 AWS Config ロールがすでに作成されている場合は、他の AWS サービスが期待どおりに実行されるように、セットアップ時に使用する IAM ロールが、既に作成された AWS Config ロールと同じ最小権限 AWS Config を保持していることを確認する必要があります。
例えば、 AWS Control Tower に Amazon S3 オブジェクト AWS Config の読み取りを許可する IAM ロールがある場合、セットアップ時に使用する IAM ロール内で同じアクセス許可が付与されていることを確認する必要があります AWS Config。そうしないと、 AWS Control Tower のオペレーションが妨げられる可能性があります。
の IAM ロールの詳細については AWS Config、[AWS 「Identity and Access Management](https://docs.aws.amazon.com/config/latest/developerguide/security-iam.html)」を参照してください。
**AWS サービスのロールを作成するには**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソールを開きます。
1. IAM コンソールのナビゲーションペインで、**[ロール]**、**[ロールを作成]** を選択します。
1. **[Select trusted entity]** (信頼されたエンティティの選択) で、**[AWS のサービス]** を選択します。
1. 目的のユースケースを選択します AWS Config。**Config - カスタマイズ可能**、**Config - 組織**、**Config**、または **Config - コンフォーマンスパック**。その後、**[Next]** を選択します。
1. **[Name, review, and create]** (名前、確認、および作成) ページで、ロールの詳細を確認し、**[Create Role]** (ロールの作成) を選択します。
### AWS SDKsの使用
AWS SDK を使用するには、認証情報を使用して設定する必要があります。詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルと認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html)」を参照してください。
次のサンプルコードは、`CreateRole` を使用する方法を説明しています。
------
#### [ .NET ]
**SDK for .NET**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/IAM#code-examples)での設定と実行の方法を確認してください。
```
///
/// Create a new IAM role.
///
/// The name of the IAM role.
/// The name of the IAM policy document
/// for the new role.
/// The Amazon Resource Name (ARN) of the role.
public async Task CreateRoleAsync(string roleName, string rolePolicyDocument)
{
var request = new CreateRoleRequest
{
RoleName = roleName,
AssumeRolePolicyDocument = rolePolicyDocument,
};
var response = await _IAMService.CreateRoleAsync(request);
return response.Role.Arn;
}
```
+ API の詳細については、「*AWS SDK for .NET API リファレンス*」の「[CreateRole](https://docs.aws.amazon.com/goto/DotNetSDKV3/iam-2010-05-08/CreateRole)」を参照してください。
------
#### [ Bash ]
**AWS CLI Bash スクリプトを使用する**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/iam#code-examples)での設定と実行の方法を確認してください。
```
###############################################################################
# function errecho
#
# This function outputs everything sent to it to STDERR (standard error output).
###############################################################################
function errecho() {
printf "%s\n" "$*" 1>&2
}
###############################################################################
# function iam_create_role
#
# This function creates an IAM role.
#
# Parameters:
# -n role_name -- The name of the IAM role.
# -p policy_json -- The assume role policy document.
#
# Returns:
# The ARN of the role.
# And:
# 0 - If successful.
# 1 - If it fails.
###############################################################################
function iam_create_role() {
local role_name policy_document response
local option OPTARG # Required to use getopts command in a function.
# bashsupport disable=BP5008
function usage() {
echo "function iam_create_user_access_key"
echo "Creates an AWS Identity and Access Management (IAM) role."
echo " -n role_name The name of the IAM role."
echo " -p policy_json -- The assume role policy document."
echo ""
}
# Retrieve the calling parameters.
while getopts "n:p:h" option; do
case "${option}" in
n) role_name="${OPTARG}" ;;
p) policy_document="${OPTARG}" ;;
h)
usage
return 0
;;
\?)
echo "Invalid parameter"
usage
return 1
;;
esac
done
export OPTIND=1
if [[ -z "$role_name" ]]; then
errecho "ERROR: You must provide a role name with the -n parameter."
usage
return 1
fi
if [[ -z "$policy_document" ]]; then
errecho "ERROR: You must provide a policy document with the -p parameter."
usage
return 1
fi
response=$(aws iam create-role \
--role-name "$role_name" \
--assume-role-policy-document "$policy_document" \
--output text \
--query Role.Arn)
local error_code=${?}
if [[ $error_code -ne 0 ]]; then
aws_cli_error_log $error_code
errecho "ERROR: AWS reports create-role operation failed.\n$response"
return 1
fi
echo "$response"
return 0
}
```
+ API の詳細については、「*AWS CLI コマンドリファレンス*」の「[CreateRole](https://docs.aws.amazon.com/goto/aws-cli/iam-2010-05-08/CreateRole)」を参照してください。
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/iam#code-examples)での設定と実行の方法を確認してください。
```
bool AwsDoc::IAM::createIamRole(
const Aws::String &roleName,
const Aws::String &policy,
const Aws::Client::ClientConfiguration &clientConfig) {
Aws::IAM::IAMClient client(clientConfig);
Aws::IAM::Model::CreateRoleRequest request;
request.SetRoleName(roleName);
request.SetAssumeRolePolicyDocument(policy);
Aws::IAM::Model::CreateRoleOutcome outcome = client.CreateRole(request);
if (!outcome.IsSuccess()) {
std::cerr << "Error creating role. " <<
outcome.GetError().GetMessage() << std::endl;
}
else {
const Aws::IAM::Model::Role iamRole = outcome.GetResult().GetRole();
std::cout << "Created role " << iamRole.GetRoleName() << "\n";
std::cout << "ID: " << iamRole.GetRoleId() << "\n";
std::cout << "ARN: " << iamRole.GetArn() << std::endl;
}
return outcome.IsSuccess();
}
```
+ API の詳細については、「*AWS SDK for C\$1\$1 API リファレンス*」の「[CreateRole](https://docs.aws.amazon.com/goto/SdkForCpp/iam-2010-05-08/CreateRole)」を参照してください。
------
#### [ CLI ]
**AWS CLI**
**例 1: IAM ロールを作成するには**
次の `create-role` コマンドは、`Test-Role` という名前のロールを作成し、それに信頼ポリシーをアタッチします。
```
aws iam create-role \
--role-name Test-Role \
--assume-role-policy-document file://Test-Role-Trust-Policy.json
```
出力:
```
{
"Role": {
"AssumeRolePolicyDocument": "",
"RoleId": "AKIAIOSFODNN7EXAMPLE",
"CreateDate": "2013-06-07T20:43:32.821Z",
"RoleName": "Test-Role",
"Path": "/",
"Arn": "arn:aws:iam::123456789012:role/Test-Role"
}
}
```
信頼ポリシーは、*Test-Role-Trust-Policy.json *ファイル内で JSON ドキュメントとして定義されます。(ファイル名と拡張子には意味はありません。) 信頼ポリシーはプリンシパルを指定する必要があります。
アクセス許可ポリシーをロールにアタッチするには、`put-role-policy` コマンドを使用します。
詳細については、「*AWS IAM ユーザーガイド*」の「[IAM ロールの作成](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html)」を参照してください。
**例 2: 最大セッション期間を指定して IAM ロールを作成するには**
次の `create-role` コマンドは、`Test-Role` という名前のロールを作成し、最大セッション時間を 7,200 秒 (2 時間) に設定します。
```
aws iam create-role \
--role-name Test-Role \
--assume-role-policy-document file://Test-Role-Trust-Policy.json \
--max-session-duration 7200
```
出力:
```
{
"Role": {
"Path": "/",
"RoleName": "Test-Role",
"RoleId": "AKIAIOSFODNN7EXAMPLE",
"Arn": "arn:aws:iam::12345678012:role/Test-Role",
"CreateDate": "2023-05-24T23:50:25+00:00",
"AssumeRolePolicyDocument": {
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Statement1",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::12345678012:root"
},
"Action": "sts:AssumeRole"
}
]
}
}
}
```
詳細については、*AWS IAM ユーザーガイド*[の「ロールの最大セッション期間 (AWS API) の変更](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-api.html#roles-modify_max-session-duration-api)」を参照してください。
**例 3: タグを使用して IAM ロールを作成するには**
次のコマンドは、タグを使用して IAM ロール `Test-Role` を作成します。この例では、次の JSON 形式のタグを持つ `--tags` パラメータフラグを使用します: `'{"Key": "Department", "Value": "Accounting"}' '{"Key": "Location", "Value": "Seattle"}'`。あるいは、`--tags` フラグを次の短縮形式のタグとともに使用することもできます: `'Key=Department,Value=Accounting Key=Location,Value=Seattle'`。
```
aws iam create-role \
--role-name Test-Role \
--assume-role-policy-document file://Test-Role-Trust-Policy.json \
--tags '{"Key": "Department", "Value": "Accounting"}' '{"Key": "Location", "Value": "Seattle"}'
```
出力:
```
{
"Role": {
"Path": "/",
"RoleName": "Test-Role",
"RoleId": "AKIAIOSFODNN7EXAMPLE",
"Arn": "arn:aws:iam::123456789012:role/Test-Role",
"CreateDate": "2023-05-25T23:29:41+00:00",
"AssumeRolePolicyDocument": {
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Statement1",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:root"
},
"Action": "sts:AssumeRole"
}
]
},
"Tags": [
{
"Key": "Department",
"Value": "Accounting"
},
{
"Key": "Location",
"Value": "Seattle"
}
]
}
}
```
詳細については、「*AWS IAM ユーザーガイド*」の「[IAM ロールのタグ付け](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags_roles.html)」を参照してください。
+ API の詳細については、*AWS CLI コマンドリファレンス*の「[CreateRole](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iam/create-role.html)」を参照してください。
------
#### [ Go ]
**SDK for Go V2**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/iam#code-examples)での設定と実行の方法を確認してください。
```
import (
"context"
"encoding/json"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/iam"
"github.com/aws/aws-sdk-go-v2/service/iam/types"
)
// RoleWrapper encapsulates AWS Identity and Access Management (IAM) role actions
// used in the examples.
// It contains an IAM service client that is used to perform role actions.
type RoleWrapper struct {
IamClient *iam.Client
}
// CreateRole creates a role that trusts a specified user. The trusted user can assume
// the role to acquire its permissions.
// PolicyDocument shows how to work with a policy document as a data structure and
// serialize it to JSON by using Go's JSON marshaler.
func (wrapper RoleWrapper) CreateRole(ctx context.Context, roleName string, trustedUserArn string) (*types.Role, error) {
var role *types.Role
trustPolicy := PolicyDocument{
Version: "2012-10-17",
Statement: []PolicyStatement{{
Effect: "Allow",
Principal: map[string]string{"AWS": trustedUserArn},
Action: []string{"sts:AssumeRole"},
}},
}
policyBytes, err := json.Marshal(trustPolicy)
if err != nil {
log.Printf("Couldn't create trust policy for %v. Here's why: %v\n", trustedUserArn, err)
return nil, err
}
result, err := wrapper.IamClient.CreateRole(ctx, &iam.CreateRoleInput{
AssumeRolePolicyDocument: aws.String(string(policyBytes)),
RoleName: aws.String(roleName),
})
if err != nil {
log.Printf("Couldn't create role %v. Here's why: %v\n", roleName, err)
} else {
role = result.Role
}
return role, err
}
```
+ API の詳細については、「*AWS SDK for Go API リファレンス*」の「[CreateRole](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/iam#Client.CreateRole)」を参照してください。
------
#### [ Java ]
**SDK for Java 2.x**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/iam#code-examples)での設定と実行の方法を確認してください。
```
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import software.amazon.awssdk.services.iam.model.CreateRoleRequest;
import software.amazon.awssdk.services.iam.model.CreateRoleResponse;
import software.amazon.awssdk.services.iam.model.IamException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.iam.IamClient;
import java.io.FileReader;
/*
* This example requires a trust policy document. For more information, see:
* https://aws.amazon.com/blogs/security/how-to-use-trust-policies-with-iam-roles/
*
*
* In addition, set up your development environment, including your credentials.
*
* For information, see this documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class CreateRole {
public static void main(String[] args) throws Exception {
final String usage = """
Usage:
\s
Where:
rolename - The name of the role to create.\s
fileLocation - The location of the JSON document that represents the trust policy.\s
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String rolename = args[0];
String fileLocation = args[1];
Region region = Region.AWS_GLOBAL;
IamClient iam = IamClient.builder()
.region(region)
.build();
String result = createIAMRole(iam, rolename, fileLocation);
System.out.println("Successfully created user: " + result);
iam.close();
}
public static String createIAMRole(IamClient iam, String rolename, String fileLocation) throws Exception {
try {
JSONObject jsonObject = (JSONObject) readJsonSimpleDemo(fileLocation);
CreateRoleRequest request = CreateRoleRequest.builder()
.roleName(rolename)
.assumeRolePolicyDocument(jsonObject.toJSONString())
.description("Created using the AWS SDK for Java")
.build();
CreateRoleResponse response = iam.createRole(request);
System.out.println("The ARN of the role is " + response.role().arn());
} catch (IamException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return "";
}
public static Object readJsonSimpleDemo(String filename) throws Exception {
FileReader reader = new FileReader(filename);
JSONParser jsonParser = new JSONParser();
return jsonParser.parse(reader);
}
}
```
+ API の詳細については、「*AWS SDK for Java 2.x API リファレンス*」の「[CreateRole](https://docs.aws.amazon.com/goto/SdkForJavaV2/iam-2010-05-08/CreateRole)」を参照してください。
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/iam#code-examples)での設定と実行の方法を確認してください。
ロールを作成します。
```
import { CreateRoleCommand, IAMClient } from "@aws-sdk/client-iam";
const client = new IAMClient({});
/**
*
* @param {string} roleName
*/
export const createRole = (roleName) => {
const command = new CreateRoleCommand({
AssumeRolePolicyDocument: JSON.stringify({
Version: "2012-10-17",
Statement: [
{
Effect: "Allow",
Principal: {
Service: "lambda.amazonaws.com",
},
Action: "sts:AssumeRole",
},
],
}),
RoleName: roleName,
});
return client.send(command);
};
```
+ API の詳細については、「*AWS SDK for JavaScript API リファレンス*」の「[CreateRole](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iam/command/CreateRoleCommand)」を参照してください。
------
#### [ PHP ]
**SDK for PHP**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/iam#code-examples)での設定と実行の方法を確認してください。
```
$uuid = uniqid();
$service = new IAMService();
$assumeRolePolicyDocument = "{
\"Version\": \"2012-10-17\",
\"Statement\": [{
\"Effect\": \"Allow\",
\"Principal\": {\"AWS\": \"{$user['Arn']}\"},
\"Action\": \"sts:AssumeRole\"
}]
}";
$assumeRoleRole = $service->createRole("iam_demo_role_$uuid", $assumeRolePolicyDocument);
echo "Created role: {$assumeRoleRole['RoleName']}\n";
/**
* @param string $roleName
* @param string $rolePolicyDocument
* @return array
* @throws AwsException
*/
public function createRole(string $roleName, string $rolePolicyDocument)
{
$result = $this->customWaiter(function () use ($roleName, $rolePolicyDocument) {
return $this->iamClient->createRole([
'AssumeRolePolicyDocument' => $rolePolicyDocument,
'RoleName' => $roleName,
]);
});
return $result['Role'];
}
```
+ API の詳細については、「*AWS SDK for PHP API リファレンス*」の「[CreateRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateRole)」を参照してください。
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**例 1: この例では、`MyNewRole` という名前の新しいロールを作成し、`NewRoleTrustPolicy.json` ファイルにあるポリシーをそのロールにアタッチします。JSON ポリシーファイルを正常に処理するには、`-Raw` switch パラメータを使用する必要があることに注意してください。出力に表示されるポリシードキュメントは、URL でエンコードされています。この例では、`UrlDecode` .NET メソッドを使用してデコードされています。**
```
$results = New-IAMRole -AssumeRolePolicyDocument (Get-Content -raw NewRoleTrustPolicy.json) -RoleName MyNewRole
$results
```
**出力:**
```
Arn : arn:aws:iam::123456789012:role/MyNewRole
AssumeRolePolicyDocument : %7B%0D%0A%20%20%22Version%22%3A%20%222012-10-17%22%2C%0D%0A%20%20%22Statement%22
%3A%20%5B%0D%0A%20%20%20%20%7B%0D%0A%20%20%20%20%20%20%22Sid%22%3A%20%22%22%2C
%0D%0A%20%20%20%20%20%20%22Effect%22%3A%20%22Allow%22%2C%0D%0A%20%20%20%20%20%20
%22Principal%22%3A%20%7B%0D%0A%20%20%20%20%20%20%20%20%22AWS%22%3A%20%22arn%3Aaws
%3Aiam%3A%3A123456789012%3ADavid%22%0D%0A%20%20%20%20%20%20%7D%2C%0D%0A%20%20%20
%20%20%20%22Action%22%3A%20%22sts%3AAssumeRole%22%0D%0A%20%20%20%20%7D%0D%0A%20
%20%5D%0D%0A%7D
CreateDate : 4/15/2015 11:04:23 AM
Path : /
RoleId : V5PAJI2KPN4EAEXAMPLE1
RoleName : MyNewRole
[System.Reflection.Assembly]::LoadWithPartialName("System.Web.HttpUtility")
[System.Web.HttpUtility]::UrlDecode($results.AssumeRolePolicyDocument)
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:David"
},
"Action": "sts:AssumeRole"
}
]
}
```
+ API の詳細については、*AWS Tools for PowerShell コマンドレットリファレンス (V4)* の「[CreateRole](https://docs.aws.amazon.com/powershell/v4/reference)」を参照してください。
**Tools for PowerShell V5**
**例 1: この例では、`MyNewRole` という名前の新しいロールを作成し、`NewRoleTrustPolicy.json` ファイルにあるポリシーをそのロールにアタッチします。JSON ポリシーファイルを正常に処理するには、`-Raw` switch パラメータを使用する必要があることに注意してください。出力に表示されるポリシードキュメントは、URL でエンコードされています。この例では、`UrlDecode` .NET メソッドを使用してデコードされています。**
```
$results = New-IAMRole -AssumeRolePolicyDocument (Get-Content -raw NewRoleTrustPolicy.json) -RoleName MyNewRole
$results
```
**出力:**
```
Arn : arn:aws:iam::123456789012:role/MyNewRole
AssumeRolePolicyDocument : %7B%0D%0A%20%20%22Version%22%3A%20%222012-10-17%22%2C%0D%0A%20%20%22Statement%22
%3A%20%5B%0D%0A%20%20%20%20%7B%0D%0A%20%20%20%20%20%20%22Sid%22%3A%20%22%22%2C
%0D%0A%20%20%20%20%20%20%22Effect%22%3A%20%22Allow%22%2C%0D%0A%20%20%20%20%20%20
%22Principal%22%3A%20%7B%0D%0A%20%20%20%20%20%20%20%20%22AWS%22%3A%20%22arn%3Aaws
%3Aiam%3A%3A123456789012%3ADavid%22%0D%0A%20%20%20%20%20%20%7D%2C%0D%0A%20%20%20
%20%20%20%22Action%22%3A%20%22sts%3AAssumeRole%22%0D%0A%20%20%20%20%7D%0D%0A%20
%20%5D%0D%0A%7D
CreateDate : 4/15/2015 11:04:23 AM
Path : /
RoleId : V5PAJI2KPN4EAEXAMPLE1
RoleName : MyNewRole
[System.Reflection.Assembly]::LoadWithPartialName("System.Web.HttpUtility")
[System.Web.HttpUtility]::UrlDecode($results.AssumeRolePolicyDocument)
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:David"
},
"Action": "sts:AssumeRole"
}
]
}
```
+ API の詳細については、「*AWS Tools for PowerShell Cmdlet リファレンス (V5)*」の「[CreateRole](https://docs.aws.amazon.com/powershell/v5/reference)」を参照してください。
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/iam#code-examples)での設定と実行の方法を確認してください。
```
def create_role(role_name, allowed_services):
"""
Creates a role that lets a list of specified services assume the role.
:param role_name: The name of the role.
:param allowed_services: The services that can assume the role.
:return: The newly created role.
"""
trust_policy = {
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": service},
"Action": "sts:AssumeRole",
}
for service in allowed_services
],
}
try:
role = iam.create_role(
RoleName=role_name, AssumeRolePolicyDocument=json.dumps(trust_policy)
)
logger.info("Created role %s.", role.name)
except ClientError:
logger.exception("Couldn't create role %s.", role_name)
raise
else:
return role
```
+ API の詳細については、「*AWS SDK for Python (Boto3) API Reference*」の「[CreateRole](https://docs.aws.amazon.com/goto/boto3/iam-2010-05-08/CreateRole)」を参照してください。
------
#### [ Ruby ]
**SDK for Ruby**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/iam#code-examples)での設定と実行の方法を確認してください。
```
# Creates a role and attaches policies to it.
#
# @param role_name [String] The name of the role.
# @param assume_role_policy_document [Hash] The trust relationship policy document.
# @param policy_arns [Array] The ARNs of the policies to attach.
# @return [String, nil] The ARN of the new role if successful, or nil if an error occurred.
def create_role(role_name, assume_role_policy_document, policy_arns)
response = @iam_client.create_role(
role_name: role_name,
assume_role_policy_document: assume_role_policy_document.to_json
)
role_arn = response.role.arn
policy_arns.each do |policy_arn|
@iam_client.attach_role_policy(
role_name: role_name,
policy_arn: policy_arn
)
end
role_arn
rescue Aws::IAM::Errors::ServiceError => e
@logger.error("Error creating role: #{e.message}")
nil
end
```
+ API の詳細については、「*AWS SDK for Ruby API リファレンス*」の「[CreateRole](https://docs.aws.amazon.com/goto/SdkForRubyV3/iam-2010-05-08/CreateRole)」を参照してください。
------
#### [ Rust ]
**SDK for Rust**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples)での設定と実行の方法を確認してください。
```
pub async fn create_role(
client: &iamClient,
role_name: &str,
role_policy_document: &str,
) -> Result {
let response: CreateRoleOutput = loop {
if let Ok(response) = client
.create_role()
.role_name(role_name)
.assume_role_policy_document(role_policy_document)
.send()
.await
{
break response;
}
};
Ok(response.role.unwrap())
}
```
+ API の詳細については、「*AWS SDK for Rust API リファレンス*」の「[CreateRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_role)」を参照してください。
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/iam#code-examples)での設定と実行の方法を確認してください。
```
TRY.
oo_result = lo_iam->createrole(
iv_rolename = iv_role_name
iv_assumerolepolicydocument = iv_assume_role_policy_document ).
MESSAGE 'Role created successfully.' TYPE 'I'.
CATCH /aws1/cx_iamentityalrdyexex.
MESSAGE 'Role already exists.' TYPE 'E'.
CATCH /aws1/cx_iammalformedplydocex.
MESSAGE 'Assume role policy document is malformed.' TYPE 'E'.
CATCH /aws1/cx_iamlimitexceededex.
MESSAGE 'Role limit exceeded.' TYPE 'E'.
ENDTRY.
```
+ API の詳細については、「*AWS SDK for SAP ABAP API リファレンス*」の「[CreateRole](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)」を参照してください。
------
#### [ Swift ]
**SDK for Swift**
GitHub には、その他のリソースもあります。用例一覧を検索し、[AWS コード例リポジトリ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/iam#code-examples)での設定と実行の方法を確認してください。
```
import AWSIAM
import AWSS3
public func createRole(name: String, policyDocument: String) async throws -> String {
let input = CreateRoleInput(
assumeRolePolicyDocument: policyDocument,
roleName: name
)
do {
let output = try await client.createRole(input: input)
guard let role = output.role else {
throw ServiceHandlerError.noSuchRole
}
guard let id = role.roleId else {
throw ServiceHandlerError.noSuchRole
}
return id
} catch {
print("ERROR: createRole:", dump(error))
throw error
}
}
```
+ API の詳細については、「*AWS SDK for Swift API リファレンス*」の「[CreateRole](https://sdk.amazonaws.com/swift/api/awsiam/latest/documentation/awsiam/iamclient/createrole(input:))」を参照してください。
------
# AWS CLI を使用して顧客管理設定レコーダーから AWS Config を起動する
まず、顧客管理設定レコーダーを作成してAWS Configを起動します。AWS CLIを使用して顧客管理設定レコーダーを作成するには、[https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html)、[https://docs.aws.amazon.com/cli/latest/reference/configservice/put-delivery-channel.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-delivery-channel.html)、および [https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html) のコマンドを使用します。
+ `put-configuration-recorder` コマンドは、顧客管理設定レコーダーを作成します。
+ `put-delivery-channel` コマンドは、S3 バケットおよび SNS トピックに設定情報をAWS Config が配信する配信チャネルを作成します。
+ `start-configuration-recorder` は、顧客管理設定レコーダーを起動します。顧客管理設定レコーダーは、指定したリソースタイプの設定変更の記録を開始します。
**Topics**
+ [考慮事項](#gs-cli-subscribe-considerations)
+ [ステップ 1: put-configuration-recorder コマンドを実行する](#gs-cli-subscribe-put-configuration-recorder)
+ [ステップ 2: put-delivery-channel コマンドを実行する](#gs-cli-subscribe-put-delivery-channel)
+ [ステップ 3: start-configuration-recorder コマンドを実行する](#gs-cli-subscribe-start-configuration-recorder)
## 考慮事項
**S3 バケット、SNS トピック、IAM ロールが必要です**
顧客管理設定レコーダーを作成するには、前提条件として S3 バケット、SNS トピック、およびポリシーがアタッチされた IAM ロールを作成する必要があります。AWS Config の前提条件をセットアップするには、「[前提条件](https://docs.aws.amazon.com/config/latest/developerguide/gs-cli-prereq.html)」を参照してください。
**顧客管理設定レコーダーは各アカウントでリージョンごとに 1 つ**
顧客管理設定レコーダーは、各 AWS リージョンで AWS アカウントごとに 1 つのみ持つことができます。
**各リージョンのアカウントごとに 1 つの配信チャネル**
配信チャネルリージョンは、各 AWS リージョンで AWS アカウントごとに 1 つのみ持つことができます。
**ポリシーとコンプライアンス結果**
[IAM ポリシー](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html)と、[AWS Organizations で管理されるその他のポリシー](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies.html)が、AWS Config がリソースの設定変更の記録を許可されるかどうかに影響する可能性があります。また、リソースの設定はルールで直接評価され、評価の実行時にはこれらのポリシーは考慮されません。適用されるポリシーが、意図する AWS Config の使用方法と合致していることを確認してください。
## ステップ 1: put-configuration-recorder コマンドを実行する
[https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html) コマンドを使用して、顧客管理設定レコーダーを作成します。
このコマンドは、[`--configuration-recorder`] フィールドと [`---recording-group`] フィールドを使用します。
```
$ aws configservice put-configuration-recorder \
--configuration-recorder file://configurationRecorder.json \
--recording-group file://recordingGroup.json
```
**`configuration-recorder` フィールド**
[`configurationRecorder.json`] ファイルは、`name` および `roleArn`、さらに設定レコーダーのデフォルトの記録頻度を指定します (`recordingMode`)。このフィールドを使用して、特定のリソースタイプの記録頻度をオーバーライドすることもできます。
```
{
"name": "default",
"roleARN": "arn:aws:iam::123456789012:role/config-role",
"recordingMode": {
"recordingFrequency": CONTINUOUS or DAILY,
"recordingModeOverrides": [
{
"description": "Description you provide for the override",
"recordingFrequency": CONTINUOUS or DAILY,
"resourceTypes": [ Comma-separated list of resource types to include in the override ]
}
]
}
}
```
**`recording-group` フィールド**
`recordingGroup.json` ファイルは、記録するリソースタイプを指定します。
```
{
"allSupported": boolean,
"exclusionByResourceTypes": {
"resourceTypes": [ Comma-separated list of resource types to exclude ]
},
"includeGlobalResourceTypes": boolean,
"recordingStrategy": {
"useOnly": "Recording strategy for the configuration recorder"
},
"resourceTypes": [ Comma-separated list of resource types to include]
}
```
オブジェクトの詳細については、「*AWS CLI コマンドリファレンス*」の「[https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-configuration-recorder.html)」を参照してください。
## ステップ 2: put-delivery-channel コマンドを実行する
[https://docs.aws.amazon.com/cli/latest/reference/configservice/put-delivery-channel.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-delivery-channel.html) コマンドを使用して、配信チャネルを作成します。
このコマンドは、[`--delivery-channel`] フィールドを使用します。
```
$ aws configservice put-delivery-channel --delivery-channel file://deliveryChannel.json
```
**`delivery-channel` フィールド**
`deliveryChannel.json` ファイルでは、以下を規定します。
+ 配信チャネルの`name`。
+ AWS Config が設定スナップショットを送信する`s3BucketName`。
+ AWS Config が通知を送信する `snsTopicARN`
+ AWS Config が設定スナップショットを配信する頻度と、定期的なルールの評価を呼び出す頻度を設定する `configSnapshotDeliveryProperties`。
```
{
"name": "default",
"s3BucketName": "config-bucket-123456789012",
"snsTopicARN": "arn:aws:sns:us-east-1:123456789012:config-topic",
"configSnapshotDeliveryProperties": {
"deliveryFrequency": "Twelve_Hours"
}
}
```
オブジェクトの詳細については、「*AWS CLI コマンドリファレンス*」の「[https://docs.aws.amazon.com/cli/latest/reference/configservice/put-delivery-channel.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-delivery-channel.html)」を参照してください。
## ステップ 3: start-configuration-recorder コマンドを実行する
[https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html) コマンドを使用して AWS Config を起動します。
```
$ aws configservice start-configuration-recorder --configuration-recorder-name configRecorderName
```
オブジェクトの詳細については、「*AWS CLI コマンドリファレンス*」の「[https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/start-configuration-recorder.html)」を参照してください。
# AWS Config が で正常に開始されたことを確認する AWS CLI
開始したら AWS Config、 AWS CLI コマンドを使用して、 AWS Config が実行されていること、および AWS Config が設定レコーダーと配信チャネルを作成したことを確認できます。 AWS Config が設定の記録と配信チャネルへの配信を開始したことを確認することもできます。
**Topics**
+ [ステップ 1: 配信チャネルが作成済みであることを確認する](#gs-cli-verify-channel)
+ [ステップ 2: 設定レコーダーが作成済みであることを確認する](#gs-cli-verify-recorder)
+ [ステップ 3: AWS Config が記録を開始したことを確認する](#gs-cli-verify-config-recording)
## ステップ 1: 配信チャネルが作成済みであることを確認する
[https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-delivery-channels.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-delivery-channels.html) コマンドを使用して、Amazon S3 バケットおよび Amazon SNS トピックが設定済みであることを確認します。
`--delivery-channel-names` フィールドを使用して、配信チャネルのリストを指定できます。配信チャネルが指定されていない場合、このコマンドはアカウントに関連付けられているすべての配信チャネルの詳細を返します。
```
$ aws configservice describe-delivery-channels
{
"DeliveryChannels": [
{
"snsTopicARN": "arn:aws:sns:us-west-2:0123456789012:my-config-topic",
"name": "my-delivery-channel",
"s3BucketName": "my-config-bucket"
}
]
}
```
## ステップ 2: 設定レコーダーが作成済みであることを確認する
[https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-configuration-recorders.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-configuration-recorders.html) コマンドを使用して、設定レコーダーが作成されていることを確認します。
`arn` フィールドと `configuration-recorder-names` フィールドを使用して、設定レコーダーのリストを指定できます。設定レコーダーが指定されていない場合、このコマンドはアカウントに関連付けられているすべての設定レコーダーの詳細を返します。
```
$ aws configservice describe-configuration-recorders
{
"ConfigurationRecorders": [
{
"roleARN": "arn:aws:iam::012345678912:role/myConfigRole",
"name": "default"
}
]
}
```
## ステップ 3: AWS Config が記録を開始したことを確認する
[https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-configuration-recorder-status.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/describe-configuration-recorder-status.html) コマンドを使用して、設定レコーダーが範囲内のリソースタイプを正常に記録していることを確認します。
`arn` フィールドと `configuration-recorder-names` フィールドを使用して、設定レコーダーのリストを指定できます。設定レコーダーが指定されていない場合、このコマンドはアカウントに関連付けられているすべての設定レコーダーの詳細を返します。
```
$ aws configservice describe-configuration-recorder-status
{
"ConfigurationRecordersStatus": [
{
"name": "default",
"lastStatus": "SUCCESS",
"lastStopTime": 1414511624.914,
"lastStartTime": 1414708460.276,
"recording": true,
"lastStatusChangeTime": 1414816537.148,
"lastErrorMessage": "NA",
"lastErrorCode": "400"
}
]
}
```
`recording` フィールドの値 `true` は、設定レコーダーが設定を記録し始めたことを示します。 AWS Config は時刻を UTC で記録します。出力は Unix timestamp として表示されます。
# AWS SDK AWS Configでの の使用
AWS Software Development Kit (SDKsは、多くの一般的なプログラミング言語で使用できます。各 SDK には、デベロッパーが好みの言語でアプリケーションを簡単に構築できるようになる API、コード例、およびドキュメントが提供されています。
| SDK ドキュメント | コード例 |
| --- | --- |
| [AWS SDK for C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp) | [AWS SDK for C\$1\$1コード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp) |
| [AWS CLI](https://docs.aws.amazon.com/cli) | [AWS CLIコード例](https://docs.aws.amazon.com/code-library/latest/ug/cli_2_code_examples.html) |
| [AWS SDK for Go](https://docs.aws.amazon.com/sdk-for-go) | [AWS SDK for Goコード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2) |
| [AWS SDK for Java](https://docs.aws.amazon.com/sdk-for-java) | [AWS SDK for Javaコード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2) |
| [AWS SDK for JavaScript](https://docs.aws.amazon.com/sdk-for-javascript) | [AWS SDK for JavaScriptコード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3) |
| [AWS SDK for Kotlin](https://docs.aws.amazon.com/sdk-for-kotlin) | [AWS SDK for Kotlinコード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin) |
| [AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net) | [AWS SDK for .NETコード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3) |
| [AWS SDK for PHP](https://docs.aws.amazon.com/sdk-for-php) | [AWS SDK for PHPコード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php) |
| [AWS Tools for PowerShell](https://docs.aws.amazon.com/powershell) | [AWS Tools for PowerShellコード例](https://docs.aws.amazon.com/code-library/latest/ug/powershell_5_code_examples.html) |
| [AWS SDK for Python (Boto3)](https://docs.aws.amazon.com/pythonsdk) | [AWS SDK for Python (Boto3)コード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python) |
| [AWS SDK for Ruby](https://docs.aws.amazon.com/sdk-for-ruby) | [AWS SDK for Rubyコード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby) |
| [AWS SDK for Rust](https://docs.aws.amazon.com/sdk-for-rust) | [AWS SDK for Rustコード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1) |
| [AWS SDK for SAP ABAP](https://docs.aws.amazon.com/sdk-for-sapabap) | [AWS SDK for SAP ABAPコード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap) |
| [AWS SDK for Swift](https://docs.aws.amazon.com/sdk-for-swift) | [AWS SDK for Swiftコード例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift) |
**可用性の例**
必要なものが見つからなかった場合。このページの下側にある [**Provide feedback**] リンクから、コードの例をリクエストしてください。