

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# AWS SAM テンプレートでのリソースアクセスの設定と管理
<a name="sam-permissions"></a>

 AWS リソースが相互にやり取りするには、リソース間で適切なアクセスとアクセス許可を設定する必要があります。そのためには、 AWS Identity and Access Management (IAM) ユーザー、ロール、ポリシーを設定して、安全な方法でやり取りを行う必要があります。

このセクションのトピックはすべて、テンプレートの中で定義されているリソースへのアクセス設定に関連があります。このセクションの最初では、一般的なベストプラクティスを扱っています。次の 2 つのトピックでは、サーバーレスアプリケーションで参照されるリソース間のアクセスとアクセス許可を設定するための 2 つのオプションである AWS SAM コネクタと AWS SAM ポリシーテンプレートについて説明します。最後のトピックでは、ユーザーの管理に使用するのと同じメカニズムを使用してユーザーアクセスを管理する CloudFormation 方法の詳細を説明します。

詳細については、「*AWS CloudFormation ユーザーガイド*」の「[AWS Identity and Access Managementでアクセスを制御する](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html)」を参照してください。

 AWS Serverless Application Model (AWS SAM) には、サーバーレスアプリケーションのアクセスとアクセス許可の管理を簡素化する 2 つのオプションがあります。

1. AWS SAM コネクタ

1. AWS SAM ポリシーテンプレート

## AWS SAM コネクタ
<a name="sam-permissions-intro-connectors"></a>

コネクタを使用することで、2 つのリソース間の許可をプロビジョニングできます。そのためには、 AWS SAM テンプレート内で相互にやり取りする方法を説明します。これらは、`Connectors` リソース属性または `AWS::Serverless::Connector` リソースタイプのいずれかを使用して定義できます。コネクタは、 AWS リソースの組み合わせ間のデータとイベントのプロビジョニングと`Read``Write`アクセスをサポートします。 AWS SAM コネクタの詳細については、「」を参照してください[AWS SAM コネクタを使用したリソースアクセス許可の管理](managing-permissions-connectors.md)。

## AWS SAM ポリシーテンプレート
<a name="sam-permissions-intro-policy-templates"></a>

AWS SAM ポリシーテンプレートは、関数、 AWS Step Functions ステートマシン、および AWS Lambda それらが操作するリソース間のアクセスとアクセス許可を管理するためにテンプレートに追加 AWS SAM できるアクセス許可の事前定義されたセットです。 AWS SAM ポリシーテンプレートの詳細については、「」を参照してください[AWS SAMポリシーテンプレート](serverless-policy-templates.md)。

## AWS CloudFormation メカニズム
<a name="sam-permissions-intro-cloudformation"></a>

CloudFormation メカニズムには、 AWS リソース間のアクセス許可を管理するための IAM ユーザー、ロール、ポリシーの設定が含まれます。詳細については[CloudFormation メカニズムによる AWS SAM アクセス許可の管理](sam-permissions-cloudformation.md)を参照してください。

## ベストプラクティス
<a name="sam-permissions-intro-best-practices"></a>

サーバーレスアプリケーション全体で、複数の方法を使用してリソース間のアクセス許可を設定できます。そのため、各シナリオに最適なオプションを選択し、アプリケーション全体で複数のオプションを一緒に使用できます。最適なオプションを選択する際に留意すべき点がいくつかあります。
+ AWS SAM コネクタとポリシーテンプレートはどちらも、 AWS リソース間の安全なやり取りを容易にするために必要な IAM の専門知識を削減します。サポートされている場合は、コネクタとポリシーテンプレートを使用してください。
+ AWS SAM コネクタは、シンプルで直感的な短縮構文を提供し、 AWS SAM テンプレートのアクセス許可を定義し、IAM の専門知識を最小限に抑えます。 AWS SAM コネクタとポリシーテンプレートの両方がサポートされている場合は、 AWS SAM コネクタを使用します。
+ AWS SAM コネクタは、サポートされている AWS SAM 送信元`Read`リソースと送信先リソース間のデータとイベントをプロビジョニングして`Write`アクセスできます。サポートされているリソースの一覧については、「[AWS SAM コネクタリファレンス](reference-sam-connector.md)」を参照してください。サポートされている場合は、 AWS SAM コネクタを使用します。
+  AWS SAM ポリシーテンプレートは Lambda 関数、Step Functions ステートマシン、およびそれらが操作する AWS リソース間のアクセス許可に制限されていますが、ポリシーテンプレートはすべての CRUD オペレーションをサポートします。サポートされ、シナリオの AWS SAM ポリシーテンプレートが使用可能な場合は、 AWS SAM ポリシーテンプレートを使用します。使用可能なポリシーテンプレートのリストについては、「[AWS SAMポリシーテンプレート](serverless-policy-templates.md)」を参照してください。
+ 他のすべてのシナリオ、または詳細度が必要な場合は、 CloudFormation メカニズムを使用します。

# AWS SAM コネクタを使用したリソースアクセス許可の管理
<a name="managing-permissions-connectors"></a>

コネクタは、 として識別される AWS Serverless Application Model (AWS SAM) 抽象リソースタイプであり`AWS::Serverless::Connector`、サーバーレスアプリケーションリソース間にシンプルで適切な範囲のアクセス許可を提供します。

## AWS SAM コネクタの利点
<a name="connector-benefits"></a>

コネクタは、リソース間で適切なアクセスポリシーを自動的に作成することで、 AWS 認可機能、ポリシー言語、サービス固有のセキュリティ設定に関する専門知識を必要とせずに、サーバーレスアプリケーションを作成し、アプリケーションアーキテクチャに集中できます。したがって、コネクタは、サーバーレス開発に慣れていない開発者や、開発速度を上げたいと考えている経験豊富な開発者にとって大きなメリットです。

## AWS SAM コネクタの使用
<a name="what-are-connectors"></a>

`Connectors` リソース属性を**ソース**リソース内に埋め込んで使用します。次に、**送信先**リソースを定義し、それらのリソース間でデータまたはイベントがどのように流れるかを記述します。 AWS SAM 次に、 は、必要なやり取りを容易にするために必要なアクセスポリシーを構成します。

以下に、このリソース属性の記述方法の概要を示します。

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
  <source-resource-logical-id>:
    Type: <resource-type>
    ...
    Connectors:
      <connector-name>:
        Properties:
          Destination:
            <properties-that-identify-destination-resource>
          Permissions:
            <permission-types-to-provision>
  ...
```

## コネクタの仕組み
<a name="connectors-work"></a>

**注記**  
このセクションでは、コネクタがバックグラウンドで必要なリソースをプロビジョニングする方法について説明します。これは、コネクタを使用する際に自動的に実行されます。

まず、埋め込まれた `Connectors` リソース属性が `AWS::Serverless::Connector` リソースタイプに変換されます。その論理 ID は、*<source-resource-logical-id><embedded-connector-logical-id>* として自動的に作成されます。

例えば、これは埋め込みコネクタです。

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
  MyFunction:
    Type: AWS::Lambda::Function
    Connectors:
      MyConn:
        Properties:
          Destination:
            Id: MyTable
          Permissions:
            - Read
            - Write
  MyTable:
    Type: AWS::DynamoDB::Table
```

これにより、次の `AWS::Serverless::Connector` リソースが生成されます。

```
Transform: AWS::Serverless-2016-10-31
Resources:
  ...
  MyFunctionMyConn:
    Type: AWS::Serverless::Connector
    Properties:
      Source:
        Id: MyFunction
      Destination:
        Id: MyTable
      Permissions:
        - Read
        - Write
```

**注記**  
この構文を使用して、 AWS SAM テンプレートでコネクタを定義することもできます。これは、ソースリソースがコネクタとは別のテンプレートで定義されている場合に推奨されます。

次に、この接続に必要なアクセスポリシーが自動的に作成されます。コネクタによって生成されるリソースの詳細については、「[CloudFormation を指定したときに生成される リソース AWS::Serverless::Connector](sam-specification-generated-resources-connector.md)」を参照してください。

## コネクタの例
<a name="what-are-connectors-example"></a>

次の例は、コネクタを使用して AWS Lambda 関数から Amazon DynamoDB テーブルにデータを書き込む方法を示しています。

