翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# を使用してサーバーレスアプリケーションを開発する AWS SAM
このセクションでは、 AWS SAM テンプレートを検証し、依存関係を使用してアプリケーションを構築する方法について説明します。また、Lambda レイヤーの操作、ネストされたアプリケーションの使用、API Gateway APIs へのアクセスの制御、Step Functions を使用した AWS リソースのオーケストレーション、アプリケーションのコード署名など、特定のユースケース AWS SAM での の使用に関するトピックも含まれています。アプリケーションを開発するために完了する必要がある 3 つの主要なマイルストーンを以下に示します。
**Topics**
+ [でアプリケーションを作成する AWS SAM](using-sam-cli-init.md)
+ [でインフラストラクチャを定義する AWS SAM](serverless-authoring.md)
+ [を使用してアプリケーションを構築する AWS SAM](serverless-building.md)
# でアプリケーションを作成する AWS SAM
[使用を開始](serverless-getting-started.md)し「[( AWS Serverless Application Model AWS SAM) の使用方法](chapter-using-sam.md)」を読み終えれば、デベロッパー環境で AWS SAM プロジェクトを作成する準備が整います。 AWS SAM プロジェクトは、サーバーレスアプリケーションを記述するための出発点として機能します。`sam init` コマンドオプションのリスト AWS SAM CLIについては、「」を参照してください[sam init](sam-cli-command-reference-sam-init.md)。
AWS Serverless Application Model コマンドラインインターフェイス (AWS SAM CLI) `sam init` コマンドには、以下で構成される新しいサーバーレスアプリケーションを初期化するためのオプションが用意されています。
+ インフラストラクチャコードを定義する AWS SAM テンプレート。
+ アプリケーションを整理するフォルダ構造。
+ AWS Lambda 関数の設定。
AWS SAM プロジェクトを作成するには、このセクションのトピックを参照してください。
**注記**
`sam init` には、サポートされているランタイム (TypeScript、Python、Java) で永続的な関数用のプロジェクトテンプレートが含まれています。これらのテンプレートは、ステートフルなサーバーレスアプリケーションを構築するためのスターターコードと設定を提供します。
**Topics**
+ [新しいサーバーレスアプリケーションを初期化する](#using-sam-cli-init-new)
+ [sam init のオプション](#using-sam-cli-init-options)
+ [トラブルシューティング](#using-sam-cli-init-troubleshooting)
+ [例](#using-sam-cli-init-examples)
+ [詳細情報](#using-sam-cli-init-learn)
+ [次の手順](#w2aac18c11c39)
## 新しいサーバーレスアプリケーションを初期化する
**AWS SAM CLI を使用して新しいサーバーレスアプリケーションを初期化するには**
1. `cd` を実行して開始ディレクトリに移動します。
1. コマンドラインで次を実行します。
```
$ sam init
```
1. AWS SAM CLI は、新しいサーバーレスアプリケーションを作成するためのインタラクティブフローを通じてユーザーをガイドします。
**注記**
[チュートリアル: を使用して Hello World アプリケーションをデプロイする AWS SAM](serverless-getting-started-hello-world.md) で説明されているように、このコマンドはサーバーレスアプリケーションを初期化し、プロジェクトディレクトリを作成します。このディレクトリには、ファイルとフォルダがいくつか含まれています。最も重要なファイルは `template.yaml` です。これは AWS SAM テンプレートです。ご使用の Python のバージョンは、**sam init** コマンドで作成された `template.yaml` ファイルにリストされている Python のものと、一致する必要があります。
### 開始テンプレートを選択する
*テンプレート*は次の要素で構成されています。
1. インフラストラクチャコードの AWS SAM テンプレート。
1. プロジェクトファイルを整理する開始プロジェクトディレクトリ。例えば、これには次が含まれる場合があります。
1. Lambda 関数コードとその依存関係の構造。
1. ローカルテスト用のテストイベントを含む `events` フォルダ。
1. ユニットテストをサポートする `tests` フォルダ。
1. プロジェクトの設定を構成する `samconfig.toml` ファイル。
1. `ReadMe` ファイルおよび他の基本的な開始プロジェクトファイル。
開始プロジェクトディレクトリの例を次に示します。
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
利用可能な *AWS クイックスタートテンプレート*のリストから選択することも、*独自のカスタムテンプレートの場所*を指定することもできます。
**AWS クイックスタートテンプレートを選択するには**
1. プロンプトが表示されたら、**[AWS クイックスタートテンプレート]** を選択します。
1. 開始する AWS クイックスタートテンプレートを選択します。以下に例を示します。
```
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
4 - Scheduled task
5 - Standalone function
6 - Data processing
7 - Hello World Example With Powertools
8 - Infrastructure event management
9 - Serverless Connector Hello World Example
10 - Multi-step workflow with Connectors
11 - Lambda EFS example
12 - DynamoDB Example
13 - Machine Learning
Template: 4
```
**独自のカスタムテンプレートの場所を選択するには**
1. プロンプトが表示されたら、**[カスタムテンプレートの場所]** を選択します。
```
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 2
```
1. AWS SAM CLI は、テンプレートの場所を指定するよう促すプロンプトを表示します。
```
Template location (git, mercurial, http(s), zip, path):
```
テンプレート .zip ファイルアーカイブに対して次のいずれかの場所を指定します。
+ **GitHub リポジトリ** – GitHub リポジトリ内の .zip ファイルへのパス。ファイルはリポジトリのルートに存在する必要があります。
+ **Mercurial リポジトリ** – Mercurial リポジトリ内の .zip ファイルへのパス。ファイルはリポジトリのルートに存在する必要があります。
+ **.zip パス** – .zip ファイルへの HTTPS またはローカルパス。
1. AWS SAM CLI は、カスタムテンプレートを使用してサーバーレスアプリケーションを初期化します。
### ランタイムを選択する
*AWS クイックスタートテンプレート*を選択すると、 AWS SAM CLI は Lambda 関数のランタイムを選択するよう促すプロンプトを表示します。 AWS SAM CLI によって表示されるオプションのリストは、Lambda によってネイティブにサポートされるランタイムです。
+ [ランタイム](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-runtime)では、実行環境で実行される言語固有の環境が提供されます。
+ にデプロイされると AWS クラウド、Lambda サービスは[実行環境で](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html)関数を呼び出します。
カスタムランタイムでは他のプログラミング言語を使用できます。これを実行するには、開始アプリケーション構造を手動で作成する必要があります。その後、カスタムテンプレートの場所を設定することで、`sam init` を使用してアプリケーションを迅速に初期化できます。
選択内容に基づいて、 AWS SAM CLI は Lambda 関数コードと依存関係の開始ディレクトリを作成します。
Lambda がランタイムについて複数の依存関係マネージャーをサポートしている場合は、優先する依存関係マネージャーを選択するよう促すプロンプトが表示されます。
### パッケージタイプを選択する
*AWS クイックスタートテンプレート*と*ランタイム*を選択すると、 AWS SAM CLI は*パッケージタイプ*を選択するよう促すプロンプトを表示します。パッケージタイプによって、Lambda サービスで使用するために Lambda 関数がどのようにデプロイされるかが決まります。サポートされているパッケージタイプは次の 2 つです。
1. **コンテナイメージ** – 基本オペレーティングシステム、ランタイム、Lambda 拡張機能、アプリケーションコード、およびその依存関係が含まれています。
1. **.zip ファイルアーカイブ** – アプリケーション コードとその依存関係が含まれます。
デプロイパッケージタイプの詳細については、「*AWS Lambda デベロッパーガイド*」の「[Lambda デプロイパッケージ](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html)」を参照してください。
Lambda 関数がコンテナイメージとしてパッケージ化されたアプリケーションのディレクトリ構造の例を次に示します。はイメージ AWS SAM CLIをダウンロードし、関数の ディレクトリ`Dockerfile`に を作成してイメージを指定します。
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── Dockerfile
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
└── unit
├── __init__.py
└── test_handler.py
```
関数が .zip ファイルアーカイブとしてパッケージ化されたアプリケーションのディレクトリ構造の例を次に示します。
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
### AWS X-Ray トレースを設定する
AWS X-Ray トレースをアクティブ化することを選択できます。詳細については、「 *AWS X-Ray デベロッパーガイド*」の[「What is AWS X-Ray?](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html)」を参照してください。
アクティブ化すると、 AWS SAM CLI は AWS SAM テンプレートを設定します。以下に例を示します。
```
Globals:
Function:
...
Tracing: Active
Api:
TracingEnabled: True
```
### Amazon CloudWatch Application Insights でモニタリングを設定する
Amazon CloudWatch Application Insights を使用してモニタリングをアクティブ化することを選択できます。詳細については、「*Amazon CloudWatch ユーザーガイド*」の「[Amazon CloudWatch Application Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html)」を参照してください。
アクティブ化すると、 AWS SAM CLI は AWS SAM テンプレートを設定します。以下に例を示します。
```
Resources:
ApplicationResourceGroup:
Type: AWS::ResourceGroups::Group
Properties:
Name:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
ResourceQuery:
Type: CLOUDFORMATION_STACK_1_0
ApplicationInsightsMonitoring:
Type: AWS::ApplicationInsights::Application
Properties:
ResourceGroupName:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
AutoConfigurationEnabled: 'true'
DependsOn: ApplicationResourceGroup
```
### アプリケーションに名前を付ける
アプリケーションの名前を入力します。 AWS SAM CLI は、この名前を使用してアプリケーションの最上位フォルダを作成します。
## sam init のオプション
`sam init` コマンドで使用できる主なオプションの一部を次に示します。すべてのオプションのリストについては、「[sam init](sam-cli-command-reference-sam-init.md)」を参照してください。
### カスタムテンプレートの場所を使用してアプリケーションを初期化する
`--location` オプションを使用して、サポートされているカスタムテンプレートの場所を指定します。以下に例を示します。
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
### インタラクティブフローを使用せずにアプリケーションを初期化する
`--no-interactive` オプションを使用して、コマンドラインで設定の選択内容を指定し、インタラクティブフローをスキップします。以下に例を示します。
```
$ sam init --no-interactive --runtime go1.x --name go-demo --dependency-manager mod --app-template hello-world
```
## トラブルシューティング
のトラブルシューティングについては AWS SAM CLI、「」を参照してください[AWS SAMCLI トラブルシューティング](sam-cli-troubleshooting.md)。
## 例
### Hello World AWS Starter Template を使用して新しいサーバーレスアプリケーションを初期化する
この例については、「*チュートリアル: Hello World アプリケーションのデプロイ*」の「[ステップ 1: サンプルの Hello World アプリケーションを初期化する](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-init)」を参照してください。
### カスタムテンプレートの場所を使用して新しいサーバーレスアプリケーションを初期化する
カスタムテンプレートに GitHub の場所を提供する例を次に示します。
```
$ sam init --location gh:aws-samples/cookiecutter-aws-sam-python
$ sam init --location git+sh://git@github.com/aws-samples/cookiecutter-aws-sam-python.git
$ sam init --location hg+ssh://hg@bitbucket.org/repo/template-name
```
ローカルファイルパスの例を次に示します。
```
$ sam init --location /path/to/template.zip
```
HTTPS によって到達可能なパスの例を次に示します。
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
## 詳細情報
`sam init` コマンドの使用方法の詳細については、次を参照してください。
+ **[学習 AWS SAM: sam init](https://www.youtube.com/watch?v=9m3R-leD5Xo) ** – でのServerless Land「学習 AWS SAM」シリーズYouTube。
+ **[AWS SAM CLI で使用するサーバーレスアプリケーションの構築 (SAM S2E7 を使用したセッション)](https://www.youtube.com/watch?v=k9IRdgze9fQ)** – YouTube の AWS SAM を使用したセッションのシリーズ。
## 次の手順
AWS SAM プロジェクトを作成したら、アプリケーションの作成を開始する準備が整いました。これを行うために必要なタスクの詳細については、「[でインフラストラクチャを定義する AWS SAM](serverless-authoring.md)」を参照してください。
# でインフラストラクチャを定義する AWS SAM
プロジェクトを作成したら、 を使用してアプリケーションインフラストラクチャを定義する準備が整いました AWS SAM。これを行うには、 AWS SAM テンプレートを設定して、 AWS SAM プロジェクトの `template.yaml` ファイルであるアプリケーションのリソースとプロパティを定義します。
このセクションのトピックでは、 AWS SAM テンプレート ( `template.yaml` ファイル) でインフラストラクチャを定義する方法について説明します。また、Lambda レイヤーの操作、ネストされたアプリケーションの使用、API Gateway APIs へのアクセスの制御、Step Functions を使用したリソースのオーケストレーション、アプリケーションへのコード署名、 AWS SAM テンプレートの検証など、特定のユースケースの AWS リソースの定義に関するトピックも含まれています。
**Topics**
+ [AWS SAM テンプレートでアプリケーションリソースを定義する](authoring-define-resources.md)
+ [AWS SAM テンプレートでのリソースアクセスの設定と管理](sam-permissions.md)
+ [AWS SAM テンプレートを使用して API アクセスを制御する](serverless-controlling-access-to-apis.md)
+ [で Lambda レイヤーを使用して効率を向上させる AWS SAM](serverless-sam-cli-layers.md)
+ [でネストされたアプリケーションを使用してコードとリソースを再利用する AWS SAM](serverless-sam-template-nested-applications.md)
+ [で EventBridge スケジューラを使用して時間ベースのイベントを管理する AWS SAM](using-eventbridge-scheduler.md)
+ [を使用した AWS SAM リソースのオーケストレーション AWS Step Functions](serverless-step-functions-in-sam.md)
+ [AWS SAM アプリケーションのコード署名を設定する](authoring-codesigning.md)
+ [AWS SAM テンプレートファイルを検証する](serverless-sam-cli-using-validate.md)
# AWS SAM テンプレートでアプリケーションリソースを定義する
サーバーレスアプリケーションが使用する AWS リソースは、 AWS SAM テンプレートの `Resources`セクションで定義します。リソースを定義する際は、リソースとは何か、他のリソースとやり取りする方法、およびリソースへのアクセス方法 (リソースのアクセス許可) を特定します。
AWS SAM テンプレートの `Resources`セクションには、 CloudFormation リソースと AWS SAM リソースの組み合わせを含めることができます。さらに、次のリソースに AWS SAMの短縮構文を使用できます。
| AWS SAM 短縮構文 | 関連 AWS リソースでの動作 |
| --- | --- |
| [AWS::Serverless::Api](sam-resource-api.md) | HTTPS エンドポイント経由で呼び出すことができる API Gateway リソースとメソッドのコレクションを作成します。 |
| [AWS::Serverless::Application](sam-resource-application.md) | [AWS Serverless Application Repository](https://serverlessrepo.aws.amazon.com/applications) から、または Amazon S3 バケットからのサーバーレスアプリケーションを、ネストされたアプリケーションとして埋め込みます。 |
| [AWS::Serverless::Connector](sam-resource-connector.md) | 2 つのリソース間のアクセス許可を設定します。コネクタの概要については、「[AWS SAM コネクタを使用したリソースアクセス許可の管理](managing-permissions-connectors.md)」を参照してください。 |
| [AWS::Serverless::Function](sam-resource-function.md) | AWS Lambda 関数、 AWS Identity and Access Management (IAM) 実行ロール、および関数をトリガーするイベントソースマッピングを作成します。 |
| [AWS::Serverless::GraphQLApi](sam-resource-graphqlapi.md) | は、 AWS AppSync GraphQLサーバーレスアプリケーションの API を作成して設定します。 |
| [AWS::Serverless::HttpApi](sam-resource-httpapi.md) | REST API よりもレイテンシーとコストが低い RESTful API を作成できる Amazon API Gateway HTTP API を作成します。 |
| [AWS::Serverless::LayerVersion](sam-resource-layerversion.md) | Lambda 関数に必要なライブラリまたはランタイムコードが含まれる Lambda LayerVersion を作成します。 |
| [AWS::Serverless::SimpleTable](sam-resource-simpletable.md) | 単一属性のプライマリキーで DynamoDB テーブルを作成します。 |
| [AWS::Serverless::StateMachine](sam-resource-statemachine.md) | AWS Step Functions ステートマシンを作成します。ステートマシンを使用して、 AWS Lambda 関数やその他の AWS リソースをオーケストレーションし、複雑で堅牢なワークフローを形成できます。 |
上記のリソースは、[AWS SAM リソースとプロパティ](sam-specification-resources-and-properties.md) にも記載されています。
すべての AWS リソースおよびプロパティタイプ CloudFormation と AWS SAM サポートのリファレンス情報については、*AWS CloudFormation 「 ユーザーガイド*」の[AWS 「リソースおよびプロパティタイプのリファレンス](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html)」を参照してください。
# AWS SAM テンプレートでのリソースアクセスの設定と管理
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 コネクタ
コネクタを使用することで、2 つのリソース間の許可をプロビジョニングできます。そのためには、 AWS SAM テンプレート内で相互にやり取りする方法を説明します。これらは、`Connectors` リソース属性または `AWS::Serverless::Connector` リソースタイプのいずれかを使用して定義できます。コネクタは、 AWS リソースの組み合わせ間のデータとイベントのプロビジョニングと`Read``Write`アクセスをサポートします。 AWS SAM コネクタの詳細については、「」を参照してください[AWS SAM コネクタを使用したリソースアクセス許可の管理](managing-permissions-connectors.md)。
## AWS SAM ポリシーテンプレート
AWS SAM ポリシーテンプレートは、関数、 AWS Step Functions ステートマシン、および AWS Lambda それらが操作するリソース間のアクセスとアクセス許可を管理するためにテンプレートに追加 AWS SAM できるアクセス許可の事前定義されたセットです。 AWS SAM ポリシーテンプレートの詳細については、「」を参照してください[AWS SAMポリシーテンプレート](serverless-policy-templates.md)。
## AWS CloudFormation メカニズム
CloudFormation メカニズムには、 AWS リソース間のアクセス許可を管理するための IAM ユーザー、ロール、ポリシーの設定が含まれます。詳細については[CloudFormation メカニズムによる AWS SAM アクセス許可の管理](sam-permissions-cloudformation.md)を参照してください。
## ベストプラクティス
サーバーレスアプリケーション全体で、複数の方法を使用してリソース間のアクセス許可を設定できます。そのため、各シナリオに最適なオプションを選択し、アプリケーション全体で複数のオプションを一緒に使用できます。最適なオプションを選択する際に留意すべき点がいくつかあります。
+ 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 コネクタを使用したリソースアクセス許可の管理
コネクタは、 として識別される AWS Serverless Application Model (AWS SAM) 抽象リソースタイプであり`AWS::Serverless::Connector`、サーバーレスアプリケーションリソース間にシンプルで適切な範囲のアクセス許可を提供します。
## AWS SAM コネクタの利点
コネクタは、リソース間で適切なアクセスポリシーを自動的に作成することで、 AWS 認可機能、ポリシー言語、サービス固有のセキュリティ設定に関する専門知識を必要とせずに、サーバーレスアプリケーションを作成し、アプリケーションアーキテクチャに集中できます。したがって、コネクタは、サーバーレス開発に慣れていない開発者や、開発速度を上げたいと考えている経験豊富な開発者にとって大きなメリットです。
## AWS SAM コネクタの使用
`Connectors` リソース属性を**ソース**リソース内に埋め込んで使用します。次に、**送信先**リソースを定義し、それらのリソース間でデータまたはイベントがどのように流れるかを記述します。 AWS SAM 次に、 は、必要なやり取りを容易にするために必要なアクセスポリシーを構成します。
以下に、このリソース属性の記述方法の概要を示します。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
Destination:
Permissions:
...
```
## コネクタの仕組み
**注記**
このセクションでは、コネクタがバックグラウンドで必要なリソースをプロビジョニングする方法について説明します。これは、コネクタを使用する際に自動的に実行されます。
まず、埋め込まれた `Connectors` リソース属性が `AWS::Serverless::Connector` リソースタイプに変換されます。その論理 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)」を参照してください。
## コネクタの例
次の例は、コネクタを使用して 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 は、この接続が機能するために必要なアクセスポリシーを自動的に作成します。
## 送信元リソースと送信先リソースの間でサポートされている接続
コネクタは、ソースと送信先のリソース接続の選択された組み合わせの間におけるデータとイベントの `Read` および `Write` 許可タイプをサポートします。例えば、コネクタは `AWS::ApiGateway::RestApi` ソースリソースと `AWS::Lambda::Function` 送信先リソースの間の `Write` 接続をサポートします。
ソースリソースと送信先リソースは、サポートされているプロパティを組み合わせて定義できます。プロパティの要件は、使用する接続と、リソースが定義されている場所によって異なります。
**注記**
コネクタは、サポートされているサーバーレスリソースタイプと非サーバーレスリソースタイプの間の許可をプロビジョニングできます。
サポートされているリソース接続とそのプロパティの要件のリストについては、「[コネクタに対してサポートされている送信元リソースと送信先リソースのタイプ](reference-sam-connector.md#supported-connector-resource-types)」を参照してください。
# で読み取りおよび書き込みアクセス許可を定義する AWS SAM
では 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
ソースリソースと送信先リソースの両方について、同じテンプレート内で定義されている場合は、`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:
:
Type:
...
Connectors:
:
Properties:
SourceReference:
Qualifier:
Destination:
Permissions:
```
`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
ソースリソース内で、それぞれが異なる宛先リソースを持つ複数のコネクタを定義できます。
```
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
ソースリソース内で、複数の宛先リソースを持つ単一のコネクタを定義できます。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
リソース用にリソース属性を定義して、追加の動作や関係を指定できます。リソース属性の詳細については、「*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)」を参照してください。
## 詳細情報
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)
## フィードバックを送信する
コネクタに関するフィードバックを提供するには、*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ポリシーテンプレート
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)リンクを使用してください。
## 構文
AWS SAM テンプレートファイルで指定するポリシーテンプレートごとに、ポリシーテンプレートのプレースホルダー値を含むオブジェクトを常に指定する必要があります。ポリシーテンプレートにプレースホルダ値が必要ない場合は、空のオブジェクトを指定する必要があります。
### YAML
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Policies:
- PolicyTemplateName1: # Policy template with placeholder value
Key1: Value1
- PolicyTemplateName2: {} # Policy template with no placeholder value
```
**注記**
通常の IAM ポリシーを設定している場合、または Lambda 経由で管理ポリシーを設定している場合は、空のオブジェクトを使用せずにポリシーテンプレートを設定できます。
## 例
### 例 1: プレースホルダー値が含まれるポリシーテンプレート
以下の例は、[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: プレースホルダー値が含まれないポリシーテンプレート
以下の例には、プレースホルダー値がない [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 ポリシーを含むポリシーテンプレート
次の例には、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
```
## ポリシーテンプレート表
以下は、使用可能なポリシーテンプレートの表です。
****
| ポリシーテンプレート | 説明 |
| --- | --- |
| [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 を作成、削除、記述、およびデタッチするアクセス権を付与します。 |
## トラブルシューティング
### SAM CLI エラー:「Must specify valid parameter values for policy template '」
`sam build` の実行時に、以下のエラーが表示されます。
```
"Must specify valid parameter values for policy template ''"
```
これは、プレースホルダ値がないポリシーテンプレートを宣言したときに、空のオブジェクトが渡されなかったことを意味します。
これを修正するには、以下の [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy) 例のようにポリシーを宣言します。
```
1. MyFunction:
2. Policies:
3. - CloudWatchPutMetricPolicy: {}
```
# AWS SAM ポリシーテンプレートリスト
以下は、使用可能なポリシーテンプレートと、それぞれに適用されるアクセス許可です。 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
証明書を読み取るアクセス許可を付与します AWS Certificate Manager。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"acm:GetCertificate"
],
"Resource": {
"Fn::Sub": [
"${certificateArn}",
{
"certificateArn": {
"Ref": "CertificateArn"
}
}
]
}
}
]
```
## AMIDescribePolicy
Amazon マシンイメージ (AMI) を記述する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeImages"
],
"Resource": "*"
}
]
```
## AthenaQueryPolicy
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
指定されたシークレットの AWS Secrets Manager シークレット値を取得するアクセス許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": {
"Fn::Sub": [
"${secretArn}",
{
"secretArn": {
"Ref": "SecretArn"
}
}
]
}
}
]
```
## AWSSecretsManagerRotationPolicy
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
CloudFormation スタックを記述するアクセス許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:cloudformation:${AWS::Region}:${AWS::AccountId}:stack/*"
}
}
]
```
## CloudWatchDashboardPolicy
CloudWatch ダッシュボードで操作を行うためのメトリクスを配置する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetDashboard",
"cloudwatch:ListDashboards",
"cloudwatch:PutDashboard",
"cloudwatch:ListMetrics"
],
"Resource": "*"
}
]
```
## CloudWatchDescribeAlarmHistoryPolicy
Amazon CloudWatch のアラーム履歴を記述する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:DescribeAlarmHistory"
],
"Resource": "*"
}
]
```
## CloudWatchPutMetricPolicy
CloudWatch にメトリクスを送信する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*"
}
]
```
## CodePipelineLambdaExecutionPolicy
によって呼び出された Lambda 関数 AWS CodePipeline に、ジョブのステータスを報告するアクセス許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:PutJobSuccessResult",
"codepipeline:PutJobFailureResult"
],
"Resource": "*"
}
]
```
## CodePipelineReadOnlyPolicy
CodePipeline パイプラインの詳細を取得するための読み取り許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:ListPipelineExecutions"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codepipeline:${AWS::Region}:${AWS::AccountId}:${pipelinename}",
{
"pipelinename": {
"Ref": "PipelineName"
}
}
]
}
}
]
```
## CodeCommitCrudPolicy
特定の 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
特定の 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
エンティティ、キーフレーズ、言語、およびセンチメントを検出する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"comprehend:BatchDetectKeyPhrases",
"comprehend:DetectDominantLanguage",
"comprehend:DetectEntities",
"comprehend:BatchDetectEntities",
"comprehend:DetectKeyPhrases",
"comprehend:DetectSentiment",
"comprehend:BatchDetectDominantLanguage",
"comprehend:BatchDetectSentiment"
],
"Resource": "*"
}
]
```
## CostExplorerReadOnlyPolicy
請求履歴の読み取り専用 AWS Cost Explorer (Cost Explorer) APIs に読み取り専用アクセス許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ce:GetCostAndUsage",
"ce:GetDimensionValues",
"ce:GetReservationCoverage",
"ce:GetReservationPurchaseRecommendation",
"ce:GetReservationUtilization",
"ce:GetTags"
],
"Resource": "*"
}
]
```
## DynamoDBBackupFullAccessPolicy
テーブルの 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
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
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
DynamoDB テーブルを再構成する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateTable"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBRestoreFromBackupPolicy
バックアップから 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
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
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
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
Amazon Elastic Compute Cloud (Amazon EC2) インスタンスを記述する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeRegions",
"ec2:DescribeInstances"
],
"Resource": "*"
}
]
```
## EcsRunTaskPolicy
タスク定義の新しいタスクを開始する許可を付与します。
```
"Statement": [
{
"Action": [
"ecs:RunTask"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ecs:${AWS::Region}:${AWS::AccountId}:task-definition/${taskDefinition}",
{
"taskDefinition": {
"Ref": "TaskDefinition"
}
}
]
},
"Effect": "Allow"
}
]
```
## EFSWriteAccessPolicy
書き込みアクセス権と共に 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
Amazon Elastic Kubernetes Service (Amazon EKS) クラスターを記述またはリスト化する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster",
"eks:ListClusters"
],
"Resource": "*"
}
]
```
## ElasticMapReduceAddJobFlowStepsPolicy
実行中のクラスターに新しいステップを追加する許可を付与します。
```
"Statement": [
{
"Action": "elasticmapreduce:AddJobFlowSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceCancelStepsPolicy
実行中のクラスターで保留中のステップ (1 つ、または複数) をキャンセルする許可を付与します。
```
"Statement": [
{
"Action": "elasticmapreduce:CancelSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceFleetPolicy
クラスター内のインスタンスフリートの詳細をリスト化し、容量を変更する許可を付与します。
```
"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
クラスター内のインスタンスグループの詳細をリスト化し、設定を変更する許可を付与します。
```
"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
クラスターの終了保護を設定する許可を付与します。
```
"Statement": [
{
"Action": "elasticmapreduce:SetTerminationProtection",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceTerminateJobFlowsPolicy
クラスターをシャットダウンする許可を付与します。
```
"Statement": [
{
"Action": "elasticmapreduce:TerminateJobFlows",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticsearchHttpPostPolicy
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
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
指定されたロググループからの 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
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
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
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
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
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
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
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
すべてのアプリケーションリソースのイベントデータを配置するための書き込み専用許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobileanalytics:PutEvents"
],
"Resource": "*"
}
]
```
## OrganizationsListAccountsPolicy
子アカウントの名前と ID を一覧表示する読み取り専用許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"organizations:ListAccounts"
],
"Resource": "*"
}
]
```
## PinpointEndpointAccessPolicy
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
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
顔、ラベル、およびテキストを検出する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels",
"rekognition:DetectText"
],
"Resource": "*"
}
]
```
## RekognitionFacesManagementPolicy
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
顔とラベルを比較および検出する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces"
],
"Resource": "*"
}
]
```
## RekognitionLabelsPolicy
オブジェクトとモデレーションラベルを検出する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": "*"
}
]
```
## RekognitionNoDataAccessPolicy
顔とラベルを比較および検出する許可を付与します。
```
"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
顔をリスト化して検索する許可を付与します。
```
"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
顔のコレクションを作成してインデックス化する許可を付与します。
```
"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
Route 53 のリソースレコードセットを変更する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"route53:ChangeResourceRecordSets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:route53:::hostedzone/${HostedZoneId}",
{
"HostedZoneId": {
"Ref": "HostedZoneId"
}
}
]
}
}
]
```
## S3CrudPolicy
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
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
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
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
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
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
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
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
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
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
Amazon SES E メールテンプレートを作成、取得、リスト化、更新、および削除する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:CreateTemplate",
"ses:GetTemplate",
"ses:ListTemplates",
"ses:UpdateTemplate",
"ses:DeleteTemplate",
"ses:TestRenderTemplate"
],
"Resource": "*"
}
]
```
## SESSendBouncePolicy
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
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
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
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
Amazon SQS キューにメッセージを送信する許可を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:SendMessage*"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SSMParameterReadPolicy
このアカウントのシークレットをロードするために、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
このアカウントのシークレットをロードするために、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
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
Amazon Textract でドキュメントを検出して分析するためのアクセス権を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:DetectDocumentText",
"textract:StartDocumentTextDetection",
"textract:StartDocumentAnalysis",
"textract:AnalyzeDocument"
],
"Resource": "*"
}
]
```
## TextractGetResultPolicy
検出および分析されたドキュメントを Amazon Textract から取得するためのアクセス権を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:GetDocumentTextDetection",
"textract:GetDocumentAnalysis"
],
"Resource": "*"
}
]
```
## TextractPolicy
Amazon Textract へのフルアクセス権を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:*"
],
"Resource": "*"
}
]
```
## VPCAccessPolicy
Elastic Network Interface を作成、削除、記述、およびデタッチするアクセス権を付与します。
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DetachNetworkInterface"
],
"Resource": "*"
}
]
```
# CloudFormation メカニズムによる AWS SAM アクセス許可の管理
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 リソースを含むサーバーレスアプリケーションのみを管理できます。
以下のセクションでは、各オプションがより詳しく説明されています。
## 管理者権限を付与する
管理者権限をユーザーに付与すると、 AWS リソースの任意の組み合わせを含むサーバーレスアプリケーションを管理できます。これは最もシンプルなオプションですが、ユーザーに最も広範な許可のセットを付与するため、最も大きな影響を与えるアクションの実行が可能になります。
ユーザーへの管理者権限の付与に関する詳細については、*IAM ユーザーガイド*の「[最初の IAM 管理者ユーザーおよびユーザーグループの作成](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html)」を参照してください。
## 必要な AWS 管理ポリシーをアタッチする
ユーザーに完全な管理者権限を付与するのではなく、[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 許可を付与する
最もきめ細かなレベルのアクセスコントロールには、[ポリシステートメント](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)」を参照してください。
# AWS SAM テンプレートを使用して API アクセスを制御する
API Gateway API へのアクセスを制御すると、サーバーレスアプリケーションの安全性を担保し、有効化されている認証を通じてのみアクセスが行われることを保証できます。 AWS SAM テンプレートで認可を有効にして、API Gateway APIs にアクセスできるユーザーを制御できます。
AWS SAM は、API Gateway APIs へのアクセスを制御するためのいくつかのメカニズムをサポートしています。サポートされているメカニズムのセットは、`AWS::Serverless::HttpApi` と `AWS::Serverless::Api` のリソースタイプ間で異なります。
以下の表は、各リソースタイプがサポートするメカニズムの要約です。
| アクセスを制御するためのメカニズム | AWS::Serverless::HttpApi | AWS::Serverless::Api |
| --- | --- | --- |
| Lambda オーソライザー | ✓ | ✓ |
| IAM アクセス許可 | | ✓ |
| Amazon Cognito ユーザープール | ✓ \$1 | ✓ |
| API キー | | ✓ |
| リソースポリシー | | ✓ |
| OAuth 2.0/JWT オーソライザー | ✓ | |
\$1 `AWS::Serverless::HttpApi` リソースタイプでは、JSON Web トークン (JWT) 発行者として Amazon Cognito を使用できます。
+ **Lambda オーソライザー** - Lambda オーソライザー (これまで *カスタムオーソライザー* と呼ばれていたもの) は、API へのアクセスを制御するためにユーザーが提供する Lambda 関数です。API が呼び出されると、クライアントアプリケーションが提供するリクエストコンテキストまたは認可トークンによって、この Lambda 関数が呼び出されます。Lambda 関数は、発信者がリクエストされたオペレーションの実行を許可されているかどうかについて応答します。
`AWS::Serverless::HttpApi` と `AWS::Serverless::Api` リソースタイプの両方が Lambda オーソライザーをサポートします。
`AWS::Serverless::HttpApi` での Lambda オーソライザーの詳細については、*API Gateway デベロッパーガイド*の「[AWS Lambda オーソライザーを使用する](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html)」で HTTP API について参照してください。`AWS::Serverless::Api` での Lambda オーソライザーの詳細については、*API Gateway デベロッパーガイド*の「[API Gateway Lambda オーソライザーを使用する](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html)」を参照してください。
どちらか一方のリソースタイプ向けの Lambda オーソライザーの例については、「[の Lambda オーソライザーの例 AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)」を参照してください。
+ **IAM 許可** - [AWS Identity and Access Management (IAM) 許可](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html)を使用して、API を呼び出すことができるユーザーを制御できます。API を呼び出すユーザーは、IAM 認証情報を使用して認証される必要があります。API の呼び出しは、API 発信者を表す IAM ユーザー、ユーザーが含まれる IAM グループ、またはユーザーが引き受ける IAM ロールに IAM ポリシーがアタッチされていなければ成功しません。
IAM 許可をサポートするのは、`AWS::Serverless::Api` リソースタイプのみです。
詳細については、*API Gateway デベロッパーガイド*の「[IAM アクセス許可により API へのアクセスを制御する](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html)」を参照してください。例については、[の IAM アクセス許可の例 AWS SAM](serverless-controlling-access-to-apis-permissions.md)を参照してください。
+ **Amazon Cognito ユーザープール** - Amazon Cognito ユーザープールは、Amazon Cognito 内のユーザーディレクトリです。API のクライアントは、まずユーザーをユーザープールにサインインし、ユーザーのアイデンティティまたはアクセストークンを取得する必要があります。その後、返されたトークンの 1 つを使用して、クライアントが API を呼び出します。API コールは、必要なトークンが有効な場合にのみ成功します。
`AWS::Serverless::Api` リソースタイプが Amazon Cognito ユーザープールをサポートします。`AWS::Serverless::HttpApi` リソースタイプは、JWT 発行者としての Amazon Cognito の使用をサポートします。
詳細については、*API Gateway デベロッパーガイド*の「[Amazon Cognito ユーザープールをオーソライザーとして使用して REST API へのアクセスを制御する](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html)」を参照してください 例については、[の Amazon Cognito ユーザープールの例 AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md)を参照してください。
+ **API キー** - API キーは、API へのアクセス権を付与するためにアプリケーションデベロッパーのお客様に配信する、英数字の文字列値です。
API キーをサポートするのは、`AWS::Serverless::Api` リソースタイプのみです。
詳細については、*API Gateway デベロッパーガイド*の「[API キーを使用した使用量プランの作成と使用](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html)」を参照してください。API キーの例については、「[の API キーの例 AWS SAM](serverless-controlling-access-to-apis-keys.md)」を参照してください。
+ **リソースポリシー** - リソースポリシーは、API Gateway API にアタッチできる JSON ポリシードキュメントです。リソースポリシーは、指定されたプリンシパル (通常は IAM のユーザーまたはロール) が API を呼び出せるかどうかを制御します。
API Gateway API へのアクセスを制御するメカニズムとしてのリソースポリシーをサポートするのは、`AWS::Serverless::Api` リソースタイプのみです。
リソースポリシーの詳細については、*API Gateway デベロッパーガイド*の「[API Gateway リソースポリシーを使用して API へのアクセスを制御する](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html)」を参照してください。リソースポリシーの例については、「[のリソースポリシーの例 AWS SAM](serverless-controlling-access-to-apis-resource-policies.md)」を参照してください。
+ **OAuth 2.0/JWT オーソライザー** - [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) および [OAuth 2.0](https://oauth.net/2/) フレームワークの一部として JWT を使用して、API へのアクセスを制御できます。API Gateway は、クライアントが API リクエストと共に送信する JWT を検証し、トークン検証、およびオプションでトークン内のスコープに基づいて、リクエストを許可または拒否します。
OAuth 2.0/JWT オーソライザーをサポートするのは、`AWS::Serverless::HttpApi` リソースタイプのみです。
詳細については、*API Gateway デベロッパーガイド*の「[JWT オーソライザーを使用した HTTP API へのアクセスの制御](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html)」を参照してください。例については、[の OAuth 2.0/JWT オーソライザーの例 AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md)を参照してください。
## アクセスを制御するためのメカニズムの選択
API Gateway API へのアクセスを制御するために選択するメカニズムは、いくつかの要因に応じて異なります。例えば、認可またはアクセスコントロールが設定されていないグリーンフィールドプロジェクトの場合は、Amazon Cognito ユーザープールが最適なオプションになり得ます。ユーザープールのセットアップ時には、認証とアクセスコントロールがどちらも自動的にセットアップされるからです。
ただし、アプリケーションで認証がすでにセットアップされている場合は、Lambda オーソライザーの使用が最適なオプションになり得ます。これは、既存の認証サービスを呼び出し、レスポンスに基づいてポリシードキュメントを返すことができるためです。また、アプリケーションに、ユーザープールがサポートしないカスタム認証またはアクセスコントロールロジックが必要な場合は、Lambda オーソライザーが最適なオプションになり得ます。
使用するメカニズムを選択したら、 を使用してそのメカニズムを使用するようにアプリケーション AWS SAM を設定する方法については、 [例](#serverless-controlling-access-to-apis-examples)の対応するセクションを参照してください。
## エラーレスポンスのカスタマイズ
を使用して AWS SAM 、一部の API Gateway エラーレスポンスの内容をカスタマイズできます。カスタマイズされた API Gateway レスポンスをサポートするのは、`AWS::Serverless::Api` リソースタイプのみです。
API Gateway レスポンスの詳細については、*API Gateway デベロッパーガイド*の「[API Gateway でのゲートウェイレスポンス](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html)」を参照してください。カスタマイズされたレスポンスの例については、「[のカスタマイズされたレスポンスの例 AWS SAM](serverless-controlling-access-to-apis-customize-response.md)」を参照してください。
## 例
+ [の Lambda オーソライザーの例 AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)
+ [の IAM アクセス許可の例 AWS SAM](serverless-controlling-access-to-apis-permissions.md)
+ [の Amazon Cognito ユーザープールの例 AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md)
+ [の API キーの例 AWS SAM](serverless-controlling-access-to-apis-keys.md)
+ [のリソースポリシーの例 AWS SAM](serverless-controlling-access-to-apis-resource-policies.md)
+ [の OAuth 2.0/JWT オーソライザーの例 AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md)
+ [のカスタマイズされたレスポンスの例 AWS SAM](serverless-controlling-access-to-apis-customize-response.md)
# の Lambda オーソライザーの例 AWS SAM
`AWS::Serverless::Api` リソースタイプは、`TOKEN` オーソライザーと `REQUEST` オーソライザーの 2 つのタイプの Lambda オーソライザーをサポートします。`AWS::Serverless::HttpApi` リソースタイプは `REQUEST` オーソライザーのみをサポートします。以下は、各タイプの例です。
## Lambda `TOKEN` オーソライザーの例 (AWS::Serverless::Api)
AWS SAM テンプレート内で Lambda `TOKEN`オーソライザーを定義することで、APIs へのアクセスを制御できます。これを実行するには、[ApiAuth](sam-property-api-apiauth.md) データ型を使用します。
以下は、Lambda `TOKEN`オーソライザーの AWS SAM テンプレートセクションの例です。
**注記**
次の例では、SAM `FunctionRole` が暗黙的に生成されます。
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaTokenAuthorizer
Authorizers:
MyLambdaTokenAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
Lambda オーソライザーの詳細については、*API Gateway デベロッパーガイド*の「[API Gateway Lambda オーソライザーを使用する](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html)」を参照してください。
## Lambda `REQUEST` オーソライザーの例 (AWS::Serverless::Api)
AWS SAM テンプレート内で Lambda `REQUEST`オーソライザーを定義することで、APIs へのアクセスを制御できます。これを実行するには、[ApiAuth](sam-property-api-apiauth.md) データ型を使用します。
以下は、Lambda `REQUEST`オーソライザーの AWS SAM テンプレートセクションの例です。
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionPayloadType: REQUEST
FunctionArn: !GetAtt MyAuthFunction.Arn
Identity:
QueryStrings:
- auth
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
Lambda オーソライザーの詳細については、*API Gateway デベロッパーガイド*の「[API Gateway Lambda オーソライザーを使用する](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html)」を参照してください。
## Lambda オーソライザーの例 (AWS::Serverless::HttpApi)
AWS SAM テンプレート内で Lambda オーソライザーを定義することで、HTTP APIs へのアクセスを制御できます。これを実行するには、[HttpApiAuth](sam-property-httpapi-httpapiauth.md) データ型を使用します。
以下は、Lambda オーソライザーの AWS SAM テンプレートセクションの例です。
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
FunctionInvokeRole: !GetAtt MyAuthFunctionRole.Arn
Identity:
Headers:
- Authorization
AuthorizerPayloadFormatVersion: 2.0
EnableSimpleResponses: true
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: HttpApi
Properties:
ApiId: !Ref MyApi
Path: /
Method: get
PayloadFormatVersion: "2.0"
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
# の IAM アクセス許可の例 AWS SAM
API へのアクセスは、 AWS SAM テンプレート内で IAM 許可を定義することによって制御できます。これを実行するには、[ApiAuth](sam-property-api-apiauth.md) データ型を使用します。
IAM アクセス許可に を使用する AWS SAM テンプレートの例を次に示します。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Description: 'API with IAM authorization'
Auth:
DefaultAuthorizer: AWS_IAM #sets AWS_IAM auth for all methods in this API
MyFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.10
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
```
IAM 許可の詳細については、*API Gateway デベロッパーガイド*の「[API を呼び出すためのアクセスの制御](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html)」を参照してください。
# の Amazon Cognito ユーザープールの例 AWS SAM
API へのアクセスは、 AWS SAM テンプレート内で Amazon Cognito ユーザープールを定義することによって制御できます。これを実行するには、[ApiAuth](sam-property-api-apiauth.md) データ型を使用します。
ユーザープールの AWS SAM テンプレートセクションの例を次に示します。
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Cors: "'*'"
Auth:
DefaultAuthorizer: MyCognitoAuthorizer
Authorizers:
MyCognitoAuthorizer:
UserPoolArn: !GetAtt MyCognitoUserPool.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: lambda.handler
Runtime: nodejs12.x
Events:
Root:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: GET
MyCognitoUserPool:
Type: AWS::Cognito::UserPool
Properties:
UserPoolName: !Ref CognitoUserPoolName
Policies:
PasswordPolicy:
MinimumLength: 8
UsernameAttributes:
- email
Schema:
- AttributeDataType: String
Name: email
Required: false
MyCognitoUserPoolClient:
Type: AWS::Cognito::UserPoolClient
Properties:
UserPoolId: !Ref MyCognitoUserPool
ClientName: !Ref CognitoUserPoolClientName
GenerateSecret: false
```
Amazon Cognito ユーザープールの詳細については、*API Gateway デベロッパーガイド*の「[Amazon Cognito ユーザープールをオーソライザーとして使用して REST API へのアクセスを制御する](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html)」を参照してください
# の API キーの例 AWS SAM
AWS SAM テンプレート内で APIs キーを要求することで、API へのアクセスを制御できます。これを実行するには、[ApiAuth](sam-property-api-apiauth.md) データ型を使用します。
API キーの AWS SAM テンプレートセクションの例を次に示します。
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
ApiKeyRequired: true # sets for all methods
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: index.handler
Runtime: nodejs12.x
Events:
ApiKey:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
Auth:
ApiKeyRequired: true
```
詳細については、*API Gateway デベロッパーガイド*の「[API キーを使用した使用量プランの作成と使用](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html)」を参照してください。
# のリソースポリシーの例 AWS SAM
API へのアクセスは、 AWS SAM テンプレート内でリソースポリシーをアタッチすることによって制御できます。これを実行するには、[ApiAuth](sam-property-api-apiauth.md) データ型を使用します。
プライベート API の AWS SAM テンプレートの例を次に示します。プライベート API には、デプロイするリソースポリシーが必要です。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyPrivateApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
EndpointConfiguration: PRIVATE # Creates a private API. Resource policies are required for all private APIs.
Auth:
ResourcePolicy:
CustomStatements:
- Effect: 'Allow'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
- Effect: 'Deny'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
MyFunction:
Type: 'AWS::Serverless::Function'
Properties:
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
Handler: index.handler
Runtime: python3.10
Events:
AddItem:
Type: Api
Properties:
RestApiId:
Ref: MyPrivateApi
Path: /
Method: get
```
リソースポリシーの詳細については、*API Gateway デベロッパーガイド*の「[API Gateway リソースポリシーを使用して API へのアクセスを制御する](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html)」を参照してください。プライベート API の詳細情報については、「API Gateway デベロッパーガイド」の「[Amazon API Gateway でのプライベート API の作成](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html)」を参照してください。
# の OAuth 2.0/JWT オーソライザーの例 AWS SAM
API へのアクセスは、[OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) および [OAuth 2.0](https://oauth.net/2/) フレームワークの一部として JWT を使用することによって制御できます。これを実行するには、[HttpApiAuth](sam-property-httpapi-httpapiauth.md) データ型を使用します。
OAuth 2.0/JWT オーソライザーの AWS SAM テンプレートセクションの例を次に示します。
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
Auth:
Authorizers:
MyOauth2Authorizer:
AuthorizationScopes:
- scope
IdentitySource: $request.header.Authorization
JwtConfiguration:
audience:
- audience1
- audience2
issuer: "https://www.example.com/v1/connect/oidc"
DefaultAuthorizer: MyOauth2Authorizer
StageName: Prod
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Events:
GetRoot:
Properties:
ApiId: MyApi
Method: get
Path: /
PayloadFormatVersion: "2.0"
Type: HttpApi
Handler: index.handler
Runtime: nodejs12.x
```
OAuth 2.0/JWT オーソライザーの詳細については、*API Gateway デベロッパーガイド*の「[JWT オーソライザーを使用した HTTP API へのアクセスの制御](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html)」を参照してください。
# のカスタマイズされたレスポンスの例 AWS SAM
一部の API Gateway エラーレスポンスは、 AWS SAM テンプレート内でレスポンスヘッダーを定義することによってカスタマイズできます。これを実行するには、[Gateway Response Object](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#gateway-response-object) データ型を使用します。
以下は、`DEFAULT_5XX`エラーのカスタマイズされたレスポンスを作成する AWS SAM テンプレートの例です。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
GatewayResponses:
DEFAULT_5XX:
ResponseParameters:
Headers:
Access-Control-Expose-Headers: "'WWW-Authenticate'"
Access-Control-Allow-Origin: "'*'"
ErrorHeader: "'MyCustomErrorHeader'"
ResponseTemplates:
application/json: "{\"message\": \"Error on the $context.resourcePath resource\" }"
GetFunction:
Type: AWS::Serverless::Function
Properties:
Runtime: python3.10
Handler: index.handler
InlineCode: |
def handler(event, context):
raise Exception('Check out the new response!')
Events:
GetResource:
Type: Api
Properties:
Path: /error
Method: get
RestApiId: !Ref MyApi
```
API Gateway レスポンスの詳細については、*API Gateway デベロッパーガイド*の「[API Gateway でのゲートウェイレスポンス](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html)」を参照してください。
# で Lambda レイヤーを使用して効率を向上させる AWS SAM
を使用すると AWS SAM、サーバーレスアプリケーションにレイヤーを含めることができます。 AWS Lambda レイヤーを使用すると、Lambda 関数から Lambda レイヤーにコードを抽出し、複数の Lambda 関数で使用できます。これにより、デプロイパッケージのサイズを縮小し、コア関数ロジックを依存関係から分離し、複数の関数間で依存関係を共有できます。レイヤーの詳細情報については、「AWS Lambda デベロッパーガイド」の「[Lambda レイヤー](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)」を参照してください。
このトピックでは、以下に関する情報を提供します。
+ アプリケーションへのレイヤーの包含
+ レイヤーがローカルにキャッシュされる方法
カスタムレイヤーの構築については、「[での Lambda レイヤーの構築 AWS SAM](building-layers.md)」を参照してください。
## アプリケーションへのレイヤーの包含
アプリケーションにレイヤーを含めるには、[AWS::Serverless::Function](sam-resource-function.md) リソースタイプの `Layers` プロパティを使用します。
レイヤーを含む Lambda 関数を使用した AWS SAM テンプレートの例を次に示します。
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
-
```
## レイヤーがローカルにキャッシュされる方法
`sam local` コマンドの 1 つを使用して関数を呼び出すと、関数のレイヤーパッケージがダウンロードされ、ローカルホストにキャッシュされます。
以下の表は、異なるオペレーティングシステムのデフォルトのキャッシュディレクトリの場所を示しています。
****
| OS | ロケーション |
| --- | --- |
| Windows 7 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 8 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 10 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| macOS | \$1/.aws-sam/layers-pkg |
| Unix | \$1/.aws-sam/layers-pkg |
パッケージがキャッシュされると、 AWS SAM CLI が、関数の呼び出しに使用される Docker イメージにレイヤーをオーバーレイします。は、ビルドするイメージの名前と、キャッシュに保持されている LayerVersions AWS SAM CLIを生成します。スキーマの詳細は、後続のセクションで説明されています。
オーバーレイされたレイヤーを調査するには、以下のコマンドを実行して、調査したいイメージで bash セッションを開始します。
```
docker run -it --entrypoint=/bin/bash samcli/lambda: -i
```
**レイヤーキャッシュディレクトリ名のスキーマ**
テンプレートで定義されている LayerVersionArn を提供すると、 AWS SAM CLI が ARN から LayerName と Version を抽出し、レイヤーコンテンツを配置するための `LayerName-Version-` という名前のディレクトリを作成します。
例:
```
ARN = arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
Directory name = myLayer-1-926eeb5ff1
```
**Docker イメージのタグスキーマ**
一意のレイヤーのハッシュを計算するには、「-」の区切り記号を使用してすべての一意のレイヤー名を結合し、SHA256 ハッシュを指定してから、最初の 10 文字を指定します。
例:
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
- arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
- arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1
```
一意の名前は、レイヤーキャッシュディレクトリ名のスキーマと同じ方法で計算されます。
```
arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1 = myLayer-1-926eeb5ff1
arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1 = mySecondLayer-1-6bc1022bdf
```
一意のレイヤーのハッシュを計算するには、「-」の区切り記号を使用してすべての一意のレイヤー名を結合し、SHA256 ハッシュを指定してから、最初の 25 文字を指定します。
```
myLayer-1-926eeb5ff1-mySecondLayer-1-6bc1022bdf = 2dd7ac5ffb30d515926aef
```
次に、この値と関数のランタイムおよびアーキテクチャを区切り記号「-」で結合します。
```
python3.7-x86_64-2dd7ac5ffb30d515926aefffd
```
# でネストされたアプリケーションを使用してコードとリソースを再利用する AWS SAM
サーバーレスアプリケーションには、1 つ、または複数の**ネストされたアプリケーション**を含めることができます。ネストされたアプリケーションはより大きなアプリケーションの一部であり、スタンドアロンのアーティファクトとして、またはより大きなアプリケーションのコンポーネントとしてパッケージ化とデプロイができます。ネストされたアプリケーションを使用すると、頻繁に使用されるコードを、それ独自のアプリケーションに変換でき、より大きなサーバーレスアプリケーションまたは複数のサーバーレスアプリケーション間で再利用することができます。
サーバーレスアーキテクチャが大きくなるにつれて起こる共通のパターンに、同じコンポーネントが複数のアプリケーションテンプレートで定義されているということがあります。ネストされたアプリケーションを使用すると、共通のコード、機能、リソース、設定を別々の AWS SAM テンプレートで再利用できるため、1 つのソースからのみコードを維持できます。これにより、コードと設定の重複を減らします。さらに、このモジュラーアプローチは、開発を合理化し、コードの編成を強化し、サーバーレスアプリケーション間の一貫性を促進します。ネストされたアプリケーションを使用することで、アプリケーションに固有のビジネスロジックにさらに集中できるようになります。
サーバーレスアプリケーションでネストされたアプリケーションを定義するには、[AWS::Serverless::Application](sam-resource-application.md) リソースタイプを使用します。
ネストされたアプリケーションは、以下の 2 つのソースから定義できます。
+ **AWS Serverless Application Repository アプリケーション** - AWS Serverless Application Repositoryにある、アカウントで利用可能なアプリケーションを使用して、ネストされたアプリケーションを定義できます。これには、アカウント内の*プライベート*アプリケーション、アカウントと*プライベートに共有された*アプリケーション、または AWS Serverless Application Repositoryで*一般公開*されているアプリケーションを使用できます。異なるデプロイ許可レベルの詳細については、*AWS Serverless Application Repository デベロッパーガイド*の「[Application Deployment Permissions](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions)」と「[Publishing Applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html)」を参照してください。
+ **ローカルアプリケーション** - ローカルファイルシステムに保存されているアプリケーションを使用して、ネストされたアプリケーションを定義できます。
AWS SAM を使用して、サーバーレスアプリケーションでこれらのタイプのネストされたアプリケーションの両方を定義する方法の詳細については、以下のセクションを参照してください。
**注記**
サーバーレスアプリケーションでネストできるアプリケーションの最大数は 200 です。
ネストされたアプリケーションで使用できるパラメータの最大数は 60 です。
## からネストされたアプリケーションを定義する AWS Serverless Application Repository
ネストされたアプリケーションは、 AWS Serverless Application Repositoryで利用可能なアプリケーションを使用することによって定義できます。また、 AWS Serverless Application Repositoryを使用して、ネストされたアプリケーションが含まれるアプリケーションを保存し、配信することもできます。でネストされたアプリケーションの詳細を確認するには AWS Serverless Application Repository、 AWS SDK、、 AWS CLIまたは Lambda コンソールを使用できます。
AWS Serverless Application Repository サーバーレスアプリケーション AWS SAM テンプレートの でホストされているアプリケーションを定義するには、すべての AWS Serverless Application Repository アプリケーションの詳細ページにある **SAM リソースとしてコピー** ボタンを使用します。これを実行するには、以下の手順を実行します。
1. AWS マネジメントコンソールにサインインしていることを確認します。
1. デ*AWS Serverless Application Repository ベロッパーガイド*の「アプリケーションの参照、検索、デプロイ」セクションのステップ AWS Serverless Application Repository を使用して、 でネストするアプリケーションを見つけます。 [https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#browse-and-search-applications ](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#browse-and-search-applications )
1. [**Copy as SAM Resource**] (SAM リソースとしてコピーする) ボタンをクリックします。これで、表示されているアプリケーションの SAM テンプレートセクションがクリップボードにコピーされます。
1. このアプリケーションにネストしたいアプリケーションの SAM テンプレートファイルの `Resources:` セクションに、この SAM テンプレートセクションを貼り付けます。
以下は、 AWS Serverless Application Repositoryでホストされているネストされたアプリケーションの SAM テンプレートセクションの例です。
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location:
ApplicationId: arn:aws:serverlessrepo:us-east-1:123456789012:applications/application-alias-name
SemanticVersion: 1.0.0
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
必要なパラメータ設定がない場合は、テンプレートの `Parameters:` セクションを省略できます。
**重要**
でホストされているネストされたアプリケーションを含むアプリケーションは、ネストされたアプリケーションの共有制限を AWS Serverless Application Repository 継承します。
例えば、アプリケーションがパブリックに共有されているが、親アプリケーションを作成した AWS アカウントとのみプライベートに共有されているネストされたアプリケーションが含まれているとします。この場合、 AWS アカウントにネストされたアプリケーションをデプロイするアクセス許可がない場合、親アプリケーションをデプロイすることはできません。アプリケーションをデプロイするための許可の詳細については、*AWS Serverless Application Repository デベロッパーガイド*の「[Application Deployment Permissions](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions)」と「[Publishing Applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html)」を参照してください。
## ローカルファイルシステムからのネストされたアプリケーションの定義
ローカルファイルシステムに保存されているアプリケーションを使用して、ネストされたアプリケーションを定義できます。これを行うには、ローカルファイルシステムに保存されている AWS SAM テンプレートファイルへのパスを指定します。
以下は、ネストされたローカルアプリケーションの SAM テンプレートセクションの例です。
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location: ../my-other-app/template.yaml
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
パラメータ設定がない場合は、テンプレートの `Parameters:` セクションを省略できます。
## ネストされたアプリケーションのデプロイ
AWS SAM CLI コマンド `sam deploy` を使用して、ネストされたアプリケーションをデプロイできます。詳細については、[を使用してアプリケーションとリソースをデプロイする AWS SAM](serverless-deploying.md)を参照してください。
**注記**
ネストされたアプリケーションが含まれるアプリケーションをデプロイする場合、お客様は、これらが含まれることを承認する必要があります。これを行うには、[CreateCloudFormationChangeSet API](https://docs.aws.amazon.com/goto/WebAPI/serverlessrepo-2017-09-08/CreateCloudFormationChangeSet) `CAPABILITY_AUTO_EXPAND`に渡すか、 [https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html) AWS CLI コマンドを使用します。
ネストされたアプリケーションの承認に関する詳細については、*AWS Serverless Application Repository デベロッパーガイド*の「[Acknowledging IAM Roles, Resource Policies, and Nested Applications when Deploying Applications](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/acknowledging-application-capabilities.html)」を参照してください。
# で EventBridge スケジューラを使用して時間ベースのイベントを管理する AWS SAM
このトピックのコンテンツでは、Amazon EventBridge スケジューラの詳細、サポート AWS SAM オファー、スケジューライベントの作成方法、スケジューライベントの作成時に参照できる例について説明します。
## Amazon EventBridge スケジューラとは
EventBridge スケジューラを使用して、 AWS SAM テンプレートでイベントをスケジュールします。Amazon EventBridge スケジューラは、すべてのサービスで何千万ものイベントやタスクを作成、開始、管理できるスケジューリング AWS サービスです。このサービスは、時間関連のイベントに特に役立ちます。これは、イベントや定期的な時間ベースの呼び出しをスケジュールするために使用します。またこれは、1 回限りのイベントだけでなく、開始時刻と終了時刻を指定したレート式とChron 式もサポートしています。
Amazon EventBridge スケジューラの詳細については、「*EventBridge Scheduler User Guide*」の「[What is Amazon EventBridge Scheduler?](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html)」を参照してください。
**Topics**
+ [Amazon EventBridge スケジューラとは](#using-eventbridge-scheduler-intro)
+ [での EventBridge スケジューラのサポート AWS SAM](#using-eventbridge-scheduler-sam-support)
+ [での EventBridge スケジューライベントの作成 AWS SAM](#using-eventbridge-scheduler-sam-create)
+ [例](#using-eventbridge-scheduler-examples)
+ [詳細情報](#using-eventbridge-scheduler-learn)
## での EventBridge スケジューラのサポート AWS SAM
AWS Serverless Application Model (AWS SAM) テンプレート仕様は、 AWS Lambda および の EventBridge スケジューラでイベントをスケジュールするために使用できるシンプルで短い構文を提供します AWS Step Functions。
## での EventBridge スケジューライベントの作成 AWS SAM
`ScheduleV2` プロパティを AWS SAM テンプレートのイベントタイプとして設定し、EventBridge スケジューライベントを定義します。このプロパティは、`AWS::Serverless::Function` および `AWS::Serverless::StateMachine` リソースタイプをサポートします。
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2Function
Description: Test schedule event
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2StateMachine
Description: Test schedule event
```
EventBridge スケジューラのイベントスケジューリングでは、未処理のイベントのデッドレターキュー (DLQ) もサポートされています。デッドレターキューの詳細については、「EventBridge スケジューラユーザーガイド」の「[Configuring a dead-letter queue for EventBridge Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/configuring-schedule-dlq.html)」(EventBridge スケジューラのデッドレターキューの設定) を参照してください。
DLQ ARN を指定すると、 はスケジューラスケジュールのアクセス許可 AWS SAM を設定して DLQ にメッセージを送信します。DLQ ARN が指定されていない場合、 AWS SAM は DLQ リソースを作成します。
## 例
### で EventBridge スケジューライベントを定義する基本的な例 AWS SAM
```
Transform: AWS::Serverless-2016-10-31
Resources:
MyLambdaFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
MySFNFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
StateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Type: STANDARD
Definition:
StartAt: MyLambdaState
States:
MyLambdaState:
Type: Task
Resource: !GetAtt MySFNFunction.Arn
End: true
Policies:
- LambdaInvokePolicy:
FunctionName: !Ref MySFNFunction
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
```
## 詳細情報
`ScheduleV2` EventBridge スケジューラプロパティの定義の詳細については、以下を参照してください。
+ `AWS::Serverless::Function` 用の [ScheduleV2](sam-property-function-schedulev2.md)。
+ `AWS::Serverless::StateMachine` 用の [ScheduleV2](sam-property-statemachine-statemachineschedulev2.md)。
# を使用した AWS SAM リソースのオーケストレーション AWS Step Functions
[AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/) を使用して AWS Lambda 関数やその他の AWS リソースをオーケストレーションし、複雑で堅牢なワークフローを形成できます。Step Functions は、 AWS Lambda 関数などの AWS リソースが使用されるタイミングと条件をアプリケーションに指示します。これにより、複雑で堅牢なワークフローを形成するプロセスが簡素化されます。[AWS::Serverless::StateMachine](sam-resource-statemachine.md) を使用して、ワークフロー内の個々のステップを定義し、各ステップでリソースを関連付けてから、これらのステップを順番に並べます。また、必要な移行および条件も追加します。これにより、複雑で堅牢なワークフローを作成するプロセスが簡素化されます。
**注記**
Step Functions ステートマシンを含む AWS SAM テンプレートを管理するには、 のバージョン 0.52.0 以降を使用する必要があります AWS SAM CLI。使用しているバージョンを確認するには、`sam --version` コマンドを実行します。
Step Functions は[タスク](https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-task-state.html)と[ステートマシン](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-states.html)の概念に基づいています。ステートマシンは、JSON ベースの [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) を使用して定義します。[Step Functions コンソール](https://console.aws.amazon.com/states/home?region=us-east-1#/) にはステートマシンの構造のグラフィカルなビューが表示されるので、ステートマシンのロジックを視覚的にチェックし、実行をモニタリングできます。
Step Functions が AWS Serverless Application Model (AWS SAM) でサポートされている場合は、次の操作を実行できます。
+ AWS SAM テンプレート内で直接、または別のファイルでステートマシンを定義する
+ AWS SAM ポリシーテンプレート、インラインポリシー、または 管理ポリシーを使用してステートマシン実行ロールを作成する
+ API Gateway または Amazon EventBridge イベントを使用して、 AWS SAM テンプレート内のスケジュールに従って、または API を直接呼び出すことによってステートマシンの実行をトリガーする
+ 一般的な Step Functions 開発パターン向けに利用できる [AWS SAM ポリシーテンプレート](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html)を使用する
## 例
次の AWS SAM テンプレートファイルのスニペット例では、定義ファイルで Step Functions ステートマシンを定義します。`my_state_machine.asl.json` ファイルは [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) で記述される必要があることに注意してください。
```
AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: Sample SAM template with Step Functions State Machine
Resources:
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
DefinitionUri: statemachine/my_state_machine.asl.json
...
```
Step Functions ステートマシンを含むサンプル AWS SAM アプリケーションをダウンロードするには、 *AWS Step Functions デベロッパーガイド*の[「 を使用して Step Functions ステートマシンを作成する AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html)」を参照してください。
## 詳細情報
Step Functions とその での使用の詳細については AWS SAM、以下を参照してください。
+ [AWS Step Functions のしくみ](https://docs.aws.amazon.com/step-functions/latest/dg/how-step-functions-works.html)
+ [AWS Step Functions および AWS Serverless Application Model](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-sam-sfn.html)
+ [チュートリアル: を使用して Step Functions ステートマシンを作成する AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html)
+ [AWS SAM 仕様: AWS::Serverless::StateMachine](sam-resource-statemachine.md)
# AWS SAM アプリケーションのコード署名を設定する
信頼できるコードのみがデプロイされるようにするには、 AWS SAM を使用してサーバーレスアプリケーションでコード署名を有効にします。コードに署名すると、署名後にコードが変更されず、信頼できるパブリッシャーから署名されたコードパッケージのみが Lambda 関数で実行されるようになります。これにより組織は、デプロイパイプラインにゲートキーパーコンポーネントを構築する負担から解放されます。
コード署名の詳細については、「AWS Lambda デベロッパーガイド」の「[Lambda 関数のコード署名の設定](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html)」を参照してください。
サーバーレスアプリケーションのコード署名を設定する前に、 AWS Signer を使用して署名プロファイルを作成する必要があります。この署名プロファイルは、以下のタスクに使用します。
1. **コード署名設定の作成** - [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html) リソースを宣言して、信頼できる発行元の署名プロファイルの指定と、検証チェックのためのポリシーアクションの設定を行います。このオブジェクトは、サーバーレス関数と同じ AWS SAM テンプレート、別の AWS SAM テンプレート、または CloudFormation テンプレートで宣言できます。その後、[https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html) リソースの Amazon リソースネーム (ARN) を使用して関数の [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn) プロパティを指定することによって、サーバーレス関数のコード署名を有効にします。
1. **コードの署名** - `--signing-profiles` オプションを用いた [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html) または [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) コマンドを使用します。
**注記**
`sam package` または `sam deploy` コマンドを使用したコードの署名が正常に行われるには、これらのコマンドで使用する Amazon S3 バケットでバージョニングが有効化されている必要があります。が AWS SAM 作成する Amazon S3 バケットを使用している場合、バージョニングは自動的に有効になります。Amazon S3 バケットのバージョニング、および提供する Amazon S3 バケットでバージョニングを有効化する手順の詳細については、*Amazon Simple Storage Service ユーザーガイド*の「[S3 バケットでのバージョニングの使用](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html)」を参照してください。
サーバーレスアプリケーションをデプロイするときは、コード署名を有効にしたすべての関数に対して Lambda が検証チェックを実行します。Lambda は、これらの関数が依存するレイヤーにも検証チェックを実行します。Lambda の検証チェックの詳細については、*AWS Lambda デベロッパーガイド*の「[署名の検証](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html#config-codesigning-valid)」を参照してください。
## 例
### 署名プロファイルの作成
署名プロファイルを作成するには、以下のコマンドを実行します。
```
aws signer put-signing-profile --platform-id "AWSLambda-SHA384-ECDSA" --profile-name MySigningProfile
```
上記のコマンドが正常に実行されると、署名プロファイルの ARN が返されたことを確認できます。例えば、このようになります。
```
{
"arn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile",
"profileVersion": "SAMPLEverx",
"profileVersionArn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile/SAMPLEverx"
}
```
`profileVersionArn` フィールドには、コード署名設定を作成するときに使用する ARN が含まれています。
### コード署名設定の作成と関数のコード署名の有効化
次のサンプル AWS SAM テンプレートは、 [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)リソースを宣言し、Lambda 関数のコード署名を有効にします。この例では、信頼できるプロファイルが 1 つあり、署名チェックが失敗するとデプロイが拒否されます。
```
Resources:
HelloWorld:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.7
CodeSigningConfigArn: !Ref MySignedFunctionCodeSigningConfig
MySignedFunctionCodeSigningConfig:
Type: AWS::Lambda::CodeSigningConfig
Properties:
Description: "Code Signing for MySignedLambdaFunction"
AllowedPublishers:
SigningProfileVersionArns:
- MySigningProfile-profileVersionArn
CodeSigningPolicies:
UntrustedArtifactOnDeployment: "Enforce"
```
### コードの署名
コードは、アプリケーションをパッケージ化またはデプロイするときに署名できます。以下のコマンド例にあるように、`sam package` または `sam deploy` コマンドで `--signing-profiles` オプションを指定します。
アプリケーションをパッケージ化するときの関数コードへの署名:
```
sam package --signing-profiles HelloWorld=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
アプリケーションをパッケージ化するときの関数コードと関数が依存するレイヤー両方への署名:
```
sam package --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
関数コードの署名と、署名後のデプロイの実行:
```
sam deploy --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --template-file packaged.yaml --stack-name --region us-east-1 --capabilities CAPABILITY_IAM
```
**注記**
`sam package` または `sam deploy` コマンドを使用したコードの署名が正常に行われるには、これらのコマンドで使用する Amazon S3 バケットでバージョニングが有効化されている必要があります。が AWS SAM 作成する Amazon S3 バケットを使用している場合、バージョニングは自動的に有効になります。Amazon S3 バケットのバージョニング、および提供する Amazon S3 バケットでバージョニングを有効化する手順の詳細については、*Amazon Simple Storage Service ユーザーガイド*の「[S3 バケットでのバージョニングの使用](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html)」を参照してください。
## `sam deploy --guided` での署名プロファイルの提供
コード署名が設定されたサーバーレスアプリケーションで `sam deploy --guided` コマンドを実行すると、 はコード署名に使用する署名プロファイルを指定するように AWS SAM 求めます。`sam deploy --guided` プロンプトの詳細については、 AWS SAM CLI コマンドリファレンスの「[sam deploy](sam-cli-command-reference-sam-deploy.md)」を参照してください。
# AWS SAM テンプレートファイルを検証する
`sam validate` を使用してテンプレートを検証します。現在、このコマンドは、提供されたテンプレートが有効な JSON/YAML であることを検証します。ほとんどの AWS SAM CLI コマンドと同様に、このコマンドはデフォルトで、現行の作業ディレクトリ内の `template.[yaml|yml]` ファイルを検索します。`-t` または `--template` オプションを使用して、異なるテンプレートファイル/場所を指定できます。
例:
```
$ sam validate
/template.yaml is a valid SAM Template
```
**注記**
`sam validate` コマンドでは、 AWS 認証情報を設定する必要があります。詳細については、「[AWS SAM CLI の設定](using-sam-cli-configure.md)」を参照してください。
# を使用してアプリケーションを構築する AWS SAM
AWS SAM テンプレートに Infrastructure as Code (IaC) を追加したら、 **sam build** コマンドを使用してアプリケーションの構築を開始する準備が整います。このコマンドは、アプリケーションプロジェクトディレクトリ内のファイル ( AWS SAM テンプレートファイル、アプリケーションコード、および該当する言語固有のファイルと依存関係) からビルドアーティファクトを作成します。これらのビルドアーティファクトは、ローカルテストや AWS クラウドへのデプロイなど、アプリケーション開発の後のステップのためにサーバーレスアプリケーションを準備します。テストとデプロイの両方で、ビルドアーティファクトは入力として使用されます。
**sam build** を使用して、サーバーレスアプリケーション全体を構築できます。さらに、特定の関数、レイヤー、カスタムランタイムなど、カスタマイズされたビルドを作成できます。**sam build** の使用方法と理由の詳細については、このセクションのトピックを参照してください。`sam build` コマンドの使用方法の概要については、「[を使用した の構築の概要 AWS SAM](using-sam-cli-build.md)」を参照してください。
**Topics**
+ [を使用した の構築の概要 AWS SAM](using-sam-cli-build.md)
+ [を使用したデフォルトのビルド AWS SAM](serverless-sam-cli-using-build.md)
+ [でビルドをカスタマイズする AWS SAM](building-lambda-functions.md)
# を使用した の構築の概要 AWS SAM
AWS Serverless Application Model コマンドラインインターフェイス (AWS SAM CLI) `sam build` コマンドを使用して、ローカルテストや へのデプロイなど、開発ワークフローの後続のステップのためにサーバーレスアプリケーションを準備します AWS クラウド。このコマンドは、`sam local` および `sam deploy` が必要とする形式と場所でアプリケーションを構造化する `.aws-sam` ディレクトリを作成します。
+ の概要については AWS SAM CLI、「」を参照してください[とは AWS SAM CLI](what-is-sam-overview.md#what-is-sam-cli)。
+ `sam build` コマンドオプションのリストについては、「[sam build](sam-cli-command-reference-sam-build.md)」を参照してください。
+ 一般的な開発ワークフローでの `sam build` の使用例については、「[ステップ 2: アプリケーションを構築する](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-build)」を参照してください。
**注記**
`sam build` を使用するには、開発マシン上のサーバーレスアプリケーションの基本コンポーネントから始める必要があります。これには、 AWS SAM テンプレート、 AWS Lambda 関数コード、言語固有のファイルと依存関係が含まれます。詳細については[でアプリケーションを作成する AWS SAM](using-sam-cli-init.md)を参照してください。
**Topics**
+ [sam build を使用したアプリケーションの構築](#using-sam-cli-build-apps)
+ [ローカルでのテストとデプロイ](#using-sam-cli-build-test-deploy)
+ [ベストプラクティス](#using-sam-cli-build-best)
+ [sam build のオプション](#using-sam-cli-build-options)
+ [トラブルシューティング](#using-sam-cli-build-troubleshooting)
+ [例](#using-sam-cli-build-examples)
+ [詳細情報](#using-sam-cli-build-learn)
## sam build を使用したアプリケーションの構築
`sam build` を使用する前に、次を設定することを検討してください。
1. **Lambda 関数とレイヤー** – `sam build` コマンドは Lambda 関数とレイヤーを構築できます。Lambda レイヤーの詳細については、「[での Lambda レイヤーの構築 AWS SAM](building-layers.md)」を参照してください。
1. **Lambda ランタイム** – ランタイムは、呼び出されたときに実行環境で関数を実行する言語固有の環境を提供します。ネイティブランタイムとカスタムランタイムを設定できます。
1. **ネイティブランタイム** – サポートされている Lambda ランタイムで Lambda 関数を作成し、 AWS クラウドでネイティブ Lambda ランタイムを使用する関数を構築します。
1. **カスタムランタイム** – 任意のプログラミング言語を使用して Lambda 関数を作成し、esbuild など、makefile やサードパーティービルダーで定義されたカスタムプロセスを使用してランタイムを構築します。詳細については[でのカスタムランタイムを使用した Lambda 関数の構築 AWS SAM](building-custom-runtimes.md)を参照してください。
1. **Lambda パッケージタイプ** – Lambda 関数は、次の Lambda デプロイパッケージタイプにパッケージ化できます。
1. **.zip ファイルアーカイブ** – アプリケーション コードとその依存関係が含まれます。
1. **コンテナイメージ** – 基本オペレーティングシステム、ランタイム、Lambda 拡張機能、アプリケーションコードとその依存関係が含まれています。
これらのアプリケーション設定は、`sam init` を使用してアプリケーションを初期化するときに設定できます。
+ `sam init` の使用の詳細については、「[でアプリケーションを作成する AWS SAM](using-sam-cli-init.md)」を参照してください。
+ アプリケーションでのこれらの設定の詳細については、「[を使用したデフォルトのビルド AWS SAM](serverless-sam-cli-using-build.md)」を参照してください。
**アプリケーションを構築するには**
1. `cd` を実行してプロジェクトのルートに移動します。これは AWS SAM テンプレートと同じ場所です。
```
$ cd sam-app
```
1. 下記を実行します。
```
sam-app $ sam build
```
**注記**
一般的に使用されるオプションは `--use-container` です。詳細については[指定されたコンテナ内における Lambda 関数の構築](#using-sam-cli-build-options-container)を参照してください。
次は AWS SAM CLI 出力の例です。
```
sam-app $ sam build
Starting Build use cache
Manifest file is changed (new hash: 3298f1304...d4d421) or dependency folder (.aws-sam/deps/4d3dfad6-a267-47a6-a6cd-e07d6fae318c) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../sam-app/hello_world runtime: python3.12 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CleanUp
Running PythonPipBuilder:ResolveDependencies
Running PythonPipBuilder:CopySource
Running PythonPipBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
1. AWS SAM CLI は `.aws-sam` ビルドディレクトリを作成します。以下に例を示します。
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ ├── __init__.py
│ │ ├── app.py
│ │ └── requirements.txt
│ └── template.yaml
└── build.toml
```
アプリケーションの設定に応じて、 AWS SAM CLI は次を実行します。
1. `.aws-sam/build` ディレクトリ内の依存関係をダウンロード、インストール、整理します。
1. Lambda コードを準備します。これには、コードのコンパイル、実行可能バイナリの作成、コンテナイメージの構築などが含まれます。
1. ビルドアーティファクトを `.aws-sam` ディレクトリにコピーします。形式はアプリケーションパッケージの種類によって異なります。
1. .zip パッケージタイプの場合、アーティファクトはローカルテストに使用できるようにまだ圧縮されていません。 AWS SAM CLI は、`sam deploy` を使用するときにアプリケーションを圧縮します。
1. コンテナイメージパッケージタイプの場合、コンテナイメージはローカルで作成され、`.aws-sam/build.toml` ファイル内で参照されます。
1. AWS SAM テンプレートを `.aws-sam` ディレクトリにコピーし、必要に応じて新しいファイルパスで変更します。
`.aws-sam` ディレクトリ内のビルドアーティファクトを構成する主要なコンポーネントを次に示します。
+ **ビルドディレクトリ** – Lambda 関数と、互いに独立して構造化されたレイヤーが含まれます。これにより、`.aws-sam/build` ディレクトリ内の各関数またはレイヤー用に固有の構造が作成されます。
+ ** AWS SAM テンプレート** – ビルドプロセス中の変更に基づいて更新された値で変更されました。
+ **build.toml ファイル** – で使用されるビルド設定を含む設定ファイル AWS SAM CLI。
## ローカルでのテストとデプロイ
`sam local` を使用してローカルテストを実行する場合、または `sam deploy` を使用してデプロイを実行する場合、 AWS SAM CLI は次を実行します。
1. まず、 `.aws-sam` ディレクトリが存在するかどうか、および AWS SAM テンプレートがそのディレクトリ内にあるかどうかを確認します。これらの条件が満たされる場合、 AWS SAM CLI はこれをアプリケーションのルートディレクトリとみなします。
1. これらの条件が満たされない場合、 AWS SAM CLI は AWS SAM テンプレートの元の場所をアプリケーションのルートディレクトリと見なします。
開発中、元のアプリケーションファイルに変更が加えられた場合は、ローカルでテストする前に、`sam build` を実行して `.aws-sam` ディレクトリを更新します。
## ベストプラクティス
+ `.aws-sam/build` ディレクトリ内のコードは編集しないでください。代わりに、プロジェクトフォルダ内の元のソースコードを更新し、`sam build` を実行して `.aws-sam/build` ディレクトリを更新します。
+ 元のファイルを変更する場合は、`sam build` を実行して `.aws-sam/build` ディレクトリを更新します。
+ `sam local` を使用して開発およびテストする場合など、 AWS SAM CLI が `.aws-sam` ディレクトリではなくプロジェクトの元のルートディレクトリを参照するようにしたい場合があります。`.aws-sam` ディレクトリまたは`.aws-sam`ディレクトリ内の AWS SAM テンプレートを削除して、 AWS SAM CLIが元のプロジェクトディレクトリをルートプロジェクトディレクトリとして認識するようにします。準備ができたら、再度 `sam build` を実行して `.aws-sam` ディレクトリを作成します。
+ `sam build` を実行すると、`.aws-sam/build` ディレクトリは毎回上書きされます。`.aws-sam` ディレクトリは毎回上書きしません。ログなどのファイルを保存する場合は、上書きされないように `.aws-sam` に保存します。
## sam build のオプション
### 単一のリソースの構築
リソースの論理 ID を指定して、そのリソースのみを構築します。以下に例を示します。
```
$ sam build HelloWorldFunction
```
ネストされたアプリケーションまたはスタックのリソースを構築するには、`/` 形式を使用して、リソースの論理 ID と共に、アプリケーションまたはスタックの論理 ID を指定します。
```
$ sam build MyNestedStack/MyFunction
```
### 指定されたコンテナ内における Lambda 関数の構築
`--use-container` オプションはコンテナイメージをダウンロードし、それを使用して Lambda 関数を構築します。その後、ローカルコンテナが `.aws-sam/build.toml` ファイル内で参照されます。
このオプションでは Docker をインストールする必要があります。手順については、「[Docker のインストール](install-docker.md)」を参照してください。
このコマンドの例を次に示します。
```
$ sam build --use-container
```
`--build-image` オプションで使用するコンテナイメージを指定できます。以下に例を示します。
```
$ sam build --use-container --build-image amazon/aws-sam-cli-build-image-nodejs20.x
```
単一の関数に使用するコンテナイメージを指定するには、関数の論理 ID を指定します。以下に例を示します。
```
$ sam build --use-container --build-image Function1=amazon/aws-sam-cli-build-image-python3.12
```
### 環境変数をビルドコンテナに渡す
`--container-env-var` を使用して、環境変数をビルドコンテナに渡します。以下に例を示します。
```
$ sam build --use-container --container-env-var Function1.GITHUB_TOKEN= --container-env-var GLOBAL_ENV_VAR=
```
ファイルから環境変数を渡すには、`--container-env-var-file` オプションを使用します。以下に例を示します。
```
$ sam build --use-container --container-env-var-file
```
`env.json` ファイルの例:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
### 複数の関数を含むアプリケーションの構築を高速化する
複数の関数を含むアプリケーションで `sam build` を実行する場合、 AWS SAM CLI は各関数を一度に 1 つずつ構築します。構築プロセスを高速化するには、`--parallel` オプションを使用します。これにより、すべての関数とレイヤーが同時に構築されます。
このコマンドの例を次に示します。
```
$ sam build —-parallel
```
### ソースフォルダにプロジェクトを構築することでビルド時間を短縮する
サポートされているランタイムとビルドメソッドについては、`--build-in-source` オプションを使用してプロジェクトをソースフォルダに直接構築できます。デフォルトでは、 は一時ディレクトリに AWS SAM CLIビルドされます。これには、ソースコードとプロジェクトファイルのコピーが含まれます。を使用すると`--build-in-source` AWS SAM 、 はソースフォルダに直接CLIビルドされるため、一時ディレクトリにファイルをコピーする必要がなくなるため、ビルドプロセスが高速化されます。
サポートされているランタイムとビルドメソッドのリストについては、「`--build-in-source`」を参照してください。
## トラブルシューティング
のトラブルシューティングについては AWS SAM CLI、「」を参照してください[AWS SAMCLI トラブルシューティング](sam-cli-troubleshooting.md)。
## 例
### ネイティブランタイムと .zip パッケージタイプを使用するアプリケーションの構築
この例については、「[チュートリアル: を使用して Hello World アプリケーションをデプロイする AWS SAM](serverless-getting-started-hello-world.md)」を参照してください。
### ネイティブランタイムとイメージパッケージタイプを使用するアプリケーションの構築
まず、新しいアプリケーションを初期化するために `sam init` を実行します。インタラクティブなフロー中に、`Image` パッケージタイプを選択します。以下に例を示します。
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
4 - Scheduled task
5 - Standalone function
6 - Data processing
7 - Hello World Example With Powertools
8 - Infrastructure event management
9 - Serverless Connector Hello World Example
10 - Multi-step workflow with Connectors
11 - Lambda EFS example
12 - DynamoDB Example
13 - Machine Learning
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
...
10 - java8
11 - nodejs20.x
12 - nodejs18.x
13 - nodejs16.x
...
Runtime: 12
What package type would you like to use?
1 - Zip
2 - Image
Package type: 2
Based on your selections, the only dependency manager available is npm.
We will proceed copying the template using npm.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Base Image: amazon/nodejs18.x-base
Architectures: x86_64
Dependency Manager: npm
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app/README.md
...
```
はアプリケーションを AWS SAM CLI初期化し、次のプロジェクトディレクトリを作成します。
```
sam-app
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── Dockerfile
│ ├── app.mjs
│ ├── package.json
│ └── tests
│ └── unit
│ └── test-handler.mjs
├── samconfig.toml
└── template.yaml
```
次に、アプリケーションを構築するために `sam build` を実行します。
```
sam-app $ sam build
Building codeuri: /Users/.../build-demo/sam-app runtime: None metadata: {'DockerTag': 'nodejs18.x-v1', 'DockerContext': '/Users/.../build-demo/sam-app/hello-world', 'Dockerfile': 'Dockerfile'} architecture: arm64 functions: HelloWorldFunction
Building image for HelloWorldFunction function
Setting DockerBuildArgs: {} for HelloWorldFunction function
Step 1/4 : FROM public.ecr.aws/lambda/nodejs:18
---> f5b68038c080
Step 2/4 : COPY app.mjs package*.json ./
---> Using cache
---> 834e565aae80
Step 3/4 : RUN npm install
---> Using cache
---> 31c2209dd7b5
Step 4/4 : CMD ["app.lambdaHandler"]
---> Using cache
---> 2ce2a438e89d
Successfully built 2ce2a438e89d
Successfully tagged helloworldfunction:nodejs18.x-v1
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
### コンパイルされたプログラミング言語を含むアプリケーションの構築
この例では、Go ランタイムを使用して Lambda 関数を含むアプリケーションを構築します。
まず、`sam init` を使用して新しいアプリケーションを初期化し、アプリケーションが Go を使用するように設定します。
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
...
4 - dotnetcore3.1
5 - go1.x
6 - go (provided.al2)
...
Runtime: 5
What package type would you like to use?
1 - Zip
2 - Image
Package type: 1
Based on your selections, the only dependency manager available is mod.
We will proceed copying the template using mod.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Runtime: go1.x
Architectures: x86_64
Dependency Manager: mod
Application Template: hello-world
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app-go/README.md
...
```
はアプリケーションを AWS SAM CLI初期化します。アプリケーションのディレクトリ構造の例を次に示します。
```
sam-app
├── Makefile
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── go.mod
│ ├── go.sum
│ ├── main.go
│ └── main_test.go
├── samconfig.toml
└── template.yaml
```
このアプリケーションの要件については、`README.md` ファイルを参照します。
```
...
## Requirements
* AWS CLI already configured with Administrator permission
* [Docker installed](https://www.docker.com/community-edition)
* [Golang](https://golang.org)
* SAM CLI - [Install the SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
...
```
次に、関数をテストするために `sam local invoke` を実行します。Go がローカルマシンにインストールされていないため、このコマンドはエラーになります。
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-go1.x
Building image.................................................................................................................................................................................................................................................
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/hello-world as /var/task:ro,delegated inside runtime container
START RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Version: $LATEST
fork/exec /var/task/hello-world: no such file or directory: PathError
null
END RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31
REPORT RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Init Duration: 0.88 ms Duration: 175.75 ms Billed Duration: 176 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"errorMessage":"fork/exec /var/task/hello-world: no such file or directory","errorType":"PathError"}%
```
次に、アプリケーションを構築するために `sam build` を実行します。Go がローカルマシンにインストールされていないため、エラーが発生しました:
```
sam-app $ sam build
Starting Build use cache
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../Playground/build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Build Failed
Error: GoModulesBuilder:Resolver - Path resolution for runtime: go1.x of binary: go was not successful
```
関数を適切に構築するようにローカルマシンを設定することもできますが、代わりに `sam build` で `--use-container` オプションを使用します。はコンテナイメージ AWS SAM CLIをダウンロードし、ネイティブ GoModulesBuilder を使用して関数を構築し、結果のバイナリを `.aws-sam/build/HelloWorldFunction` ディレクトリにコピーします。
```
sam-app $ sam build --use-container
Starting Build use cache
Starting Build inside a container
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Fetching public.ecr.aws/sam/build-go1.x:latest-x86_64 Docker container image.....................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Mounting /Users/.../build/sam-app/hello-world as /tmp/samcli/source:ro,delegated inside runtime container
Running GoModulesBuilder:Build
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
`.aws-sam` ディレクトリの例を次に示します。
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ └── hello-world
│ └── template.yaml
├── build.toml
├── cache
│ └── c860d011-4147-4010-addb-2eaa289f4d95
│ └── hello-world
└── deps
```
次に、`sam local invoke` を実行します。関数は正常に呼び出されます。
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image is up-to-date
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container
START RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Version: $LATEST
END RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479
REPORT RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Init Duration: 1.20 ms Duration: 1782.46 ms Billed Duration: 1783 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"statusCode":200,"headers":null,"multiValueHeaders":null,"body":"Hello, 72.21.198.67\n"}%
```
## 詳細情報
`sam build` コマンドの使用方法の詳細については、次を参照してください。
+ **[Learning AWS SAM: sam build](https://www.youtube.com/watch?v=fDhYKp4op_g)** – での Serverless Land の「Learning AWS SAM」シリーズYouTube。
+ **[Learning AWS SAM \$1 sam build \$1 E3 ](https://www.youtube.com/watch?v=vsAvRyLnB7Y)** – での Serverless Land の「Learning AWS SAM」シリーズYouTube。
+ **[AWS SAM build: how it provides artifacts for deployment (Sessions with SAM S2E8)](https://www.youtube.com/watch?v=bNbBd6XoDHg)** — Sessions with AWS SAM series on YouTube。
+ **[AWS SAM カスタムビルド: Makefiles を使用して SAM (S2E9) でビルドをカスタマイズする方法](https://www.youtube.com/watch?v=wpccutnSbAk)** – で AWS SAM シリーズを使用するセッションYouTube。
# を使用したデフォルトのビルド AWS SAM
サーバーレスアプリケーションを構築するには、`sam build` コマンドを使用します。このコマンドは、アプリケーションの依存関係のビルドアーティファクトも収集して、ローカルでのテスト、パッケージ化、およびデプロイなどの次のステップのために、それらを適切な形式と場所に設定します。
アプリケーションの依存関係は、マニフェストファイル (`requirements.txt` (Python) または `package.json` (Node.js) など) で指定するか、関数リソースの `Layers` プロパティを使用して指定します。`Layers` プロパティには、Lambda 関数が依存する [AWS Lambda レイヤー](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)リソースのリストが含まれています。
アプリケーションのビルドアーティファクトの形式は、各関数の `PackageType` プロパティに応じて異なります。このプロパティのオプションには次のものがあります。
+ **`Zip`** - アプリケーションコードとその依存関係が含まれる .zip ファイルアーカイブ。コードを .zip ファイルアーカイブとしてパッケージ化する場合は、関数の Lambda ランタイムを指定する必要があります。
+ **`Image`** - アプリケーションコードとその依存関係に加えて、ベースオペレーティングシステム、ランタイム、および拡張機能が含まれているコンテナイメージ。
Lambda パッケージタイプに関する詳細については、*AWS Lambda デベロッパーガイド*の「[Lambda デプロイパッケージ](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html)」を参照してください。
**Topics**
+ [.zip ファイルアーカイブの構築](#build-zip-archive)
+ [コンテナイメージの構築](#build-container-image)
+ [コンテナ環境変数ファイル](#serverless-sam-cli-using-container-environment-file)
+ [ソースフォルダにプロジェクトを構築することでビルド時間を短縮する](#serverless-sam-cli-using-build-in-source)
+ [例](#building-applications-examples)
+ [の外部で関数を構築する AWS SAM](#building-applications-skip)
## .zip ファイルアーカイブの構築
サーバーレスアプリケーションを.zip ファイルアーカイブとして構築するには、サーバーレス関数に `PackageType: Zip` を宣言します。
AWS SAM は、指定した[アーキテクチャ](sam-resource-function.md#sam-function-architectures)用にアプリケーションを構築します。アーキテクチャを指定しない場合、 `x86_64` はデフォルトで AWS SAM を使用します。
ネイティブにコンパイルされたプログラムが含まれるパッケージに Lambda 関数が依存する場合は、`--use-container` フラグを使用します。このフラグは、Lambda 環境のように動作するコンテナで関数をローカルにコンパイルするため、 AWS クラウドにデプロイするときに適切な形式になります。
`--use-container` オプションを使用すると、 はデフォルトで [Amazon ECR Public](https://docs.aws.amazon.com/AmazonECR/latest/public/what-is-ecr.html) からコンテナイメージを AWS SAM プルします。別のリポジトリまたは特定のバージョンの CLI AWS SAM からコンテナイメージをプルする場合は、 `--build-image`オプションを使用して代替コンテナイメージの URI を指定できます。以下は、特定のバージョンの CLI のコンテナイメージを使用してアプリケーションを構築するための 2 AWS SAM つのコマンドの例です。
```
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
```
.zip ファイルアーカイブアプリケーションのその他の構築例については、このトピックの後半にある「例」セクションを参照してください。
## コンテナイメージの構築
サーバーレスアプリケーションをコンテナイメージとして構築するには、サーバーレス関数に `PackageType: Image` を宣言します。また、以下のエントリを使って `Metadata` リソース属性を宣言する必要もあります。
`Dockerfile`
Lambda 関数に関連付けられた Dockerfile の名前。
`DockerContext`
Dockerfile の場所。
`DockerTag`
(オプション) 構築されたイメージに適用するタグ。
`DockerBuildArgs`
ビルド用のビルド引数。
AWS SAM CLI では、`DockerBuildArgs` 引数に含める情報の編集または難読化は行われません。このセクションを使用してパスワードやシークレットなどの機密情報を保存しないことを強くお勧めします。
以下は、`Metadata` リソース属性セクションの例です。
```
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
`Image` パッケージタイプで設定されたサンプルアプリケーションをダウンロードするには、「[チュートリアル: を使用して Hello World アプリケーションをデプロイする AWS SAM](serverless-getting-started-hello-world.md)」を参照してください。インストールしたいパッケージタイプをたずねるプロンプトで、[`Image`] を選択します。
**注記**
Dockerfile でマルチアーキテクチャベースイメージを指定すると、 はホストマシンのアーキテクチャ用のコンテナイメージ AWS SAM を構築します。別のアーキテクチャ用に構築するには、特定のターゲットアーキテクチャを使用するベースイメージを指定します。
## コンテナ環境変数ファイル
ビルドコンテナの環境変数が含まれた JSON ファイルを提供するには、`sam build` コマンドで `--container-env-var-file` 引数を使用します。すべてのサーバーレスリソースに適用される単一の環境変数を提供する、または各リソースに異なる環境変数を提供することができます。
### 形式
環境変数をビルドコンテナに渡す形式は、リソースに提供する環境変数の数に応じて異なります。
すべてのリソースに対して単一の環境変数を提供するには、以下のように `Parameters` オブジェクトを指定します。
```
{
"Parameters": {
"GITHUB_TOKEN": "TOKEN_GLOBAL"
}
}
```
各リソースに異なる環境変数を提供するには、以下のようにリソースごとにオブジェクトを指定します。
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
環境変数をファイル (`env.json` と命名されたファイルなど) として保存します。以下のコマンドは、このファイルを使用して環境変数をビルドコンテナに渡します。
```
sam build --use-container --container-env-var-file env.json
```
### 優先順位
+ すべてのリソースに対する単一の環境変数よりも、特定のリソースに提供する環境変数が優先されます。
+ ファイル内の環境変数よりも、コマンドラインで提供する環境変数が優先されます。
## ソースフォルダにプロジェクトを構築することでビルド時間を短縮する
サポートされているランタイムとビルドメソッドについては、`--build-in-source` オプションを使用してプロジェクトをソースフォルダに直接構築できます。デフォルトでは、 は一時ディレクトリに AWS SAM CLIビルドされます。これには、ソースコードとプロジェクトファイルのコピーが含まれます。を使用すると`--build-in-source` AWS SAM 、 はソースフォルダに直接CLIビルドされるため、一時ディレクトリにファイルをコピーする必要がなくなるため、ビルドプロセスが高速化されます。
サポートされているランタイムとビルドメソッドのリストについては、「`--build-in-source`」を参照してください。
## 例
### 例 1。 .zip ファイルアーカイブ
以下の `sam build` コマンドは、.zip ファイルアーカイブを構築します。
```
# Build all functions and layers, and their dependencies
sam build
# Run the build process inside a Docker container that functions like a Lambda environment
sam build --use-container
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
# Build and run your functions locally
sam build && sam local invoke
# For more options
sam build --help
```
### 例 2: コンテナイメージ
次の AWS SAM テンプレートはコンテナイメージとしてビルドされます。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
PackageType: Image
ImageConfig:
Command: ["app.lambda_handler"]
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
以下は、Dockerfile 例です。
```
FROM public.ecr.aws/lambda/python:3.12
COPY app.py requirements.txt ./
RUN python3.12 -m pip install -r requirements.txt
# Overwrite the command by providing a different command directly in the template.
CMD ["app.lambda_handler"]
```
### 例 3: npm ci
Node.js アプリケーションでは、`npm install`の代わりに、`npm ci`を使用して依存関係をインストールします。`npm ci` を使用するには、Lambda 関数の `Metadata` リソース属性の `BuildProperties` の下に `UseNpmCi: True` を指定します。`npm ci` を使用するには、アプリケーションは Lambda 関数の `CodeUri` に `package-lock.json` または `npm-shrinkwrap.json` ファイルが必要です。
次の例では、`sam build` を実行するときに、`npm ci` を使用して依存関係をインストールします。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.handler
Runtime: nodejs20.x
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Properties:
Path: /hello
Method: get
Metadata:
BuildProperties:
UseNpmCi: True
```
### Python 親パッケージ
Python アプリケーションでは、構築プロセス中にパッケージ構造を保持して絶対インポートを有効にすることができます。パッケージ構造を保持するには、Lambda 関数の `Metadata` リソース属性にある `BuildProperties` で `ParentPackageMode` を指定します。
次の例では、`sam build` を実行するときに `app` パッケージ構造が保持されます。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.main.handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildProperties:
ParentPackageMode: explicit
ParentPackages: app
```
この設定では、コードが `from .utils import logger` のような相対インポートではなく、`from app.utils import logger` のような絶対インポートを使用できます。
## の外部で関数を構築する AWS SAM
デフォルトでは、 を実行すると**sam build**、 はすべての関数リソース AWS SAM を構築します。その他のオプションには以下が含まれます。
+ **の外部ですべての関数リソースを構築する AWS SAM** – すべての関数リソースを手動で構築する場合、または別のツールを使用して構築する場合、 **sam build**は必要ありません。**sam build** をスキップして、ローカルテストの実行やアプリケーションのデプロイなど、プロセスの次のステップに進むことができます。
+ **の外部で一部の関数リソースを構築する AWS SAM** – の外部で他の関数リソース AWS SAM を構築しながら、関数リソースの一部を構築する場合は AWS SAM、 AWS SAM テンプレートで指定できます。
### の外部で一部の関数リソースを構築する AWS SAM
の使用時に で関数を AWS SAM スキップするには**sam build**、 AWS SAM テンプレートで以下を設定します。
1. `SkipBuild: True` メタデータプロパティを関数に追加します。
1. 構築した関数リソースへのパスを指定します。
`TestFunction` がスキップされるように設定した例を次に示します。構築されたリソースは `built-resources/TestFunction.zip` にあります。
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
これで、 を実行すると**sam build**、 AWS SAM は以下を実行します。
1. AWS SAM は、 で設定された関数をスキップします`SkipBuild: True`。
1. AWS SAM は、他のすべての関数リソースをビルドし、`.aws-sam`ビルドディレクトリにキャッシュします。
1. スキップされた関数の場合、`.aws-sam` ビルドディレクトリ内のテンプレートは、構築された関数リソースへの指定されたパスを参照するように自動的に更新されます。
`.aws-sam` ビルドディレクトリの `TestFunction` についてキャッシュされたテンプレートの例を次に示します。
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ../../built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
# でビルドをカスタマイズする AWS SAM
ビルドをカスタマイズして、特定の Lambda 関数または Lambda レイヤーを含めることができます。関数とは、Lambda でコードを実行するために呼び出すことができるリソースです。Lambda レイヤーを使用すると、Lambda 関数からコードを抽出し、複数の Lambda 関数で再利用できます。共有の依存関係やリソースの管理を複雑にすることなく、個々のサーバーレス関数の開発とデプロイに集中する場合は、特定の Lambda 関数を使用してビルドをカスタマイズできます。さらに、デプロイパッケージのサイズを縮小し、コア関数ロジックを依存関係から分離し、複数の関数間で依存関係を共有できるように、Lambda レイヤーを構築することもできます。
このセクションのトピックでは、Lambda 関数を構築するさまざまな方法について説明します AWS SAM。これには、カスタマーランタイムを使用して Lambda 関数を構築し、Lambda レイヤーを構築することが含まれます。カスタムランタイムを使用すると、 AWS Lambda デベロッパーガイドの Lambda ランタイムにリストされていない言語をインストールして使用できます。これにより、サーバーレス関数およびアプリケーションを実行するための特殊な実行環境を作成できます。(アプリケーション全体を構築するのではなく) Lambda レイヤーのみを構築すると、いくつかの点で利点があります。これにより、デプロイパッケージのサイズを縮小し、コア関数ロジックを依存関係から分離し、複数の関数間で依存関係を共有できます。
詳細については、「AWS Lambda デベロッパーガイド」の「[Lambda の概念](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html)」を参照してください。
**Topics**
+ [で esbuild を使用して Node.js Lambda 関数を構築する AWS SAM](serverless-sam-cli-using-build-typescript.md)
+ [でのネイティブ AOT コンパイルを使用した .NET Lambda 関数の構築 AWS SAM](build-dotnet7.md)
+ [Cargo Lambda で を使用して Rust Lambda 関数を構築する AWS SAM](building-rust.md)
+ [uv で を使用して Python Lambda 関数を構築する AWS SAM](building-python-uv.md)
+ [でのカスタムランタイムを使用した Lambda 関数の構築 AWS SAM](building-custom-runtimes.md)
+ [での Lambda レイヤーの構築 AWS SAM](building-layers.md)
# で esbuild を使用して Node.js Lambda 関数を構築する AWS SAM
Node.js AWS Lambda 関数を構築してパッケージ化するには、esbuild AWS SAM CLIJavaScript バンドルャで を使用できます。esbuild バンドラーは TypeScript で記述されて Lambda 関数をサポートします。
esbuild を使用して Node.js Lambda 関数を構築するには、`AWS:Serverless::Function` リソースに `Metadata` オブジェクトを追加し、`BuildMethod` に `esbuild` を指定します。**sam build** コマンドを実行すると、 は esbuild AWS SAM を使用して Lambda 関数コードをバンドルします。
## Metadata プロパティ
`Metadata` オブジェクトは esbuild の以下のプロパティをサポートします。
### BuildMethod
アプリケーションのバンドルを指定します。`esbuild` はサポートされる唯一の値です。
### BuildProperties
Lambda 関数コードの構築プロパティを指定します。
`BuildProperties` オブジェクトは esbuild の以下のプロパティをサポートします。プロパティはすべてオプションです。デフォルトでは、 はエントリポイントに Lambda 関数ハンドラー AWS SAM を使用します。
**EntryPoint**
アプリケーションのエントリポイントを指定します。
**外部**
構築から除外するパッケージのリストを指定します。詳細については、esbuild ウェブサイトの「[External](https://esbuild.github.io/api/#external)」を参照してください。
**形式**
アプリケーションで生成される JavaScript ファイルの出力形式を指定します。詳細については、*esbuild ウェブサイト*で「[Format](https://esbuild.github.io/api/#format)」を参照してください。
**[ローダー]**
特定のファイルタイプのデータをロードするための設定のリストを指定します。
**MainFields**
パッケージを解決する際にインポートを試行する `package.json` フィールドを指定します。デフォルト値は `main,module` です。
**Minify**
バンドルされた出力コードを縮小するかどうかを指定します。デフォルト値は `true` です。
**OutExtension**
esbuild が生成するファイルのファイル拡張子をカスタマイズします。詳細については、*esbuild ウェブサイト*で「[Out extension](https://esbuild.github.io/api/#out-extension)」を参照してください。
**Sourcemap**
バンドラーでソースマップファイルを生成するかどうかを指定します。デフォルト値は `false` です。
`true` に設定すると、`NODE_OPTIONS: --enable-source-maps` が Lambda 関数の環境変数に追加され、ソースマップが生成されて関数に含まれます。
また、`NODE_OPTIONS: --enable-source-maps` が関数の環境変数に含まれると、`Sourcemap` が自動的に `true` に設定されます。
競合する場合、`Sourcemap: false` は `NODE_OPTIONS: --enable-source-maps` より優先されます。
デフォルトでは、Lambda は保存中のすべての環境変数を AWS Key Management Service (AWS KMS) で暗号化します。デプロイを正常に行うには、ソースマップを使用するとき、関数の実行ロールに `kms:Encrypt` アクションを実行するアクセス許可が必要です。
**SourcesContent**
ソースマップファイルにソースコードを含めるかどうかを指定します。`Sourcemap` が `'true'` に設定されている場合、このプロパティを設定します。
+ すべてのソースコードを含めるには `SourcesContent: 'true'` を指定します。
+ すべてのソースコードを除外するには `SourcesContent: 'false'` を指定します。これにより、ソースマップのファイルサイズが小さくなり、起動時間が短縮されるため本番環境で役立ちます。ただし、ソースコードはデバッガーでは使用できません。
デフォルト値は `SourcesContent: true` です。
詳細については、*esbuild ウェブサイト*で「[ソースコンテンツ](https://esbuild.github.io/api/#sources-content)」を参照してください。
**ターゲット**
ターゲットの ECMAScript バージョンを指定します。デフォルト値は `es2020` です。
## TypeScript Lambda 関数の例
次の AWS SAM テンプレートスニペット例では、esbuild を使用して、 の TypeScript コードから Node.js Lambda 関数を作成します`hello-world/app.ts`。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.handler
Runtime: nodejs20.x
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Properties:
Path: /hello
Method: get
Environment:
Variables:
NODE_OPTIONS: --enable-source-maps
Metadata:
BuildMethod: esbuild
BuildProperties:
Format: esm
Minify: false
OutExtension:
- .js=.mjs
Target: "es2020"
Sourcemap: true
EntryPoints:
- app.ts
External:
- ""
```
# でのネイティブ AOT コンパイルを使用した .NET Lambda 関数の構築 AWS SAM
( AWS Serverless Application Model AWS SAM) を使用して .NET 8 AWS Lambda 関数を構築およびパッケージ化し、ネイティブAhead-of-TimeAOT) コンパイルを利用して AWS Lambda コールドスタート時間を短縮します。
**Topics**
+ [.NET 8 ネイティブ AOT の概要](#build-dotnet7-overview)
+ [.NET 8 Lambda 関数 AWS SAM での の使用](#build-dotnet7-sam)
+ [インストール条件](#build-dotnet7-prerequisites)
+ [AWS SAM テンプレートで .NET 8 Lambda 関数を定義する](#build-dotnet7-sam-define)
+ [AWS SAM CLI を使用してアプリケーションを構築する](#build-dotnet7-sam-build)
+ [詳細情報](#build-dotnet7-learn-more)
## .NET 8 ネイティブ AOT の概要
従来の .NET Lambda 関数にはコールドスタート時間があり、それがユーザーエクスペリエンスを損ね、システムのレイテンシーやサーバーレスアプリケーションの使用コストに影響を及ぼしていました。.NET ネイティブ AOT コンパイルを使用すると、Lambda 関数のコールドスタート時間を短縮できます。.NET 8 のネイティブ AOT の詳細については、GitHub の dotnet リポジトリで「[ネイティブ AOT の使用](https://github.com/dotnet/runtime/tree/main/src/coreclr/nativeaot#readme)」を参照してください。
## .NET 8 Lambda 関数 AWS SAM での の使用
AWS Serverless Application Model (AWS SAM) を使用して.NET 8 Lambda 関数を設定するには、次の手順を実行します。
+ 開発マシンに前提条件をインストールする。
+ AWS SAM テンプレートで .NET 8 Lambda 関数を定義します。
+ を使用してアプリケーションを構築します AWS SAM CLI。
## インストール条件
以下がインストールの前提条件となります。
+ AWS SAM CLI「��
+ .NET Core CLI
+ Amazon.Lambda.Tools .NET Core Global Tool
+ Docker
**AWS SAM CLI のインストール**
1. AWS SAM CLI がインストールされているかを確認するには、次のコマンドを実行します。
```
sam --version
```
1. をインストールするには AWS SAM CLI、「」を参照してください[AWS SAM CLI のインストール](install-sam-cli.md)。
1. のインストール済みバージョンをアップグレードするには AWS SAM CLI、「」を参照してください[AWS SAM CLI のアップグレード](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade)。
**.NET Core CLI をインストールする**
1. .NET Core CLI をダウンロードしてインストールするには、Microsoft の Web サイトで「[.NET のダウンロード](https://dotnet.microsoft.com/download)」を参照してください。
1. NET Core CLI の詳細については、「*AWS Lambda デベロッパーガイド*」の「[.NET Core CLI](https://docs.aws.amazon.com/lambda/latest/dg/csharp-package-cli.html)」を参照してください。
**Amazon.Lambda.Tools .NET Core Global Tool をインストールする**
1. 次のコマンドを実行します。
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. ツールがすでにインストールされている場合には、次のコマンドを実行し、最新バージョンを使用していることを確認します。
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Amazon.Lambda.Tools の .NET Core Global Tool の詳細については、GitHub の [AWS Extensions for .NET CLI](https://github.com/aws/aws-extensions-for-dotnet-cli) リポジトリを参照してください。
**Docker をインストールする**
+ ネイティブ AOT を構築に使用するには、Docker をインストールする必要があります。インストール手順については、「[AWS SAM CLI で Docker を使用するためのインストール方法](install-docker.md)」を参照してください。
## AWS SAM テンプレートで .NET 8 Lambda 関数を定義する
AWS SAM テンプレートで .NET8 Lambda 関数を定義するには、次の手順を実行します。
1. 選択した開始ディレクトリから次のコマンドを実行します。
```
sam init
```
1. `AWS Quick Start Templates` を選択して開始テンプレートを選択します。
1. `Hello World Example` テンプレートを選択します。
1. `n` を入力して、最も人気のあるランタイムとパッケージタイプを使用しないことを選択します。
1. ランタイムで、`dotnet8` を選択します。
1. パッケージタイプで、`Zip` を選択します。
1. スターターテンプレートで、`Hello World Example using native AOT` を選択します。
**Docker をインストールする**
+ ネイティブ AOT を構築に使用するには、Docker をインストールする必要があります。インストール手順については、「[AWS SAM CLI で Docker を使用するためのインストール方法](install-docker.md)」を参照してください。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src/HelloWorldAot/
Handler: bootstrap
Runtime: dotnet8
Architectures:
- x86_64
Events:
HelloWorldAot:
Type: Api
Properties:
Path: /hello
Method: get
```
**注記**
の `Event`プロパティ`AWS::Serverless::Function`が に設定されているが`Api`、 `RestApiId`プロパティが指定されていない場合、 は`AWS::ApiGateway::RestApi` CloudFormation リソース AWS SAM を生成します。
## AWS SAM CLI を使用してアプリケーションを構築する
プロジェクトのルートディレクトリから `sam build` コマンドを実行して、アプリケーションの構築を開始します。.NET 8 プロジェクトファイルで `PublishAot` プロパティを定義済みの場合、 AWS SAM CLI はネイティブ AOT コンパイルにより構築されます。`PublishAot` プロパティの詳細については、Microsoft の「*.NET ドキュメント*」で「[ネイティブ AOT デプロイ](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/)」を参照してください。
関数を構築する際、 AWS SAM CLI は Amazon.Lambda.Tools .NET Core Global Tool を使用する .NET Core CLI を呼び出します。
**注記**
構築時にプロジェクトの同じディレクトリか親ディレクトリに `.sln` ファイルが存在する場合、`.sln` ファイルが格納されたディレクトリがコンテナにマウントされます。`.sln` ファイルが見つからない場合は、プロジェクトフォルダだけがマウントされます。そのためマルチプロジェクトアプリケーションを構築する場合は、`.sln` ファイルが存在することを確認してください。
## 詳細情報
.NET 8 Lambda 関数の構築の詳細については、「[AWS Lambdaの .NET 8 ランタイムの紹介](https://aws.amazon.com/blogs/compute/introducing-the-net-8-runtime-for-aws-lambda/)」を参照してください。
**sam build** コマンドのリファレンスについては、「[sam build](sam-cli-command-reference-sam-build.md)」を参照してください。
# Cargo Lambda で を使用して Rust Lambda 関数を構築する AWS SAM
| |
| --- |
| この機能は のプレビューリリースであり AWS SAM 、変更される可能性があります。 |
Rust AWS Lambda 関数で AWS Serverless Application Model コマンドラインインターフェイス (AWS SAM CLI) を使用します。
**Topics**
+ [前提条件](#building-rust-prerequisites)
+ [Rust Lambda 関数で使用する AWS SAM ための の設定](#building-rust-configure)
+ [例](#building-rust-examples)
## 前提条件
**Rust 言語**
Rust をインストールするには、Rust 言語ウェブサイトの「[Rust をインストールする](https://www.rust-lang.org/tools/install)」を参照してください。
**Cargo Lambda**
AWS SAM CLI では、Cargo のサブコマンドである [https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html) のインストールが必要です。インストール手順については、「*Cargo Lambda ドキュメント*」で「[Installation](https://www.cargo-lambda.info/guide/installation.html)」を参照してください。
**Docker**
Rust Lambda 関数の構築とテストには Docker が必要です。インストール手順については、「[Docker のインストール](install-docker.md)」を参照してください。
** AWS SAM CLI ベータ機能にオプトインする**
この機能はプレビュー段階にあるため、次のいずれかの方法を使用してオプトインする必要があります。
1. 次の環境変数を使用します: `SAM_CLI_BETA_RUST_CARGO_LAMBDA=1`。
1. 次のコードを `samconfig.toml` ファイルに追加します。
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. サポートされている AWS SAM CLI のコマンドを使用する場合は、`--beta-features` オプションを使用します。例えば、次のようになります。
```
$ sam build --beta-features
```
1. AWS SAM CLI でオプトインするよう促すプロンプトが表示されたら、オプション `y` を選択します。以下に例を示します。
```
$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Rust Lambda 関数で使用する AWS SAM ための の設定
### ステップ 1: AWS SAM テンプレートを設定する
以下を使用して AWS SAM テンプレートを設定します。
+ **Binary** – オプション。テンプレートに複数の Rust Lambda 関数が含まれる場合に指定します。
+ **BuildMethod** – `rust-cargolambda`。
+ **CodeUri** – `Cargo.toml` ファイルへのパス。
+ **Handler** – `bootstrap`。
+ **Runtime** – `provided.al2`。
カスタムランタイムの詳細については、「 *AWS Lambda デベロッパーガイド*」の[「カスタム AWS Lambda ランタイム](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html)」を参照してください。
設定済み AWS SAM テンプレートの例を次に示します。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties: function_a
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
...
```
### ステップ 2: Rust Lambda 関数で AWS SAM CLI を使用する
AWS SAM テンプレートで任意の AWS SAM CLIコマンドを使用します。詳細については、「[AWS SAM CLI](using-sam-cli.md)」を参照してください。
## 例
### Hello World の例
**この例では、ランタイムとして Rust を使用してサンプルの Hello World アプリケーションを構築します。**
まず、`sam init` を使用して新しいサーバーレスアプリケーションを初期化します。インタラクティブフロー中に、**[Hello World アプリケーション]** を選択し、**[Rust]** ランタイムを選択します。
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
1 - dotnet8
2 - dotnet6
3 - go (provided.al2)
...
18 - python3.11
19 - python3.10
20 - ruby3.3
21 - ruby3.2
22 - rust (provided.al2)
23 - rust (provided.al2023)
Runtime: 22
Based on your selections, the only Package type available is Zip.
We will proceed to selecting the Package type as Zip.
Based on your selections, the only dependency manager available is cargo.
We will proceed copying the template using cargo.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: hello-rust
-----------------------
Generating application:
-----------------------
Name: hello-rust
Runtime: rust (provided.al2)
Architectures: x86_64
Dependency Manager: cargo
Application Template: hello-world
Output Directory: .
Configuration file: hello-rust/samconfig.toml
Next steps can be found in the README file at hello-rust/README.md
Commands you can use next
=========================
[*] Create pipeline: cd hello-rust && sam pipeline init --bootstrap
[*] Validate SAM template: cd hello-rust && sam validate
[*] Test Function in the Cloud: cd hello-rust && sam sync --stack-name {stack-name} --watch
```
Hello World アプリケーションの構造を次に示します。
```
hello-rust
├── README.md
├── events
│ └── event.json
├── rust_app
│ ├── Cargo.toml
│ └── src
│ └── main.rs
├── samconfig.toml
└── template.yaml
```
AWS SAM テンプレートでは、Rust関数は次のように定義されます。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Path: /hello
Method: get
```
次に、`sam build` を実行してアプリケーションを構築し、デプロイの準備をします。 AWS SAM CLI は `.aws-sam` ディレクトリを作成し、そこにビルドアーティファクトを整理します。関数は Cargo Lambda を使用して構築され、実行可能バイナリとして `.aws-sam/build/HelloWorldFunction/bootstrap` に保存されます。
**注記**
MacOS で **sam local invoke** コマンドを実行する予定がある場合は、呼び出す前に関数を別の方法で構築する必要があります。これを行うには、次のコマンドを使用します。
**SAM\$1BUILD\$1MODE=debug sam build**
このコマンドは、ローカルテストが行われる場合にのみ必要です。これは、デプロイ用に構築する場合は推奨されません。
```
hello-rust$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-rust/rust_app runtime: provided.al2 metadata: {'BuildMethod': 'rust-cargolambda'} architecture: x86_64 functions: HelloWorldFunction
Running RustCargoLambdaBuilder:CargoLambdaBuild
Running RustCargoLambdaBuilder:RustCopyAndRename
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
次に、`sam deploy --guided` を使用してアプリケーションをデプロイします。
```
hello-rust$ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [hello-rust]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: ENTER
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
Looking for resources needed for deployment:
...
Uploading to hello-rust/56ba6585d80577dd82a7eaaee5945c0b 817973 / 817973 (100.00%)
Deploying with following values
===============================
Stack name : hello-rust
Region : us-west-2
Confirm changeset : True
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
Uploading to hello-rust/a4fc54cb6ab75dd0129e4cdb564b5e89.template 1239 / 1239 (100.00%)
Waiting for changeset to be created..
CloudFormation stack changeset
---------------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
---------------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHelloW AWS::Lambda::Permission N/A
orldPermissionProd
...
---------------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1681427201/f0ef1563-5ab6-4b07-9361-864ca3de6ad6
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-13 13:07:17 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
---------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
...
---------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
---------------------------------------------------------------------------------------------------------
Outputs
---------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/hello-rust-HelloWorldFunctionRole-10II2P13AUDUY
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:hello-rust-HelloWorldFunction-
yk4HzGzYeZBj
---------------------------------------------------------------------------------------------------------
Successfully created/updated stack - hello-rust in us-west-2
```
テストするには、API エンドポイントを使用して Lambda 関数を呼び出します。
```
$ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Hello World!%
```
関数をローカルでテストするには、まず関数の `Architectures` プロパティがローカルマシンと一致するようにします。
```
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
Metadata:
BuildMethod: rust-cargolambda # More info about Cargo Lambda: https://github.com/cargo-lambda/cargo-lambda
Properties:
CodeUri: ./rust_app # Points to dir of Cargo.toml
Handler: bootstrap # Do not change, as this is the default executable name produced by Cargo Lambda
Runtime: provided.al2
Architectures:
- arm64
...
```
この例ではアーキテクチャを `x86_64` から `arm64` に変更したため、ビルドアーティファクトを更新するために `sam build` を実行します。その後、ローカルで関数を呼び出すために `sam local invoke` を実行します。
```
hello-rust$ sam local invoke
Invoking bootstrap (provided.al2)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-provided.al2
Building image.....................................................................................................................................
Using local image: public.ecr.aws/lambda/provided:al2-rapid-arm64.
Mounting /Users/.../hello-rust/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
START RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Version: $LATEST
{"statusCode":200,"body":"Hello World!"}END RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6
REPORT RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Init Duration: 0.68 ms Duration: 130.63 ms Billed Duration: 131 ms Memory Size: 128 MB Max Memory Used: 128 MB
```
### 単一 Lambda 関数プロジェクト
**1 つの Rust Lambda 関数を含むサーバーレスアプリケーションの例を次に示します。**
プロジェクトのディレクトリ構造:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ └── main.rs
└── template.yaml
```
AWS SAM テンプレート:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
...
```
### 複数の Lambda 関数プロジェクト
**複数の Rust Lambda 関数を含むサーバーレスアプリケーションの例を次に示します。**
プロジェクトのディレクトリ構造:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ ├── function_a.rs
│ └── function_b.rs
└── template.yaml
```
AWS SAM テンプレート:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
FunctionA:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_a
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
FunctionB:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_b
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
```
`Cargo.toml` ファイル:
```
[package]
name = "test-handler"
version = "0.1.0"
edition = "2021"
[dependencies]
lambda_runtime = "0.6.0"
serde = "1.0.136"
tokio = { version = "1", features = ["macros"] }
tracing = { version = "0.1", features = ["log"] }
tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
[[bin]]
name = "function_a"
path = "src/function_a.rs"
[[bin]]
name = "function_b"
path = "src/function_b.rs"
```
# uv で を使用して Python Lambda 関数を構築する AWS SAM
| |
| --- |
| この機能は のプレビューリリースであり AWS SAM 、変更される可能性があります。 |
高速 Python パッケージインストーラおよびリゾルバーuvである で AWS Serverless Application Model コマンドラインインターフェイス (AWS SAM CLI) を使用して、Python AWS Lambda 関数を構築します。
**Topics**
+ [前提条件](#building-python-uv-prerequisites)
+ [Python Lambda 関数と で使用する AWS SAM ように を設定する uv](#building-python-uv-configure)
+ [例](#building-python-uv-examples)
## 前提条件
**Python**
Python をインストールするには、[Python ウェブサイトの「Python のダウンロード](https://www.python.org/downloads/)」を参照してください。 **
**uv**
には[https://docs.astral.sh/uv/](https://docs.astral.sh/uv/)、非常に高速な Python パッケージインストーラおよびリゾルバーである のインストール AWS SAM CLIが必要です。インストール手順については、「*uv ドキュメント*」で「[Installation](https://docs.astral.sh/uv/getting-started/installation/)」を参照してください。
** AWS SAM CLI ベータ機能にオプトインする**
この機能はプレビュー段階にあるため、次のいずれかの方法を使用してオプトインする必要があります。
1. 次の環境変数を使用します: `SAM_CLI_BETA_PYTHON_UV=1`。
1. 次のコードを `samconfig.toml` ファイルに追加します。
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. サポートされている AWS SAM CLI のコマンドを使用する場合は、`--beta-features` オプションを使用します。例えば、次のようになります。
```
$ sam build --beta-features
```
1. AWS SAM CLI でオプトインするよう促すプロンプトが表示されたら、オプション `y` を選択します。以下に例を示します。
```
$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Python Lambda 関数と で使用する AWS SAM ように を設定する uv
### ステップ 1: AWS SAM テンプレートを設定する
以下を使用して AWS SAM テンプレートを設定します。
+ **BuildMethod** – `python-uv`。
+ **CodeUri** – `pyproject.toml`または を含む関数コードディレクトリへのパス`requirements.txt`。
+ **ハンドラー** – 関数ハンドラー (例: `app.lambda_handler`)。
+ **ランタイム** – Python ランタイムバージョン (例: `python3.12`)。
設定済みの AWS SAM テンプレートの例を次に示します。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./my_function
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: python-uv
...
```
## 例
### Hello World の例
**この例では、Python をパッケージマネージャーuvとして使用してサンプル Hello World アプリケーションを構築します。**
uv は、 `pyproject.toml`または `requirements.txt` を使用して依存関係を読み取ることができます。両方が指定されている場合、 `sam build`は依存関係`requirements.txt`の から読み取ります。
Hello World アプリケーションの構造を次に示します。
```
hello-python-uv
├── README.md
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── pyproject.toml
├── samconfig.toml
└── template.yaml
```
`pyproject.toml` ファイル:
```
[project]
name = "my-function"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
"requests>=2.31.0",
"boto3>=1.28.0",
]
```
AWS SAM テンプレートでは、Python 関数は次のように定義されます。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildMethod: python-uv
```
次に、`sam build` を実行してアプリケーションを構築し、デプロイの準備をします。 AWS SAM CLI は `.aws-sam` ディレクトリを作成し、そこにビルドアーティファクトを整理します。関数の依存関係は、 を使用してインストールuvされ、 に保存されます`.aws-sam/build/HelloWorldFunction/`。
```
hello-python-uv$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-python-uv/hello_world runtime: python3.12 metadata: {'BuildMethod': 'python-uv'} architecture: x86_64 functions: HelloWorldFunction
Running PythonUvBuilder:UvBuild
Running PythonUvBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
**注記**
`python-uv` ビルドメソッドは、 `Metadata`セクションの関数ごとに設定されます。テンプレート内の各関数は異なるビルドメソッドを使用できるため、 uvベースの関数を同じ AWS SAM テンプレート内の `pip`ベースの関数と混在させることができます。ビルドメソッドが指定されていない場合は、デフォルトで `pip` が使用されます。
# でのカスタムランタイムを使用した Lambda 関数の構築 AWS SAM
`sam build` コマンドを使用して、Lambda 関数に必要なカスタムランタイムを構築できます。Lambda 関数に `Runtime: provided` を指定することによって、その関数がカスタムランタイムを使用するように宣言します。
カスタムランタイムを構築するには、`BuildMethod: makefile` エントリを使用して `Metadata` リソース属性を宣言します。ユーザーは、ランタイムの build コマンドが含まれた `build-function-logical-id` フォームのビルドターゲットを宣言するカスタム makefile を提供します。Makefile は、必要に応じてカスタムランタイムをコンパイルして、ワークフローにおける後続のステップに必要となる適切な場所にビルドアーティファクトをコピーする責任を担います。Makefile の場所は、関数リソースの `CodeUri` プロパティによって指定され、`Makefile` と命名される必要があります。
## 例
### 例 1: Rust で記述された関数用のカスタムランタイム
**注記**
Cargo Lambda を使用して Lambda 関数を構築することをお勧めします。詳細については[Cargo Lambda で を使用して Rust Lambda 関数を構築する AWS SAM](building-rust.md)を参照してください。
次の AWS SAM テンプレートは、Rust で記述された Lambda 関数にカスタムランタイムを使用する関数を宣言し、`build-HelloRustFunction`ビルドターゲットのコマンドを実行する`sam build`ように に指示します。
```
Resources:
HelloRustFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: HelloRust
Handler: bootstrap.is.real.handler
Runtime: provided
MemorySize: 512
CodeUri: .
Metadata:
BuildMethod: makefile
```
以下の makefile には、ビルドターゲットと実行されるコマンドが含まれています。`CodeUri` プロパティが `.` に設定されていることから、makefile がプロジェクトのルートディレクトリ (つまり、アプリケーションの AWS SAM テンプレートファイルと同じディレクトリ) に置かれている必要があることに注意してください。ファイル名は `Makefile` にする必要があります。
```
build-HelloRustFunction:
cargo build --release --target x86_64-unknown-linux-musl
cp ./target/x86_64-unknown-linux-musl/release/bootstrap $(ARTIFACTS_DIR)
```
上記の `makefile` で `cargo build` コマンドを実行するための開発環境のセットアップに関する詳細については、「[Rust Runtime for AWS Lambda](https://aws.amazon.com/blogs/opensource/rust-runtime-for-aws-lambda/)」ブログ記事を参照してください。
### 例 2: Python 3.12 用の makefile ビルダー (バンドルされたビルダーの代わりに使用)
バンドルされたビルダーに含まれていないライブラリやモジュールを使用したい場合があります。この例では、makefile ビルダーを使用した Python3.12 ランタイムの AWS SAM テンプレートを示しています。
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: makefile
```
以下の makefile には、ビルドターゲットと実行されるコマンドが含まれています。`CodeUri` プロパティが `hello_world` に設定されているため、makefile は `hello_world` サブディレクトリのルートに置き、ファイル名を `Makefile` にする必要があることに注意してください。
```
build-HelloWorldFunction:
cp *.py $(ARTIFACTS_DIR)
cp requirements.txt $(ARTIFACTS_DIR)
python -m pip install -r requirements.txt -t $(ARTIFACTS_DIR)
rm -rf $(ARTIFACTS_DIR)/bin
```
# での Lambda レイヤーの構築 AWS SAM
を使用して AWS SAM カスタム Lambda レイヤーを構築できます。Lambda レイヤーを使用すると、Lambda 関数からコードを抽出し、複数の Lambda 関数で再利用できます。(アプリケーション全体を構築するのではなく) Lambda レイヤーのみを構築すると、いくつかの点で利点があります。これにより、デプロイパッケージのサイズを縮小し、コア関数ロジックを依存関係から分離し、複数の関数間で依存関係を共有できます。レイヤーの詳細については、*AWS Lambda デベロッパーガイド*の「[AWS Lambda レイヤー](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)」参照してください。
## で Lambda レイヤーを構築する方法 AWS SAM
**注記**
Lambda レイヤーを構築する前に、まず AWS SAM テンプレートに Lambda レイヤーを記述する必要があります。これを行う方法についての詳細と例については、「[で Lambda レイヤーを使用して効率を向上させる AWS SAM](serverless-sam-cli-layers.md)」を参照してください。
カスタムレイヤーを構築するには、それを AWS Serverless Application Model (AWS SAM) テンプレートファイルに宣言し、`Metadata`リソース属性セクションを`BuildMethod`エントリに含めます。`BuildMethod` に有効な値は、[AWS Lambda ランタイム](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html)の識別子、または `makefile` です。`BuildArchitecture` エントリを含めて、レイヤーがサポートする命令セットアーキテクチャを指定します。`BuildArchitecture` の有効値は、[Lambda 命令セットアーキテクチャ](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html)です。
`makefile` を指定する場合は、レイヤーの build コマンドが含まれた `build-layer-logical-id` フォームのビルドターゲットを宣言するカスタム makefile を提供します。Makefile は、必要に応じてレイヤーをコンパイルして、ワークフローにおける後続のステップに必要となる適切な場所にビルドアーティファクトをコピーする責任を担います。Makefile の場所は、レイヤーリソースの `ContentUri` プロパティによって指定され、`Makefile` と命名される必要があります。
**注記**
カスタムレイヤーを作成すると、 は環境変数 AWS Lambda に応じてレイヤーコードを見つけます。Lambda ランタイムは、レイヤーコードがコピーされた `/opt` ディレクトリにパスを含めます。カスタムレイヤーコードを見つけられるようにするため、プロジェクトのビルドアーティファクトのフォルダ構造が、ランタイムが期待するフォルダ構造と一致している必要があります。
例えば、Python ではコードを `python/` サブディレクトリに置くことができます。NodeJS では、コードを `nodejs/node_modules/` サブディレクトリに置くことができます。
詳細については、*AWS Lambda デベロッパーガイド*の「[ライブラリの依存関係をレイヤーに含める](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-path)」を参照してください。
以下は、`Metadata` リソース属性セクションの例です。
```
Metadata:
BuildMethod: python3.12
BuildArchitecture: arm64
```
**注記**
`Metadata` リソース属性セクションを含めない場合、 AWS SAM はレイヤーを構築しません。その代わりに、レイヤーリソースの `CodeUri` プロパティで指定された場所からビルドアーティファクトをコピーします。詳細については、`AWS::Serverless::LayerVersion` リソースタイプの「[ContentUri](sam-resource-layerversion.md#sam-layerversion-contenturi)」プロパティを参照してください。
`Metadata` リソース属性セクションを含めると、 `sam build` コマンドを使用して、独立したオブジェクトとして、または AWS Lambda 関数の依存関係としてレイヤーを構築できます。
+ ****独立したオブジェクトとして。****レイヤーに対するコード変更をローカルでテストしており、アプリケーション全体を構築する必要がないときなど、レイヤーオブジェクトだけを構築したい場合があります。レイヤーを個別に構築するには、`sam build layer-logical-id` コマンドでレイヤーリソースを指定します。
+ **Lambda 関数の依存関係として。**同じ AWS SAM テンプレートファイルにある Lambda 関数の `Layers` プロパティにレイヤーの論理 ID を含めると、レイヤーはその Lambda 関数の依存関係になります。そのレイヤーに `BuildMethod` エントリがある `Metadata` リソース属性セクションも含める場合は、`sam build` コマンドを使用してアプリケーション全体を構築する、または `sam build function-logical-id` コマンドで関数リソースを指定することによってレイヤーを構築します。
## 例
### テンプレート例 1: Python 3.12 ランタイム環境に対してレイヤーを構築する
次のサンプル AWS SAM テンプレートは、Python 3.12 ランタイム環境に対してレイヤーを構築します。
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: python3.12 # Required to have AWS SAM build this layer
```
### テンプレート例 2: カスタム makefile を使用してレイヤーを構築する
次のサンプル AWS SAM テンプレートでは、カスタム `makefile` を使用してレイヤーを構築します。
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: makefile
```
以下の `makefile` には、ビルドターゲットと実行されるコマンドが含まれています。`ContentUri` プロパティが `my_layer` に設定されているため、makefile は `my_layer` サブディレクトリのルートに置き、ファイル名を `Makefile` にする必要があることに注意してください。また、ビルドアーティファクトは `python/`サブディレクトリにコピーされるため、 AWS Lambda はレイヤーコードを見つけることができます。
```
build-MyLayer:
mkdir -p "$(ARTIFACTS_DIR)/python"
cp *.py "$(ARTIFACTS_DIR)/python"
python -m pip install -r requirements.txt -t "$(ARTIFACTS_DIR)/python"
```
**注記**
`makefile` が呼び出されると、適切なターゲットがトリガーされ、アーティファクトが公開された環境変数 `$ARTIFACTS_DIR` にコピーされます。詳細については、GitHub で「[aws-lambda-builders](https://github.com/aws/aws-lambda-builders/blob/develop/aws_lambda_builders/workflows/custom_make/DESIGN.md)」を参照してください。
### sam build コマンドの例
以下の `sam build` コマンドは、`Metadata` リソース属性セクションが含まれたレイヤーを構築します。
```
# Build the 'layer-logical-id' resource independently
$ sam build layer-logical-id
# Build the 'function-logical-id' resource and layers that this function depends on
$ sam build function-logical-id
# Build the entire application, including the layers that any function depends on
$ sam build
```