![\[AWS SAM コネクタを使用して DynamoDB テーブルにデータを書き込む Lambda 関数。\]](http://docs.aws.amazon.com/ja_jp/serverless-application-model/latest/developerguide/images/managing-connectors-example.png)


```
Transform: AWS::Serverless-2016-10-31
Resources:
  MyTable:
    Type: AWS::Serverless::SimpleTable
  MyFunction:
    Type: AWS::Serverless::Function
    Connectors:
      MyConn:
        Properties:
          Destination:
            Id: MyTable
          Permissions:
            - Write
    Properties:
      Runtime: nodejs16.x
      Handler: index.handler
      InlineCode: |
        const AWS = require("aws-sdk");
        const docClient = new AWS.DynamoDB.DocumentClient();
        exports.handler = async (event, context) => {
          await docClient.put({
            TableName: process.env.TABLE_NAME,
            Item: {
              id: context.awsRequestId,
              event: JSON.stringify(event) 
            }
          }).promise();
        }
      Environment:
        Variables:
          TABLE_NAME: !Ref MyTable
```

`Connectors` リソース属性は、Lambda 関数のソースリソース内に埋め込まれています。DynamoDB テーブルは、`Id` プロパティを使用して送信先リソースとして定義されます。コネクタは、これら 2 つのリソース間の `Write` 許可をプロビジョニングします。

 AWS SAM テンプレートを にデプロイすると CloudFormation、 AWS SAM は、この接続が機能するために必要なアクセスポリシーを自動的に作成します。

## 送信元リソースと送信先リソースの間でサポートされている接続
<a name="supported-connector-resources"></a>

コネクタは、ソースと送信先のリソース接続の選択された組み合わせの間におけるデータとイベントの `Read` および `Write` 許可タイプをサポートします。例えば、コネクタは `AWS::ApiGateway::RestApi` ソースリソースと `AWS::Lambda::Function` 送信先リソースの間の `Write` 接続をサポートします。

ソースリソースと送信先リソースは、サポートされているプロパティを組み合わせて定義できます。プロパティの要件は、使用する接続と、リソースが定義されている場所によって異なります。

**注記**  
コネクタは、サポートされているサーバーレスリソースタイプと非サーバーレスリソースタイプの間の許可をプロビジョニングできます。

サポートされているリソース接続とそのプロパティの要件のリストについては、「[コネクタに対してサポートされている送信元リソースと送信先リソースのタイプ](reference-sam-connector.md#supported-connector-resource-types)」を参照してください。

# で読み取りおよび書き込みアクセス許可を定義する AWS SAM
<a name="connector-usage-define"></a>

では AWS SAM、 `Read`および アクセス`Write`許可を 1 つのコネクタ内にプロビジョニングできます。

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
  MyFunction:
    Type: AWS::Lambda::Function
    Connectors:
      MyTableConn:
        Properties:
          Destination:
            Id: MyTable
          Permissions:
            - Read
            - Write
  MyTable:
    Type: AWS::DynamoDB::Table
```

コネクタの使用の詳細については、「[AWS SAM コネクタリファレンス](reference-sam-connector.md)」を参照してください。

# でサポートされている他のプロパティを使用してリソースを定義する AWS SAM
<a name="connector-usage-other-properties"></a>

ソースリソースと送信先リソースの両方について、同じテンプレート内で定義されている場合は、`Id` プロパティを使用します。オプションで、`Qualifier` を追加して、定義したリソースの範囲を絞り込むことができます。リソースが同じテンプレート内にない場合は、サポートされているプロパティの組み合わせを使用してください。
+ ソースリソースと送信先リソースでサポートされているプロパティの組み合わせのリストについては、「[コネクタに対してサポートされている送信元リソースと送信先リソースのタイプ](reference-sam-connector.md#supported-connector-resource-types)」を参照してください。
+ コネクタで使用できるプロパティの説明については、「[AWS::Serverless::Connector](sam-resource-connector.md)」を参照してください。

`Id` 以外のプロパティでソースリソースを定義する場合は、`SourceReference` プロパティを使用します。

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
  <source-resource-logical-id>:
    Type: <resource-type>
    ...
    Connectors:
      <connector-name>:
        Properties:
          SourceReference:
            Qualifier: <optional-qualifier>
            <other-supported-properties>
          Destination:
            <properties-that-identify-destination-resource>
          Permissions:
            <permission-types-to-provision>
```

`Qualifier` を使用して Amazon API Gateway リソースの範囲を絞り込む例を次に示します。

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
  MyApi:
    Type: AWS::Serverless::Api
    Connectors:
      ApiToLambdaConn:
        Properties:
          SourceReference:
            Qualifier: Prod/GET/foobar
          Destination:
            Id: MyFunction
          Permissions:
            - Write           
  ...
```

サポートされている `Arn` と `Type` の組み合わせを使用して、別のテンプレートから送信先リソースを定義する例を次に示します。

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Connectors:
      TableConn:
        Properties:
          Destination:
            Type: AWS::DynamoDB::Table
            Arn: !GetAtt MyTable.Arn
  ...
```

コネクタの使用の詳細については、「[AWS SAM コネクタリファレンス](reference-sam-connector.md)」を参照してください。

# で 1 つのソースから複数のコネクタを作成する AWS SAM
<a name="connector-usage-single-source"></a>

ソースリソース内で、それぞれが異なる宛先リソースを持つ複数のコネクタを定義できます。

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Connectors:
      BucketConn:
        Properties:
          Destination:
            Id: amzn-s3-demo-bucket
          Permissions:
            - Read
            - Write
      SQSConn:
        Properties:
          Destination:
            Id: MyQueue
          Permissions:
            - Read
            - Write
      TableConn:
        Properties:
          Destination:
            Id: MyTable
          Permissions:
            - Read
            - Write
      TableConnWithTableArn:
        Properties:
          Destination:
            Type: AWS::DynamoDB::Table
            Arn: !GetAtt MyTable.Arn
          Permissions:
            - Read
            - Write
...
```

コネクタの使用の詳細については、「[AWS SAM コネクタリファレンス](reference-sam-connector.md)」を参照してください。

# でマルチ宛先コネクタを作成する AWS SAM
<a name="connector-usage-multi-destination"></a>

ソースリソース内で、複数の宛先リソースを持つ単一のコネクタを定義できます。Amazon Simple Storage Service (Amazon S3) バケットと DynamoDB テーブルに接続する Lambda 関数のソースリソースの例を次に示します。

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Connectors:
      WriteAccessConn:
        Properties:
          Destination:
            - Id: OutputBucket
            - Id: CredentialTable
          Permissions:
            - Write
  ...
  OutputBucket:
    Type: AWS::S3::Bucket
  CredentialTable:
    Type: AWS::DynamoDB::Table
```

コネクタの使用の詳細については、「[AWS SAM コネクタリファレンス](reference-sam-connector.md)」を参照してください。

# でコネクタを使用してリソース属性を定義する AWS SAM
<a name="connector-usage-resource-attributes"></a>

リソース用にリソース属性を定義して、追加の動作や関係を指定できます。リソース属性の詳細については、「*AWS CloudFormation ユーザーガイド*」の「[リソース属性リファレンス](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-product-attribute-reference.html)」を参照してください。

リソース属性をコネクタプロパティと同じレベルで定義することで、埋め込みコネクタに追加できます。テンプレート AWS SAM がデプロイ時に変換されると、属性は生成されたリソースに渡されます。

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Connectors:
      MyConn:
        DeletionPolicy: Retain
        DependsOn: AnotherFunction
        Properties:
          ...
```

コネクタの使用の詳細については、「[AWS SAM コネクタリファレンス](reference-sam-connector.md)」を参照してください。

## 詳細情報
<a name="connector-learn-more"></a>

 AWS SAM コネクタの使用の詳細については、以下のトピックを参照してください。
+ [AWS::Serverless::Connector](sam-resource-connector.md)
+ [で読み取りおよび書き込みアクセス許可を定義する AWS SAM](connector-usage-define.md)
+ [でサポートされている他のプロパティを使用してリソースを定義する AWS SAM](connector-usage-other-properties.md)
+ [で 1 つのソースから複数のコネクタを作成する AWS SAM](connector-usage-single-source.md)
+ [でマルチ宛先コネクタを作成する AWS SAM](connector-usage-multi-destination.md)
+ [で読み取りおよび書き込みアクセス許可を定義する AWS SAM](connector-usage-define.md)
+ [でコネクタを使用してリソース属性を定義する AWS SAM](connector-usage-resource-attributes.md)

## フィードバックを送信する
<a name="connector-feedback"></a>

コネクタに関するフィードバックを提供するには、*serverless-application-model AWS GitHubリポジトリ*で[新しい問題を送信します](https://github.com/aws/serverless-application-model/issues/new?assignees=&labels=area%2Fconnectors,stage%2Fneeds-triage&template=other.md&title=%28Feature%20Request%29)。

# AWS SAMポリシーテンプレート
<a name="serverless-policy-templates"></a>

 AWS Serverless Application Model (AWS SAM) を使用すると、ポリシーテンプレートのリストから選択して、Lambda 関数と AWS Step Functions ステートマシンのアクセス許可を、アプリケーションで使用されるリソースに絞り込むことができます。

AWS SAM ポリシーテンプレート AWS Serverless Application Repository を使用する のアプリケーションでは、 からアプリケーションをデプロイするために特別な顧客確認は必要ありません AWS Serverless Application Repository。

新しいポリシーテンプレートの追加をリクエストしたい場合は、以下を実行します。

1.  AWS SAM GitHub プロジェクトの `develop`ブランチの policy\$1templates.json ソースファイルに対してプルリクエストを送信します。このソースファイルは、GitHub ウェブサイトの [policy\$1templates.json](https://github.com/aws/serverless-application-model/blob/develop/samtranslator/policy_templates_data/policy_templates.json) にあります。

1. プルリクエストの理由とリクエストへのリンクを含む問題を AWS SAM GitHub プロジェクトに送信します。新しい問題を送信するには、[AWS Serverless Application Model: 問題](https://github.com/aws/serverless-application-model/issues/new)リンクを使用してください。

## 構文
<a name="serverless-policy-template-syntax"></a>

 AWS SAM テンプレートファイルで指定するポリシーテンプレートごとに、ポリシーテンプレートのプレースホルダー値を含むオブジェクトを常に指定する必要があります。ポリシーテンプレートにプレースホルダ値が必要ない場合は、空のオブジェクトを指定する必要があります。

### YAML
<a name="serverless-policy-template-syntax.yaml"></a>

```
MyFunction:
  Type: AWS::Serverless::Function
  Properties:
    Policies:
      - PolicyTemplateName1:        # Policy template with placeholder value
          Key1: Value1
      - PolicyTemplateName2: {}     # Policy template with no placeholder value
```

**注記**  
通常の IAM ポリシーを設定している場合、または Lambda 経由で管理ポリシーを設定している場合は、空のオブジェクトを使用せずにポリシーテンプレートを設定できます。

## 例
<a name="serverless-policy-template-examples"></a>

### 例 1: プレースホルダー値が含まれるポリシーテンプレート
<a name="policy-template-example-1"></a>

以下の例は、[SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) ポリシーテンプレートがリソースとして `QueueName` を期待する例です。 AWS SAM テンプレートは、`MyQueue`Amazon SQSキューの名前を取得します。このキューは、同じアプリケーションで作成することも、アプリケーションのパラメータとしてリクエストすることもできます。

```
 1. MyFunction:
 2.   Type: 'AWS::Serverless::Function'
 3.   Properties:
 4.     CodeUri: ${codeuri}
 5.     Handler: hello.handler
 6.     Runtime: python2.7
 7.     Policies:
 8.       - SQSPollerPolicy:
 9.           QueueName:
10.             !GetAtt MyQueue.QueueName
```

### 例 2: プレースホルダー値が含まれないポリシーテンプレート
<a name="policy-template-example-2"></a>

以下の例には、プレースホルダー値がない [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy) ポリシーテンプレートが含まれています。

**注記**  
プレースホルダ値がない場合でも、空のオブジェクトを指定する必要があります。指定されない場合は、エラーが発生します。

```
1. MyFunction:
2.   Type: 'AWS::Serverless::Function'
3.   Properties:
4.     CodeUri: ${codeuri}
5.     Handler: hello.handler
6.     Runtime: python2.7
7.     Policies:
8.       - CloudWatchPutMetricPolicy: {}
```

### 例 3: プレースホルダー値と通常の IAM ポリシーを含むポリシーテンプレート
<a name="policy-template-example-3"></a>

次の例には、AmazonSQSFullAcess ポリシーと [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) ポリシーテンプレートが含まれています。AmazonSQSFullAccess ポリシーは IAM ポリシーであり、 AWS SAM ポリシーではないため、ポリシーが に直接渡されるため、空のオブジェクトを指定する必要はありません CloudFormation。

```
 1. MyFunction:
 2.   Type: 'AWS::Serverless::Function'
 3.   Properties:
 4.     CodeUri: ${codeuri}
 5.     Handler: hello.handler
 6.     Runtime: python2.7
 7.     Policies:
 8.       - AmazonSQSFullAccess // IAM policy could be set without passing an empty object
 9.       - DynamoDBCrudPolicy: // SAM specific policy, has a defined structure
10.            TableName: 
11.              !Ref SampleTable
```

## ポリシーテンプレート表
<a name="serverless-policy-template-table"></a>

以下は、使用可能なポリシーテンプレートの表です。


****  

| ポリシーテンプレート | 説明 | 
| --- | --- | 
| [AcmGetCertificatePolicy](serverless-policy-template-list.md#acm-get-certificate-policy) | 証明書を読み取るアクセス許可を付与します AWS Certificate Manager。 | 
| [AMIDescribePolicy](serverless-policy-template-list.md#ami-describe-policy) | Amazon マシンイメージ (AMI) を記述する許可を付与します。 | 
| [AthenaQueryPolicy](serverless-policy-template-list.md#athena-query-policy) | Athena クエリを実行する許可を付与します。 | 
| [AWSSecretsManagerGetSecretValuePolicy](serverless-policy-template-list.md#secrets-manager-get-secret-value-policy) | 指定された AWS Secrets Manager シークレットのシークレット値を取得する許可を付与します。 | 
| [AWSSecretsManagerRotationPolicy](serverless-policy-template-list.md#secrets-manager-rotation-policy) |  AWS Secrets Managerのシークレットをローテーションを行う許可を付与します。 | 
| [CloudFormationDescribeStacksPolicy](serverless-policy-template-list.md#cloud-formation-describe-stacks-policy) |  CloudFormation スタックを記述するアクセス許可を付与します。 | 
| [CloudWatchDashboardPolicy](serverless-policy-template-list.md#cloudwatch-dashboard-policy) | CloudWatch ダッシュボードで操作を行うためのメトリクスを配置する許可を付与します。 | 
| [CloudWatchDescribeAlarmHistoryPolicy](serverless-policy-template-list.md#cloudwatch-describe-alarm-history-policy) | CloudWatch アラーム履歴を記述する許可を付与します。 | 
| [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy) | CloudWatch にメトリクスを送信する許可を付与します。 | 
| [CodeCommitCrudPolicy](serverless-policy-template-list.md#codecommit-crud-policy) | 特定の CodeCommit リポジトリ内にあるオブジェクトを作成/読み取り/更新/削除する許可を付与します。 | 
| [CodeCommitReadPolicy](serverless-policy-template-list.md#codecommit-read-policy) | 特定の CodeCommit リポジトリ内にあるオブジェクトを読み取る許可を付与します。 | 
| [CodePipelineLambdaExecutionPolicy](serverless-policy-template-list.md#code-pipeline-lambda-execution-policy) | CodePipeline によって呼び出された Lambda 関数がジョブのステータスを報告するための許可を付与します。 | 
| [CodePipelineReadOnlyPolicy](serverless-policy-template-list.md#code-pipeline-readonly-policy) | CodePipeline パイプラインの詳細を取得するための読み取り許可を付与します。 | 
| [ComprehendBasicAccessPolicy](serverless-policy-template-list.md#comprehend-basic-access-policy) | エンティティ、キーフレーズ、言語、およびセンチメントを検出する許可を付与します。 | 
| [CostExplorerReadOnlyPolicy](serverless-policy-template-list.md#cost-explorer-readonly-policy) | 請求履歴の読み取り専用 Cost Explorer API に読み取り専用許可を付与します。 | 
| [DynamoDBBackupFullAccessPolicy](serverless-policy-template-list.md#ddb-back-full-policy) | テーブルの DynamoDB オンデマンドバックアップに読み取りおよび書き込み許可を付与します。 | 
| [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) | Amazon DynamoDB テーブルに作成、読み取り、更新、および削除許可を付与します。 | 
| [DynamoDBReadPolicy](serverless-policy-template-list.md#dynamo-db-read-policy) | DynamoDB テーブルに読み取り専用許可を付与します。 | 
| [DynamoDBReconfigurePolicy](serverless-policy-template-list.md#dynamo-db-reconfigure-policy) | DynamoDB テーブルを再構成する許可を付与します。 | 
| [DynamoDBRestoreFromBackupPolicy](serverless-policy-template-list.md#ddb-restore-from-backup-policy) | バックアップから DynamoDB テーブルを復元する許可を付与します。 | 
| [DynamoDBStreamReadPolicy](serverless-policy-template-list.md#dynamo-db-stream-read-policy) | DynamoDB のストリームとレコードを記述および読み取る許可を付与します。 | 
| [DynamoDBWritePolicy](serverless-policy-template-list.md#dynamo-db-write-policy) | DynamoDB テーブルに書き込み専用許可を付与します。 | 
| [EC2CopyImagePolicy](serverless-policy-template-list.md#ec2-copy-image-policy) | Amazon EC2 イメージをコピーする許可を付与します | 
| [EC2DescribePolicy](serverless-policy-template-list.md#ec2-describe-policy) | Amazon Elastic Compute Cloud (Amazon EC2) インスタンスを記述する許可を付与します。 | 
| [EcsRunTaskPolicy](serverless-policy-template-list.md#ecs-run-task-policy) | タスク定義の新しいタスクを開始する許可を付与します。 | 
| [EFSWriteAccessPolicy](serverless-policy-template-list.md#efs-write-access-policy) | 書き込みアクセス権と共に Amazon EFS ファイルシステムをマウントする許可を付与します。 | 
| [EKSDescribePolicy](serverless-policy-template-list.md#eks-describe-policy) | Amazon EKS クラスターを記述またはリスト化する許可を付与します。 | 
| [ElasticMapReduceAddJobFlowStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-add-job-flows-policy) | 実行中のクラスターに新しいステップを追加する許可を付与します。 | 
| [ElasticMapReduceCancelStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-cancel-steps-policy) | 実行中のクラスターで保留中のステップ (1 つ、または複数) をキャンセルする許可を付与します。 | 
| [ElasticMapReduceModifyInstanceFleetPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-fleet-policy) | クラスター内のインスタンスフリートの詳細をリスト化し、容量を変更する許可を付与します。 | 
| [ElasticMapReduceModifyInstanceGroupsPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-groups-policy) | クラスター内のインスタンスグループの詳細をリスト化し、設定を変更する許可を付与します。 | 
| [ElasticMapReduceSetTerminationProtectionPolicy](serverless-policy-template-list.md#elastic-map-reduce-set-termination-protection-policy) | クラスターの終了保護を設定する許可を付与します。 | 
| [ElasticMapReduceTerminateJobFlowsPolicy](serverless-policy-template-list.md#elastic-map-reduce-terminate-job-flows-policy) | クラスターをシャットダウンする許可を付与します。 | 
| [ElasticsearchHttpPostPolicy](serverless-policy-template-list.md#elastic-search-http-post-policy) | Amazon OpenSearch Service に POST 許可を付与します。 | 
| [EventBridgePutEventsPolicy](serverless-policy-template-list.md#eventbridge-put-events-policy) | EventBridge にイベントを送信する許可を付与します。 | 
| [FilterLogEventsPolicy](serverless-policy-template-list.md#filter-log-events-policy) | 指定されたロググループからの CloudWatch Logs イベントをフィルタリングする許可を付与します。 | 
| [FirehoseCrudPolicy](serverless-policy-template-list.md#firehose-crud-policy) | Firehose の配信ストリームに対し作成、書き込み、更新、および削除を行うアクセス許可を付与します。 | 
| [FirehoseWritePolicy](serverless-policy-template-list.md#firehose-write-policy) | Firehose の配信ストリームに書き込むアクセス許可を付与します | 
| [KinesisCrudPolicy](serverless-policy-template-list.md#kinesis-crud-policy) | Amazon Kinesis のストリームを作成、発行、および削除する許可を付与します。 | 
| [KinesisStreamReadPolicy](serverless-policy-template-list.md#kinesis-stream-read-policy) | Amazon Kinesis のストリームをリスト化して読み取る許可を付与します。 | 
| [KMSDecryptPolicy](serverless-policy-template-list.md#kms-decrypt-policy) |  AWS Key Management Service (AWS KMS) キーを使用して復号するアクセス許可を付与します。 | 
| [KMSEncryptPolicy](serverless-policy-template-list.md#kms-encrypt-policy) |  AWS Key Management Service (AWS KMS) キーで暗号化するアクセス許可を付与します。 | 
| [LambdaInvokePolicy](serverless-policy-template-list.md#lambda-invoke-policy) |  AWS Lambda 関数、エイリアス、またはバージョンを呼び出すアクセス許可を付与します。 | 
| [MobileAnalyticsWriteOnlyAccessPolicy](serverless-policy-template-list.md#mobile-analytics-write-only-access-policy) | すべてのアプリケーションリソースのイベントデータを配置するための書き込み専用許可を付与します。 | 
| [OrganizationsListAccountsPolicy](serverless-policy-template-list.md#organizations-list-accounts-policy) | 子アカウントの名前と ID を一覧表示する読み取り専用許可を付与します。 | 
| [PinpointEndpointAccessPolicy](serverless-policy-template-list.md#pinpoint-endpoint-access-policy) | Amazon Pinpoint アプリケーションのエンドポイントを取得して更新する許可を付与します | 
| [PollyFullAccessPolicy](serverless-policy-template-list.md#polly-full-access-policy) | Amazon Polly のレキシコンリソースへのフルアクセス許可を付与します。 | 
| [RekognitionDetectOnlyPolicy](serverless-policy-template-list.md#rekognition-detect-only-policy) | 顔、ラベル、およびテキストを検出する許可を付与します。 | 
| [RekognitionFacesManagementPolicy](serverless-policy-template-list.md#rekognition-face-management-policy) | Amazon Rekognition コレクション内の顔を追加、削除、および検索する許可を付与します。 | 
| [RekognitionFacesPolicy](serverless-policy-template-list.md#rekognition-faces-policy) | 顔とラベルを比較および検出する許可を付与します。 | 
| [RekognitionLabelsPolicy](serverless-policy-template-list.md#rekognition-labels-policy) | オブジェクトとモデレーションラベルを検出する許可を付与します。 | 
| [RekognitionNoDataAccessPolicy](serverless-policy-template-list.md#rekognition-no-data-access-policy) | 顔とラベルを比較および検出する許可を付与します。 | 
| [RekognitionReadPolicy](serverless-policy-template-list.md#rekognition-read-policy) | 顔をリスト化して検索する許可を付与します。 | 
| [RekognitionWriteOnlyAccessPolicy](serverless-policy-template-list.md#rekognition-write-only-access-policy) | 顔のコレクションを作成してインデックス化する許可を付与します。 | 
| [Route53ChangeResourceRecordSetsPolicy](serverless-policy-template-list.md#route53-change-resource-record-sets-policy) | Route 53 のリソースレコードセットを変更する許可を付与します。 | 
| [S3CrudPolicy](serverless-policy-template-list.md#s3-crud-policy) | Amazon S3 バケット内のオブジェクトでアクションを実行するための作成、読み取り、更新、および削除許可を付与します。 | 
| [S3FullAccessPolicy](serverless-policy-template-list.md#s3-full-access-policy) | Amazon S3 バケット内のオブジェクトでアクションを実行するためのフルアクセス許可を付与します。 | 
| [S3ReadPolicy](serverless-policy-template-list.md#s3-read-policy) | Amazon Simple Storage Service (Amazon S3) バケットにあるオブジェクトを読み取るための読み取り専用許可を付与します。 | 
| [S3WritePolicy](serverless-policy-template-list.md#s3-write-policy) | Amazon S3 バケットにオブジェクトを書き込むための書き込み許可を付与します。 | 
| [SageMakerCreateEndpointConfigPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-config-policy) | SageMaker AI でエンドポイント設定を作成する許可を付与します。 | 
| [SageMakerCreateEndpointPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-policy) | SageMaker AI でエンドポイントを作成する許可を付与します。 | 
| [ServerlessRepoReadWriteAccessPolicy](serverless-policy-template-list.md#serverlessrepo-read-write-access-policy) |  AWS Serverless Application Repository サービスでアプリケーションを作成および一覧表示するアクセス許可を付与します。 | 
| [SESBulkTemplatedCrudPolicy](serverless-policy-template-list.md#ses-bulk-templated-crud-policy) | E メール、テンプレート化された E メール、テンプレート化されたバルク E メールを送信し、アイデンティティを確認する許可を付与します。 | 
| [SESBulkTemplatedCrudPolicy\$1v2](serverless-policy-template-list.md#ses-bulk-templated-crud-policy-v2) | Amazon SES E メール、テンプレート化された E メール、およびテンプレート化されたバルク E メールを送信し、アイデンティティを確認する許可を付与します。 | 
| [SESCrudPolicy](serverless-policy-template-list.md#ses-crud-policy) | E メールを送信し、アイデンティティを確認する許可を付与します。 | 
| [SESEmailTemplateCrudPolicy](serverless-policy-template-list.md#ses-email-template-crud-policy) | Amazon SES E メールテンプレートを作成、取得、リスト化、更新、および削除する許可を付与します。 | 
| [SESSendBouncePolicy](serverless-policy-template-list.md#ses-send-bounce-policy) | Amazon Simple Email Service (Amazon SES) アイデンティティに SendBounce 許可を付与します。 | 
| [SNSCrudPolicy](serverless-policy-template-list.md#sns-crud-policy) | Amazon SNS トピックを作成、公開、およびサブスクライブする許可を付与します。 | 
| [SNSPublishMessagePolicy](serverless-policy-template-list.md#sqs-publish-message-policy) | Amazon Simple Notification Service (Amazon SNS) トピックにメッセージを発行する許可を付与します。 | 
| [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) | Amazon Simple Queue Service (Amazon SQS) キューをポーリングする許可を付与します。 | 
| [SQSSendMessagePolicy](serverless-policy-template-list.md#sqs-send-message-policy) | Amazon SQS キューにメッセージを送信する許可を付与します。 | 
| [SSMParameterReadPolicy](serverless-policy-template-list.md#ssm-parameter-read-policy) | このアカウントのシークレットをロードするために、Amazon EC2 Systems Manager (SSM) パラメータストアからのパラメータにアクセスするための許可を付与します。パラメータ名にスラッシュプレフィックスが含まれていない場合に使用します。 | 
| [SSMParameterWithSlashPrefixReadPolicy](serverless-policy-template-list.md#ssm-parameter-slash-read-policy) | このアカウントのシークレットをロードするために、Amazon EC2 Systems Manager (SSM) パラメータストアからのパラメータにアクセスするための許可を付与します。パラメータ名にスラッシュプレフィックスが含まれている場合に使用します。 | 
| [StepFunctionsExecutionPolicy](serverless-policy-template-list.md#stepfunctions-execution-policy) | Step Functions ステートマシンの実行を開始する許可を付与します。 | 
| [TextractDetectAnalyzePolicy](serverless-policy-template-list.md#textract-detect-analyze-policy) | Amazon Textract でドキュメントを検出して分析するためのアクセス権を付与します。 | 
| [TextractGetResultPolicy](serverless-policy-template-list.md#textract-get-result-policy) | 検出および分析されたドキュメントを Amazon Textract から取得するためのアクセス権を付与します。 | 
| [TextractPolicy](serverless-policy-template-list.md#textract-policy) | Amazon Textract へのフルアクセス権を付与します。 | 
| [VPCAccessPolicy](serverless-policy-template-list.md#vpc-access-policy) | Elastic Network Interface を作成、削除、記述、およびデタッチするアクセス権を付与します。 | 

## トラブルシューティング
<a name="serverless-policy-template-troubleshooting"></a>

### SAM CLI エラー:「Must specify valid parameter values for policy template '<policy-template-name>」
<a name="serverless-policy-template-troubleshooting-"></a>

`sam build` の実行時に、以下のエラーが表示されます。

```
"Must specify valid parameter values for policy template '<policy-template-name>'"
```

これは、プレースホルダ値がないポリシーテンプレートを宣言したときに、空のオブジェクトが渡されなかったことを意味します。

これを修正するには、以下の [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy) 例のようにポリシーを宣言します。

```
1. MyFunction:
2.   Policies:
3.     - CloudWatchPutMetricPolicy: {}
```

# AWS SAM ポリシーテンプレートリスト
<a name="serverless-policy-template-list"></a>

以下は、使用可能なポリシーテンプレートと、それぞれに適用されるアクセス許可です。 AWS Serverless Application Model (AWS SAM) はプレースホルダー項目 ( AWS リージョンやアカウント ID など) に適切な情報を自動的に入力します。

**Topics**
+ [AcmGetCertificatePolicy](#acm-get-certificate-policy)
+ [AMIDescribePolicy](#ami-describe-policy)
+ [AthenaQueryPolicy](#athena-query-policy)
+ [AWSSecretsManagerGetSecretValuePolicy](#secrets-manager-get-secret-value-policy)
+ [AWSSecretsManagerRotationPolicy](#secrets-manager-rotation-policy)
+ [CloudFormationDescribeStacksPolicy](#cloud-formation-describe-stacks-policy)
+ [CloudWatchDashboardPolicy](#cloudwatch-dashboard-policy)
+ [CloudWatchDescribeAlarmHistoryPolicy](#cloudwatch-describe-alarm-history-policy)
+ [CloudWatchPutMetricPolicy](#cloudwatch-put-metric-policy)
+ [CodePipelineLambdaExecutionPolicy](#code-pipeline-lambda-execution-policy)
+ [CodePipelineReadOnlyPolicy](#code-pipeline-readonly-policy)
+ [CodeCommitCrudPolicy](#codecommit-crud-policy)
+ [CodeCommitReadPolicy](#codecommit-read-policy)
+ [ComprehendBasicAccessPolicy](#comprehend-basic-access-policy)
+ [CostExplorerReadOnlyPolicy](#cost-explorer-readonly-policy)
+ [DynamoDBBackupFullAccessPolicy](#ddb-back-full-policy)
+ [DynamoDBCrudPolicy](#dynamo-db-crud-policy)
+ [DynamoDBReadPolicy](#dynamo-db-read-policy)
+ [DynamoDBReconfigurePolicy](#dynamo-db-reconfigure-policy)
+ [DynamoDBRestoreFromBackupPolicy](#ddb-restore-from-backup-policy)
+ [DynamoDBStreamReadPolicy](#dynamo-db-stream-read-policy)
+ [DynamoDBWritePolicy](#dynamo-db-write-policy)
+ [EC2CopyImagePolicy](#ec2-copy-image-policy)
+ [EC2DescribePolicy](#ec2-describe-policy)
+ [EcsRunTaskPolicy](#ecs-run-task-policy)
+ [EFSWriteAccessPolicy](#efs-write-access-policy)
+ [EKSDescribePolicy](#eks-describe-policy)
+ [ElasticMapReduceAddJobFlowStepsPolicy](#elastic-map-reduce-add-job-flows-policy)
+ [ElasticMapReduceCancelStepsPolicy](#elastic-map-reduce-cancel-steps-policy)
+ [ElasticMapReduceModifyInstanceFleetPolicy](#elastic-map-reduce-modify-instance-fleet-policy)
+ [ElasticMapReduceModifyInstanceGroupsPolicy](#elastic-map-reduce-modify-instance-groups-policy)
+ [ElasticMapReduceSetTerminationProtectionPolicy](#elastic-map-reduce-set-termination-protection-policy)
+ [ElasticMapReduceTerminateJobFlowsPolicy](#elastic-map-reduce-terminate-job-flows-policy)
+ [ElasticsearchHttpPostPolicy](#elastic-search-http-post-policy)
+ [EventBridgePutEventsPolicy](#eventbridge-put-events-policy)
+ [FilterLogEventsPolicy](#filter-log-events-policy)
+ [FirehoseCrudPolicy](#firehose-crud-policy)
+ [FirehoseWritePolicy](#firehose-write-policy)
+ [KinesisCrudPolicy](#kinesis-crud-policy)
+ [KinesisStreamReadPolicy](#kinesis-stream-read-policy)
+ [KMSDecryptPolicy](#kms-decrypt-policy)
+ [KMSEncryptPolicy](#kms-encrypt-policy)
+ [LambdaInvokePolicy](#lambda-invoke-policy)
+ [MobileAnalyticsWriteOnlyAccessPolicy](#mobile-analytics-write-only-access-policy)
+ [OrganizationsListAccountsPolicy](#organizations-list-accounts-policy)
+ [PinpointEndpointAccessPolicy](#pinpoint-endpoint-access-policy)
+ [PollyFullAccessPolicy](#polly-full-access-policy)
+ [RekognitionDetectOnlyPolicy](#rekognition-detect-only-policy)
+ [RekognitionFacesManagementPolicy](#rekognition-face-management-policy)
+ [RekognitionFacesPolicy](#rekognition-faces-policy)
+ [RekognitionLabelsPolicy](#rekognition-labels-policy)
+ [RekognitionNoDataAccessPolicy](#rekognition-no-data-access-policy)
+ [RekognitionReadPolicy](#rekognition-read-policy)
+ [RekognitionWriteOnlyAccessPolicy](#rekognition-write-only-access-policy)
+ [Route53ChangeResourceRecordSetsPolicy](#route53-change-resource-record-sets-policy)
+ [S3CrudPolicy](#s3-crud-policy)
+ [S3FullAccessPolicy](#s3-full-access-policy)
+ [S3ReadPolicy](#s3-read-policy)
+ [S3WritePolicy](#s3-write-policy)
+ [SageMakerCreateEndpointConfigPolicy](#sagemaker-create-endpoint-config-policy)
+ [SageMakerCreateEndpointPolicy](#sagemaker-create-endpoint-policy)
+ [ServerlessRepoReadWriteAccessPolicy](#serverlessrepo-read-write-access-policy)
+ [SESBulkTemplatedCrudPolicy](#ses-bulk-templated-crud-policy)
+ [SESBulkTemplatedCrudPolicy\$1v2](#ses-bulk-templated-crud-policy-v2)
+ [SESCrudPolicy](#ses-crud-policy)
+ [SESEmailTemplateCrudPolicy](#ses-email-template-crud-policy)
+ [SESSendBouncePolicy](#ses-send-bounce-policy)
+ [SNSCrudPolicy](#sns-crud-policy)
+ [SNSPublishMessagePolicy](#sqs-publish-message-policy)
+ [SQSPollerPolicy](#sqs-poller-policy)
+ [SQSSendMessagePolicy](#sqs-send-message-policy)
+ [SSMParameterReadPolicy](#ssm-parameter-read-policy)
+ [SSMParameterWithSlashPrefixReadPolicy](#ssm-parameter-slash-read-policy)
+ [StepFunctionsExecutionPolicy](#stepfunctions-execution-policy)
+ [TextractDetectAnalyzePolicy](#textract-detect-analyze-policy)
+ [TextractGetResultPolicy](#textract-get-result-policy)
+ [TextractPolicy](#textract-policy)
+ [VPCAccessPolicy](#vpc-access-policy)

## AcmGetCertificatePolicy
<a name="acm-get-certificate-policy"></a>

証明書を読み取るアクセス許可を付与します AWS Certificate Manager。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "acm:GetCertificate"
    ],
    "Resource": {
      "Fn::Sub": [
        "${certificateArn}",
        {
          "certificateArn": {
            "Ref": "CertificateArn"
          }
        }
      ]
    }
  }
]
```

## AMIDescribePolicy
<a name="ami-describe-policy"></a>

Amazon マシンイメージ (AMI) を記述する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "ec2:DescribeImages"
    ],
    "Resource": "*"
  }
]
```

## AthenaQueryPolicy
<a name="athena-query-policy"></a>

Athena クエリを実行する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "athena:ListWorkGroups",
      "athena:GetExecutionEngine",
      "athena:GetExecutionEngines",
      "athena:GetNamespace",
      "athena:GetCatalogs",
      "athena:GetNamespaces",
      "athena:GetTables",
      "athena:GetTable"
    ],
    "Resource": "*"
  },
  {
    "Effect": "Allow",
    "Action": [
      "athena:StartQueryExecution",
      "athena:GetQueryResults",
      "athena:DeleteNamedQuery",
      "athena:GetNamedQuery",
      "athena:ListQueryExecutions",
      "athena:StopQueryExecution",
      "athena:GetQueryResultsStream",
      "athena:ListNamedQueries",
      "athena:CreateNamedQuery",
      "athena:GetQueryExecution",
      "athena:BatchGetNamedQuery",
      "athena:BatchGetQueryExecution",
      "athena:GetWorkGroup"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:athena:${AWS::Region}:${AWS::AccountId}:workgroup/${workgroupName}",
        {
          "workgroupName": {
            "Ref": "WorkGroupName"
          }
        }
      ]
    }
  }
]
```

## AWSSecretsManagerGetSecretValuePolicy
<a name="secrets-manager-get-secret-value-policy"></a>

指定されたシークレットの AWS Secrets Manager シークレット値を取得するアクセス許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "secretsmanager:GetSecretValue"
    ],
    "Resource": {
      "Fn::Sub": [
        "${secretArn}",
        {
          "secretArn": {
            "Ref": "SecretArn"
          }
        }
      ]
    }
  }
]
```

## AWSSecretsManagerRotationPolicy
<a name="secrets-manager-rotation-policy"></a>

 AWS Secrets Managerのシークレットをローテーションを行う許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "secretsmanager:DescribeSecret",
      "secretsmanager:GetSecretValue",
      "secretsmanager:PutSecretValue",
      "secretsmanager:UpdateSecretVersionStage"
    ],
    "Resource": {
      "Fn::Sub": "arn:${AWS::Partition}:secretsmanager:${AWS::Region}:${AWS::AccountId}:secret:*"
    },
    "Condition": {
      "StringEquals": {
        "secretsmanager:resource/AllowRotationLambdaArn": {
          "Fn::Sub": [
            "arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}",
            {
              "functionName": {
                "Ref": "FunctionName"
              }
            }
          ]
        }
      }
    }
  },
  {
    "Effect": "Allow",
    "Action": [
      "secretsmanager:GetRandomPassword"
    ],
    "Resource": "*"
  }
]
```

## CloudFormationDescribeStacksPolicy
<a name="cloud-formation-describe-stacks-policy"></a>

 CloudFormation スタックを記述するアクセス許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "cloudformation:DescribeStacks"
    ],
    "Resource": {
      "Fn::Sub": "arn:${AWS::Partition}:cloudformation:${AWS::Region}:${AWS::AccountId}:stack/*"
    }
  }
]
```

## CloudWatchDashboardPolicy
<a name="cloudwatch-dashboard-policy"></a>

CloudWatch ダッシュボードで操作を行うためのメトリクスを配置する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "cloudwatch:GetDashboard",
      "cloudwatch:ListDashboards",
      "cloudwatch:PutDashboard",
      "cloudwatch:ListMetrics"
    ],
    "Resource": "*"
  }
]
```

## CloudWatchDescribeAlarmHistoryPolicy
<a name="cloudwatch-describe-alarm-history-policy"></a>

Amazon CloudWatch のアラーム履歴を記述する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "cloudwatch:DescribeAlarmHistory"
    ],
    "Resource": "*"
  }
]
```

## CloudWatchPutMetricPolicy
<a name="cloudwatch-put-metric-policy"></a>

CloudWatch にメトリクスを送信する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "cloudwatch:PutMetricData"
    ],
    "Resource": "*"
  }
]
```

## CodePipelineLambdaExecutionPolicy
<a name="code-pipeline-lambda-execution-policy"></a>

によって呼び出された Lambda 関数 AWS CodePipeline に、ジョブのステータスを報告するアクセス許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "codepipeline:PutJobSuccessResult",
      "codepipeline:PutJobFailureResult"
    ],
    "Resource": "*"
  }
]
```

## CodePipelineReadOnlyPolicy
<a name="code-pipeline-readonly-policy"></a>

CodePipeline パイプラインの詳細を取得するための読み取り許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "codepipeline:ListPipelineExecutions"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:codepipeline:${AWS::Region}:${AWS::AccountId}:${pipelinename}",
        {
          "pipelinename": {
            "Ref": "PipelineName"
          }
        }
      ]
    }
  }
]
```

## CodeCommitCrudPolicy
<a name="codecommit-crud-policy"></a>

特定の CodeCommit リポジトリ内にあるオブジェクトを作成、読み取り、更新、および削除する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "codecommit:GitPull",
      "codecommit:GitPush",
      "codecommit:CreateBranch",
      "codecommit:DeleteBranch",
      "codecommit:GetBranch",
      "codecommit:ListBranches",
      "codecommit:MergeBranchesByFastForward",
      "codecommit:MergeBranchesBySquash",
      "codecommit:MergeBranchesByThreeWay",
      "codecommit:UpdateDefaultBranch",
      "codecommit:BatchDescribeMergeConflicts",
      "codecommit:CreateUnreferencedMergeCommit",
      "codecommit:DescribeMergeConflicts",
      "codecommit:GetMergeCommit",
      "codecommit:GetMergeOptions",
      "codecommit:BatchGetPullRequests",
      "codecommit:CreatePullRequest",
      "codecommit:DescribePullRequestEvents",
      "codecommit:GetCommentsForPullRequest",
      "codecommit:GetCommitsFromMergeBase",
      "codecommit:GetMergeConflicts",
      "codecommit:GetPullRequest",
      "codecommit:ListPullRequests",
      "codecommit:MergePullRequestByFastForward",
      "codecommit:MergePullRequestBySquash",
      "codecommit:MergePullRequestByThreeWay",
      "codecommit:PostCommentForPullRequest",
      "codecommit:UpdatePullRequestDescription",
      "codecommit:UpdatePullRequestStatus",
      "codecommit:UpdatePullRequestTitle",
      "codecommit:DeleteFile",
      "codecommit:GetBlob",
      "codecommit:GetFile",
      "codecommit:GetFolder",
      "codecommit:PutFile",
      "codecommit:DeleteCommentContent",
      "codecommit:GetComment",
      "codecommit:GetCommentsForComparedCommit",
      "codecommit:PostCommentForComparedCommit",
      "codecommit:PostCommentReply",
      "codecommit:UpdateComment",
      "codecommit:BatchGetCommits",
      "codecommit:CreateCommit",
      "codecommit:GetCommit",
      "codecommit:GetCommitHistory",
      "codecommit:GetDifferences",
      "codecommit:GetObjectIdentifier",
      "codecommit:GetReferences",
      "codecommit:GetTree",
      "codecommit:GetRepository",
      "codecommit:UpdateRepositoryDescription",
      "codecommit:ListTagsForResource",
      "codecommit:TagResource",
      "codecommit:UntagResource",
      "codecommit:GetRepositoryTriggers",
      "codecommit:PutRepositoryTriggers",
      "codecommit:TestRepositoryTriggers",
      "codecommit:GetBranch",
      "codecommit:GetCommit",
      "codecommit:UploadArchive",
      "codecommit:GetUploadArchiveStatus",
      "codecommit:CancelUploadArchive"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
        {
          "repositoryName": {
            "Ref": "RepositoryName"
          }
        }
      ]
    }
  }
]
```

## CodeCommitReadPolicy
<a name="codecommit-read-policy"></a>

特定の CodeCommit リポジトリ内にあるオブジェクトを読み取る許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "codecommit:GitPull",
      "codecommit:GetBranch",
      "codecommit:ListBranches",
      "codecommit:BatchDescribeMergeConflicts",
      "codecommit:DescribeMergeConflicts",
      "codecommit:GetMergeCommit",
      "codecommit:GetMergeOptions",
      "codecommit:BatchGetPullRequests",
      "codecommit:DescribePullRequestEvents",
      "codecommit:GetCommentsForPullRequest",
      "codecommit:GetCommitsFromMergeBase",
      "codecommit:GetMergeConflicts",
      "codecommit:GetPullRequest",
      "codecommit:ListPullRequests",
      "codecommit:GetBlob",
      "codecommit:GetFile",
      "codecommit:GetFolder",
      "codecommit:GetComment",
      "codecommit:GetCommentsForComparedCommit",
      "codecommit:BatchGetCommits",
      "codecommit:GetCommit",
      "codecommit:GetCommitHistory",
      "codecommit:GetDifferences",
      "codecommit:GetObjectIdentifier",
      "codecommit:GetReferences",
      "codecommit:GetTree",
      "codecommit:GetRepository",
      "codecommit:ListTagsForResource",
      "codecommit:GetRepositoryTriggers",
      "codecommit:TestRepositoryTriggers",
      "codecommit:GetBranch",
      "codecommit:GetCommit",
      "codecommit:GetUploadArchiveStatus"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
        {
          "repositoryName": {
            "Ref": "RepositoryName"
          }
        }
      ]
    }
  }
]
```

## ComprehendBasicAccessPolicy
<a name="comprehend-basic-access-policy"></a>

エンティティ、キーフレーズ、言語、およびセンチメントを検出する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "comprehend:BatchDetectKeyPhrases",
      "comprehend:DetectDominantLanguage",
      "comprehend:DetectEntities",
      "comprehend:BatchDetectEntities",
      "comprehend:DetectKeyPhrases",
      "comprehend:DetectSentiment",
      "comprehend:BatchDetectDominantLanguage",
      "comprehend:BatchDetectSentiment"
    ],
    "Resource": "*"
  }
]
```

## CostExplorerReadOnlyPolicy
<a name="cost-explorer-readonly-policy"></a>

請求履歴の読み取り専用 AWS Cost Explorer (Cost Explorer) APIs に読み取り専用アクセス許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "ce:GetCostAndUsage",
      "ce:GetDimensionValues",
      "ce:GetReservationCoverage",
      "ce:GetReservationPurchaseRecommendation",
      "ce:GetReservationUtilization",
      "ce:GetTags"
    ],
    "Resource": "*"
  }
]
```

## DynamoDBBackupFullAccessPolicy
<a name="ddb-back-full-policy"></a>

テーブルの DynamoDB オンデマンドバックアップに読み取りおよび書き込み許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "dynamodb:CreateBackup",
      "dynamodb:DescribeContinuousBackups"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
        {
          "tableName": {
            "Ref": "TableName"
          }
        }
      ]
    }
  },
  {
    "Effect": "Allow",
    "Action": [
      "dynamodb:DeleteBackup",
      "dynamodb:DescribeBackup",
      "dynamodb:ListBackups"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
        {
          "tableName": {
            "Ref": "TableName"
          }
        }
      ]
    }
  }
]
```

## DynamoDBCrudPolicy
<a name="dynamo-db-crud-policy"></a>

Amazon DynamoDB テーブルに作成、読み取り、更新、および削除許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "dynamodb:GetItem",
      "dynamodb:DeleteItem",
      "dynamodb:PutItem",
      "dynamodb:Scan",
      "dynamodb:Query",
      "dynamodb:UpdateItem",
      "dynamodb:BatchWriteItem",
      "dynamodb:BatchGetItem",
      "dynamodb:DescribeTable",
      "dynamodb:ConditionCheckItem"
    ],
    "Resource": [
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
          {
            "tableName": {
              "Ref": "TableName"
            }
          }
        ]
      },
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
          {
            "tableName": {
              "Ref": "TableName"
            }
          }
        ]
      }
    ]
  }
]
```

## DynamoDBReadPolicy
<a name="dynamo-db-read-policy"></a>

DynamoDB テーブルに読み取り専用許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "dynamodb:GetItem",
      "dynamodb:Scan",
      "dynamodb:Query",
      "dynamodb:BatchGetItem",
      "dynamodb:DescribeTable"
    ],
    "Resource": [
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
          {
            "tableName": {
              "Ref": "TableName"
            }
          }
        ]
      },
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
          {
            "tableName": {
              "Ref": "TableName"
            }
          }
        ]
      }
    ]
  }
]
```

## DynamoDBReconfigurePolicy
<a name="dynamo-db-reconfigure-policy"></a>

DynamoDB テーブルを再構成する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "dynamodb:UpdateTable"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
        {
          "tableName": {
            "Ref": "TableName"
          }
        }
      ]
    }
  }
]
```

## DynamoDBRestoreFromBackupPolicy
<a name="ddb-restore-from-backup-policy"></a>

バックアップから DynamoDB テーブルを復元する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "dynamodb:RestoreTableFromBackup"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
        {
          "tableName": {
            "Ref": "TableName"
          }
        }
      ]
    }
  },
  {
    "Effect": "Allow",
    "Action": [
      "dynamodb:PutItem",
      "dynamodb:UpdateItem",
      "dynamodb:DeleteItem",
      "dynamodb:GetItem",
      "dynamodb:Query",
      "dynamodb:Scan",
      "dynamodb:BatchWriteItem"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
        {
          "tableName": {
            "Ref": "TableName"
          }
        }
      ]
    }
  }
]
```

## DynamoDBStreamReadPolicy
<a name="dynamo-db-stream-read-policy"></a>

DynamoDB のストリームとレコードを記述および読み取る許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "dynamodb:DescribeStream",
      "dynamodb:GetRecords",
      "dynamodb:GetShardIterator"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/${streamName}",
        {
          "tableName": {
            "Ref": "TableName"
          },
          "streamName": {
            "Ref": "StreamName"
          }
        }
      ]
    }
  },
  {
    "Effect": "Allow",
    "Action": [
      "dynamodb:ListStreams"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/*",
        {
          "tableName": {
            "Ref": "TableName"
          }
        }
      ]
    }
  }          
]
```

## DynamoDBWritePolicy
<a name="dynamo-db-write-policy"></a>

DynamoDB テーブルに書き込み専用許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "dynamodb:PutItem",
      "dynamodb:UpdateItem",
      "dynamodb:BatchWriteItem"
    ],
    "Resource": [
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
          {
            "tableName": {
              "Ref": "TableName"
            }
          }
        ]
      },
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
          {
            "tableName": {
              "Ref": "TableName"
            }
          }
        ]
      }
    ]
  }
]
```

## EC2CopyImagePolicy
<a name="ec2-copy-image-policy"></a>

Amazon EC2 イメージをコピーする許可を付与します

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "ec2:CopyImage"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:ec2:${AWS::Region}:${AWS::AccountId}:image/${imageId}",
        {
          "imageId": {
            "Ref": "ImageId"
          }
        }
      ]
    }
  }
]
```

## EC2DescribePolicy
<a name="ec2-describe-policy"></a>

Amazon Elastic Compute Cloud (Amazon EC2) インスタンスを記述する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "ec2:DescribeRegions",
      "ec2:DescribeInstances"
    ],
    "Resource": "*"
  }
]
```

## EcsRunTaskPolicy
<a name="ecs-run-task-policy"></a>

タスク定義の新しいタスクを開始する許可を付与します。

```
"Statement": [
  {
    "Action": [
      "ecs:RunTask"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:ecs:${AWS::Region}:${AWS::AccountId}:task-definition/${taskDefinition}",
        {
          "taskDefinition": {
            "Ref": "TaskDefinition"
          }
        }
      ]
    },
    "Effect": "Allow"
  }
]
```

## EFSWriteAccessPolicy
<a name="efs-write-access-policy"></a>

書き込みアクセス権と共に Amazon EFS ファイルシステムをマウントする許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "elasticfilesystem:ClientMount",
      "elasticfilesystem:ClientWrite"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:file-system/${FileSystem}",
        {
          "FileSystem": {
            "Ref": "FileSystem"
          }
        }
      ]
    },
    "Condition": {
      "StringEquals": {
        "elasticfilesystem:AccessPointArn": {
          "Fn::Sub": [
            "arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:access-point/${AccessPoint}",
            {
              "AccessPoint": {
                "Ref": "AccessPoint"
              }
            }
          ]
        }
      }
    }
  }
]
```

## EKSDescribePolicy
<a name="eks-describe-policy"></a>

Amazon Elastic Kubernetes Service (Amazon EKS) クラスターを記述またはリスト化する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "eks:DescribeCluster",
      "eks:ListClusters"
    ],
    "Resource": "*"
  }
]
```

## ElasticMapReduceAddJobFlowStepsPolicy
<a name="elastic-map-reduce-add-job-flows-policy"></a>

実行中のクラスターに新しいステップを追加する許可を付与します。

```
"Statement": [
  {
    "Action": "elasticmapreduce:AddJobFlowSteps",
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
        {
          "clusterId": {
            "Ref": "ClusterId"
          }
        }
      ]
    },
    "Effect": "Allow"
  }
]
```

## ElasticMapReduceCancelStepsPolicy
<a name="elastic-map-reduce-cancel-steps-policy"></a>

実行中のクラスターで保留中のステップ (1 つ、または複数) をキャンセルする許可を付与します。

```
"Statement": [
  {
    "Action": "elasticmapreduce:CancelSteps",
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
        {
          "clusterId": {
            "Ref": "ClusterId"
          }
        }
      ]
    },
    "Effect": "Allow"
  }
]
```

## ElasticMapReduceModifyInstanceFleetPolicy
<a name="elastic-map-reduce-modify-instance-fleet-policy"></a>

クラスター内のインスタンスフリートの詳細をリスト化し、容量を変更する許可を付与します。

```
"Statement": [
  {
    "Action": [
      "elasticmapreduce:ModifyInstanceFleet",
      "elasticmapreduce:ListInstanceFleets"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
        {
          "clusterId": {
            "Ref": "ClusterId"
          }
        }
      ]
    },
    "Effect": "Allow"
  }
]
```

## ElasticMapReduceModifyInstanceGroupsPolicy
<a name="elastic-map-reduce-modify-instance-groups-policy"></a>

クラスター内のインスタンスグループの詳細をリスト化し、設定を変更する許可を付与します。

```
"Statement": [
  {
    "Action": [
      "elasticmapreduce:ModifyInstanceGroups",
      "elasticmapreduce:ListInstanceGroups"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
        {
          "clusterId": {
            "Ref": "ClusterId"
          }
        }
      ]
    },
    "Effect": "Allow"
  }
]
```

## ElasticMapReduceSetTerminationProtectionPolicy
<a name="elastic-map-reduce-set-termination-protection-policy"></a>

クラスターの終了保護を設定する許可を付与します。

```
"Statement": [
  {
    "Action": "elasticmapreduce:SetTerminationProtection",
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
        {
          "clusterId": {
            "Ref": "ClusterId"
          }
        }
      ]
    },
    "Effect": "Allow"
  }
]
```

## ElasticMapReduceTerminateJobFlowsPolicy
<a name="elastic-map-reduce-terminate-job-flows-policy"></a>

クラスターをシャットダウンする許可を付与します。

```
"Statement": [
  {
    "Action": "elasticmapreduce:TerminateJobFlows",
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
        {
          "clusterId": {
            "Ref": "ClusterId"
          }
        }
      ]
    },
    "Effect": "Allow"
  }
]
```

## ElasticsearchHttpPostPolicy
<a name="elastic-search-http-post-policy"></a>

Amazon OpenSearch Service に POST および PUT 許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "es:ESHttpPost",
      "es:ESHttpPut"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:es:${AWS::Region}:${AWS::AccountId}:domain/${domainName}/*",
        {
          "domainName": {
            "Ref": "DomainName"
          }
        }
      ]
    }
  }
]
```

## EventBridgePutEventsPolicy
<a name="eventbridge-put-events-policy"></a>

Amazon EventBridge にイベントを送信する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": "events:PutEvents",
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:events:${AWS::Region}:${AWS::AccountId}:event-bus/${eventBusName}",
        {
          "eventBusName": {
            "Ref": "EventBusName"
          }
        }
      ]
    }
  }
]
```

## FilterLogEventsPolicy
<a name="filter-log-events-policy"></a>

指定されたロググループからの CloudWatch Logs イベントをフィルタリングする許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "logs:FilterLogEvents"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:logs:${AWS::Region}:${AWS::AccountId}:log-group:${logGroupName}:log-stream:*",
        {
          "logGroupName": {
            "Ref": "LogGroupName"
          }
        }
      ]
    }
  }
]
```

## FirehoseCrudPolicy
<a name="firehose-crud-policy"></a>

Firehose の配信ストリームに対し作成、書き込み、更新、および削除を行うアクセス許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "firehose:CreateDeliveryStream",
      "firehose:DeleteDeliveryStream",
      "firehose:DescribeDeliveryStream",
      "firehose:PutRecord",
      "firehose:PutRecordBatch",
      "firehose:UpdateDestination"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
        {
          "deliveryStreamName": {
            "Ref": "DeliveryStreamName"
          }
        }
      ]
    }
  }
]
```

## FirehoseWritePolicy
<a name="firehose-write-policy"></a>

Firehose の配信ストリームに書き込むアクセス許可を付与します

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "firehose:PutRecord",
      "firehose:PutRecordBatch"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
        {
          "deliveryStreamName": {
            "Ref": "DeliveryStreamName"
          }
        }
      ]
    }
  }
]
```

## KinesisCrudPolicy
<a name="kinesis-crud-policy"></a>

Amazon Kinesis のストリームを作成、発行、および削除する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "kinesis:AddTagsToStream",
      "kinesis:CreateStream",
      "kinesis:DecreaseStreamRetentionPeriod",
      "kinesis:DeleteStream",
      "kinesis:DescribeStream",
      "kinesis:DescribeStreamSummary",
      "kinesis:GetShardIterator",
      "kinesis:IncreaseStreamRetentionPeriod",
      "kinesis:ListTagsForStream",
      "kinesis:MergeShards",
      "kinesis:PutRecord",
      "kinesis:PutRecords",
      "kinesis:SplitShard",
      "kinesis:RemoveTagsFromStream"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
        {
          "streamName": {
            "Ref": "StreamName"
          }
        }
      ]
    }
  }
]
```

## KinesisStreamReadPolicy
<a name="kinesis-stream-read-policy"></a>

Amazon Kinesis のストリームをリスト化して読み取る許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "kinesis:ListStreams",
      "kinesis:DescribeLimits"
    ],
    "Resource": {
      "Fn::Sub": "arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/*"
    }
  },
  {
    "Effect": "Allow",
    "Action": [
      "kinesis:DescribeStream",
      "kinesis:DescribeStreamSummary",
      "kinesis:GetRecords",
      "kinesis:GetShardIterator"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
        {
          "streamName": {
            "Ref": "StreamName"
          }
        }
      ]
    }
  }
]
```

## KMSDecryptPolicy
<a name="kms-decrypt-policy"></a>

 AWS Key Management Service (AWS KMS) キーを使用して復号するアクセス許可を付与します。は AWS KMS キーエイリアスではなく、キー ID `keyId`である必要があります。

```
"Statement": [
  {
    "Action": "kms:Decrypt",
    "Effect": "Allow",
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
        {
          "keyId": {
            "Ref": "KeyId"
          }
        }
      ]
    }
  }
]
```

## KMSEncryptPolicy
<a name="kms-encrypt-policy"></a>

 AWS KMS キーで暗号化するアクセス許可を付与します。keyId は AWS KMS キーエイリアスではなくキー ID である必要があります。

```
"Statement": [
  {
    "Action": "kms:Encrypt",
    "Effect": "Allow",
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
        {
          "keyId": {
            "Ref": "KeyId"
          }
        }
      ]
    }
  }
]
```

## LambdaInvokePolicy
<a name="lambda-invoke-policy"></a>

 AWS Lambda 関数、エイリアス、またはバージョンを呼び出すアクセス許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "lambda:InvokeFunction"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}*",
        {
          "functionName": {
            "Ref": "FunctionName"
          }
        }
      ]
    }
  }
]
```

## MobileAnalyticsWriteOnlyAccessPolicy
<a name="mobile-analytics-write-only-access-policy"></a>

すべてのアプリケーションリソースのイベントデータを配置するための書き込み専用許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "mobileanalytics:PutEvents"
    ],
    "Resource": "*"
  }
]
```

## OrganizationsListAccountsPolicy
<a name="organizations-list-accounts-policy"></a>

子アカウントの名前と ID を一覧表示する読み取り専用許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "organizations:ListAccounts"
    ],
    "Resource": "*"
  }
]
```

## PinpointEndpointAccessPolicy
<a name="pinpoint-endpoint-access-policy"></a>

Amazon Pinpoint アプリケーションのエンドポイントを取得して更新する許可を付与します

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "mobiletargeting:GetEndpoint",
      "mobiletargeting:UpdateEndpoint",
      "mobiletargeting:UpdateEndpointsBatch"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:mobiletargeting:${AWS::Region}:${AWS::AccountId}:apps/${pinpointApplicationId}/endpoints/*",
        {
          "pinpointApplicationId": {
            "Ref": "PinpointApplicationId"
          }
        }
      ]
    }
  }
]
```

## PollyFullAccessPolicy
<a name="polly-full-access-policy"></a>

Amazon Polly のレキシコンリソースへのフルアクセス許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "polly:GetLexicon",
      "polly:DeleteLexicon"
    ],
    "Resource": [
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/${lexiconName}",
          {
            "lexiconName": {
              "Ref": "LexiconName"
            }
          }
        ]
      }
    ]
  },
  {
    "Effect": "Allow",
    "Action": [
      "polly:DescribeVoices",
      "polly:ListLexicons",
      "polly:PutLexicon",
      "polly:SynthesizeSpeech"
    ],
    "Resource": [
      {
        "Fn::Sub": "arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/*"
      }
    ]
  }
]
```

## RekognitionDetectOnlyPolicy
<a name="rekognition-detect-only-policy"></a>

顔、ラベル、およびテキストを検出する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "rekognition:DetectFaces",
      "rekognition:DetectLabels",
      "rekognition:DetectModerationLabels",
      "rekognition:DetectText"
    ],
    "Resource": "*"
  }
]
```

## RekognitionFacesManagementPolicy
<a name="rekognition-face-management-policy"></a>

Amazon Rekognition コレクション内の顔を追加、削除、および検索する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "rekognition:IndexFaces",
      "rekognition:DeleteFaces",
      "rekognition:SearchFaces",
      "rekognition:SearchFacesByImage",
      "rekognition:ListFaces"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
        {
          "collectionId": {
            "Ref": "CollectionId"
          }
        }
      ]
    }
  }
]
```

## RekognitionFacesPolicy
<a name="rekognition-faces-policy"></a>

顔とラベルを比較および検出する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "rekognition:CompareFaces",
      "rekognition:DetectFaces"
    ],
    "Resource": "*"
  }
]
```

## RekognitionLabelsPolicy
<a name="rekognition-labels-policy"></a>

オブジェクトとモデレーションラベルを検出する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "rekognition:DetectLabels",
      "rekognition:DetectModerationLabels"
    ],
    "Resource": "*"
  }
]
```

## RekognitionNoDataAccessPolicy
<a name="rekognition-no-data-access-policy"></a>

顔とラベルを比較および検出する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "rekognition:CompareFaces",
      "rekognition:DetectFaces",
      "rekognition:DetectLabels",
      "rekognition:DetectModerationLabels"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
        {
          "collectionId": {
            "Ref": "CollectionId"
          }
        }
      ]
    }
  }
]
```

## RekognitionReadPolicy
<a name="rekognition-read-policy"></a>

顔をリスト化して検索する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "rekognition:ListCollections",
      "rekognition:ListFaces",
      "rekognition:SearchFaces",
      "rekognition:SearchFacesByImage"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
        {
          "collectionId": {
            "Ref": "CollectionId"
          }
        }
      ]
    }
  }
]
```

## RekognitionWriteOnlyAccessPolicy
<a name="rekognition-write-only-access-policy"></a>

顔のコレクションを作成してインデックス化する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "rekognition:CreateCollection",
      "rekognition:IndexFaces"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
        {
          "collectionId": {
            "Ref": "CollectionId"
          }
        }
      ]
    }
  }
]
```

## Route53ChangeResourceRecordSetsPolicy
<a name="route53-change-resource-record-sets-policy"></a>

Route 53 のリソースレコードセットを変更する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "route53:ChangeResourceRecordSets"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:route53:::hostedzone/${HostedZoneId}",
        {
          "HostedZoneId": {
            "Ref": "HostedZoneId"
          }
        }
      ]
    }
  }
]
```

## S3CrudPolicy
<a name="s3-crud-policy"></a>

Amazon S3 バケット内のオブジェクトでアクションを実行するための作成、読み取り、更新、および削除許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "s3:GetObject",
      "s3:ListBucket",
      "s3:GetBucketLocation",
      "s3:GetObjectVersion",
      "s3:PutObject",
      "s3:PutObjectAcl",
      "s3:GetLifecycleConfiguration",
      "s3:PutLifecycleConfiguration",
      "s3:DeleteObject"
    ],
    "Resource": [
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:s3:::${bucketName}",
          {
            "bucketName": {
              "Ref": "BucketName"
            }
          }
        ]
      },
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:s3:::${bucketName}/*",
          {
            "bucketName": {
              "Ref": "BucketName"
            }
          }
        ]
      }
    ]
  }
]
```

## S3FullAccessPolicy
<a name="s3-full-access-policy"></a>

Amazon S3 バケット内のオブジェクトでアクションを実行するためのフルアクセス許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "s3:GetObject",
      "s3:GetObjectAcl",
      "s3:GetObjectVersion",
      "s3:PutObject",
      "s3:PutObjectAcl",
      "s3:DeleteObject",
      "s3:DeleteObjectTagging",
      "s3:DeleteObjectVersionTagging",
      "s3:GetObjectTagging",
      "s3:GetObjectVersionTagging",
      "s3:PutObjectTagging",
      "s3:PutObjectVersionTagging"
    ],
    "Resource": [
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:s3:::${bucketName}/*",
          {
            "bucketName": {
              "Ref": "BucketName"
            }
          }
        ]
      }
    ]
  },
  {
    "Effect": "Allow",
    "Action": [
      "s3:ListBucket",
      "s3:GetBucketLocation",
      "s3:GetLifecycleConfiguration",
      "s3:PutLifecycleConfiguration"
    ],
    "Resource": [
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:s3:::${bucketName}",
          {
            "bucketName": {
              "Ref": "BucketName"
            }
          }
        ]
      }
    ]
  }
]
```

## S3ReadPolicy
<a name="s3-read-policy"></a>

Amazon Simple Storage Service (Amazon S3) バケットにあるオブジェクトを読み取るための読み取り専用許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "s3:GetObject",
      "s3:ListBucket",
      "s3:GetBucketLocation",
      "s3:GetObjectVersion",
      "s3:GetLifecycleConfiguration"
    ],
    "Resource": [
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:s3:::${bucketName}",
          {
            "bucketName": {
              "Ref": "BucketName"
            }
          }
        ]
      },
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:s3:::${bucketName}/*",
          {
            "bucketName": {
              "Ref": "BucketName"
            }
          }
        ]
      }
    ]
  }
]
```

## S3WritePolicy
<a name="s3-write-policy"></a>

Amazon S3 バケットにオブジェクトを書き込むための書き込み許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "s3:PutObject",
      "s3:PutObjectAcl",
      "s3:PutLifecycleConfiguration"
    ],
    "Resource": [
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:s3:::${bucketName}",
          {
            "bucketName": {
              "Ref": "BucketName"
            }
          }
        ]
      },
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:s3:::${bucketName}/*",
          {
            "bucketName": {
              "Ref": "BucketName"
            }
          }
        ]
      }
    ]
  }
]
```

## SageMakerCreateEndpointConfigPolicy
<a name="sagemaker-create-endpoint-config-policy"></a>

SageMaker AI でエンドポイント設定を作成する許可を付与します。

```
"Statement": [
  {
    "Action": [
      "sagemaker:CreateEndpointConfig"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint-config/${endpointConfigName}",
        {
          "endpointConfigName": {
            "Ref": "EndpointConfigName"
          }
        }
      ]
    },
    "Effect": "Allow"
  }
]
```

## SageMakerCreateEndpointPolicy
<a name="sagemaker-create-endpoint-policy"></a>

SageMaker AI でエンドポイントを作成する許可を付与します。

```
"Statement": [
  {
    "Action": [
      "sagemaker:CreateEndpoint"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint/${endpointName}",
        {
          "endpointName": {
            "Ref": "EndpointName"
          }
        }
      ]
    },
    "Effect": "Allow"
  }
]
```

## ServerlessRepoReadWriteAccessPolicy
<a name="serverlessrepo-read-write-access-policy"></a>

 AWS Serverless Application Repository (AWS SAM) サービスでアプリケーションを作成および一覧表示するアクセス許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "serverlessrepo:CreateApplication",
      "serverlessrepo:CreateApplicationVersion",
      "serverlessrepo:GetApplication",
      "serverlessrepo:ListApplications",
      "serverlessrepo:ListApplicationVersions"
    ],
    "Resource": [
      {
        "Fn::Sub": "arn:${AWS::Partition}:serverlessrepo:${AWS::Region}:${AWS::AccountId}:applications/*"
      }
    ]
  }
]
```

## SESBulkTemplatedCrudPolicy
<a name="ses-bulk-templated-crud-policy"></a>

Amazon SES E メール、テンプレート化された E メール、およびテンプレート化されたバルク E メールを送信し、アイデンティティを確認する許可を付与します。

**注記**  
 `ses:SendTemplatedEmail` アクションにはテンプレート ARN が必要です。代わりに `SESBulkTemplatedCrudPolicy_v2` を使用します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "ses:GetIdentityVerificationAttributes",
      "ses:SendEmail",
      "ses:SendRawEmail",
      "ses:SendTemplatedEmail",
      "ses:SendBulkTemplatedEmail",
      "ses:VerifyEmailIdentity"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
        {
          "identityName": {
            "Ref": "IdentityName"
          }
        }
      ]
    }
  }
]
```

## SESBulkTemplatedCrudPolicy\$1v2
<a name="ses-bulk-templated-crud-policy-v2"></a>

Amazon SES E メール、テンプレート化された E メール、およびテンプレート化されたバルク E メールを送信し、アイデンティティを確認する許可を付与します。

```
"Statement": [
  {
    "Action": [
      "ses:SendEmail",
      "ses:SendRawEmail",
      "ses:SendTemplatedEmail",
      "ses:SendBulkTemplatedEmail"
    ],
    "Effect": "Allow",
    "Resource": [
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
          {
            "identityName": {
              "Ref": "IdentityName"
            }
          }
        ]
      },
      {
        "Fn::Sub": [
          "arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:template/${templateName}",
          {
            "templateName": {
              "Ref": "TemplateName"
            }
          }
        ]
      }
    ]
  },
  {
    "Action": [
      "ses:GetIdentityVerificationAttributes",
      "ses:VerifyEmailIdentity"
    ],
    "Effect": "Allow",
    "Resource": "*"
  }
]
```

## SESCrudPolicy
<a name="ses-crud-policy"></a>

E メールを送信し、アイデンティティを確認する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "ses:GetIdentityVerificationAttributes",
      "ses:SendEmail",
      "ses:SendRawEmail",
      "ses:VerifyEmailIdentity"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
        {
          "identityName": {
            "Ref": "IdentityName"
          }
        }
      ]
    }
  }
]
```

## SESEmailTemplateCrudPolicy
<a name="ses-email-template-crud-policy"></a>

Amazon SES E メールテンプレートを作成、取得、リスト化、更新、および削除する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "ses:CreateTemplate",
      "ses:GetTemplate",
      "ses:ListTemplates",
      "ses:UpdateTemplate",
      "ses:DeleteTemplate",
      "ses:TestRenderTemplate"
    ],
    "Resource": "*"
  }
]
```

## SESSendBouncePolicy
<a name="ses-send-bounce-policy"></a>

Amazon Simple Email Service (Amazon SES) アイデンティティに SendBounce 許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "ses:SendBounce"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
        {
          "identityName": {
            "Ref": "IdentityName"
          }
        }
      ]
    }
  }
]
```

## SNSCrudPolicy
<a name="sns-crud-policy"></a>

Amazon SNS トピックを作成、公開、およびサブスクライブする許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "sns:ListSubscriptionsByTopic",
      "sns:CreateTopic",
      "sns:SetTopicAttributes",
      "sns:Subscribe",
      "sns:Publish"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}*",
        {
          "topicName": {
            "Ref": "TopicName"
          }
        }
      ]
    }
  }
]
```

## SNSPublishMessagePolicy
<a name="sqs-publish-message-policy"></a>

Amazon Simple Notification Service (Amazon SNS) トピックにメッセージを発行する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "sns:Publish"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}",
        {
          "topicName": {
            "Ref": "TopicName"
          }
        }
      ]
    }
  }
]
```

## SQSPollerPolicy
<a name="sqs-poller-policy"></a>

Amazon Simple Queue Service (Amazon SQS) キューをポーリングする許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "sqs:ChangeMessageVisibility",
      "sqs:ChangeMessageVisibilityBatch",
      "sqs:DeleteMessage",
      "sqs:DeleteMessageBatch",
      "sqs:GetQueueAttributes",
      "sqs:ReceiveMessage"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
        {
          "queueName": {
            "Ref": "QueueName"
          }
        }
      ]
    }
  }
]
```

## SQSSendMessagePolicy
<a name="sqs-send-message-policy"></a>

Amazon SQS キューにメッセージを送信する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "sqs:SendMessage*"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
        {
          "queueName": {
            "Ref": "QueueName"
          }
        }
      ]
    }
  }
]
```

## SSMParameterReadPolicy
<a name="ssm-parameter-read-policy"></a>

このアカウントのシークレットをロードするために、Amazon EC2 Systems Manager (SSM) パラメータストアからのパラメータにアクセスするための許可を付与します。パラメータ名にスラッシュプレフィックスが含まれていない場合に使用します。

**注記**  
デフォルトのキーを使用していない場合は、`KMSDecryptPolicy` ポリシーも必要になります。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "ssm:DescribeParameters"
    ],
    "Resource": "*"
  },
  {
    "Effect": "Allow",
    "Action": [
      "ssm:GetParameters",
      "ssm:GetParameter",
      "ssm:GetParametersByPath"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter/${parameterName}",
        {
          "parameterName": {
            "Ref": "ParameterName"
          }
        }
      ]
    }
  }
]
```

## SSMParameterWithSlashPrefixReadPolicy
<a name="ssm-parameter-slash-read-policy"></a>

このアカウントのシークレットをロードするために、Amazon EC2 Systems Manager (SSM) パラメータストアからのパラメータにアクセスするための許可を付与します。パラメータ名にスラッシュプレフィックスが含まれている場合に使用します。

**注記**  
デフォルトのキーを使用していない場合は、`KMSDecryptPolicy` ポリシーも必要になります。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "ssm:DescribeParameters"
    ],
    "Resource": "*"
  },
  {
    "Effect": "Allow",
    "Action": [
      "ssm:GetParameters",
      "ssm:GetParameter",
      "ssm:GetParametersByPath"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter${parameterName}",
        {
          "parameterName": {
            "Ref": "ParameterName"
          }
        }
      ]
    }
  }
]
```

## StepFunctionsExecutionPolicy
<a name="stepfunctions-execution-policy"></a>

Step Functions ステートマシンの実行を開始する許可を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "states:StartExecution"
    ],
    "Resource": {
      "Fn::Sub": [
        "arn:${AWS::Partition}:states:${AWS::Region}:${AWS::AccountId}:stateMachine:${stateMachineName}",
        {
          "stateMachineName": {
            "Ref": "StateMachineName"
          }
        }
      ]
    }
  }
]
```

## TextractDetectAnalyzePolicy
<a name="textract-detect-analyze-policy"></a>

Amazon Textract でドキュメントを検出して分析するためのアクセス権を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "textract:DetectDocumentText",
      "textract:StartDocumentTextDetection",
      "textract:StartDocumentAnalysis",
      "textract:AnalyzeDocument"
    ],
    "Resource": "*"
  }
]
```

## TextractGetResultPolicy
<a name="textract-get-result-policy"></a>

検出および分析されたドキュメントを Amazon Textract から取得するためのアクセス権を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "textract:GetDocumentTextDetection",
      "textract:GetDocumentAnalysis"
    ],
    "Resource": "*"
  }
]
```

## TextractPolicy
<a name="textract-policy"></a>

Amazon Textract へのフルアクセス権を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "textract:*"
    ],
    "Resource": "*"
  }
]
```

## VPCAccessPolicy
<a name="vpc-access-policy"></a>

Elastic Network Interface を作成、削除、記述、およびデタッチするアクセス権を付与します。

```
"Statement": [
  {
    "Effect": "Allow",
    "Action": [
      "ec2:CreateNetworkInterface",
      "ec2:DeleteNetworkInterface",
      "ec2:DescribeNetworkInterfaces",
      "ec2:DetachNetworkInterface"
    ],
    "Resource": "*"
  }
]
```

# CloudFormation メカニズムによる AWS SAM アクセス許可の管理
<a name="sam-permissions-cloudformation"></a>

 AWS リソースへのアクセスを制御するために、 AWS Serverless Application Model (AWS SAM) は と同じメカニズムを使用できます CloudFormation。詳細については、*AWS CloudFormation ユーザーガイド*の「[Controlling access with AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html)」を参照してください。

サーバーレスアプリケーションを管理するためのユーザー権限の付与には、3 つの主なオプションがあります。各オプションは、ユーザーに異なるレベルのアクセスコントロールを提供します。
+ 管理者権限を付与する。
+ 必要な AWS 管理ポリシーをアタッチします。
+ 特定の AWS Identity and Access Management (IAM) アクセス許可を付与します。

選択したオプションに応じて、ユーザーはアクセス許可を持つ AWS リソースを含むサーバーレスアプリケーションのみを管理できます。

以下のセクションでは、各オプションがより詳しく説明されています。

## 管理者権限を付与する
<a name="sam-permissions-cloudformation-admin"></a>

管理者権限をユーザーに付与すると、 AWS リソースの任意の組み合わせを含むサーバーレスアプリケーションを管理できます。これは最もシンプルなオプションですが、ユーザーに最も広範な許可のセットを付与するため、最も大きな影響を与えるアクションの実行が可能になります。

ユーザーへの管理者権限の付与に関する詳細については、*IAM ユーザーガイド*の「[最初の IAM 管理者ユーザーおよびユーザーグループの作成](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html)」を参照してください。

## 必要な AWS 管理ポリシーをアタッチする
<a name="sam-permissions-cloudformation-managed-policies"></a>

ユーザーに完全な管理者権限を付与するのではなく、[AWS 管理ポリシー](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies)を使用して権限のサブセットを付与することができます。このオプションを使用する場合は、ユーザーが管理するサーバーレスアプリケーションに必要なすべてのアクションとリソースが AWS 管理ポリシーのセットに含まれていることを確認してください。

たとえば、[サンプルの Hello World アプリケーションをデプロイ](serverless-getting-started-hello-world.md)するには、次の AWS 管理ポリシーで十分です。
+ AWSCloudFormationFullAccess
+ IAMFullAccess
+ AWSLambda\$1FullAccess
+ AmazonAPIGatewayAdministrator
+ AmazonS3FullAccess
+ AmazonEC2ContainerRegistryFullAccess

 IAM ユーザーへのポリシーのアタッチに関する詳細については、*IAM ユーザーガイド*の「[IAM ユーザーのアクセス権限の変更](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html)」を参照してください。

## 特定の IAM 許可を付与する
<a name="sam-permissions-cloudformation-policy-statement"></a>

最もきめ細かなレベルのアクセスコントロールには、[ポリシステートメント](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_statement.html)を使用して、ユーザーに特定の IAM 許可を付与することができます。このオプションを使用する場合は、ユーザーが管理するサーバーレスアプリケーションに必要なすべてのアクションとリソースがポリシーステートメントに含まれていることを確認してください。

このオプションのベストプラクティスは、ユーザーが昇格された許可を自分自身に付与できないように、Lambda 実行ロールを含めたロールを作成するための許可をユーザーに付与しないことです。このため、管理者は、ユーザーが管理するサーバーレスアプリケーションで指定される [Lambda 実行ロール](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html)を最初に作成する必要があります。Lambda 実行ロールの作成については、「[IAM コンソールでの実行ロールの作成](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html#permissions-executionrole-console)」を参照してください。

[サンプル Hello World アプリケーション](serverless-getting-started-hello-world.md)の実行には、**AWSLambdaBasicExecutionRole** で十分です。Lambda 実行ロールを作成したら、サンプルの Hello World アプリケーションの AWS SAM テンプレートファイルを変更して、次のプロパティを`AWS::Serverless::Function`リソースに追加します。

```
  Role: lambda-execution-role-arn
```

変更された Hello World アプリケーションを使用すると、以下のポリシーステートメントが、アプリケーションをデプロイ、更新、および削除するために十分な許可をユーザーに付与します。

**注記**  
このセクションのポリシーステートメントの例では、[Hello World アプリケーションのサンプル](serverless-getting-started-hello-world.md)をデプロイ、更新、および削除するための十分な権限を付与します。アプリケーションにリソースタイプを追加する場合は、ポリシーステートメントを更新して以下を含める必要があります。  
アプリケーションがサービスのアクションを呼び出すための権限。
サービスのアクションに必要な場合は、サービスプリンシパル。
例えば、Step Functions ワークフローを追加する場合は、[ここに](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsstepfunctions.html#awsstepfunctions-actions-as-permissions)リストされているアクションに対するアクセス許可と、`states.amazonaws.com` サービスプリンシパルを追加する必要があります。

IAM ポリシーの詳細については、*IAM ユーザーガイド*の「[IAM ポリシーの管理](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html)」を参照してください。