# AWS Lambda 関数の設定
Lambda API またはコンソールを使用して、Lambda 関数の中核的な機能とオプションを設定する方法を学びます。
**[.zip ファイルアーカイブ](configuration-function-zip.md) **
依存関係、カスタムランタイムのレイヤー、関数コード以外のファイルを含める場合、Lambda 関数のデプロイパッケージを作成します。デプロイパッケージは、関数コードおよびその依存関係を含む .zip ファイルアーカイブです。
**[コンテナイメージ](images-create.md) **
ビルドプロセスをより詳細に制御する必要がある場合、または関数にカスタムランタイム設定が必要な場合、コンテナイメージを使用して関数コードおよび依存関係をパッケージ化します。Docker CLI などのツールを使用し、Lambda 関数をコンテナイメージとして構築、テスト、デプロイすることができます。
**[メモリ](configuration-memory.md)**
関数のメモリを増やす方法とタイミングについて説明します。
**[エフェメラルストレージ](configuration-ephemeral-storage.md) **
関数の一時ストレージ容量を増やす方法とタイミングについて説明します。
**[タイムアウト](configuration-timeout.md) **
関数のタイムアウト値を増やす方法とタイミングについて説明します。
**[耐久性のある設定](durable-configuration.md) **
呼び出し間の状態を維持しながら、Lambda 関数を長期間実行 (最大 1 年間) できるようにします。長時間のステートフルワークフローに実行タイムアウト、状態保持、バージョニング動作を設定します。耐久性のある関数により、一時停止、再開、自動的に中断を処理できる複雑な複数ステップのプロセスを構築できます。
** [環境変数](configuration-envvars.md)**
環境変数を使用することによって、関数コードを移植可能にするとともに、シークレットを関数の設定内に保存することで、それらがコードに含まれないようにします。
**[アウトバウンドネットワーク](configuration-vpc.md) **
Lambda 関数は、Amazon VPC 内の AWS リソースと使用できます。関数を VPC に接続すると、リレーショナルデータベースやキャッシュなどのプライベートサブネットのリソースにアクセスできます。
** [インバウンドネットワーク](configuration-vpc-endpoints.md)**
インターフェイス VPC エンドポイントを使用して、パブリックインターネットを経由せずに Lambda 関数を呼び出すことができます。
**[ファイルシステム](configuration-filesystem.md)**
Lambda 関数を使用して、Amazon EFS をローカルディレクトリにマウントすることができます。ファイルシステムは、関数コードが安全かつ高い同時実行性で共有リソースにアクセスし、変更することを可能にします。
**[エイリアス](configuration-aliases.md)**
エイリアスを使用することによって、クライアントを更新する代わりに、特定の Lambda 関数バージョンを呼び出すようにクライアントを設定できます。
**[バージョン](configuration-versions.md)**
関数のバージョンを発行することによって、変更できない別個のリソースとしてコードと設定を保存できます。
**[タグ](configuration-tags.md)**
タグを使用すると、属性ベースのアクセス制御 (ABAC) の有効化、Lambda 関数の整理、ならびに AWS Cost Explorer または AWS Billing and Cost Management サービスを使用した関数のフィルタリングおよび関数のレポートの生成が可能になります。
**[レスポンスストリーミング](configuration-response-streaming.md)**
Lambda 関数 URL を設定して、レスポンスペイロードをクライアントにストリーミングで返すようにできます。レスポンスストリーミングは、最初のバイトまでの時間 (TTFB) のパフォーマンスを向上させることで、レイテンシーの影響を受けやすいアプリケーションに役立ちます。これは、レスポンスの一部が利用可能になったときにクライアントに返送できるためです。さらに、レスポンスストリーミングを使用して、より大きなペイロードを返す関数を構築できます。
**[メタデータエンドポイント](configuration-metadata-endpoint.md)**
Lambda メタデータエンドポイントを使用して、関数が実行されているアベイラビリティーゾーンを検出し、同じ AZ リソースにルーティングしてレイテンシーを最適化し、AZ 対応のレジリエンスパターンを実装できます。
# Lambda 関数の .zip ファイルアーカイブとしてのデプロイ
Lambda 関数を作成する場合、関数コードをデプロイパッケージにパッケージ化します。Lambda は、コンテナイメージと .zip ファイルアーカイブの 2 種類のデプロイパッケージをサポートします。関数を作成するワークフローは、デプロイパッケージの種類によって異なります。コンテナイメージとして定義される関数の作成については、[コンテナイメージを使用した Lambda 関数の作成](images-create.md)を参照してください。
Lambda コンソールと Lambda API を使用して、.zip ファイルアーカイブで定義された関数を作成できます。更新済みの .zip ファイルをアップロードして、関数コードを変更することもできます。
**注記**
既存の関数の[デプロイパッケージタイプ](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip またはコンテナイメージ) を変更することはできません。例えば、既存のコンテナイメージ関数を、.zip ファイルアーカイブを使用するように変換することはできません。この場合は、新しい関数を作成する必要があります。
**Topics**
+ [
## 関数の作成
](#configuration-function-create)
+ [
## コンソールのコードエディタの使用
](#configuration-functions-console-update)
+ [
## 関数コードの更新
](#configuration-function-update)
+ [
## ランタイムの変更
](#configuration-function-runtime)
+ [
## アーキテクチャの変更
](#configuration-function-arch)
+ [
## Lambda API の使用
](#configuration-function-api)
+ [
## 関数コードのダウンロード
](#configuration-function-download)
+ [
## CloudFormation
](#configuration-function-cloudformation)
+ [
# Lambda .zip デプロイパッケージの暗号化
](encrypt-zip-package.md)
## 関数の作成
.zip ファイルアーカイブで定義した関数を作成する場合、その関数のコードテンプレート、言語バージョン、実行ロールを選択します。Lambda が関数を作成したら、関数コードを追加します。
**関数を作成するには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. [**関数の作成**] を選択してください。
1. [**Author from scratch**] (ゼロから作る) または [**Use a blueprint**] (設計図の使用) を選択して関数を作成します。
1. **[基本的な情報]** で、以下を実行します。
1. [**関数名**] に関数名を入力します。関数名の長さは 64 文字に制限されています。
1. [**Runtime**] (ランタイム) で、関数で使用する言語バージョンを選択します。
1. (オプション) **アーキテクチャ**で、関数に使用する命令セットアーキテクチャを選択します。デフォルトのアーキテクチャは x86\$164 です。関数用のデプロイパッケージを構築するときは、この[命令セットアーキテクチャ](foundation-arch.md)と互換性があることを確認してください。
1. (オプション) [**アクセス権限**] で、[**デフォルトの実行ロールの変更**] を展開します。**実行ロール**を使用することも、既存のロールを使用することもできます。
1. (オプション) [**詳細設定**] を展開します。関数の [**Code signing configuration**] (コード署名設定) を選択します。関数がアクセスできるように (Amazon VPC) を設定することもできます。
1. [**Create function**] (関数の作成) をクリックします。
Lambda によって、新しい関数が作成されます。コンソールを使用して関数コードを追加し、他の関数のパラメータや機能を設定できるようになりました。コードのデプロイに関する手順については、関数が使用するランタイムのハンドラーページを参照してください。
------
#### [ Node.js ]
[.zip ファイルアーカイブで Node.js Lambda 関数をデプロイする](nodejs-package.md)
------
#### [ Python ]
[Python Lambda 関数で .zip ファイルアーカイブを使用する](python-package.md)
------
#### [ Ruby ]
[.zip ファイルアーカイブで Ruby Lambda 関数をデプロイする](ruby-package.md)
------
#### [ Java ]
[.zip または JAR ファイルアーカイブで Java Lambda 関数をデプロイする](java-package.md)
------
#### [ Go ]
[.zip ファイルアーカイブを使用して Go Lambda 関数をデプロイする](golang-package.md)
------
#### [ C\$1 ]
[.zip ファイルアーカイブを使用して C\$1 Lambda 関数を構築し、デプロイする](csharp-package.md)
------
#### [ PowerShell ]
[.zip ファイルアーカイブを使用した PowerShell Lambda 関数のデプロイする](powershell-package.md)
------
## コンソールのコードエディタの使用
コンソールで、単一のソースファイルを含む Lambda 関数が作成されます。スクリプト言語の場合、このファイルを編集し、組み込みのコードエディタを使用してファイルをさらに追加することができます。変更を保存するには [**保存**] を選択します。コードを実行するには、[**Test**] (テスト) を選択します。
関数コードを保存すると、Lambda コンソールは .zip ファイルアーカイブのデプロイパッケージを作成します。コンソール外で (SDE を使用して) 関数コードを開発するときは、[デプロイパッケージを作成して](nodejs-package.md)、Lambda 関数にコードをアップロードします。
## 関数コードの更新
スクリプト言語 (Node.js, Python, and Ruby) の場合は、組み込みのコードエディタで関数コードを編集することができます。コードが 3 MBを超える場合、またはライブラリを追加する必要がある場合、またはエディタでサポートされていない言語 (Java, Go, C\$1) の場合は、関数コードを .zip アーカイブとしてアップロードする必要があります。.zip ファイルアーカイブが 50 MB 未満の場合は、ローカルマシンから .zip ファイルアーカイブをアップロードできます。ファイルが 50 MB を超える場合は、Amazon S3 バケットから関数にファイルをアップロードします。
**関数コードを.zip アーカイブとしてアップロードするには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 更新する関数を選択し、[**Code**] (コード) タブを選択します。
1. [**Code source (コードソース)**] で、[**Upload from (アップロード元)**] を選択します。
1. [**.zip file (.zip ファイル)**]、[**Upload (アップロード) **] の順に選択します。
1. ファイルチューザで新しいイメージバージョンを選択し、[**Open (開く)**]、[**Save (保存) **] の順に選択します。
1. (ステップ 4 の代わりに) **Amazon S3 の場所**を選択します。
1. テキストボックスに .zip ファイルアーカイブの S3 リンク URL を入力し、[**Save**] (保存) を選択します。
## ランタイムの変更
新しいランタイムを使用するように関数の設定を更新する場合は、新しいランタイムとの互換性を確保するために関数コードを更新する必要がある場合があります。別のランタイムを使用するように関数設定を更新した場合は、ランタイムおよびアーキテクチャと互換性のある新しい関数コードを提供する**必要があります**。関数コードのデプロイパッケージを作成する方法については、関数が使用するランタイムのハンドラーページを参照してください。
Node.js 20、Python 3.12、Java 21、.NET 8、Ruby 3.3 以降のベースイメージは、Amazon Linux 2023 の最小コンテナイメージに基づいています。以前のベースイメージでは Amazon Linux 2 が使用されています。AL2023 ランタイムには、デプロイのフットプリントが小さいことや、`glibc` などのライブラリのバージョンが更新されていることなど、Amazon Linux 2 に比べていくつかの利点があります。詳細については、AWS コンピューティングブログの「[Introducing the Amazon Linux 2023 runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/)」を参照してください。
**ランタイムを変更する**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 更新する関数を選択し、[**Code**] (コード) タブを選択します。
1. コードエディタの下にある **[Runtime settings]** (ランタイム設定) セクションまで下にスクロールします。
1. **[編集]** を選択します。
1. **[Runtime]** (ランタイム) で、ランタイム識別子を選択します。
1. [**Handler**] (ハンドラ) で、関数のファイル名とハンドラを指定します。
1. **アーキテクチャ**で、関数に使用する命令セットアーキテクチャを選択します。
1. **[保存]** を選択します。
## アーキテクチャの変更
命令セットアーキテクチャを変更する前に、関数コードがターゲットアーキテクチャと互換性があることを確認する必要があります。
Node.js、Python、Ruby を使用し、組み込みエディタで関数コードを編集する場合、既存のコードが変更されずに実行されることがあります。
ただし、.zip ファイルアーカイブのデプロイパッケージを使用して関数コードを提供する場合は、ターゲットランタイムおよび命令セットアーキテクチャ用に正しくコンパイルされ、構築された新しい .zip ファイルアーカイブを準備する必要があります。手順については、関数ランタイムのハンドラーページを参照してください。
**命令セットアーキテクチャを変更するには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 更新する関数を選択し、[**Code**] (コード) タブを選択します。
1. [**Runtime settings**] (ランタイム設定) で、[**Edit**] (編集) を選択します。
1. **アーキテクチャ**で、関数に使用する命令セットアーキテクチャを選択します。
1. **[保存]** を選択します。
## Lambda API の使用
.zip ファイルアーカイブを使用する関数を作成および設定するには、以下の API オペレーションを使用します。
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
## 関数コードのダウンロード
関数コード .zip の最新の未公開 (`$LATEST`) バージョンは、Lambda コンソールからダウンロードできます。このためには、まず次の IAM アクセス許可があることを確認します。
+ `iam:GetPolicy`
+ `iam:GetPolicyVersion`
+ `iam:GetRole`
+ `iam:GetRolePolicy`
+ `iam:ListAttachedRolePolicies`
+ `iam:ListRolePolicies`
+ `iam:ListRoles`
**関数コード .zip をダウンロードするには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 関数コード .zip をダウンロードする関数を選択します。
1. **[関数の概要]** で、**[ダウンロード]** ボタンを選択し、**[ファンクションコード .zip をダウンロード]** を選択します。
1. または、**[AWS SAM ファイルをダウンロード]** を選択して、関数の設定に基づいて SAM テンプレートを生成してダウンロードします。**[両方ダウンロード]** を選択して、.zip と SAM テンプレートの両方をダウンロードすることもできます。
## CloudFormation
CloudFormation を使用して、.zip ファイルアーカイブを使用する Lambda 関数を作成できます。CloudFormation テンプレートでは、Lambda 関数は `AWS::Lambda::Function` のリソースにより指定されます。`AWS::Lambda::Function` リソースのプロパティの詳細については、*AWS CloudFormation ユーザーガイド*の「[AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)」を参照してください。
`AWS::Lambda::Function` リソースで、次のプロパティを設定して .zip ファイルアーカイブとして定義された関数を作成します。
+ AWS::Lambda::Function
+ PackageType － `Zip` に設定します。
+ コード — Amazon S3 バケット名と.zip ファイル名を `S3Bucket` および `S3Key` のフィールドに入力します。Node.js または Python では、Lambda 関数のインラインソースコードを提供できます。
+ ランタイム — ランタイム値を設定します。
+ アーキテクチャ — AWS Graviton2 プロセッサを使用するには、アーキテクチャ値を`arm64`に設定します。デフォルトでは、アーキテクチャ値は`x86_64`です。
# Lambda .zip デプロイパッケージの暗号化
Lambda では、.zip デプロイパッケージと関数設定詳細の保管時のサーバー側暗号化に常に AWS KMS keyを提供します。デフォルトでは、Lambda は [AWS 所有のキー](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk) を使用します。このデフォルトの動作がワークフローに適している場合は、他の設定をする必要はありません。AWS では、このキーの使用に料金は発生しません。
必要に応じて、AWS KMS カスタマー管理のキーを使用することもできます。その場合、KMS キーのローテーションの制御や、KMS キーの管理に関する組織の要件への準拠を行うことができます。カスタマーマネージドキーを使用すると、KMS キーへのアクセス許可があるアカウントのユーザーのみが、関数のコードや設定を表示または管理できます。
カスタマーマネージドキーには、標準の AWS KMS 料金が発生します。詳細については、「[AWS Key Management Service 料金表](https://aws.amazon.com/kms/pricing/)」を参照してください。
## カスタマーマネージドキーを作成する
対称カスタマーマネージドキーを作成するには、AWS マネジメントコンソール または AWS KMS API を使用します。
**対称カスタマーマネージドキーを作成するには**
「*AWS Key Management Service デベロッパーガイド*」の「[KMS キーを作成する](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk)」の手順に従ってください。
### アクセス許可
**キーポリシー**
[キーポリシー](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)は、カスタマーマネージドキーへのアクセスを制御します。すべてのカスタマーマネージドキーには、キーポリシーが 1 つだけ必要です。このポリシーには、そのキーを使用できるユーザーとその使用方法を決定するステートメントが含まれています。詳細については、「*AWS Key Management Service デベロッパーガイド*」の「[キーポリシーを変更する方法](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html#key-policy-modifying-how-to)」を参照してください。
カスタマーマネージドキーを使用して .zip デプロイパッケージを暗号化する場合、Lambda はキーに [grant](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) を追加しません。AWS KMS キーポリシーで、Lambda がユーザーに代わって次の AWS KMS API オペレーションを呼び出せるようにする必要があります。
+ [kms:GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)
+ [kms:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
次のキーポリシーの例では、アカウント 111122223333 のすべての Lambda 関数が、指定されたカスタマーマネージドキーに必要な AWS KMS オペレーションを呼び出せるようにします。
**Example AWS KMS キーポリシー**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/key-id",
"Condition": {
"StringLike": {
"kms:EncryptionContext:aws:lambda:FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:*"
}
}
}
]
}
```
[キーアクセスのトラブルシューティング](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html#example-no-iam)に関する詳細については、「AWS Key Management Service デベロッパーガイド」を参照してください。**
**プリンシパルアクセス権限**
カスタマーマネージドキーを使用して .zip デプロイパッケージを暗号化すると、そのキーにアクセスできる[プリンシパル](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html)のみが .zip デプロイパッケージにアクセスできます。例えば、カスタマーマネージドキーにアクセスできないプリンシパルは、[GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html) レスポンスに含まれている署名付き S3 URL を使用して .zip パッケージをダウンロードすることはできません。`AccessDeniedException` は、レスポンスの `Code` セクションで返されます。
**Example AWS KMS AccessDeniedException**
```
{
"Code": {
"RepositoryType": "S3",
"Error": {
"ErrorCode": "AccessDeniedException",
"Message": "KMS access is denied. Check your KMS permissions. KMS Exception: AccessDeniedException KMS Message: User: arn:aws:sts::111122223333:assumed-role/LambdaTestRole/session is not authorized to perform: kms:Decrypt on resource: arn:aws:kms:us-east-1:111122223333:key/key-id with an explicit deny in a resource-based policy"
},
"SourceKMSKeyArn": "arn:aws:kms:us-east-1:111122223333:key/key-id"
},
...
```
AWS KMS キーのアクセス許可については、「[AWS KMS キーアクセスとアクセス許可](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html)」を参照してください。
## .zip デプロイパッケージにカスタマーマネージドキーを使用する
次の API パラメータを使用して、.zip デプロイパッケージのカスタマーマネージドキーを設定します。
+ [SourceKMSKeyArn](https://docs.aws.amazon.com/lambda/latest/api/API_FunctionCode.html#lambda-Type-FunctionCode-SourceKMSKeyArn): ソースの .zip デプロイパッケージ (アップロードするファイル) を暗号化します。
+ [KMSKeyArn](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-KMSKeyArn): [環境変数](configuration-envvars-encryption.md)と [Lambda SnapStart](snapstart.md) のスナップショットを暗号化します。
`SourceKMSKeyArn` と `KMSKeyArn` の両方が指定されている場合、Lambda は `KMSKeyArn` キーを使用して、Lambda が関数の呼び出しに使用する解凍されたバージョンのパッケージを暗号化します。`SourceKMSKeyArn` が指定されていて `KMSKeyArn` が指定されていない場合、Lambda は [AWS マネージドキー](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk)を使用して解凍されたバージョンのパッケージを暗号化します。
------
#### [ Lambda console ]
**関数の作成時にカスタマーマネージドキーの暗号化を追加するには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. [**関数の作成**] を選択してください。
1. **[Author from scratch]** (一から作成) または **[Container image]** (コンテナイメージ) をクリックします。
1. **[基本的な情報]** で、以下を実行します。
1. [**関数名**] に関数名を入力します。
1. [**Runtime**] (ランタイム) で、関数で使用する言語バージョンを選択します。
1. **[詳細設定]** を展開し、**[AWS KMS カスタマーマネージドキーによる暗号化を有効にする]** を選択します。
1. カスタマーマネージドキーを選択します。
1. [**関数の作成**] を選択してください。
カスタマーマネージドキーの暗号化を削除するか、別のキーを使用するには、.zip デプロイパッケージを再度アップロードする必要があります。
**カスタマーマネージドキーの暗号化を既存の関数に追加するには**
1. Lambda コンソールの[関数ページ](https://console.aws.amazon.com/lambda/home#/functions)を開きます。
1. 関数の名前を選択します。
1. **[コードソース]** ペインで、**[アップロード元]** をクリックします。
1. **[.zip ファイル]** または **[Amazon S3 の場所]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/upload-zip.png)
1. ファイルをアップロードするか、Amazon S3 の場所を入力します。
1. **[AWS KMS カスタマーマネージドキーによる暗号化を有効にする]** を選択します。
1. カスタマーマネージドキーを選択します。
1. **[保存]** を選択します。
------
#### [ AWS CLI ]
**関数の作成時にカスタマーマネージドキーの暗号化を追加するには**
次に [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) の例を示します。
+ `--code`: zip デプロイパッケージへのローカルパス (`ZipFile`) および暗号化するためのカスタマーマネージドキー (`SourceKMSKeyArn`) を指定します。
+ `--kms-key-arn`: 環境変数と解凍されたバージョンのデプロイパッケージを暗号化するカスタマーマネージドキーを指定します。
```
aws lambda create-function \
--function-name myFunction \
--runtime nodejs24.x \
--handler index.handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code ZipFile=fileb://myFunction.zip,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \
--kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id
```
次に [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) の例を示します。
+ `--code`: Amazon S3 バケット内の .zip ファイルの場所 (`S3Bucket`、`S3Key`、`S3ObjectVersion`) および暗号化するためのカスタマーマネージドキー (`SourceKMSKeyArn`) を指定します。
+ `--kms-key-arn`: 環境変数と解凍されたバージョンのデプロイパッケージを暗号化するカスタマーマネージドキーを指定します。
```
aws lambda create-function \
--function-name myFunction \
--runtime nodejs24.x --handler index.handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \
--kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id
```
**カスタマーマネージドキーの暗号化を既存の関数に追加するには**
次に [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) の例を示します。
+ `--zip-file`: .zip デプロイパッケージへのローカルパスを指定します。
+ `--source-kms-key-arn`: zip 化されたバージョンのデプロイパッケージを暗号化するカスタマーマネージドキーを指定します。Lambda は、AWS 所有キーを使用して、解凍されたパッケージを関数呼び出しのために暗号化します。カスタマーマネージドキーを使用して解凍されたバージョンのパッケージを暗号化する場合は、`--kms-key-arn` オプションを指定して [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) コマンドを実行します。
```
aws lambda update-function-code \
--function-name myFunction \
--zip-file fileb://myFunction.zip \
--source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id
```
次に [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) の例を示します。
+ `--s3-bucket`: Amazon S3 バケット内の .zip ファイルの場所を指定します。
+ `--s3-key`: デプロイパッケージの Amazon S3 キーを指定します。
+ `--s3-object-version`: バージョニングオブジェクトの場合、使用するデプロイパッケージオブジェクトのバージョンです。
+ `--source-kms-key-arn`: zip 化されたバージョンのデプロイパッケージを暗号化するカスタマーマネージドキーを指定します。Lambda は、AWS 所有キーを使用して、解凍されたパッケージを関数呼び出しのために暗号化します。カスタマーマネージドキーを使用して解凍されたバージョンのパッケージを暗号化する場合は、`--kms-key-arn` オプションを指定して [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) コマンドを実行します。
```
aws lambda update-function-code \
--function-name myFunction \
--s3-bucket amzn-s3-demo-bucket \
--s3-key myFileName.zip \
--s3-object-version myObject Version
--source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id
```
**既存の関数からカスタマーマネージドキーの暗号化を削除するには**
次の [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) の例では、`--zip-file` で .zip デプロイパッケージのローカルパスを指定します。`--source-kms-key-arn` オプションを指定せずにこのコマンドを実行すると、Lambda は AWS 所有キーを使用して、zip 化されたバージョンのデプロイパッケージを暗号化します。
```
aws lambda update-function-code \
--function-name myFunction \
--zip-file fileb://myFunction.zip
```
------
# コンテナイメージを使用した Lambda 関数の作成
AWS Lambda 関数のコードは、スクリプトまたはコンパイルされたプログラム、さらにそれらの依存関係で構成されます。*デプロイパッケージ*を使用して、Lambda に関数コードをデプロイします。Lambda は、コンテナイメージと .zip ファイルアーカイブの 2 種類のデプロイパッケージをサポートします。
Lambda 関数のコンテナイメージを構築するには 3 つの方法があります。
+ [Lambda の AWS ベースイメージを使用する](#runtimes-images-lp)
[AWS ベースイメージ](#runtimes-images-lp)には、言語ランタイム、Lambda と関数コード間のやり取りを管理するランタイムインターフェースクライアント、ローカルテスト用のランタイムインターフェースエミュレーターがあらかじめロードされています。
+ [AWS の OS 専用ベースイメージを使用する](#runtimes-images-provided)
[AWS OS 専用ベースイメージ](https://gallery.ecr.aws/lambda/provided)には、Amazon Linux ディストリビューションおよび[ランタイムインターフェイスエミュレータ](https://github.com/aws/aws-lambda-runtime-interface-emulator/)が含まれています。これらのイメージは、[Go](go-image.md#go-image-provided) や [Rust](lambda-rust.md) などのコンパイル済み言語や、Lambda がベースイメージを提供していない言語または言語バージョン (Node.js 19 など) のコンテナイメージの作成によく使用されます。OS 専用のベースイメージを使用して[カスタムランタイム](runtimes-custom.md)を実装することもできます。イメージに Lambda との互換性を持たせるには、当該言語の[ランタイムインターフェイスクライアント](#images-ric)をイメージに含める必要があります。
+ [非 AWS ベースイメージを使用する](#images-types)
Alpine Linux や Debian など、別のコンテナレジストリの代替ベースイメージを使用することもできます。組織が作成したカスタムイメージを使用することもできます。イメージに Lambda との互換性を持たせるには、当該言語の[ランタイムインターフェイスクライアント](#images-ric)をイメージに含める必要があります。
**ヒント**
Lambda コンテナ関数がアクティブになるまでの時間を短縮するには、「Docker ドキュメント」の「[マルチステージビルドを使用する](https://docs.docker.com/build/building/multi-stage/)」を参照してください。効率的なコンテナイメージを構築するには、「[Dockerfiles を記述するためのベストプラクティス](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/)」に従ってください。
コンテナイメージから Lambda 関数を作成するには、イメージをローカルでビルドして、Amazon Elastic Container Registry (Amazon ECR) リポジトリにアップロードします。[AWS Marketplace](https://docs.aws.amazon.com/marketplace/latest/userguide/container-based-products.html) 販売者が提供するコンテナイメージを使用している場合、まずイメージをプライベート Amazon ECR リポジトリにクローンする必要があります。次に、関数の作成時にリポジトリ URI を指定します。Amazon ECR リポジトリは Lambda 関数と同じ AWS リージョン に配置されている必要があります。イメージが Lambda 関数と同じリージョンに配置されていれば、別の AWS アカウントのイメージを使用して関数を作成することができます。詳細については、「[Amazon ECR クロスアカウント許可](#configuration-images-xaccount-permissions)」を参照してください。
**注記**
Lambda は、コンテナイメージの Amazon ECR FIPS エンドポイントに対応していません。リポジトリ URI に `ecr-fips` が含まれていれば、現在 FIPS エンドポイントを使用していることになります。例えば、`111122223333.dkr.ecr-fips.us-east-1.amazonaws.com` などです。
このページでは、Lambda 互換のコンテナイメージを作成するためのベースイメージタイプと要件について説明します。
**注記**
既存の関数の[デプロイパッケージタイプ](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip またはコンテナイメージ) を変更することはできません。例えば、既存のコンテナイメージ関数を、.zip ファイルアーカイブを使用するように変換することはできません。この場合は、新しい関数を作成する必要があります。
**Topics**
+ [
## 要件
](#images-reqs)
+ [
## Lambda の AWS ベースイメージを使用する
](#runtimes-images-lp)
+ [
## AWS の OS 専用ベースイメージを使用する
](#runtimes-images-provided)
+ [
## 非 AWS ベースイメージを使用する
](#images-types)
+ [
## ランタイムインターフェイスクライアント
](#images-ric)
+ [
## Amazon ECR のアクセス許可
](#gettingstarted-images-permissions)
+ [
## 関数のライフサイクル
](#images-lifecycle)
## 要件
[AWS CLIバージョン 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) および [Docker CLI](https://docs.docker.com/get-docker) をインストールします。さらに、次の各要件にも注意してください。
+ コンテナイメージには、[カスタムランタイムに Lambda ランタイム API を使用する](runtimes-api.md) が実装されている必要があります。AWS からの、オープンソースの[ランタイムインターフェイスクライアント](#images-ric)には、この API が実装されています。ランタイムインターフェイスクライアントを必要なベースイメージに追加することで、Lambda と互換性を持たせることができます。
+ コンテナイメージは、読み取り専用のファイルシステム上で実行可能である必要があります。機能コードは、512 MB から 10,240 MB の間で、1 MB 刻みで書き込み可能な `/tmp` ディレクトリにアクセスできます。
+ デフォルトの Lambda ユーザーは、関数コードを実行するために必要なすべてのファイルを読み取ることができる必要があります。Lambda は、最小特権のアクセス許可を持つデフォルトの Linux ユーザーを定義することで、セキュリティのベストプラクティスに従います。つまり、Dockerfile に [USER](https://docs.docker.com/reference/dockerfile/#user) を指定する必要はありません。ご自身のアプリケーションコードが、外部の Linux ユーザーによる実行が制限されているファイルに依存していないことを確認します。
+ Lambda では、Linux ベースのコンテナイメージのみがサポートされます。
+ Lambda は、マルチアーキテクチャのベースイメージを提供します。ただし、関数用に構築するイメージは、アーキテクチャの 1 つだけをターゲットにする必要があります。Lambda は、マルチアーキテクチャのコンテナイメージを使用する関数をサポートしません。
## Lambda の AWS ベースイメージを使用する
Lambda に [AWS ベースイメージ](https://gallery.ecr.aws/lambda/)の 1 つを使用して、関数コードのコンテナイメージを構築します。ベースイメージには、Lambda でコンテナイメージを実行するために必要な言語ランタイムおよびその他のコンポーネントがプリロードされます。関数コードと依存関係をベースイメージに追加し、コンテナイメージとしてパッケージ化します。
AWS では、Lambda 用の AWS ベースイメージの更新を定期的に実施しています。Dockerfile の FROM プロパティにイメージ名が含まれている場合、Docker クライアントは [Amazon ECR リポジトリ](https://gallery.ecr.aws/lambda/)から最新バージョンのイメージを取り出します。更新されたベースイメージを使用するには、コンテナイメージを再ビルドして、[関数のコードを更新](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)する必要があります。
Node.js 20、Python 3.12、Java 21、.NET 8、Ruby 3.3 以降のベースイメージは、[Amazon Linux 2023 の最小コンテナイメージ](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html)に基づいています。以前のベースイメージでは Amazon Linux 2 が使用されています。AL2023 ランタイムには、デプロイのフットプリントが小さいことや、`glibc` などのライブラリのバージョンが更新されていることなど、Amazon Linux 2 に比べていくつかの利点があります。
AL2023 ベースのイメージでは、Amazon Linux 2 のデフォルトのパッケージマネージャである `yum` の代わりに `microdnf` (`dnf` としてシンボリックリンク) がパッケージマネージャとして使用されています。`microdnf` は `dnf` のスタンドアロン実装です。AL2023 ベースのイメージに含まれるパッケージのリストについては、「[Comparing packages installed on Amazon Linux 2023 Container Images](https://docs.aws.amazon.com/linux/al2023/ug/al2023-container-image-types.html)」の「**Minimal Container**」列を参照してください。AL2023 と Amazon Linux 2 の違いの詳細については、AWS コンピューティングブログの「[Introducing the Amazon Linux 2023 runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/)」を参照してください。
**注記**
AWS Serverless Application Model (AWS SAM) を含む AL2023 ベースのイメージをローカルで実行するには、Docker バージョン 20.10.10 以降を使用する必要があります。
AWS ベースイメージを使用してコンテナイメージを構築するには、お好みの言語での手順を選択してください。
+ [Node.js](nodejs-image.md#nodejs-image-instructions)
+ [TypeScript](typescript-image.md#base-image-typescript) (Node.js ベースイメージを使用)
+ [Python](python-image.md#python-image-instructions)
+ [Java](java-image.md#java-image-instructions)
+ [Go](go-image.md#go-image-provided)
+ [.NET](csharp-image.md#csharp-image-instructions)
+ [Ruby](ruby-image.md#ruby-image-instructions)
## AWS の OS 専用ベースイメージを使用する
[AWS OS 専用ベースイメージ](https://gallery.ecr.aws/lambda/provided)には、Amazon Linux ディストリビューションおよび[ランタイムインターフェイスエミュレータ](https://github.com/aws/aws-lambda-runtime-interface-emulator/)が含まれています。これらのイメージは、[Go](go-image.md#go-image-provided) や [Rust](lambda-rust.md) などのコンパイル済み言語や、Lambda がベースイメージを提供していない言語または言語バージョン (Node.js 19 など) のコンテナイメージの作成によく使用されます。OS 専用のベースイメージを使用して[カスタムランタイム](runtimes-custom.md)を実装することもできます。イメージに Lambda との互換性を持たせるには、当該言語の[ランタイムインターフェイスクライアント](#images-ric)をイメージに含める必要があります。
| タグ | ランタイム | オペレーティングシステム | Dockerfile | 非推奨 |
| --- | --- | --- | --- | --- |
| al2023 | OS 専用ランタイム | Amazon Linux 2023 | [GitHub の OS 専用ランタイムの Dockerfile](https://github.com/aws/aws-lambda-base-images/blob/provided.al2023/Dockerfile.provided.al2023) | 2029 年 6 月 30 日 |
| al2 | OS 専用ランタイム | Amazon Linux 2 | [GitHub の OS 専用ランタイムの Dockerfile](https://github.com/aws/aws-lambda-base-images/blob/provided.al2/Dockerfile.provided.al2) | 2026 年 7 月 31 日 |
Amazon Elastic コンテナレジストリ公開ギャラリー: [gallery.ecr.aws/lambda/provided](https://gallery.ecr.aws/lambda/provided)
## 非 AWS ベースイメージを使用する
Lambda では、次のいずれかのイメージマニフェストの形式に準拠するイメージをサポートしています。
+ Docker Image Manifest V2 Schema 2 (Docker バージョン 1.10 以降で使用)
+ Open Container Initiative (OCI) 仕様 (v1.0.0 以降)
Lambda は、すべてのレイヤーを含めて最大 10 GB の非圧縮のイメージサイズをサポートします。
**注記**
イメージに Lambda との互換性を持たせるには、当該言語の[ランタイムインターフェイスクライアント](#images-ric)をイメージに含める必要があります。
最適なパフォーマンスを得るには、イメージマニフェストのサイズを 25,400 バイト未満に維持します。イメージマニフェストのサイズを減らすには、イメージ内のレイヤーの数を最小限に抑え、注釈を減らします。
## ランタイムインターフェイスクライアント
[OS 専用ベースイメージ](#runtimes-images-provided)または代替のベースイメージを使用する場合、イメージにランタイムインターフェイスクライアントを含める必要があります。ランタイムインターフェイスクライアントは、Lambda と関数コード間のやり取りを管理する [カスタムランタイムに Lambda ランタイム API を使用する](runtimes-api.md) を拡張する必要があります。AWS では、オープンソースのランタイムインターフェイスクライアントを次の言語で提供しています。
+ [Node.js](nodejs-image.md#nodejs-image-clients)
+ [Python](python-image.md#python-image-clients)
+ [Java](java-image.md#java-image-clients)
+ [.NET](csharp-image.md#csharp-image-clients)
+ [Go](go-image.md#go-image-clients)
+ [Ruby](ruby-image.md#ruby-image-clients)
+ [Rust](lambda-rust.md) –
使用している言語に AWS の提供するランタイムインターフェイスクライアントがない場合、独自のランタイムインターフェイスクライアントを作成する必要があります。
## Amazon ECR のアクセス許可
コンテナイメージから Lambda 関数を作成する前に、そのイメージをローカルでビルドし、 Amazon ECR リポジトリにアップロードする必要があります。関数の作成時に、Amazon ECR リポジトリ URI を指定します。
関数を作成するユーザーまたはロールのアクセス許可に、`GetRepositoryPolicy`、`SetRepositoryPolicy`、`BatchGetImage`、`GetDownloadUrlForLayer` が含まれていることを確認してください。
例えば、IAM コンソールを使用して、次のポリシーでロールを作成します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"ecr:SetRepositoryPolicy",
"ecr:GetRepositoryPolicy",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world"
}
]
}
```
------
### Amazon ECR リポジトリポリシー
Amazon ECR のコンテナイメージと同じアカウント内の関数の場合、Amazon ECR リポジトリポリシーに `ecr:BatchGetImage` および `ecr:GetDownloadUrlForLayer` のアクセス許可を追加できます。次の例は、最小ポリシーを示しています。
```
{
"Sid": "LambdaECRImageRetrievalPolicy",
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
]
}
```
Amazon ECR リポジトリへのアクセス許可に関する詳細については、詳しくは「*Amazon Elastic Container Registry のユーザーガイド*」の「[プライベートリポジトリポリシー](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html)」を参照してください。
Amazon ECR リポジトリにこれらのアクセス許可が含まれていない場合、Lambda はその許可を自動的に追加しようとします。Lambda は、Lambda を呼び出すプリンシパルに `ecr:getRepositoryPolicy` および `ecr:setRepositoryPolicy` のアクセス許可がある場合にのみ、アクセス許可を追加できます。
Amazon ECR リポジトリへのアクセス許可を表示または編集するには、「*Amazon Elastic Container Registry のユーザーガイド*」の「[プライベートリポジトリのポリシーステートメントの設定](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html)」の手順に従ってください。
#### Amazon ECR クロスアカウント許可
同じリージョン内の別のアカウントで、アカウントが所有するコンテナイメージを使用する関数を作成できます。次の例では、[Amazon ECR リポジトリへのアクセス許可ポリシー](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html)で、アカウント番号 123456789012 にアクセス権を付与するために、次のステートメントが必要です。
+ **CrossAccountPermission** — アカウント 123456789012 が、この ECR リポジトリからイメージを使用する Lambda 関数を作成および更新できるようにします。
+ **LambdaECRImageCrossAccountRetrievalPolicy** – Lambda は、関数が長期間呼び出されない場合、最終的に関数の状態を非アクティブに設定します。このステートメントは、123456789012 が所有する関数に代わって Lambda が最適化およびキャッシュのためにコンテナイメージを取得できるようにするために必要です。
**Example クロスアカウント許可をリポジトリに追加する**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CrossAccountPermission",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Principal": {
"AWS": "arn:aws:iam::123456789012:root"
},
"Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository"
},
{
"Sid": "LambdaECRImageCrossAccountRetrievalPolicy",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Condition": {
"ArnLike": {
"aws:sourceARN": "arn:aws:lambda:us-east-1:123456789012:function:*"
}
},
"Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository"
}
]
}
```
複数のアカウントにアクセス権を付与するには、`CrossAccountPermission` ポリシーの [Principal] (プリンシパル) リストと `LambdaECRImageCrossAccountRetrievalPolicy` の [Condition] (条件) 評価リストにアカウント ID を追加します。
AWS Organization で複数のアカウントを扱う場合は、ECR の許可ポリシーで各アカウント ID を列挙することをお勧めします。このアプローチは、IAM ポリシーで狭い範囲の許可を設定するという AWS セキュリティのベストプラクティスに沿ったものです。
Lambda のアクセス許可に加えて、関数を作成するユーザーまたはロールには、`BatchGetImage` および `GetDownloadUrlForLayer` アクセス許可も必要です。
## 関数のライフサイクル
新規または更新済みのコンテナイメージをアップロードすると、Lambda は、関数が呼び出しを処理する前にイメージを最適化します。最適化プロセスには数秒かかる場合があります。この関数は、プロセスが完了するまで `Pending` 状態のままです。完了したら状態は `Active` に変換されます。関数が `Active` 状態になるまで呼び出すことはできません。
数週間にわたって関数が呼び出されない場合、Lambda は最適化されたバージョンを回収し、関数は `Inactive` 状態に移行します。関数を再度アクティブにするには、関数を呼び出す必要があります。Lambda は最初の呼び出しを拒否し、関数は Lambda がイメージを再最適化するまで `Pending` 状態に入ります。その後、関数は `Active` 状態に戻ります。
Lambda は、Amazon ECR リポジトリから関連するコンテナイメージを定期的に取得します。対応するコンテナイメージが Amazon ECR に存在しなくなった場合、またはアクセス許可が失効した場合、関数は `Failed` 状態になり、Lambda が関数呼び出しに対して失敗を返します。
Lambda API を使用して、関数の状態に関する情報を取得できます。詳細については、「[Lambda 関数の状態](functions-states.md)」を参照してください。
# Lambda 関数のメモリを設定
Lambda は、設定されたメモリの量に比例して CPU パワーを割り当てます。*メモリ*は、実行時に Lambda 関数で使用できるメモリの量です。**[メモリ]** 設定を使用して、関数に割り当てられたメモリと CPU パワーを増減できます。メモリは、128 MB～10,240 MB の値を 1 MB 単位で設定できます。1,769 MB の場合、1 つの vCPU (1 秒あたりのクレジットの 1 vCPU 秒分) に相当します。
このページでは、Lambda 関数のメモリ設定を更新の方法とタイミングについて説明します。
**Topics**
+ [
## Lambda 関数の適切なメモリ設定を確認する
](#configuration-memory-use-cases)
+ [
## 関数メモリの設定 (コンソール)
](#configuration-memory-console)
+ [
## 関数のメモリの設定 (AWS CLI)
](#configuration-memory-cli)
+ [
## 関数のメモリの設定 (AWS SAM)
](#configuration-memory-sam)
+ [
## 関数のメモリーの推奨事項を受け入れる (コンソール)
](#configuration-memory-optimization-accept)
## Lambda 関数の適切なメモリ設定を確認する
メモリは、関数のパフォーマンスを制御するための主要な手段です。デフォルト設定の 128 MB は、設定可能な最小値です。イベントを変換して他のサービスにルーティングする関数など、シンプルな Lambda 関数には 128 MB で使用することをお勧めしますAWS。メモリ割り当てを増やすと、インポートされたライブラリ [Lambda レイヤー](chapter-layers.md)、Amazon Simple Storage Service (Amazon S3)、または Amazon Elastic File System (Amazon EFS) を使用する関数のパフォーマンスを向上させることができます。メモリを追加すると、CPU の処理量が比例的に増加して、計算能力全体が向上します。関数が CPU、ネットワーク、またはメモリにバインドされている場合、メモリ設定を増やすとパフォーマンスが大幅に向上する可能性があります。
適切なメモリ設定を見つけるには、Amazon CloudWatch で関数をモニタリングし、メモリ消費量が設定された最大値に近づいた場合にアラームを設定します。これにより、メモリバウンド関数を識別できます。CPU バウンド関数および IO バウンド関数の場合、時間をモニタリングするとインサイトを得ることもできます。このような場合、メモリを増やすと、コンピューティングまたはネットワークのボトルネックを解決するのに役立つことがあります。
オープンソースの [AWS Lambda パワーチューニング](https://github.com/alexcasalboni/aws-lambda-power-tuning)ツールの使用を検討することもできます。このツールは AWS Step Functions を使用して、異なるメモリ割り当てで複数のバージョンの Lambda 関数を同時に実行し、パフォーマンスを測定します。入力関数は AWS アカウントで実行され、ライブ HTTP 呼び出しと SDK インタラクションを実行して、ライブ本番環境で期待されるパフォーマンスを測定します。このツールを使用して、デプロイする新しい関数のパフォーマンスを自動的に測定する CI/CD プロセスを実装することもできます。
## 関数メモリの設定 (コンソール)
関数のメモリは Lambda コンソールで設定できます。
**関数のメモリ割り当てを変更するには**
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択します。
1. **[設定]** を選択してから、**[一般設定]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/configuration-tab.png)
1. **[全般設定]** で、**[編集]** を選択します。
1. **[メモリ]** に、128 MB から 10,240 MB の値を設定します。
1. **[保存]** を選択します。
## 関数のメモリの設定 (AWS CLI)
[update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) コマンドを使用して、関数のメモリを設定できます。
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--memory-size 1024
```
## 関数のメモリの設定 (AWS SAM)
[AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) を使用して、関数のメモリを設定できます。`template.yaml` ファイル内の [MemorySize](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-memorysize) プロパティを更新し、[sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) を実行します。
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 1024
# Other function properties...
```
## 関数のメモリーの推奨事項を受け入れる (コンソール)
AWS Identity and Access Management (IAM) での管理者権限がある場合は、Lambda 関数のメモリ設定に関する推奨事項を、AWS Compute Optimizer から受け取るようにオプトインできます。アカウントまたは組織でメモリの推奨事項にオプトインする手順については、*AWS Compute Optimizer ユーザーガイド*の「[アカウントにオプトインする](https://docs.aws.amazon.com/compute-optimizer/latest/ug/getting-started.html#account-opt-in)」を参照してください。
**注記**
Compute Optimizer は x86\$164 アーキテクチャを使用する関数のみをサポートします。
オプトインが完了しており、[Lambda 関数が Compute Optimizer の要件を満たしている](https://docs.aws.amazon.com/compute-optimizer/latest/ug/requirements.html#requirements-lambda-functions)場合は、Compute Optimizer による関数のメモリに関する推奨事項を、Lambda コンソールの **[一般設定]** で表示したり、受け入れたりすることができます。
# Lambda 関数のエフェメラルストレージを設定する
Lambda は、 `/tmp` ディレクトリ内の関数にエフェメラルストレージを提供します。このストレージは一時的なものであり、各実行環境に固有のものです。エフェメラルストレージ設定で、関数に割り当てられる**エフェメラルストレージ**の容量を変更できます。エフェメラルストレージの容量は、512 MB から 10,240 MB まで、1-MB 単位で設定できます。`/tmp` に保存されているすべてのデータは、AWS によって管理されるキーを使用して保管時に暗号化されます。
このページでは、一般的なユースケースと、Lambda 関数のエフェメラルストレージを更新する方法について説明します。
**Topics**
+ [
## エフェメラルストレージを増やす一般的なユースケース
](#configuration-ephemeral-storage-use-cases)
+ [
## エフェメラルストレージの設定 (コンソール)
](#configuration-ephemeral-storage-console)
+ [
## エフェメラルストレージの設定 (AWS CLI)
](#configuration-ephemeral-storage-cli)
+ [
## エフェメラルストレージの設定 (AWS SAM)
](#configuration-ephemeral-storage-sam)
## エフェメラルストレージを増やす一般的なユースケース
エフェメラルストレージを増やすことでメリットを得られる一般的なユースケースを以下に示します。
+ **抽出/変換ロード (ETL) ジョブ:** コードが中間計算を実行するか、他のリソースをダウンロードして処理を完了すると、エフェメラルストレージが増加します。一時スペースが多いほど、Lambda 関数でより複雑な ETL ジョブを実行できます。
+ **機械学習 (ML) 推論：** 多くの推論タスクは、ライブラリやモデルを含む大規模なリファレンスデータファイルに依存しています。エフェメラルストレージを使用すると、Amazon Simple Storage Service (Amazon S3) から `/tmp` により大きなモデルをダウンロードして、処理に使用できます。
+ **データ処理：** Amazon S3S3 からオブジェクトをダウンロードするワークロードの場合、`/tmp`領域を増やすと、インメモリ処理を考慮せずに大きなオブジェクトを処理できます。PDF を作成したり、メディアを処理したりするワークロードも、より一時的なストレージの恩恵を受けます。
+ **グラフィック処理:** 画像処理は Lambda ベースのアプリケーションの一般的なユースケースです。大きな TIFF ファイルまたは衛星画像を処理するワークロードの場合、エフェメラルストレージを使用すると、ライブラリの使用と Lambda での計算の実行が容易になります。
## エフェメラルストレージの設定 (コンソール)
Lambda コンソールでエフェメラルストレージを設定できます。
**関数のエフェメラルストレージを変更するには**
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択します。
1. **[設定]** を選択してから、**[一般設定]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/configuration-tab.png)
1. **[全般設定]** で、**[編集]** を選択します。
1. **エフェメラルストレージ** の場合、512 MB から 10,240 MB までの値を 1-MB 単位で設定します。
1. **[保存]** を選択します。
## エフェメラルストレージの設定 (AWS CLI)
[update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) コマンドを使用して、エフェメラルストレージを設定できます。
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--ephemeral-storage '{"Size": 1024}'
```
## エフェメラルストレージの設定 (AWS SAM)
[AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) を使用して、関数のエフェメラルストレージを設定できます。`template.yaml` ファイル内の [EphemeralStorage](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-ephemeralstorage) プロパティを更新し、[sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) を実行します。
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
Handler: index.handler
Runtime: nodejs22.x
Architectures:
- x86_64
EphemeralStorage:
Size: 10240
# Other function properties...
```
# Lambda 関数の命令セットアーキテクチャの選択と設定
Lambda 関数の*命令セットアーキテクチャ*は、Lambda が関数の実行に使用するコンピュータプロセッサのタイプを決定します。Lambda は、命令セットアーキテクチャの選択肢を提供します。
+ arm64 — AWS Graviton2 プロセッサ用の 64 ビット ARM アーキテクチャです。
+ x86\$164 — x86 ベースプロセッサ用の 64 ビット x86 アーキテクチャです。
**注記**
arm64 アーキテクチャは、ほとんどの AWS リージョン にあります。詳細については、[AWS Lambda の料金](https://aws.amazon.com//lambda/pricing/#aws-element-9ccd9262-b656-4d9c-8a72-34ee6b662135)を参照してください。メモリの料金表で、**[Arm 料金]** タブを選択し、**[リージョン]** ドロップダウンリストを開いて、どの AWS リージョン が Lambda での arm64 の使用をサポートしているかを確認してください。
arm64 アーキテクチャで関数を作成する方法の例については、「[AWS Graviton2 プロセッサを搭載した AWS Lambda 関数](https://aws.amazon.com/blogs/aws/aws-lambda-functions-powered-by-aws-graviton2-processor-run-your-functions-on-arm-and-get-up-to-34-better-price-performance/)」を参照してください。
**Topics**
+ [
## arm64 アーキテクチャを使用する利点
](#foundation-arch-adv)
+ [
## arm64 アーキテクチャへの移行の要件
](#foundation-arch-consider)
+ [
## arm64 アーキテクチャとの関数コードの互換性
](#foundation-arch-considerations)
+ [
## arm64 アーキテクチャへの移行方法
](#foundation-arch-steps)
+ [
## 命令セットアーキテクチャの設定
](#foundation-arch-config)
## arm64 アーキテクチャを使用する利点
arm64 アーキテクチャ (AWS Graviton2 プロセッサ) を使用するLambda 関数は、x86\$164 アーキテクチャで実行される同等の関数よりも大幅に優れた料金とパフォーマンスを実現します。高性能コンピューティング、ビデオエンコーディング、シミュレーションワークロードなど、コンピュータ集約型のアプリケーションに arm64 を使用することを検討してください。
Graviton2 CPU は Neoverse N1 コアを使用し、Armv8.2 (CRCおよび暗号拡張機能を含む) に加えて、複数の他のアーキテクチャ拡張機能をサポートします。
Graviton2 は vCPU あたりでより大きな L2 キャッシュを提供することにより、メモリの読み取り時間を短縮します。これにより、ウェブおよびモバイルバックエンド、マイクロサービス、データ処理システムのレイテンシーパフォーマンスが向上します。Graviton2 は暗号化パフォーマンスも改善し、CPU ベースの機械学習推論のレイテンシーを改善する命令セットをサポートします。
AWS Graviton2 の詳細については、[AWS Graviton プロセッサ](https://aws.amazon.com/ec2/graviton)を参照してください。
## arm64 アーキテクチャへの移行の要件
arm64 アーキテクチャに移行する Lambda 関数を選択する際は、スムーズな移行を確保するために、関数が次の要件を満たしていることを確認してください。
+ デプロイパッケージには、ユーザーが管理するオープンソースコンポーネントとソースコードのみが含まれており、移行に必要な更新を行うことができます。
+ 関数コードにサードパーティーの依存関係が含まれている場合、各ライブラリまたはパッケージは arm64 バージョンを提供します。
## arm64 アーキテクチャとの関数コードの互換性
Lambda 関数コードは、関数の命令セットアーキテクチャと互換性がある必要があります。関数を arm64 アーキテクチャに移行する前に、現在の関数コードに関する次の点に注意してください。
+ 組み込みコードエディタを使用して関数コードを追加した場合、コードはどちらのアーキテクチャでも変更なしで実行される可能性があります。
+ 関数コードをアップロードした場合は、ターゲットアーキテクチャと互換性のある新しいコードをアップロードする必要があります。
+ 関数でレイヤーを使用する場合は、[各レイヤーをチェックして](adding-layers.md#finding-layer-information)新しいアーキテクチャと互換性があることを確認する必要があります。レイヤーに互換性がない場合は、関数を編集して、現在のレイヤーバージョンを互換性のあるレイヤーバージョンに置き換えます。
+ 関数で Lambda 拡張機能を使用する場合は、各拡張機能をチェックして、新しいアーキテクチャと互換性があることを確認する必要があります。
+ 関数でコンテナイメージデプロイパッケージタイプを使用する場合は、関数のアーキテクチャと互換性のある新しいコンテナイメージを作成する必要があります。
## arm64 アーキテクチャへの移行方法
Lambda 関数を arm64 アーキテクチャに移行するために、次のステップに従うことをお勧めします。
1. アプリケーションまたはワークロードの依存関係のリストを構築します。一般的な依存関係は次のとおりです。
+ 関数が使用するすべてのライブラリとパッケージ。
+ コンパイラー、テストスイート、継続的インテグレーション、継続的デリバリー (CI/CD) パイプライン、プロビジョニングツール、スクリプトなど、関数の構築、デプロイ、テストに使用するツール。
+ 本番環境で関数をモニタリングするために使用する Lambda 拡張機能およびサードパーティー製ツール。
1. 各依存関係についてバージョンをチェックし、次に、arm64 バージョンが使用可能かどうかをチェックします。
1. アプリケーションを移行する環境を構築します。
1. アプリケーションをブートストラップします。
1. アプリケーションをテストおよびデバッグします。
1. arm64 関数のパフォーマンスをテストします。x86\$164 バージョンとパフォーマンスを比較します。
1. arm64 Lambda 関数をサポートするように、インフラストラクチャパイプラインを更新します。
1. デプロイを本番環境にステージングします。
たとえば、[エイリアスルーティング設定](configuring-alias-routing.md)を使用して、関数の x86 バージョンと arm64 バージョン間でトラフィックを分割し、パフォーマンスとレイテンシーを比較します。
Java、Go、.NET、Python の言語固有の情報を含む arm64 アーキテクチャのコード環境を作成する方法の詳細については、GitHub レポジトリの「[AWS Graviton](https://github.com/aws/aws-graviton-getting-started) の使用を開始する」を参照してください。
## 命令セットアーキテクチャの設定
Lambda コンソール、AWS SDK、AWS Command Line Interface (AWS CLI)、CloudFormation を使用して、新規および既存の Lambda 関数の命令セットアーキテクチャを設定できます。コンソールから既存の Lambda 関数の命令セットアーキテクチャを変更するには、次の手順に従います。
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 命令セットアーキテクチャを設定する関数の名前を選択します。
1. メインの **[コード]** タブの **[ランタイム設定]** セクションで、**[編集]** を選択します。
1. **[アーキテクチャ]** で、関数が使用する命令セットアーキテクチャを選択します。
1. **[保存]** を選択します。
# Lambda 関数のタイムアウトを設定する
Lambda は、コードを一定時間実行してからタイムアウトします。*タイムアウト*は、Lambda 関数が実行できる最大時間を秒数で表したものです。この設定のデフォルト値は 3 秒ですが、最大値の 900 秒 (15 分) まで 1 秒単位で調整できます。
このページでは、Lambda 関数のタイムアウト設定を更新する方法とタイミングについて説明します。
**Topics**
+ [
## Lambda 関数の適切なタイムアウト値を決定する
](#configuration-timeout-use-cases)
+ [
## タイムアウトの設定 (コンソール)
](#configuration-timeout-console)
+ [
## タイムアウトの設定 (AWS CLI）
](#configuration-timeout-cli)
+ [
## タイムアウトの設定 (AWS SAM）
](#configuration-timeout-sam)
## Lambda 関数の適切なタイムアウト値を決定する
タイムアウト値が関数の平均期間に近い場合、関数が予期せずタイムアウトするリスクが高くなります。関数の期間は、データ転送と処理の量、および関数が相互作用するサービスのレイテンシーによって異なる場合があります。タイムアウトの一般的な原因には、次のようなものがあります。
+ Amazon Simple Storage Service (Amazon S3) からダウンロードを行う場合、通常よりもサイズが大きくなり、時間がかかります。
+ 関数が別のサービスにリクエストを行う場合、応答に時間がかかります。
+ 関数に使用されるパラメータでは、関数の計算が複雑になり、呼び出しに時間がかかります。
アプリケーションをテストする際は、テストがデータのサイズと量、および実際のパラメータ値を正確に反映していることを確認してください。テストでは、便宜上小さいサンプルがよく使用されますが、ワークロードで適度に予想される上限のデータセットを使用する必要があります。
## タイムアウトの設定 (コンソール)
Lambda コンソールで関数のタイムアウトを設定できます。
**関数のタイムアウトを変更する方法**
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択します。
1. **[設定]** を選択してから、**[一般設定]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/configuration-tab.png)
1. **[全般設定]** で、**[編集]** を選択します。
1. **[タイムアウト]** に、1～900 秒 (15 分) の値を入力します。
1. **[保存]** を選択します。
## タイムアウトの設定 (AWS CLI）
[update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) コマンドを使用して、タイムアウト値を秒単位で設定できます。次のコマンドの例では、関数のタイムアウトを 120 秒 (2 分) に増やします。
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--timeout 120
```
## タイムアウトの設定 (AWS SAM）
[AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) を使用して、関数のタイムアウト値を設定できます。`template.yaml` ファイルの [Timeout](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-timeout) プロパティを更新し、[sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) を実行します。
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
# Other function properties...
```
# Lambda の耐久性のある関数の設定
Lambda 関数の耐久性のある実行を有効にするには、関数を実行できる期間、状態データを保持する期間、必要なアクセス許可を制御する特定の設定を構成する必要があります。
## 耐久性のある実行を有効にする
Lambda 関数の耐久性のある実行を有効にするには、関数設定で `DurableConfig` を設定します。この設定は実行タイムアウト、状態保持、バージョニング動作を制御します。
------
#### [ AWS CLI ]
```
aws lambda update-function-configuration \
--function-name my-durable-function \
--durable-config '{
"ExecutionTimeout": 3600,
"RetentionPeriodInDays": 30,
"AllowInvokeLatest": true
}'
```
------
#### [ CloudFormation ]
```
Resources:
MyDurableFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: my-durable-function
Runtime: nodejs18.x
Handler: index.handler
Code:
ZipFile: |
// Your durable function code
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 30
AllowInvokeLatest: true
```
------
**設定パラメータ:**
+ `ExecutionTimeout` – 秒単位での最大実行時間 (1 年間で最大 31,536,000)
+ `RetentionPeriodInDays` – 実行状態および履歴を保持する期間 (1 ～ 365 日)
+ `AllowInvokeLatest` – 耐久性のある実行に \$1LATEST バージョンを呼び出す許可の可否
## 耐久性のある関数の IAM アクセス許可
耐久性のある関数には、標準の Lambda 実行ロール以外に追加の IAM アクセス許可が必要です。関数の実行ロールには、状態管理および耐久性のある実行 API のアクセス許可が含まれている必要があります。
**必要最小限のアクセス許可:**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ManageDurableState",
"lambda:GetDurableExecution",
"lambda:ListDurableExecutions"
],
"Resource": "arn:aws:lambda:*:*:function:*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
**CloudFormation の実行ロールの例:**
```
DurableFunctionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Policies:
- PolicyName: DurableFunctionPolicy
PolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Action:
- lambda:ManageDurableState
- lambda:GetDurableExecution
- lambda:ListDurableExecutions
Resource: '*'
```
## 設定のベストプラクティス
本番稼働用に耐久性のある関数を設定する際、次のベストプラクティスに従ってください。
+ **適切な実行タイムアウトの設定** – ワークフローの最大予想期間に基づいて `ExecutionTimeout` を設定します。コストおよびリソースの割り当てに影響するため、不要に長いタイムアウトを設定しないでください。
+ **ストレージコストで保持のバランスを取る** – デバッグおよび監査の要件に基づいて `RetentionPeriodInDays` を設定します。保持期間を長くすると、ストレージコストが増加します。
+ **本番稼働でバージョニングの使用** – 本番環境で `AllowInvokeLatest` を `false` に設定し、耐久性のある実行に特定の関数バージョンまたはエイリアスを使用します。
+ **状態サイズのモニタリング** – 大規模な状態オブジェクトはストレージコストを増加させ、パフォーマンスに影響する可能性があります。状態を最小限に抑えて、大容量データには外部ストレージを使用します。
+ **適切なログ記録の設定** – 長時間のワークフローをトラブルシューティングするため、詳細なログ記録を有効にしますが、ログの量とコストには注意してください。
**本番稼働設定の例**
```
{
"ExecutionTimeout": 86400,
"RetentionPeriodInDays": 7,
"AllowInvokeLatest": false
}
```
# Lambda 環境変数の操作
環境変数を使用すると、コードを更新せずに関数の動作を調整できます。環境変数は、関数のバージョン固有の設定に保存される文字列のペアです。Lambda ランタイムは、環境変数をコードで使用できるようにし、関数と呼び出しリクエストに関する情報を含む追加の環境変数を設定します。
**注記**
セキュリティを強化するには、データベースの認証情報や API キーや認可トークンなどその他の機密情報を保存するために、環境変数の代わりに AWS Secrets Manager を使用することをお勧めします。詳細については、「[Lambda 関数で Secrets Manager シークレットを使用する](with-secrets-manager.md)」を参照してください。
環境変数は、関数を呼び出す前には評価されません。定義した値はリテラル文字列とみなされ、展開されません。関数コードで変数の評価を実行します。
## Lambda 環境変数の作成
Lambda コンソール、AWS Command Line Interface (AWS CLI)、AWS Serverless Application Model (AWS SAM)、または AWS SDK を使用して、Lambda で環境変数を設定できます。
------
#### [ Console ]
環境変数は、関数の未公開バージョンで定義します。バージョンを公開するとき、他の[バージョン固有の構成設定](configuration-versions.md)とともに、そのバージョンの環境変数がロックされます。
関数の環境変数を作成するには、キーと値を定義します。関数は、キーの名前を使用して、環境変数の値を取得します。
**Lambda コンソールで環境変数を設定するには**
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択します。
1. **[設定]** タブを選択してから、**[環境変数]** を選択します。
1. [**環境変数**] で、[**編集**] を選択します。
1. **[環境変数の追加]** を選択します。
1. キーと値を入力します。
**要件**
+ キーは文字で始まり、少なくとも 2 文字です。
+ キーには、文字、数字、およびアンダースコア (`_`) のみを含める。
+ キーは [Lambda によって予約](#configuration-envvars-runtime)されていない。
+ すべての環境変数の合計サイズは 4 KB を超えない。
1. **[保存]** を選択します。
**コンソールコードエディタで環境変数のリストを生成するには**
Lambda コードエディタで環境変数のリストを生成することができます。これを使用することで、コーディング中に環境変数を簡単に参照することができます。
1. **[コード]** タブを選択します。
1. コードエディタの **[ENVIRONMENT VARIABLES]** セクションまでスクロールします。既存の環境変数を以下に示します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/env-var.png)
1. 新しい環境変数を作成するには、プラス記号 (![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/add-plus.png)) を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/create-env-var.png)
環境変数は、コンソールのコードエディタに一覧表示されても暗号化されたままです。転送中の暗号化の暗号化ヘルパーを有効にした場合、それらの設定は変更されません。詳細については、「[Lambda 環境変数の保護](configuration-envvars-encryption.md)」を参照してください。
環境変数リストは読み取り専用で、Lambda コンソールでのみ使用できます。このファイルは、関数の .zip ファイルアーカイブをダウンロードしたときには含まれていません。また、このファイルをアップロードしても環境変数を追加することはできません。
------
#### [ AWS CLI ]
次の例では、`my-function` という名前の関数に 2 つの環境変数を設定します。
```
aws lambda update-function-configuration \
--function-name my-function \
--environment "Variables={BUCKET=amzn-s3-demo-bucket,KEY=file.txt}"
```
`update-function-configuration` コマンドを使用して環境変数を適用すると、`Variables` 構造体の内容全体が置き換えられます。新しい環境変数を追加するときに既存の環境変数を保持するには、リクエストに既存の値をすべて含めます。
現在の設定を取得するには、`get-function-configuration` コマンドを使用します。
```
aws lambda get-function-configuration \
--function-name my-function
```
以下の出力が表示されます。
```
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:111122223333:function:my-function",
"Runtime": "nodejs24.x",
"Role": "arn:aws:iam::111122223333:role/lambda-role",
"Environment": {
"Variables": {
"BUCKET": "amzn-s3-demo-bucket",
"KEY": "file.txt"
}
},
"RevisionId": "0894d3c1-2a3d-4d48-bf7f-abade99f3c15",
...
}
```
`get-function-configuration` の出力にあるリビジョン ID をパラメータとして `update-function-configuration` に渡すことができます。これにより、構成を読み込んだときから更新したときまでの間に、値が変更されることはありません。
関数の暗号化キーを設定するには、`KMSKeyARN` オプションを設定します。
```
aws lambda update-function-configuration \
--function-name my-function \
--kms-key-arn arn:aws:kms:us-east-2:111122223333:key/055efbb4-xmpl-4336-ba9c-538c7d31f599
```
------
#### [ AWS SAM ]
[AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) を使用して関数の環境変数を設定できます。`template.yaml` ファイル内の [Environment](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-environment) プロパティと [Variables](https://docs.aws.amazon.com//AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-environment.html#cfn-lambda-function-environment-variables) プロパティを更新し、[sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) を実行します。
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
Handler: index.handler
Runtime: nodejs24.x
Architectures:
- x86_64
EphemeralStorage:
Size: 10240
Environment:
Variables:
BUCKET: amzn-s3-demo-bucket
KEY: file.txt
# Other function properties...
```
------
#### [ AWS SDKs ]
AWS SDK を使用して環境変数を管理するには、以下の API オペレーションを使用します。
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
詳細については、目的のプログラミング言語の [AWS SDK ドキュメント](https://aws.amazon.com/developer/tools/)を参照してください。
------
## 環境変数のシナリオ例
環境変数を使用して、テスト環境および本番環境における関数の動作をカスタマイズできます。例えば、同じコードでも設定が異なる 2 つの関数を作成できます。1 つの関数はテストデータベースに接続し、もう 1 つはプロダクションデータベースに接続します。この状況では、環境変数を使用して、データベースのホスト名とその他の接続に関する詳細を関数に渡します。
次の例は、データベースホストとデータベース名を環境変数として定義する方法を示しています。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/console-env.png)
テスト環境で本番環境よりも多くのデバッグ情報を生成する場合は、環境変数を設定して、より詳細なログ記録またはトレースを使用するようにテスト環境を設定できます。
例えばテスト環境では、`LOG_LEVEL` キーと、デバッグまたはトレースのログレベルを示す値を使用して環境変数を設定できます。Lambda 関数のコードで、この環境変数を使用してログレベルを設定できます。
Python と Node.js の次のコード例は、これを実現する方法を示しています。これらの例では、環境変数の値が Python の場合は `DEBUG`、Node.js の場合は `debug` であることを前提としています。
------
#### [ Python ]
**Example ログレベルを設定する Python コード**
```
import os
import logging
# Initialize the logger
logger = logging.getLogger()
# Get the log level from the environment variable and default to INFO if not set
log_level = os.environ.get('LOG_LEVEL', 'INFO')
# Set the log level
logger.setLevel(log_level)
def lambda_handler(event, context):
# Produce some example log outputs
logger.debug('This is a log with detailed debug information - shown only in test environment')
logger.info('This is a log with standard information - shown in production and test environments')
```
------
#### [ Node.js (ES module format) ]
**Example ログレベルを設定する Node.js コード**
この例では、`winston` ログ記録ライブラリを使用します。npm を使用して、このライブラリを関数のデプロイパッケージに追加します。詳細については、「[依存関係を含めて .zip デプロイパッケージを作成する](nodejs-package.md#nodejs-package-create-dependencies)」を参照してください。
```
import winston from 'winston';
// Initialize the logger using the log level from environment variables, defaulting to INFO if not set
const logger = winston.createLogger({
level: process.env.LOG_LEVEL || 'info',
format: winston.format.json(),
transports: [new winston.transports.Console()]
});
export const handler = async (event) => {
// Produce some example log outputs
logger.debug('This is a log with detailed debug information - shown only in test environment');
logger.info('This is a log with standard information - shown in production and test environment');
};
```
------
## Lambda 環境変数の取得
関数コード内の環境変数を取得するには、プログラミング言語の標準メソッドを使用します。
------
#### [ Node.js ]
```
let region = process.env.AWS_REGION
```
------
#### [ Python ]
```
import os
region = os.environ['AWS_REGION']
```
**注記**
場合によっては、次の形式の使用が必要になる場合があります。
```
region = os.environ.get('AWS_REGION')
```
------
#### [ Ruby ]
```
region = ENV["AWS_REGION"]
```
------
#### [ Java ]
```
String region = System.getenv("AWS_REGION");
```
------
#### [ Go ]
```
var region = os.Getenv("AWS_REGION")
```
------
#### [ C\$1 ]
```
string region = Environment.GetEnvironmentVariable("AWS_REGION");
```
------
#### [ PowerShell ]
```
$region = $env:AWS_REGION
```
------
Lambda は、環境変数を保管時に暗号化して安全に保存します。[別の暗号化キーを使用](configuration-envvars-encryption.md)したり、クライアント側で環境変数値を暗号化したり、CloudFormation テンプレートで AWS Secrets Manager を使用して環境変数を設定したりするように Lambda を設定できます。
## 定義されたランタイム環境変数
Lambda [ランタイム](lambda-runtimes.md)は、初期化中にいくつかの環境変数を設定します。ほとんどの環境変数は、関数またはランタイムに関する情報を提供します。これらの環境変数のキーは*予約済み*であるため、関数設定では設定できません。
**予約済み環境変数**
+ `_HANDLER` － 関数に設定されているハンドラの場所。
+ `_X_AMZN_TRACE_ID` － [X-Ray トレースヘッダー](services-xray.md)。この環境変数は呼び出しごとに変化します。
+ この環境変数は OS 専用ランタイム (`provided` ランタイムファミリー) には定義されていません。カスタムランタイムには [次の呼び出し](runtimes-api.md#runtimes-api-next) からの `Lambda-Runtime-Trace-Id` レスポンスのヘッダーに `_X_AMZN_TRACE_ID` を設定できます。
+ Java ランタイムバージョン 17 以降では、この環境変数は使用されません。代わりに、Lambda はトレース情報を `com.amazonaws.xray.traceHeader` システムプロパティに保存します。
+ `AWS_DEFAULT_REGION` － Lambda 関数が実行されるデフォルトの AWS リージョン。
+ `AWS_REGION` － Lambda 関数が実行される AWS リージョン。定義されている場合、この値は `AWS_DEFAULT_REGION` を上書きします。
+ AWS SDK での AWS リージョン 環境変数を使用する方法の詳細については、「*AWS SDK とツールリファレンスガイド*」の「[AWSリージョン](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html#feature-region-sdk-compat)」を参照してください。
+ `AWS_EXECUTION_ENV` – `AWS_Lambda_` (例: `AWS_Lambda_java8`) のプレフィックスが付いた[ランタイム識別子](lambda-runtimes.md)。この環境変数は OS 専用ランタイム (`provided` ランタイムファミリー) には定義されていません。
+ `AWS_LAMBDA_FUNCTION_NAME` － 関数の名前。
+ `AWS_LAMBDA_FUNCTION_MEMORY_SIZE` － 関数で使用できるメモリの量 (MB 単位)。
+ `AWS_LAMBDA_FUNCTION_VERSION` － 実行される関数のバージョン。
+ `AWS_LAMBDA_INITIALIZATION_TYPE` – 関数の初期化タイプ。`on-demand`、`provisioned-concurrency`、`snap-start`、`lambda-managed-instances` のいずれかになります。詳細については、「[プロビジョニングされた同時実行の設定](provisioned-concurrency.md)」、「[Lambda SnapStart による起動パフォーマンスの向上](snapstart.md)」、「[Lambda マネージドインスタンス](lambda-managed-instances.md)」を参照してください。
+ `AWS_LAMBDA_LOG_GROUP_NAME`、`AWS_LAMBDA_LOG_STREAM_NAME` － Amazon CloudWatch Logs グループの名前と関数のストリーム。`AWS_LAMBDA_LOG_GROUP_NAME` および `AWS_LAMBDA_LOG_STREAM_NAME` の[環境変数](#configuration-envvars-runtime)は Lambda SnapStart 関数では使用できません。
+ `AWS_ACCESS_KEY`、`AWS_ACCESS_KEY_ID`、`AWS_SECRET_ACCESS_KEY`、`AWS_SESSION_TOKEN` – 関数の[実行ロール](lambda-intro-execution-role.md)から取得したアクセスキー。
+ `AWS_LAMBDA_RUNTIME_API` － ([カスタムランタイム](runtimes-custom.md)) [ランタイム API](runtimes-api.md) のホストおよびポート。
+ `LAMBDA_TASK_ROOT` － Lambda 関数コードへのパス。
+ `LAMBDA_RUNTIME_DIR` － ランタイムライブラリへのパス。
+ `AWS_LAMBDA_MAX_CONCURRENCY` – (Lambda マネージドインスタンスのみ) Lambda が 1 つの実行環境に送信する同時呼び出しの最大数。
+ `AWS_LAMBDA_METADATA_API` – `{ipv4_address}:{port}` 形式の[メタデータエンドポイント](configuration-metadata-endpoint.md)サーバーアドレス (例: `169.254.100.1:9001`)。
+ `AWS_LAMBDA_METADATA_TOKEN` – [メタデータエンドポイント](configuration-metadata-endpoint.md)へのリクエストを認証するために使用される現在の実行環境に対する一意の認証トークン。Lambda は、初期化時にこのトークンを自動的に生成します。
以下の追加の環境変数は予約されていないため、関数設定で拡張できます。
**予約されていない環境変数**
+ `LANG` － ランタイムのロケール (`en_US.UTF-8`)。
+ `PATH` － 実行パス (`/usr/local/bin:/usr/bin/:/bin:/opt/bin`)。
+ `LD_LIBRARY_PATH` － システムライブラリのパス (`/var/lang/lib:/lib64:/usr/lib64:$LAMBDA_RUNTIME_DIR:$LAMBDA_RUNTIME_DIR/lib:$LAMBDA_TASK_ROOT:$LAMBDA_TASK_ROOT/lib:/opt/lib`)。
+ `NODE_PATH` － ([Node.js](lambda-nodejs.md)) Node.js ライブラリのパス (`/opt/nodejs/node12/node_modules/:/opt/nodejs/node_modules:$LAMBDA_RUNTIME_DIR/node_modules`)。
+ `NODE_OPTIONS` – ([Node.js](lambda-nodejs.md)) Node.js ランタイムの場合、`NODE_OPTIONS` を使用して、Lambda がデフォルトで無効にする実験的機能を再度有効にできます。
+ `PYTHONPATH` – ([Python](lambda-python.md)) Python ライブラリパス (`$LAMBDA_RUNTIME_DIR`)。
+ `GEM_PATH` － ([Ruby](lambda-ruby.md)) Ruby ライブラリのパス (`$LAMBDA_TASK_ROOT/vendor/bundle/ruby/3.3.0:/opt/ruby/gems/3.3.0`)。
+ `AWS_XRAY_CONTEXT_MISSING` － X-Ray トレースの場合、Lambda は X-Ray SDK からランタイムエラーがスローされないように、これを `LOG_ERROR` に設定します。
+ `AWS_XRAY_DAEMON_ADDRESS` － X-Ray トレーシングの場合、X-Ray デーモンの IP アドレスとポート。
+ `AWS_LAMBDA_DOTNET_PREJIT` – ([.NET](lambda-csharp.md)) この変数を設定して、.NET 固有のランタイムの最適化を有効または無効にします。値には `always`、`never`、および `provisioned-concurrency` があります。詳細については、「[関数に対するプロビジョニングされた同時実行数の設定](provisioned-concurrency.md)」を参照してください。
+ `TZ` － 環境のタイムゾーン (`:UTC`)。実行環境は、システムクロックを同期するために NTP を使用します。
表示されるサンプル値は、最新のランタイムを反映しています。特定の変数やその値の有無は、以前のランタイムでは異なる場合があります。
# Lambda 環境変数の保護
環境変数の保護する場合、サーバー側の暗号化を使用して保管中のデータを保護し、クライアント側の暗号化を使用して転送中のデータを保護することができます。
**注記**
データベースのセキュリティを強化するには、環境変数の代わりに AWS Secrets Manager を使用してデータベースの認証情報を保存することをお勧めします。詳細については、「[Lambda 関数で Secrets Manager シークレットを使用する](with-secrets-manager.md)」を参照してください。
**保管時のセキュリティ**
Lambda は、AWS KMS key で常にサーバー側の暗号化を提供します。デフォルトでは、Lambda は AWS マネージドキーを使用します。このデフォルトの動作がワークフローに適している場合は、他の設定をする必要はありません。Lambda はアカウントに AWS マネージドキーを作成し、それに対するアクセス許可を管理します。このキーの使用に対する AWS の請求は発生しません。
必要に応じて、AWS KMS カスタマー管理のキーを使用することもできます。その場合、KMS キーのローテーションの制御や、KMS キーの管理に関する組織の要件への準拠を行うことができます。カスタマー管理のキーを使用すると、KMS キーへのアクセス許可があるアカウントのユーザーのみが、関数の環境変数を表示または管理できます。
カスタマーマネージドキーには、標準の AWS KMS 料金が発生します。詳細については、「[AWS Key Management Service 料金表](https://aws.amazon.com/kms/pricing/)」を参照してください。
**転送中のセキュリティ**
セキュリティを強化するために、転送中の暗号化のヘルパーを有効にして、転送中の保護のために環境変数をクライアント側で暗号化することができます。
**環境変数の暗号化を設定するには**
1. AWS Key Management Service (AWS KMS) を使用して、Lambda でサーバー側およびクライアント側の暗号化に使用するカスタマー管理のキーを作成します。詳細については、 *AWS Key Management Service デベロッパーガイド*の「[キーの作成](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html)」を参照してください。
1. Lambda コンソールを使用して、[**環境変数の編集**] ページに移動します。
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択します。
1. [**設定**] を選択し、左側のナビゲーションバーで [**環境変数**] を選択します。
1. [**環境変数**] セクションで、[**編集**] を選択します。
1. [**暗号化設定**] を展開します。
1. コンソール暗号化ヘルパーを有効にして、クライアント側の暗号化を使用し、転送中のデータを保護します (オプション)。
1. [**転送時の暗号化**] で、[**転送時の暗号化に使用するヘルパーの有効化**] を選択します。
1. コンソール暗号化ヘルパーを有効にする各環境変数に対して、環境変数の横にある **[Encrypt]** (暗号化) を選択します。
1. 転送時に暗号化する AWS KMS key で、この手順の最初で作成したカスタマー管理キーを選択します。
1. [**実行ロールポリシー**] をクリックしてポリシーをコピーします。このポリシーは、環境変数を復号化するアクセス許可を関数の実行ロールに付与します。
このポリシーは、この手順の最後のステップで使用するために保存します。
1. 環境変数を暗号化する関数にコードを追加します。例を表示するには、**[Decrypt secrets snippet]** を選択します。
1. 保管中の暗号化に使用するカスタマーマネージドキーを指定します (オプション)。
1. [**カスタマーマスターキーの使用**] を選択します。
1. この手順の最初に作成したカスタマー管理のキーを選択します。
1. **[保存]** を選択します。
1. 許可を設定します。
サーバー側の暗号化でカスタマーマネージドキーを使用している場合は、関数の環境変数を表示または管理できるようにしたいユーザーまたはロールに許可を付与します。詳細については、「[サーバー側の暗号化 KMS キーに対するアクセス許可の管理](#managing-permissions-to-your-server-side-encryption-key)」を参照してください。
転送時のセキュリティの目的でクライアント側の暗号化を有効にする場合、関数に `kms:Decrypt` API オペレーションを呼び出すためのアクセス許可が必要です。この手順で以前に保存したポリシーを関数の[実行ロール](lambda-intro-execution-role.md)に追加します。
## サーバー側の暗号化 KMS キーに対するアクセス許可の管理
ユーザーや関数の実行ロールには、デフォルトの暗号化キーを使用するための AWS KMS アクセス許可が不要です。カスタマー管理のキーを使用するには、キーを使用するためのアクセス許可が必要です。Lambda はユーザーのアクセス許可を使用して、キーを付与します。これにより、Lambda はこのキーを暗号化に使用できます。
+ `kms:ListAliases` － Lambda コンソールでキーを表示します。
+ `kms:CreateGrant`、`kms:Encrypt` － 関数でカスタマー管理のキーを設定します。
+ `kms:Decrypt` － カスタマー管理のキーで暗号化された環境変数を表示および管理します。
これらの許可は、AWS アカウントから、またはキーのリソースベースの許可ポリシーから取得できます。`ListAliases` は、[Lambda のマネージドポリシー](access-control-identity-based.md)から提供されます。キーポリシーは、**キーユーザー**グループのユーザーに対して残りのアクセス許可を付与します。
`Decrypt` アクセス許可を持たないユーザーは、引き続き関数を管理できますが、Lambda コンソールで環境変数を表示または管理することはできません。ユーザーが環境変数を表示できないようにするには、デフォルトキー、カスタマー管理キー、またはすべてのキーへのアクセスを拒否するステートメントをユーザーのアクセス許可に追加します。
**Example IAM ポリシー － キー ARN によるアクセスの拒否**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Deny",
"Action": [
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-2:111122223333:key/3be10e2d-xmpl-4be4-bc9d-0405a71945cc"
}
]
}
```
キーのアクセス許可の管理に関する詳細については、「*AWS Key Management Service デベロッパーガイド*」の「[AWS KMS のキーポリシー](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)」を参照してください。
# Lambda 関数に Amazon VPC 内のリソースへのアクセスを許可する
Amazon Virtual Private Cloud (Amazon VPC) を使用すると、AWS アカウント にプライベートネットワークを作成して、Amazon Elastic Compute Cloud (Amazon EC2) インスタンス、Amazon Relational Database Service (Amazon RDS) インスタンス、Amazon ElastiCache インスタンスなどのリソースをホストできます。リソースを含むプライベートサブネットを介して関数を VPC にアタッチすることで、Lambda 関数に Amazon VPC でホストされているリソースへのアクセスを許可できます。Lambda コンソール、AWS Command Line Interface (AWS CLI）、または AWS SAM を使用して Lambda 関数を Amazon VPC にアタッチするには、次のセクションの手順に従います。
**注記**
すべての Lambda 関数は、Lambda サービスによって所有および管理されている VPC 内で実行されます。これらの VPC は Lambda によって自動的に管理され、顧客には表示されません。Amazon VPC 内の他の AWS リソースにアクセスするように関数を設定しても、関数が内部で実行される Lambda が管理する VPC には影響しません。
**Topics**
+ [
## 必要な IAM 許可
](#configuration-vpc-permissions)
+ [
## AWS アカウント の Amazon VPC への Lambda 関数のアタッチ
](#configuration-vpc-attaching)
+ [
## VPC にアタッチされたときのインターネットアクセス
](#configuration-vpc-internet-access)
+ [
## IPv6 サポート
](#configuration-vpc-ipv6)
+ [
## Amazon VPC で Lambda を使用するためのベストプラクティス
](#configuration-vpc-best-practice)
+ [
## Elastic Network Interface (ENI) について
](#configuration-vpc-enis)
+ [
## VPC 設定で IAM 条件キーを使用する
](#vpc-conditions)
+ [
## VPC チュートリアル
](#vpc-tutorials)
## 必要な IAM 許可
Lambda 関数をAWS アカウント の Amazon VPC にアタッチするには、Lambda が VPC 内のリソースへのアクセスを関数に許可するために使用するネットワークインターフェイスを作成および管理するためのアクセス許可が必要です。
Lambda が作成するネットワークインターフェイスは、Hyperplane Elastic Network Interface または Hyperplane ENI と呼ばれます。これらのネットワークインターフェイスの詳細については、「[Elastic Network Interface (ENI) について](#configuration-vpc-enis)」を参照してください。
AWS マネージドポリシーである [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) を関数の実行ロールにアタッチすることで、必要な許可を関数に付与できます。Lambda コンソールで新しい関数を作成して VPC にアタッチすると、Lambda は自動的にこのアクセス許可ポリシーを追加します。
独自の IAM 許可ポリシーを作成する場合は、次の許可をすべて追加して、すべてのリソース (`"Resource": "*"`) にそれらを許可してください。
+ ec2:CreateNetworkInterface
+ ec2:DescribeNetworkInterfaces
+ ec2:DescribeSubnets
+ ec2:DeleteNetworkInterface
+ ec2:AssignPrivateIpAddresses
+ ec2:UnassignPrivateIpAddresses
関数のロールにこれらのアクセス許可が必要なのは、関数を呼び出すためではなく、ネットワーク インターフェイスを作成するためだけであることに注意してください。関数の実行ロールからこれらのアクセス許可を削除しても、関数が Amazon VPC にアタッチされたときにその関数を正常に呼び出すことができます。
関数を VPC にアタッチするには、Lambda も IAM ユーザーロールを使用してネットワークリソースを検証する必要があります。ユーザー ロールに次の IAM アクセス許可があることを確認してください。
+ **ec2:DescribeSecurityGroups**
+ **ec2:DescribeSubnets**
+ **ec2:DescribeVpcs**
+ **ec2:GetSecurityGroupsForVpc**
**注記**
関数の実行ロールに付与する Amazon EC2 許可は、関数を VPC にアタッチするために Lambda サービスが使用します。ただし、これらのアクセス許可を関数のコードに暗黙的に付与することになります。これは、関数コードがこれらの Amazon EC2 API コールを実行できることを意味します。セキュリティのベストプラクティスに従うためのアドバイスについては、「[セキュリティのベストプラクティス](#configuration-vpc-best-practice-security)」を参照してください。
## AWS アカウント の Amazon VPC への Lambda 関数のアタッチ
Lambda コンソール、AWS アカウント、または AWS CLI を使用して、AWS SAM の Amazon VPC に関数をアタッチします。AWS CLI または AWS SAM を使用している場合、または Lambda コンソールを使用して既存の関数を VPC にアタッチする場合は、関数の実行ロールに前のセクションに記載されている必要なアクセス許可があることを確認してください。
Lambda 関数は、[ハードウェア専有インスタンスのテナンシー](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html)を使用して VPC に直接接続することはできません。専有 VPC のリソースに接続するには、[デフォルトのテナンシーで 2 番目の VPC にピア接続します](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-dedicated-vpc/)。
------
#### [ Lambda console ]
**作成時に Amazon VPC に関数をアタッチするには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開き、**[関数の作成]** を選択します。
1. **[基本的な情報]** の **[関数名]** に、関数の名前を入力します。
1. 次の手順を実行して、関数の VPC 設定を行います。
1. **[詳細設定]** を展開します。
1. **[VPC を有効化]** を選択し、次に関数をアタッチする VPC を選択します。
1. (オプション) [アウトバウンド IPv6 トラフィック](#configuration-vpc-ipv6)を許可するには、**[デュアルスタックサブネットの IPv6 トラフィックを許可]** をクリックします。
1. ネットワークインターフェイスを作成するサブネットとセキュリティグループを選択します。**[デュアルスタックサブネットの IPv6 トラフィックを許可する]** を選択した場合は、選択したすべてのサブネットに IPv4 CIDR ブロックと IPv6 CIDR ブロックが必要です。
**注記**
プライベートリソースにアクセスするには、関数をプライベートサブネットに接続します。関数にインターネットアクセスが必要な場合、「[VPC に接続された Lambda 関数にインターネットアクセスを有効にする](configuration-vpc-internet.md)」を参照してください。関数をパブリックサブネットに接続しても、インターネットアクセスやパブリック IP アドレスは提供されません。
1. [**関数の作成**] を選択してください。
**既存の関数を Amazon VPC にアタッチするには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開き、関数を選択します。
1. **[設定]** タブを選択し、次に **[VPC]** を選択します。
1. **[編集]** を選択します。
1. **VPC** で、関数をアタッチする Amazon VPC を選択します。
1. (オプション) [アウトバウンド IPv6 トラフィック](#configuration-vpc-ipv6)を許可するには、**[デュアルスタックサブネットの IPv6 トラフィックを許可]** をクリックします。
1. ネットワークインターフェイスを作成するサブネットとセキュリティグループを選択します。**[デュアルスタックサブネットの IPv6 トラフィックを許可する]** を選択した場合は、選択したすべてのサブネットに IPv4 CIDR ブロックと IPv6 CIDR ブロックが必要です。
**注記**
プライベートリソースにアクセスするには、関数をプライベートサブネットに接続します。関数にインターネットアクセスが必要な場合、「[VPC に接続された Lambda 関数にインターネットアクセスを有効にする](configuration-vpc-internet.md)」を参照してください。関数をパブリックサブネットに接続しても、インターネットアクセスやパブリック IP アドレスは提供されません。
1. **[保存]** を選択します。
------
#### [ AWS CLI ]
**作成時に Amazon VPC に関数をアタッチするには**
+ Lambda 関数を作成して VPC にアタッチするには、次の CLI `create-function` コマンドを実行します。
```
aws lambda create-function --function-name my-function \
--runtime nodejs24.x --handler index.js --zip-file fileb://function.zip \
--role arn:aws:iam::123456789012:role/lambda-role \
--vpc-config Ipv6AllowedForDualStack=true,SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb
```
独自のサブネットとセキュリティグループを指定し、ユースケースに応じて `Ipv6AllowedForDualStack` を `true`または `false` に設定します。
**既存の関数を Amazon VPC にアタッチするには**
+ 既存の関数を VPC にアタッチするには、次の CLI `update-function-configuration` コマンドを実行します。
```
aws lambda update-function-configuration --function-name my-function \
--vpc-config Ipv6AllowedForDualStack=true, SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb
```
**VPC から関数のアタッチを解除するには**
+ VPC から関数をアタッチ解除するには、VPC サブネットとセキュリティグループの空のリストを使用して次の `update-function-configuration` CLI コマンドを実行します。
```
aws lambda update-function-configuration --function-name my-function \
--vpc-config SubnetIds=[],SecurityGroupIds=[]
```
------
#### [ AWS SAM ]
**関数を VPC にアタッチするには**
+ Lambda 関数を Amazon VPC にアタッチするには、次のテンプレート例に示すように、関数定義に `VpcConfig` プロパティを追加します。このプロパティの詳細については、「*CloudFormationユーザーガイド*」の「[AWS::Lambda::Function VpcConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-vpcconfig.html)」を参照してください (AWS SAM`VpcConfig` プロパティは CloudFormation `AWS::Lambda::Function` リソースの `VpcConfig` プロパティに直接渡されます)。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./lambda_function/
Handler: lambda_function.handler
Runtime: python3.12
VpcConfig:
SecurityGroupIds:
- !Ref MySecurityGroup
SubnetIds:
- !Ref MySubnet1
- !Ref MySubnet2
Policies:
- AWSLambdaVPCAccessExecutionRole
MySecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Security group for Lambda function
VpcId: !Ref MyVPC
MySubnet1:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MyVPC
CidrBlock: 10.0.1.0/24
MySubnet2:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MyVPC
CidrBlock: 10.0.2.0/24
MyVPC:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 10.0.0.0/16
```
AWS SAM で VPC を設定する方法の詳細については、「*CloudFormation のユーザーガイド*」の「[AWS::EC2::VPC](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html)」を参照してください。
------
## VPC にアタッチされたときのインターネットアクセス
デフォルトでは、Lambda 関数はインターネットにアクセスできます。関数を VPC にアタッチすると、関数でアクセスできるのは、その VPC 内で利用可能なリソースのみになります。関数にインターネットへのアクセスを許可するには、インターネットにアクセスできるように VPC を設定する必要があります。詳細については[VPC に接続された Lambda 関数にインターネットアクセスを有効にする](configuration-vpc-internet.md)を参照してください。
## IPv6 サポート
関数は IPv6 経由でデュアルスタック VPC サブネット内のリソースに接続することができます。このオプションはデフォルトでオフに設定されています。アウトバウンド IPv6 トラフィックを許可するには、コンソールを使用するか、`--vpc-config Ipv6AllowedForDualStack=true` オプションで [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) または [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) コマンドを使用します。
**注記**
VPC でアウトバウンド IPv6 トラフィックを許可するには、関数に接続されているすべてのサブネットがデュアルスタックサブネットである必要があります。Lambda は、VPC 内の IPv6 専用サブネットのアウトバウンド IPv6 接続または VPC に接続されていない関数のアウトバウンド IPv6 接続をサポートしていません。
IPv6 経由でサブネットリソースに明示的に接続するように関数コードを更新することができます。次の Python の例では、ソケットを開いて IPv6 サーバーに接続します。
**Example — IPv6 サーバへの接続**
```
def connect_to_server(event, context):
server_address = event['host']
server_port = event['port']
message = event['message']
run_connect_to_server(server_address, server_port, message)
def run_connect_to_server(server_address, server_port, message):
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)
try:
# Send data
sock.connect((server_address, int(server_port), 0, 0))
sock.sendall(message.encode())
BUFF_SIZE = 4096
data = b''
while True:
segment = sock.recv(BUFF_SIZE)
data += segment
# Either 0 or end of data
if len(segment) < BUFF_SIZE:
break
return data
finally:
sock.close()
```
## Amazon VPC で Lambda を使用するためのベストプラクティス
Lambda VPC 設定がベストプラクティスガイドラインに準拠するには、次のセクションのアドバイスに従ってください。
### セキュリティのベストプラクティス
Lambda 関数を VPC にアタッチするには、関数の実行ロールに複数の Amazon EC2 アクセス許可を付与する必要があります。これらのアクセス許可は、関数が VPC 内のリソースにアクセスするために使用するネットワークインターフェイスを作成するために必要です。ただし、これらのアクセス許可は関数のコードにも暗黙的に付与されます。つまり、関数コードにはこれらの Amazon EC2 API コールを行うアクセス許可が付与されます。
最小特権アクセスの原則に従うには、次の例のような拒否ポリシーを関数の実行ロールに追加します。このポリシーは、関数コードが Amazon EC2 API を呼び出すのを防ぎ、Lambda サービスがユーザーに代わって VPC リソースを管理できるようにします。ポリシーは `lambda:SourceFunctionArn` 条件キーを使用します。これは、実行中に関数コードによって行われた API コールにのみ適用されます。詳細については、「[ソース関数 ARN を使用した関数のアクセス動作の制御](permissions-source-function-arn.md)」を参照してください。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeSubnets",
"ec2:DetachNetworkInterface",
"ec2:AssignPrivateIpAddresses",
"ec2:UnassignPrivateIpAddresses"
],
"Resource": [ "*" ],
"Condition": {
"ArnEquals": {
"lambda:SourceFunctionArn": [
"arn:aws:lambda:us-west-2:123456789012:function:my_function"
]
}
}
}
]
}
```
------
AWS は、VPC のセキュリティを強化するために、*[セキュリティグループ](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)*と*[アクセスコントロールリスト (ACL)](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html)* を提供します。セキュリティグループは、リソースのインバウンドトラフィックとアウトバウンドトラフィックをコントロールします。ネットワーク ACL は、サブネットのインバウンドトラフィックとアウトバウンドトラフィックをコントロールします。セキュリティグループは、ほとんどのサブネットに対して十分なアクセス制御を提供します。VPC に追加のセキュリティレイヤーが必要な場合は、ネットワーク ACL を使用できます。Amazon VPC を使用する際のセキュリティのベスト プラクティスに関する一般的なガイドラインについては、「*Amazon Virtual Private Cloud ユーザーガイド*」の「[VPC のセキュリティのベスト プラクティス](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-best-practices.html)」を参照してください。
### パフォーマンスに関するベストプラクティス
関数を VPC にアタッチすると、Lambda は接続に使用できるネットワークリソース (Hyperplane ENI) があるかどうかを確認します。Hyperplane ENI は、セキュリティグループと VPC サブネットの特定の組み合わせに関連付けられています。VPC にすでに 1 つの関数をアタッチしている場合、別の関数をアタッチするときに同じサブネットとセキュリティグループを指定すると、Lambda はネットワークリソースを共有でき、新しい Hyperplane ENI を作成する必要がなくなります。Hyperplane ENI とそのライフサイクルの詳細については、「[Elastic Network Interface (ENI) について](#configuration-vpc-enis)」を参照してください。
## Elastic Network Interface (ENI) について
Hyperplane ENI は、Lambda 関数と関数に接続するリソースとの間のネットワークインターフェイスとして機能するマネージドリソースです。Lambda サービスは、関数を VPC にアタッチするときに、これらの ENI を自動的に作成および管理します。
Hyperplane ENI は直接表示されないため、設定や管理を行う必要はありません。ただし、関数がどのように機能するかを知っておくと、VPC にアタッチする際の関数の動作を理解するのに役立ちます。
特定のサブネットとセキュリティグループの組み合わせを使用して VPC に関数を初めてアタッチすると、Lambda は Hyperplane ENI を作成します。同じサブネットとセキュリティグループの組み合わせを使用するアカウント内の他の関数も、この ENI を使用できます。Lambda は可能な限り既存の ENI を再利用して、リソースの使用率を最適化し、新しい ENI の作成を最小限に抑えます。各 Hyperplane ENI は最大 65,000 個の接続/ポートをサポートします。接続数がこの制限を超えると、Lambda はネットワークトラフィックと同時実行要件に基づいて ENI の数を自動的にスケーリングします。
新しい関数の場合、Lambda が Hyperplane ENI を作成している間は、関数は保留状態のままになり、呼び出されることはありません。関数は、Hyperplane ENI の準備ができた場合にのみアクティブ状態に移行します。これには数分かかる場合があります。既存の関数の場合、バージョンの作成や関数のコードの更新など、関数をターゲットとする追加のオペレーションを実行することはできませんが、関数の以前のバージョンを引き続き呼び出すことはできます。
ENI ライフサイクルの管理の一環として、Lambda は ENI を削除して再作成し、ENI 間でネットワークトラフィックを負荷分散したり、ENI ヘルスチェックで見つかった問題に対処したりする場合があります。さらに、Lambda 関数が 14 日間アイドル状態のままである場合、Lambda は未使用の Hyperplane ENI を回収し、関数の状態を`Inactive`に設定します 次の呼び出しの試行は失敗し、Lambda が Hyperplane ENI の作成または割り当てを完了するまで、関数は再び保留状態になります。設計が ENI の永続性に依存しないことをお勧めします。
関数を更新してその VPC 設定を削除する場合、Lambda はアタッチされた Hyperplane ENI を削除するのに最大 20 分かかります。Lambda は、他の関数 (または発行された関数のバージョン) がその Hyperplane ENI を使用していない場合にのみ ENI を削除します。
Lambda は、関数[実行ロール](lambda-intro-execution-role.md)のアクセス許可により、Hyperplane ENI を削除します。Lambda が Hyperplane ENI を削除する前に実行ロールを削除すると、Lambda は Hyperplane ENI を削除できません。削除は手動で実行できます。
## VPC 設定で IAM 条件キーを使用する
VPC 設定で Lambda 固有の条件キーを使用して、Lambda 関数に追加のアクセス許可コントロールを提供できます。例えば、組織内のすべての関数を VPC に接続するように要求できます。また、関数のユーザーに対して使用を許可または拒否するサブネットとセキュリティグループを指定することもできます。
Lambda は IAM ポリシーで次の条件キーをサポートしています。
+ **lambda:VpcIds** － 1 つ以上の VPC を許可または拒否します。
+ **lambda:SubnetIds** － 1 つ以上のサブネットを許可または拒否します。
+ **lambda:SecurityGroupIds** － 1 つ以上のセキュリティグループを許可または拒否します。
Lambda API オペレーションの [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html) および [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html) は、これらの条件キーをサポートしています。IAM ポリシーでの条件キーの使用の詳細については、*IAM ユーザーガイド*の「[IAM JSON ポリシーエレメント: 条件](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html)」を参照してください。
**ヒント**
関数に以前の API リクエストの VPC 設定が既に含まれている場合は、VPC 設定なしで `UpdateFunctionConfiguration` リクエストを送信できます。
### VPC 設定の条件キーを使用したポリシーの例
以下の例は、VPC 設定で条件キーを使用する方法を示しています。必要な制限を含むポリシーステートメントを作成したら、このポリシーステートメントをターゲットのユーザーまたはロールに追加します。
#### ユーザーに対して VPC に接続された関数のみをデプロイさせる
すべてのユーザーに対して VPC に接続された関数のみをデプロイさせるには、有効な VPC ID を含まない関数の作成および更新オペレーションを拒否できます。
VPC ID は `CreateFunction` リクエストまたは `UpdateFunctionConfiguration` リクエストへの入力パラメータではないことに注意してください。Lambda は、サブネットとセキュリティグループのパラメータに基づいて VPC ID 値を取得します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceVPCFunction",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"Null": {
"lambda:VpcIds": "true"
}
}
}
]
}
```
------
#### 特定の VPC、サブネット、セキュリティグループに対するユーザーアクセスを拒否する
特定の VPC へのユーザーアクセスを拒否するには、`StringEquals` を使用して `lambda:VpcIds` 条件の値を確認します。次の例では、 `vpc-1` および `vpc-2` へのユーザーアクセスを拒否します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceOutOfVPC",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": [
"vpc-1",
"vpc-2"
]
}
}
}
]
}
```
------
特定のサブネットへのユーザーアクセスを拒否するには、`StringEquals` を使用して `lambda:SubnetIds` 条件の値を確認します。次の例では、 `subnet-1` および `subnet-2` へのユーザーアクセスを拒否します。
```
{
"Sid": "EnforceOutOfSubnet",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}
```
特定のセキュリティグループへのユーザーアクセスを拒否するには、`StringEquals` を使用して `lambda:SecurityGroupIds` 条件の値を確認します。次の例では、 `sg-1` および `sg-2` へのユーザーアクセスを拒否します。
```
{
"Sid": "EnforceOutOfSecurityGroups",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}
```
#### 特定の VPC 設定を使用して関数を作成および更新することをユーザーに許可する
特定の VPC にアクセスすることをユーザーに許可するには、`StringEquals` を使用して `lambda:VpcIds` 条件の値を確認します。次の例では、`vpc-1` および `vpc-2` にアクセスすることをユーザーに許可します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceStayInSpecificVpc",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": [
"vpc-1",
"vpc-2"
]
}
}
}
]
}
```
------
特定のサブネットにアクセスすることをユーザーに許可するには、`StringEquals` を使用して `lambda:SubnetIds` 条件の値を確認します。次の例では、`subnet-1` および `subnet-2` にアクセスすることをユーザーに許可します。
```
{
"Sid": "EnforceStayInSpecificSubnets",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}
```
特定のセキュリティグループにアクセスすることをユーザーに許可するには、`StringEquals` を使用して `lambda:SecurityGroupIds` 条件の値を確認します。次の例では、`sg-1` および `sg-2` にアクセスすることをユーザーに許可します。
```
{
"Sid": "EnforceStayInSpecificSecurityGroup",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}
```
## VPC チュートリアル
次のチュートリアルでは、VPC 内のリソースに Lambda 関数を接続します。
+ [チュートリアル: Lambda 関数を使用して Amazon VPC 内の Amazon RDS にアクセスする](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-lambda-tutorial.html)
+ [チュートリアル: Amazon VPC の Amazon ElastiCache にアクセスする Lambda 関数の設定](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/LambdaRedis.html)
# Lambda 関数に別のアカウントの Amazon VPC 内のリソースへのアクセスを許可する
別のアカウントによって管理されている Amazon Virtual Private Cloud の Amazon VPC 内のリソースへのアクセスを、VPC をインターネットに公開することなく、AWS Lambda 関数に許可できます。このアクセスパターンにより、AWS を使用して他の組織とデータを共有できます。このアクセスパターンを使用すると、インターネット経由よりも高いレベルのセキュリティとパフォーマンスで、VPC 間でデータを共有できます。Amazon VPC ピアリング接続を使用してこれらのリソースにアクセスするように Lambda 関数を設定します。
**警告**
アカウントまたは VPC 間のアクセスを許可する場合は、プランがこれらのアカウントを管理する各組織のセキュリティ要件を満たしていることを確認します。このドキュメントの手順に従うことは、リソースのセキュリティ体制に影響します。
このチュートリアルでは、IPv4 を使用してピアリング接続で 2 つのアカウントを接続します。Amazon VPC にまだ接続されていない Lambda 関数を設定します。静的 IP を提供しないリソースに関数を接続するように DNS 解決を設定します。これらの手順を他のピアリングシナリオに適応させるには、「[VPC ピアリングガイド](https://docs.aws.amazon.com//vpc/latest/peering/what-is-vpc-peering.html)」を参照してください。
## 前提条件
Lambda 関数に別のアカウントのリソースへのアクセスを許可するには、次のものが必要です。
+ リソースを使用して承認し、リソースから読み取るように設定されている Lambda 関数。
+ Amazon RDS クラスターなど、Amazon VPC 経由で利用可能な別のアカウントのリソース。
+ Lambda 関数のアカウントとリソースのアカウントの認証情報。リソースのアカウントを使用する権限がない場合は、権限を持つユーザーに連絡してそのアカウントを準備します。
+ Lambda 関数に関連付ける VPC (およびサポートされている Amazon VPC リソース) を作成および更新するアクセス許可。
+ Lambda 関数の実行ロールと VPC 設定を更新するアクセス許可。
+ Lambda 関数のアカウントに VPC ピアリング接続を作成するアクセス許可。
+ リソースのアカウントで VPC ピアリング接続を受け入れるアクセス許可。
+ リソースの VPC (および Amazon VPC リソースのサポート) の設定を更新するアクセス許可。
+ Lambda 関数を呼び出すアクセス許可。
## 関数のアカウントに Amazon VPC を作成する
Lambda 関数のアカウントに Amazon VPC、サブネット、ルートテーブル、セキュリティグループを作成します。
**コンソールを使用して VPC、サブネット、その他の VPC リソースを作成するには**
1. Amazon VPC コンソール ([https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)) を開きます。
1. ダッシュボードで、**[VPC を作成]** を選択します。
1. **[IPv4 CIDR ブロック]** には、プライベート CIDR ブロックを指定します。CIDR ブロックは、リソースの VPC で使用されるブロックと重複してはいけません。リソースの VPC がリソースに IP を割り当てるために使用するブロックや、リソース VPC のルートテーブルで既に定義されているブロックを選択しないでください。適切な CIDR ブロックの定義の詳細については、「[VPC CIDR ブロック](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html)」を参照してください。
1. **[AZ のカスタマイズ]** を選択します。
1. リソースと同じ AZ を選択します。
1. **[パブリックサブネットの数]** には、**[0]** を選択します。
1. **[VPC エンドポイント]** には、**[なし]** を選択します。
1. **[Create VPC（VPC の作成）]** を選択します。
## 関数の実行ロールに VPC アクセス許可を付与します。
[AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) を関数の実行ロールにアタッチして、VPC に接続できるようにします。
**関数の実行ロールに VPC アクセス許可を付与するには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 関数の名前を選択します。
1. **[設定]** を選択します。
1. **[許可]** を選択してください。
1. **[実行ロール]** で、実行ロールを選択します。
1. **[アクセス許可ポリシー]** セクションで、**[アクセス許可の追加]** を選択します。
1. ドロップダウンリストで、**[ポリシーをアタッチ]** を選択します。
1. 検索ボックスに「`AWSLambdaVPCAccessExecutionRole`」と入力します。
1. ポリシー名の左側で、チェックボックスを選択します。
1. [**Add permissions (許可の追加)**] を選択します。
**関数を Amazon VPC にアタッチするには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 関数の名前を選択します。
1. **[設定]** タブを選択し、次に **[VPC]** を選択します。
1. **[編集]** を選択します。
1. **[VPC]** で、自分の VPC を選択します
1. **[サブネット]** で、サブネットを選択します。
1. **[セキュリティグループ]** で、VPC のデフォルトのセキュリティグループを選択します。
1. **[保存]** を選択します。
## VPC ピアリング接続リクエストの作成
関数の VPC (リクエスタ VPC) からリソースの VPC (アクセプタ VPC) への VPC ピアリング接続リクエストを作成します。
**関数の VPC から VPC ピアリング接続をリクエストするには**
1. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) を開きます。
1. ナビゲーションペインで、**[Peering Connections]** (ピアリング接続) をクリックします。
1. **[Create Peering Connection]** (ピアリング接続の作成) をクリックします。
1. **[VPC ID (リクエスタ)]** には、関数の VPC を選択します。
1. **[アカウント ID]** には、リソースのアカウントの ID を入力します。
1. **[VPC ID (アクセプタ)]** には、リソースの VPC を入力します。
## リソースのアカウントを準備する
ピアリング接続を作成し、接続を使用するようにリソースの VPC を準備するには、前提条件に記載されているアクセス許可を保持するロールを使用してリソースのアカウントにログインします。ログインする手順は、アカウントのセキュリティ保護方法によって異なる場合があります。AWS アカウントにサインインする方法の詳細については、「[AWS Sign-in User Guide](https://docs.aws.amazon.com//signin/latest/userguide/what-is-sign-in.html)」を参照してください。リソースのアカウントで、次の手順を実行します。
**VPC ピアリング接続リクエストを受け入れるには**
1. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) を開きます。
1. ナビゲーションペインで、**[Peering Connections]** (ピアリング接続) をクリックします。
1. 保留中の VPC ピアリング接続を選択します (ステータスは承認待ちです)。
1. **[アクション]** を選択します。
1. ドロップダウンリストから、**[リクエストを受け入れる]** を選択します。
1. 確認を求められたら、**[リクエストの承諾]** を選択します。
1. **[ルートテーブルを今すぐ変更]** を選択して VPC のメインルートテーブルにルートを追加すると、ピアリング接続を介してトラフィックを送受信できるようになります。
リソースの VPC のルートテーブルを検査します。Amazon VPC によって生成されたルートは、リソースの VPC の設定方法に基づいて接続を確立しない場合があります。VPC の新しいルートと既存の設定の間に競合がないことを確認します。トラブルシューティングの詳細については、「*Amazon Virtual Private Cloud VPC ピアリング接続ガイド*」の「[VPC ピアリング接続のトラブルシューティング](https://docs.aws.amazon.com/vpc/latest/peering/troubleshoot-vpc-peering-connections.html)」を参照してください。
**リソースのセキュリティグループを更新するには**
1. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) を開きます。
1. ナビゲーションペインで、**[セキュリティグループ]** を選択します。
1. リソースのセキュリティグループを選択します。
1. **[アクション]** を選択します。
1. ドロップダウンリストから、**[インバウンドルールの編集]** を選択します。
1. [**ルールの追加**] を選択します。
1. **[ソース]** には、関数のアカウント ID とセキュリティグループ ID をフォワードスラッシュで区切って入力します (例: 111122223333/sg-1a2b3c4d)。
1. **[Edit outbound rules]** (アウトバウンドルールの編集) を選択します。
1. アウトバウンドトラフィックが制限されているかどうかを確認します。デフォルトの VPC 設定では、すべてのアウトバウンドトラフィックが許可されます。アウトバウンドトラフィックが制限されている場合は、次のステップに進みます。
1. [**ルールの追加**] を選択します。
1. **[送信先]** には、関数のアカウント ID とセキュリティグループ ID をフォワードスラッシュで区切って入力します (例: 111122223333/sg-1a2b3c4d)。
1. [**ルールの保存**] を選択します。
**ピアリング接続の DNS 解決を有効にするには**
1. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) を開きます。
1. ナビゲーションペインで、**[Peering Connections]** (ピアリング接続) をクリックします。
1. ピアリング接続を選択します。
1. **[アクション]** を選択します。
1. **[DNS 設定の編集]** を選択します。
1. **[アクセプタ DNS 解決]** で、**[リクエスタ VPC がアクセプタ VPC ホストの DNS をプライベート IP に解決できるようにする]** を選択します。
1. **[Save changes]** (変更の保存) をクリックします。
## 関数のアカウントで VPC 設定を更新する
関数のアカウントにログインし、VPC 設定を更新します。
**VPC ピアリング接続のルートを追加するには**
1. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) を開きます。
1. ナビゲーションペインで、**[Route tables]** (ルートテーブル) を選択します。
1. 関数に関連付けたサブネットのルートテーブルの名前の横にあるチェックボックスをオンにします。
1. **[アクション]** を選択します。
1. [**Export routes**] (ルートのエクスポート) を選択します。
1. **[Add Rule]** (ルートの追加) を選択します。
1. **[送信先]** には、リソースの VPC の CIDR ブロックを入力します。
1. **[ターゲット]** には、VPC ピアリング接続を選択します。
1. **[Save changes]** (変更の保存) をクリックします。
ルートテーブルの更新中に発生する可能性のある考慮事項の詳細については、「[VPC ピアリング接続のルートテーブルを更新する](https://docs.aws.amazon.com//vpc/latest/peering/vpc-peering-routing.html)」を参照してください。
**Lambda 関数のセキュリティグループを更新するには**
1. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) を開きます。
1. ナビゲーションペインで、**[セキュリティグループ]** を選択します。
1. **[アクション]** を選択します。
1. **インバウンドのルールを編集** を選択します。
1. **ルールを追加** を選択してください。
1. **[ソース]** には、リソースのアカウント ID とセキュリティグループ ID をフォワードスラッシュで区切って入力します (例: 111122223333/sg-1a2b3c4d)。
1. [**ルールの保存**] を選択します。
**ピアリング接続の DNS 解決を有効にするには**
1. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) を開きます。
1. ナビゲーションペインで、**[Peering Connections]** (ピアリング接続) をクリックします。
1. ピアリング接続を選択します。
1. **[アクション]** を選択します。
1. **[DNS 設定の編集]** を選択します。
1. **[リクエスタ DNS 解決]** で、**[アクセプタ VPC がリクエスタ VPC ホストの DNS をプライベート IP に解決できるようにする]** を選択します。
1. **[Save changes]** (変更の保存) をクリックします。
## 関数をテストする
**テストイベントを作成し、関数の出力を検査するには**
1. **[コードソース]** ペインで、**[テスト]** を選択します。
1. **[新しいイベントを作成]** を選択します。
1. **[イベント JSON]** パネルで、デフォルト値を Lambda 関数に適した入力に置き換えます。
1. **[呼び出し]** を選択します。
1. **[実行結果]** タブで、**[レスポンス]** に想定した出力が含まれていることを確認します。
さらに、関数のログをチェックして、ログが想定どおりに機能していることを確認できます。
**CloudWatch Logs で関数の呼び出しレコードを表示するには**
1. [**Monitor**] (モニタリング) タブを選択します。
1. **[CloudWatch Logs を表示]** を選択します。
1. **[ログストリーム]** タブで、関数呼び出しに対応するログストリームを選択します。
1. ログが想定どおりに機能していることを確認します。
# VPC に接続された Lambda 関数にインターネットアクセスを有効にする
デフォルトでは、Lambda 関数は、インターネットにアクセスできる Lambda 管理型 VPC で実行されます。アカウントで VPC のリソースにアクセスするには、VPC 設定を関数に追加できます。これにより、VPC がインターネットにアクセスできる場合を除き、機能は VPC 内のリソースに制限されます。このページでは、VPC に接続された Lambda 関数にインターネットアクセスを提供する方法について説明します。
## VPC をまだ持っていません
### VPC を作成する
**[VPC ワークフローの作成]** は、サブネット、NAT ゲートウェイ、インターネットゲートウェイ、ルートテーブルエントリなど、Lambda 関数がプライベートサブネットからパブリックインターネットにアクセスするために必要なすべての VPC リソースを作成します。
**VPC を作成するには**
1. Amazon VPC コンソールの [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) を開いてください。
1. ダッシュボードで、**[VPC を作成]** を選択します。
1. **[Resources to create]** (作成するリソース) で、**[VPC and more]** (VPC など) を選択します。
1. **VPC を設定する**
1. [**名前タグの自動生成**] に、VPC の名前を入力します。
1. **[IPv4 CIDR ブロック]** で、デフォルトの候補を維持するか、アプリケーションまたはネットワークが必要とする CIDR ブロックを入力します。
1. アプリケーションが IPv6 アドレスを使用して通信する場合は、**[IPv6 CIDR ブロック]**、**[Amazon が提供する IPv6 CIDR ブロック]** を選択します。
1. **サブネットを設定する**
1. [**アベイラビリティゾーンの数**] で、[**2**] を選択します。高可用性を実現するには、少なくとも 2 つの AZ をお勧めします。
1. **[Number of public subnets]** (パブリックサブネットの数) で **2** を選択します。
1. **[Number of private subnets]** (プライベートサブネットの数) は、**2** を選択します。
1. パブリックサブネットのデフォルトの CIDR ブロックをそのまま使用することも、**[サブネット CIDR ブロックをカスタマイズする]** を展開して CIDR ブロックを入力することもできます。詳細については、「[サブネット CIDR ブロック](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-sizing.html)」を参照してください。
1. **[NAT ゲートウェイ]** で **[AZ ごとに 1]** を選択すると、回復性が高まります。
1. **[Egress 専用インターネットゲートウェイ]** では、IPv6 CIDR ブロックを含める場合は **[はい]** を選択します。
1. **[VPC エンドポイント]** は、デフォルトの **[S3 ゲートウェイ]** のままにします。このオプションには費用はかかりません。詳細については、「[Amazon S3 向け VPC エンドポイントの種類](https://docs.aws.amazon.com/AmazonS3/latest/userguide/privatelink-interface-endpoints.html#types-of-vpc-endpoints-for-s3)」を参照してください。
1. **[DNS オプション]**については、デフォルト設定のままにします。
1. **[Create VPC（VPC の作成）]** を選択します。
### Lambda 関数を設定
**関数の作成時に VPC を設定するには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. [**関数の作成**] を選択してください。
1. [**基本的な情報**] の [**関数名**] に、関数の名前を入力します。
1. **[詳細設定]** を展開します。
1. **[VPC を有効にする]** を選択したら、VPC を選択します。
1. (オプション) [アウトバウンド IPv6 トラフィック](configuration-vpc.md#configuration-vpc-ipv6)を許可するには、**[デュアルスタックサブネットの IPv6 トラフィックを許可]** をクリックします。
1. **[サブネット]** では、すべてのプライベートサブネットを選択します。プライベートサブネットは、NAT ゲートウェイ経由でインターネットにアクセスできます。関数をパブリックサブネットに接続しても、インターネットにアクセスできません。
**注記**
**[デュアルスタックサブネットの IPv6 トラフィックを許可する]** を選択した場合は、選択したすべてのサブネットに IPv4 CIDR ブロックと IPv6 CIDR ブロックが必要です。
1. **[セキュリティグループ]** では、アウトバウンドトラフィックを許可するセキュリティグループを選択します。
1. [**関数の作成**] を選択してください。
Lambda は、「[AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html)」 AWS 管理ポリシーをで実行ロールを自動的に作成します。このポリシーのアクセス許可は、VPC 設定の Elastic Network Interface を作成するためにのみに必要であり、関数を呼び出すためではありません。最小特権のアクセス許可を適用するには、関数および VPC 設定を作成した後に、実行ロールから **[AWSLambdaVPCAccessExecutionRole]** ポリシーを削除できます。詳細については、「[必要な IAM 許可](configuration-vpc.md#configuration-vpc-permissions)」を参照してください。
**既存の関数に対して VPC を設定するには**
既存の関数に VPC 設定を追加するには、関数の実行ロールに [Elastic Network Interface を作成して管理する許可](configuration-vpc.md#configuration-vpc-permissions) が必要です。「[AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html)」 AWS 管理ポリシーには、必要な許可が含まれています。最小特権のアクセス許可を適用するには、VPC 設定を作成した後に、実行ロールから **[AWSLambdaVPCAccessExecutionRole]** ポリシーを削除できます。
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択します。
1. **[設定]** タブを選択したら、**[VPC]** を選択します。
1. [**VPC**] で、[**編集**] を選択します。
1. VPC を選択します。
1. (オプション) [アウトバウンド IPv6 トラフィック](configuration-vpc.md#configuration-vpc-ipv6)を許可するには、**[デュアルスタックサブネットの IPv6 トラフィックを許可]** をクリックします。
1. **[サブネット]** では、すべてのプライベートサブネットを選択します。プライベートサブネットは、NAT ゲートウェイ経由でインターネットにアクセスできます。関数をパブリックサブネットに接続しても、インターネットにアクセスできません。
**注記**
**[デュアルスタックサブネットの IPv6 トラフィックを許可する]** を選択した場合は、選択したすべてのサブネットに IPv4 CIDR ブロックと IPv6 CIDR ブロックが必要です。
1. **[セキュリティグループ]** では、アウトバウンドトラフィックを許可するセキュリティグループを選択します。
1. **[保存]** を選択します。
### 関数をテストする
次のサンプルコードを使用し、VPC に接続された関数がパブリックインターネットにアクセスできることを確認します。正常に処理された場合、コードは `200` ステータスコードを返します。失敗した場合、関数がタイムアウトします。
------
#### [ Node.js ]
1. Lambda コンソールの **[コードソース]** ペインで、次のコードを **[index.mjs]** ファイルに貼り付けます。この関数はパブリックエンドポイントに HTTP GET リクエストを行い、HTTP レスポンスコードを返し、関数がパブリックインターネットにアクセスできるかどうかをテストします。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/code-source-nodejs.png)
**Example — async/await を持つ HTTP リクエスト**
```
const url = "https://aws.amazon.com/";
export const handler = async(event) => {
try {
const res = await fetch(url);
console.info("status", res.status);
return res.status;
}
catch (e) {
console.error(e);
return 500;
}
};
```
1. **[DEPLOY]** セクションで、**[デプロイ]** を選択して関数のコードを更新します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. **[テスト]** タブを選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/test-tab.png)
1. **[テスト]** を選択します。
1. 関数は `200` ステータスコードを返します。つまり、この関数はアウトバウンドのインターネットアクセスができることを意味します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/test-successful-200.png)
関数がパブリックインターネットにアクセスできない場合、次のようなエラーメッセージが表示されます。
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
#### [ Python ]
1. Lambda コンソールの **[コードソースペイン]** ペインで、次のコードを **[lambda\$1function.py]** ファイルに貼り付けます。この関数はパブリックエンドポイントに HTTP GET リクエストを行い、HTTP レスポンスコードを返し、関数がパブリックインターネットにアクセスできるかどうかをテストします。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/code-source-python.png)
```
import urllib.request
def lambda_handler(event, context):
try:
response = urllib.request.urlopen('https://aws.amazon.com')
status_code = response.getcode()
print('Response Code:', status_code)
return status_code
except Exception as e:
print('Error:', e)
raise e
```
1. **[DEPLOY]** セクションで、**[デプロイ]** を選択して関数のコードを更新します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. **[テスト]** タブを選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/test-tab.png)
1. **[テスト]** を選択します。
1. 関数は `200` ステータスコードを返します。つまり、この関数はアウトバウンドのインターネットアクセスができることを意味します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/test-successful-200.png)
関数がパブリックインターネットにアクセスできない場合、次のようなエラーメッセージが表示されます。
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
## VPC を既に持っています
VPC は既にあるが、Lambda 関数用にパブリックインターネットアクセスを設定する必要がある場合は、次の手順に従ってください。この手順では、VPC に少なくとも 2 つのサブネットがあることを前提としています。サブネットが 2 つない場合、Amazon VPC ユーザーガイドの「[サブネットを作成する](https://docs.aws.amazon.com/vpc/latest/userguide/create-subnets.html)」を参照してください。
### ルートテーブルの設定を確認する
1. Amazon VPC コンソールの [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) を開いてください。
1. **[VPC ID]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/vpc-id.png)
1. **[リソースマップ]** セクションまでスクロールダウンします。ルートテーブルのマッピングをメモします。サブネットにマッピングされている各ルートテーブルを開きます。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/route-table-associations.png)
1. **[ルート]** タブまでスクロールダウンします。ルートをチェックして、VPC に次の両方のルートテーブルがあるかどうかを確認します。この各要件は、個別のルートテーブルで満たされる必要があります。
+ インターネット向けトラフィック (IPv4 用に `0.0.0.0/0`、IPv6 用に `::/0`) は、インターネットゲートウェイ (`igw-xxxxxxxxxx`) にルーティングされます。つまり、ルートテーブルに関連付けられているサブネットはパブリックサブネットです。
**注記**
サブネットに IPv6 CIDR ブロックがない場合、IPv4 ルート (`0.0.0.0/0`) のみが表示されます。
**Example パブリックサブネットのルートテーブル**
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/routes-public.png)
+ IPv4 (`0.0.0.0/0`) のインターネット向けトラフィックは、パブリックサブネットに関連付けられた NAT ゲートウェイ (`nat-xxxxxxxxxx`) にルーティングされます。つまり、サブネットは NAT ゲートウェイ経由でインターネットにアクセスできるプライベートサブネットです。
**注記**
サブネットに IPv6 CIDR ブロックがある場合、ルートテーブルはインターネット向け IPv6 トラフィック (`::/0`) も Egress-Only のインターネットゲートウェイ (`eigw-xxxxxxxxxx`) にルーティングする必要があります。サブネットに IPv6 CIDR ブロックがない場合、IPv4 ルート (`0.0.0.0/0`) のみが表示されます。
**Example プライベートサブネットのルートテーブル**
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/routes-private.png)
1. VPC のサブネットに関連付けられている各ルートテーブルを確認し、インターネットゲートウェイを含むルートテーブルおよび NAT ゲートウェイを含むルートテーブルがあることを確認できるまで、前の手順を繰り返します。
インターネットゲートウェイへのルートおよび NAT ゲートウェイへのルートで構成される 2 つのルートテーブルがない場合、次の手順に従って不足しているリソースおよびルートテーブルのエントリを作成します。
### ルートテーブルの作成
次の手順に従って、ルートテーブルを作成し、サブネットに関連付けます。
**Amazon VPC コンソールを使用してカスタムルートテーブルを作成する方法**
1. Amazon VPC コンソールの [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) を開いてください。
1. ナビゲーションペインで、**[Route tables]** (ルートテーブル) を選択します。
1. [**ルートテーブルの作成**] を選択します。
1. (オプション) **[Name]** (名前) には、ルートテーブルの名前を入力します。
1. **[VPC]** で、ユーザーの VPC を選択します。
1. (オプション) タグを追加するには、**[Add new tag]** (新しいタグを追加) を選択し、タグキーとタグ値を入力します。
1. [**ルートテーブルの作成**] を選択します。
1. [**Subnet Associations**] (サブネットの関連付け) タブで、 [**Edit subnet associations**] (サブネットの関連付けの編集) を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/route-table-subnet.png)
1. ルートテーブルに関連付けるサブネットのチェックボックスをオンにします。
1. [**Save associations**] (関連付けを保存する) を選択します。
### インターネットゲートウェイを作成する
次の手順を実行してインターネットゲートウェイを作成し、VPC にアタッチしてパブリックサブネットのルートテーブルに追加します。
**インターネットゲートウェイを作成するには**
1. Amazon VPC コンソールの [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) を開いてください。
1. ナビゲーションペインで、**[Internet gateways]** (インターネットゲートウェイ) を選択します。
1. [**インターネットゲートウェイの作成**] を選択します。
1. (オプション) インターネットゲートウェイの名前を入力します。
1. (オプション) タグを追加するには、**[Add new tag]** (新しいタグを追加) を選択し、そのタグのキーと値を入力します。
1. [**インターネットゲートウェイの作成**] を選択します。
1. 画面上部のバナーから **[VPC にアタッチ]** を選択し、利用可能な VPC を選択したら、**[インターネットゲートウェイをアタッチする]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/igw-attach-vpc.png)
1. **[VPC ID]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/igw-subnet-1.png)
1. **[VPC ID]** を再び選択し、VPC 詳細ページを開きます。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/igw-your-vpcs.png)
1. **[リソースマップ]** セクションまでスクロールダウンし、サブネットを選択します。サブネットの詳細は新しいタブに表示されます。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/vpc-subnets.png)
1. **[ルートテーブル]** のリンクを選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/subnet-route-table.png)
1. **[ルートテーブル ID]** を選択し、ルートテーブルの詳細ページを開きます。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/route-table-id.png)
1. **[ルート]** で、**[ルートを編集する]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/edit-routes.png)
1. **[ルートを追加する]** を選択し、**[宛先]** ボックスに `0.0.0.0/0` と入力します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/create-route-1.png)
1. **[ターゲット]**] には、**[インターネットゲートウェイ]** を選択し、先ほど作成したインターネットゲートウェイを選択します。サブネットに IPv6 CIDR ブロックがある場合、同じインターネットゲートウェイに `::/0` のルートも追加する必要があります。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/create-route-2.png)
1. **[Save changes]** (変更の保存) をクリックします。
### NAT ゲートウェイを作成する
次の手順に従って NAT ゲートウェイを作成し、パブリックサブネットに関連付けて、プライベートサブネットのルートテーブルに追加します。
**NAT ゲートウェイを作成してパブリックサブネットに関連付ける方法**
1. ナビゲーションペインで **[NAT ゲートウェイ]** を選択します。
1. **[NAT ゲートウェイを作成]** を選択します。
1. (オプション) NAT ゲートウェイの名前を入力します。
1. **[サブネット]** では、VPC のパブリックサブネットを選択します。(パブリックサブネットは、ルートテーブルにインターネットゲートウェイへの直接ルートを持つサブネットです。)
**注記**
NAT ゲートウェイはパブリックサブネットに関連付けられていますが、ルートテーブルのエントリはプライベートサブネットにあります。
1. **[Elastic IP 配分 ID]** には、Elastic IP アドレスを選択するか、**[Elastic IP を配分する]** を選択します。
1. **[NAT ゲートウェイを作成]** を選択します。
**プライベートサブネットのルートテーブルで NAT ゲートウェイにルートを追加する方法**
1. ナビゲーションペインで、[**サブネット**] を選択してください。
1. VPC 内のプライベートサブネットを選択します。(プライベートサブネットは、ルートテーブルにインターネットゲートウェイへのルートがないサブネットです。)
1. **[ルートテーブル]** のリンクを選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/subnet-route-table.png)
1. **[ルートテーブル ID]** を選択し、ルートテーブルの詳細ページを開きます。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/route-table-id.png)
1. スクロールダウンして**[ルート]** タブを選択し、**[ルートを編集する]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/route-table-edit-routes.png)
1. **[ルートを追加する]** を選択し、**[宛先]** ボックスに `0.0.0.0/0` と入力します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/create-route-1.png)
1. **[ターゲット]** には、**[NAT ゲートウェイ]** を選択し、先ほど作成した NAT ゲートウェイを選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/create-route-nat.png)
1. **[Save changes]** (変更の保存) をクリックします。
### Egress-Only のインターネットゲートウェイ (IPv6 のみ) を作成する
次の手順に従って Egress-Only のインターネットゲートウェイを作成し、プライベートサブネットのルートテーブルに追加します。
**Egress-Only インターネットゲートウェイを作成するには**
1. ナビゲーションペインで、**[Egress Only インターネットゲートウェイ]** を選択します。
1. **[Egress Only インターネットゲートウェイの作成]** を選択します。
1. (オプション) 名前を入力します。
1. Egress-Only インターネットゲートウェイを作成する VPC を選択します。
1. **[Egress Only インターネットゲートウェイの作成]** を選択します。
1. **[アタッチされた VPC ID]** のリンクを選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/eigw-details.png)
1. **[VPC ID]** のリンクを選択し、VPC の詳細ページを開きます。
1. **[リソースマップ]** セクションまでスクロールダウンし、プライベートサブネットを選択します。(プライベートサブネットは、ルートテーブルにインターネットゲートウェイへのルートがないサブネットです。) サブネットの詳細は新しいタブに表示されます。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/vpc-subnet-private.png)
1. **[ルートテーブル]** のリンクを選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/private-subnet-route-table.png)
1. **[ルートテーブル ID]** を選択し、ルートテーブルの詳細ページを開きます。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/route-table-id.png)
1. **[ルート]** で、**[ルートを編集する]** を選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/edit-routes.png)
1. **[ルートを追加する]** を選択し、**[宛先]** ボックスに `::/0` と入力します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/create-route-1.png)
1. **[ターゲット]** では、**[Egress Only インターネットゲートウェイ]** を選択し、先ほど作成したゲートウェイを選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/eigw-route.png)
1. **[Save changes]** (変更の保存) をクリックします。
### Lambda 関数を設定
**関数の作成時に VPC を設定するには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. [**関数の作成**] を選択してください。
1. [**基本的な情報**] の [**関数名**] に、関数の名前を入力します。
1. **[詳細設定]** を展開します。
1. **[VPC を有効にする]** を選択したら、VPC を選択します。
1. (オプション) [アウトバウンド IPv6 トラフィック](configuration-vpc.md#configuration-vpc-ipv6)を許可するには、**[デュアルスタックサブネットの IPv6 トラフィックを許可]** をクリックします。
1. **[サブネット]** では、すべてのプライベートサブネットを選択します。プライベートサブネットは、NAT ゲートウェイ経由でインターネットにアクセスできます。関数をパブリックサブネットに接続しても、インターネットにアクセスできません。
**注記**
**[デュアルスタックサブネットの IPv6 トラフィックを許可する]** を選択した場合は、選択したすべてのサブネットに IPv4 CIDR ブロックと IPv6 CIDR ブロックが必要です。
1. **[セキュリティグループ]** では、アウトバウンドトラフィックを許可するセキュリティグループを選択します。
1. [**関数の作成**] を選択してください。
Lambda は、「[AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html)」 AWS 管理ポリシーをで実行ロールを自動的に作成します。このポリシーのアクセス許可は、VPC 設定の Elastic Network Interface を作成するためにのみに必要であり、関数を呼び出すためではありません。最小特権のアクセス許可を適用するには、関数および VPC 設定を作成した後に、実行ロールから **[AWSLambdaVPCAccessExecutionRole]** ポリシーを削除できます。詳細については、「[必要な IAM 許可](configuration-vpc.md#configuration-vpc-permissions)」を参照してください。
**既存の関数に対して VPC を設定するには**
既存の関数に VPC 設定を追加するには、関数の実行ロールに [Elastic Network Interface を作成して管理する許可](configuration-vpc.md#configuration-vpc-permissions) が必要です。「[AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html)」 AWS 管理ポリシーには、必要な許可が含まれています。最小特権のアクセス許可を適用するには、VPC 設定を作成した後に、実行ロールから **[AWSLambdaVPCAccessExecutionRole]** ポリシーを削除できます。
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択します。
1. **[設定]** タブを選択したら、**[VPC]** を選択します。
1. [**VPC**] で、[**編集**] を選択します。
1. VPC を選択します。
1. (オプション) [アウトバウンド IPv6 トラフィック](configuration-vpc.md#configuration-vpc-ipv6)を許可するには、**[デュアルスタックサブネットの IPv6 トラフィックを許可]** をクリックします。
1. **[サブネット]** では、すべてのプライベートサブネットを選択します。プライベートサブネットは、NAT ゲートウェイ経由でインターネットにアクセスできます。関数をパブリックサブネットに接続しても、インターネットにアクセスできません。
**注記**
**[デュアルスタックサブネットの IPv6 トラフィックを許可する]** を選択した場合は、選択したすべてのサブネットに IPv4 CIDR ブロックと IPv6 CIDR ブロックが必要です。
1. **[セキュリティグループ]** では、アウトバウンドトラフィックを許可するセキュリティグループを選択します。
1. **[保存]** を選択します。
### 関数をテストする
次のサンプルコードを使用し、VPC に接続された関数がパブリックインターネットにアクセスできることを確認します。正常に処理された場合、コードは `200` ステータスコードを返します。失敗した場合、関数がタイムアウトします。
------
#### [ Node.js ]
1. Lambda コンソールの **[コードソース]** ペインで、次のコードを **[index.mjs]** ファイルに貼り付けます。この関数はパブリックエンドポイントに HTTP GET リクエストを行い、HTTP レスポンスコードを返し、関数がパブリックインターネットにアクセスできるかどうかをテストします。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/code-source-nodejs.png)
**Example — async/await を持つ HTTP リクエスト**
```
const url = "https://aws.amazon.com/";
export const handler = async(event) => {
try {
const res = await fetch(url);
console.info("status", res.status);
return res.status;
}
catch (e) {
console.error(e);
return 500;
}
};
```
1. **[DEPLOY]** セクションで、**[デプロイ]** を選択して関数のコードを更新します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. **[テスト]** タブを選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/test-tab.png)
1. **[テスト]** を選択します。
1. 関数は `200` ステータスコードを返します。つまり、この関数はアウトバウンドのインターネットアクセスができることを意味します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/test-successful-200.png)
関数がパブリックインターネットにアクセスできない場合、次のようなエラーメッセージが表示されます。
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
#### [ Python ]
1. Lambda コンソールの **[コードソースペイン]** ペインで、次のコードを **[lambda\$1function.py]** ファイルに貼り付けます。この関数はパブリックエンドポイントに HTTP GET リクエストを行い、HTTP レスポンスコードを返し、関数がパブリックインターネットにアクセスできるかどうかをテストします。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/code-source-python.png)
```
import urllib.request
def lambda_handler(event, context):
try:
response = urllib.request.urlopen('https://aws.amazon.com')
status_code = response.getcode()
print('Response Code:', status_code)
return status_code
except Exception as e:
print('Error:', e)
raise e
```
1. **[DEPLOY]** セクションで、**[デプロイ]** を選択して関数のコードを更新します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. **[テスト]** タブを選択します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/test-tab.png)
1. **[テスト]** を選択します。
1. 関数は `200` ステータスコードを返します。つまり、この関数はアウトバウンドのインターネットアクセスができることを意味します。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/test-successful-200.png)
関数がパブリックインターネットにアクセスできない場合、次のようなエラーメッセージが表示されます。
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
# Lambda 用のインバウンドインターフェイス VPC エンドポイントの接続
Amazon Virtual Private Cloud (Amazon VPC) を使用して AWS リソースをホストする場合、VPC と Lambda の間の接続を確立できます。この接続を使用して、パブリックインターネットを交差せずに Lambda 関数を呼び出すことができます。
VPC と Lambda とのプライベート接続を確立するには、[インターフェイス VPC エンドポイント](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html)を作成します。インターフェイスエンドポイントは、インターネットゲートウェイ、NAT デバイス、VPN 接続、AWS Direct Connect 接続のいずれも必要とせずに Lambda API にプライベートにアクセスできる [AWS PrivateLink](https://aws.amazon.com/privatelink) を利用しています。VPC のインスタンスは、パブリック IP アドレスがなくても Lambda API と通信できます。VPC と Lambda との間のトラフィックは、AWS ネットワークを離れません。
各インターフェイスエンドポイントは、サブネット内の 1 つ以上の [Elastic Network Interface](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) によって表されます。ネットワークインターフェイスは、Lambda へのトラフィックのエントリポイントとなるプライベート IP アドレスを提供します。
**Topics**
+ [
## Lambda インターフェイスエンドポイントに関する考慮事項
](#vpc-endpoint-considerations)
+ [
## Lambda のインターフェイスエンドポイントの作成
](#vpc-endpoint-create)
+ [
## Lambda のインターフェイスエンドポイントポリシーを作成する
](#vpc-endpoint-policy)
## Lambda インターフェイスエンドポイントに関する考慮事項
Lambda のインターフェイスエンドポイントを設定する前に、*Amazon VPC ユーザーガイド*の「[インターフェイスエンドポイントのプロパティと制限](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#vpce-interface-limitations)」を確認してください。
VPC から任意の Lambda API オペレーションを呼び出すことができます。例えば、VPC 内で `Invoke` API を呼び出すことで、Lambda 関数を呼び出すことができます。Lambda API の完全なリストについては、Lambda API リファレンスの「[アクション](https://docs.aws.amazon.com/lambda/latest/dg/API_Operations.html)」を参照してください。
`use1-az3` は、Lambda VPC 関数のキャパシティが制限されたリージョンです。このアベイラビリティーゾーンのサブネットを Lambda 関数で使用しないでください。これは、停止した場合にゾーンレベルの冗長性が低下する可能性があるためです。
### 永続的な接続のための Keep-alive
Lambda は長期間アイドル状態の接続を削除するため、永続的な接続を維持するには、Keep-alive ディレクティブを使用します。関数を呼び出すときにアイドル状態の接続を再利用しようとすると、接続エラーが発生します。永続的な接続を維持するには、ランタイムに関連付けられている keep-alive ディレクティブを使用します。例については、*AWS SDK for JavaScript 開発者ガイド*の「[Node.js で Keep-alive を使用して接続を再利用する](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html)」を参照してください。
### 請求に関する考慮事項
インターフェイスエンドポイントを介して Lambda 関数にアクセスするための追加料金はありません。Lambda の料金の詳細については、「[AWS Lambda の料金](https://aws.amazon.com/lambda/pricing/)」を参照してください。
Lambda のインターフェイスエンドポイントには、AWS PrivateLink の標準料金が適用されます。AWS アカウントは、各アベイラビリティーゾーンでインターフェイスエンドポイントがプロビジョニングされる時間ごと、およびインターフェイスエンドポイントを介して処理されたデータに対して請求されます。インターフェイスエンドポイント料金の詳細については、「[AWS PrivateLink の料金](https://aws.amazon.com/privatelink/pricing/)」を参照してください。
### VPC ピアリングに関する考慮事項
他の VPC は、インターフェイスエンドポイントを使用して [VPC ピアリング接続](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) によって VPC に接続できます。VPC ピアリングは、2 つの VPC 間のネットワーク接続です。自分が所有者である 2 つの VPC 間や、他の AWS アカウント内の VPC との間で、VPC ピアリング接続を確立できます。VPC は 2 つの異なる AWS リージョンの間でも使用できます。
ピア接続された VPC 間のトラフィックは AWS ネットワーク上に留まり、パブリックインターネットを経由しません。VPC がピア接続されると、Amazon Elastic Compute Cloud (Amazon EC2) インスタンス、Amazon Relational Database Service (Amazon RDS) インスタンス、または双方の VPC の VPC 対応 Lambda 関数などのリソースは、いずれかの VPC で作成されたインターフェイスエンドポイントを介して Lambda API にアクセスできます。
## Lambda のインターフェイスエンドポイントの作成
Amazon VPC コンソールまたは AWS Command Line Interface (AWS CLI) を使用して、Lambda のインターフェイスエンドポイントを作成できます。詳細については、*Amazon VPC ユーザーガイド*の[インターフェイスエンドポイントの作成](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#create-interface-endpoint)を参照してください。
**Lambda のインターフェイスエンドポイントを作成するには (コンソール)**
1. Amazon VPC コンソールの [[Endpoints (エンドポイント)] ページ](https://console.aws.amazon.com/vpc/home?#Endpoints)を開きます。
1. [**Create endpoint**] (エンドポイントの作成) を選択します。
1. **[サービスカテゴリ]** で、**[AWS のサービス]** が選択されていることを確認します。
1. [**サービス名**] で [**com.amazonaws.*region*.lambda** を選択します。[**タイプ**] が [**インターフェイス**] であることを確認します。
1. VPC とサブネットを選択します。
1. インターフェイスエンドポイントのプライベート DNS を有効にするには、[**Enable DNS Name**] (DNS 名を有効にする) でチェックボックスをオンにします。AWS のサービスの VPC エンドポイントに対してプライベート DNS ホスト名を有効にすることをお勧めします。これにより、AWS SDK を介して行われたリクエストなど、パブリックサービスエンドポイントを使用するリクエストが VPC エンドポイントに解決されるようになります。
1. [**セキュリティグループ**] で、1 つ以上のセキュリティグループを選択します。
1. **[エンドポイントの作成]** を選択します。
プライベート DNS オプションを使用するには、VPC の `enableDnsHostnames` および `enableDnsSupportattributes` を設定する必要があります。詳細については、*Amazon VPC ユーザーガイド*の「[VPC の DNS サポートを表示および更新する](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-updating)」を参照してください。エンドポイントのプライベート DNS を有効にすると、リージョンのデフォルト DNS 名 (`lambda.us-east-1.amazonaws.com` など) を使用して、Lambda への API リクエストを実行できます。サービスエンドポイントの詳細については、「AWS 全般のリファレンス」の「[サービスエンドポイントとクォータ](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html)」を参照してください。
詳細については、「Amazon VPC ユーザーガイド**」の「[インターフェイスエンドポイントを介したサービスへのアクセス](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#access-service-though-endpoint)」を参照してください。
CloudFormation を使用してエンドポイントを作成および設定する方法については、*AWS CloudFormation ユーザーガイド*の「[AWS::EC2::VPCEndpoint](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html)」リソースを参照してください。
**Lambda のインターフェイスエンドポイントを作成するには (AWS CLI)**
[create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html) コマンドを使用し、VPC ID、VPC エンドポイントタイプ (インターフェイス)、サービス名、エンドポイントを使用するサブネット、およびエンドポイントネットワークインターフェイスに関連付けるセキュリティグループを指定します。例:
```
aws ec2 create-vpc-endpoint
--vpc-id vpc-ec43eb89
--vpc-endpoint-type Interface
--service-name com.amazonaws.us-east-1.lambda
--subnet-id subnet-abababab
--security-group-id sg-1a2b3c4d
```
## Lambda のインターフェイスエンドポイントポリシーを作成する
インターフェイスエンドポイントを使用できるユーザーと、ユーザーがアクセスできる Lambda 関数を制御するために、エンドポイントにエンドポイントポリシーをアタッチできます。このポリシーでは、以下の情報を指定します。
+ アクションを実行できるプリンシパル。
+ プリンシパルが実行できるアクション。
+ プリンシパルがアクションを実行できるリソース。
詳細については、*Amazon VPC ユーザーガイド*の「[VPC エンドポイントによるサービスのアクセスコントロール](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html)」を参照してください。
**例: Lambda アクションのインターフェイスエンドポイントポリシー**
Lambda のエンドポイントポリシーの例を次に示します。エンドポイントにアタッチされると、このポリシーにより、ユーザー `MyUser` は 関数 `my-function` を呼び出すことができます。
**注記**
リソースには、修飾関数 ARN と非修飾関数 ARN の両方を含める必要があります。
```
{
"Statement":[
{
"Principal":
{
"AWS": "arn:aws:iam::111122223333:user/MyUser"
},
"Effect":"Allow",
"Action":[
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:us-east-2:123456789012:function:my-function",
"arn:aws:lambda:us-east-2:123456789012:function:my-function:*"
]
}
]
}
```
# Lambda 関数のファイルシステムアクセスの設定
Amazon Elastic File System (Amazon EFS) ファイルシステムをローカルディレクトリにマウントするように関数を設定できます。Amazon EFS を使用すると、関数コードは共有リソースに安全かつ高い同時実行数でアクセスして変更できます。
## サポート対象のリージョン
Amazon EFS for Lambda は、アジアパシフィック (ニュージーランド)、アジアパシフィック (台北)、アジアパシフィック (マレーシア)、メキシコ (中部)、アジアパシフィック (タイ)、およびカナダ西部 (カルガリー) を除くすべての[商用リージョン](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#region)で利用可能です。
**Topics**
+ [
## サポート対象のリージョン
](#configuration-filesystem-supported-regions)
+ [
## 実行ロールとユーザーアクセス許可
](#configuration-filesystem-permissions)
+ [
## ファイルシステムとアクセスポイントの設定
](#configuration-filesystem-setup)
+ [
## ファイルシステムへの接続 (コンソール)
](#configuration-filesystem-config)
## 実行ロールとユーザーアクセス許可
ファイルシステムにユーザー設定の AWS Identity and Access Management (IAM) ポリシーがない場合、EFS は、ファイルシステムマウントターゲットを使用してファイルシステムに接続できるすべてのクライアントへのフルアクセスを許可するデフォルトのポリシーを使用します。ファイルシステムにユーザー設定の IAM ポリシーがある場合、関数の実行ロールには正しい `elasticfilesystem` 許可が必要です。
**実行ロールのアクセス許可**
+ **elasticfilesystem:ClientMount**
+ **elasticfilesystem:ClientWrite (読み取り専用接続には不要)**
これらのアクセス許可は、**AmazonElasticFileSystemClientReadWriteAccess** 管理ポリシーに含まれています。さらに、実行ロールは、[ファイルシステムの VPC に接続するために必要な許可](configuration-vpc.md#configuration-vpc-permissions)を備えている必要があります。
ファイルシステムを設定する場合、Lambda はアクセス許可を使用してマウントターゲットを検証します。ファイルシステムに接続するように関数を設定するには、ユーザーに以下のアクセス許可が必要です。
**ユーザーアクセス許可**
+ **elasticfilesystem:DescribeMountTargets**
## ファイルシステムとアクセスポイントの設定
関数が接続するすべてのアベイラビリティーゾーンにマウントターゲットを持つファイルシステムを Amazon EFS に作成します。パフォーマンスと耐障害性のために、少なくとも 2 つのアベイラビリティーゾーンを使用します。たとえば、シンプルな設定では、別々のアベイラビリティーゾーンに 2 つのプライベートサブネットを持つ VPC を作成できます。この関数は両方のサブネットに接続し、それぞれのサブネットでマウントターゲットを使用できます。NFS トラフィック (ポート 2049) が、関数およびマウントターゲットで使用されるセキュリティグループによって許可されていることを確認します。
**注記**
ファイルシステムを作成するときは、後で変更できないパフォーマンスモードを選択します。**汎用** モードではレイテンシーが低く、**最大 I/O** モードではより高い最大スループットと IOPS がサポートされます。選択のヘルプについては、*Amazon Elastic File System ユーザーガイド*の「[Amazon EFS のパフォーマンス](https://docs.aws.amazon.com/efs/latest/ug/performance.html)」を参照してください。
アクセスポイントは、関数の各インスタンスを、接続先のアベイラビリティーゾーンの適切なマウントターゲットに接続します。最大のパフォーマンスを得るには、ルート以外のパスを持つアクセスポイントを作成し、各ディレクトリに作成するファイル数を制限します。次の例では、ファイルシステムに `my-function` という名前のディレクトリを作成し、標準ディレクトリ許可 (755) で所有者 ID を 1001 に設定します。
**Example アクセスポイントの設定**
+ **名前** － `files`
+ **ユーザー ID** － `1001`
+ **グループ ID** － `1001`
+ **パス** － `/my-function`
+ **アクセス許可** － `755`
+ **所有者ユーザー ID** － `1001`
+ **グループユーザー ID** － `1001`
関数がアクセスポイントを使用する場合、ユーザー ID 1001 とディレクトリへのフルアクセス許可が与えられます。
詳細については、*Amazon Elastic File System ユーザーガイド*の次のトピックを参照してください。
+ [Amazon EFS のリソースの作成](https://docs.aws.amazon.com/efs/latest/ug/creating-using.html)
+ [ユーザー、グループ、アクセス許可の操作](https://docs.aws.amazon.com/efs/latest/ug/accessing-fs-nfs-permissions.html)
## ファイルシステムへの接続 (コンソール)
関数は、VPC 内のローカルネットワークを介してファイルシステムに接続します。関数が接続するサブネットは、ファイルシステムのマウントポイントを含む同じサブネットでも、NFS トラフィック (ポート 2049) をファイルシステムにルーティングできる同じアベイラビリティーゾーン内のサブネットでもかまいません。
**注記**
関数が VPC にまだ接続されていない場合は、「」を参照してください[Lambda 関数に Amazon VPC 内のリソースへのアクセスを許可する](configuration-vpc.md)
**ファイルシステムアクセスを設定するには**
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択します。
1. [**設定**]、[** ファイルシステム **] の順にクリックします。
1. [**ファイルシステム**] で、[**ファイルシステムの追加**] を選択します。
1. 以下のプロパティを設定します。
+ **EFS ファイルシステム** － 同じ VPC 内のファイルシステムのアクセスポイント。
+ **ローカルマウントパス** － ファイルシステムが Lambda 関数にマウントされている場所 (`/mnt/` で始まります)。
**料金**
Amazon EFS では、ストレージとスループットに対して料金が発生します。レートはストレージクラスによって異なります。詳細については、「[Amazon EFS の料金](https://aws.amazon.com/efs/pricing)」を参照してください。
Lambda では、VPC 間のデータ転送に対して料金が発生します。これは、関数の VPC がファイルシステムを持つ別の VPC にピア接続されている場合にのみ該当します。レートは、同じリージョン内の VPC 間の Amazon EC2 データ転送と同じです。詳細については、「[Lambda の料金](https://aws.amazon.com/lambda/pricing)」を参照してください。
# Lambda 関数のエイリアスの作成
Lambda 関数のエイリアスを作成できます。Lambda のエイリアスとは、更新可能な関数のバージョンへのポインタです。関数のユーザーは、エイリアス Amazon リソースネーム (ARN) を使用して関数のバージョンにアクセスできます。新しいバージョンをデプロイする場合は、新しいバージョンを使用するようにエイリアスを更新するか、2 つのバージョン間でトラフィックを分割することができます。
------
#### [ Console ]
**コンソールを使用してエイリアスを作成するには**
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択します。
1. [**エイリアス**]、[** エイリアスの作成 **] の順にクリックします。
1. **[Create alias (エイリアスの作成)] ページ**で、以下の操作を行います。
1. [**Name (名前)**] で、エイリアスの名前を入力します。
1. (オプション) [**Description (説明)**] で、エイリアスの説明を入力します。
1. [**Version (バージョン)**] で、エイリアスが参照する関数のバージョンを選択します。
1. (オプション) エイリアスのルーティングを設定するには、[**Weighted alias (加重エイリアス)**] を展開します。詳細については、「[加重エイリアスを使用して Lambda カナリアデプロイの実装](configuring-alias-routing.md)」を参照してください。
1. [**Save**] を選択します。
------
#### [ AWS CLI ]
AWS Command Line Interface (AWS CLI) を使用してエイリアスを作成するには、[create-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html) コマンドを使用します。
```
aws lambda create-alias \
--function-name my-function \
--name alias-name \
--function-version version-number \
--description " "
```
関数の新しいバージョンをポイントするようにエイリアスを変更するには、[update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html) コマンドを使用します。
```
aws lambda update-alias \
--function-name my-function \
--name alias-name \
--function-version version-number
```
エイリアスを削除するには、[delete-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-alias.html) コマンドを使用します。
```
aws lambda delete-alias \
--function-name my-function \
--name alias-name
```
前のステップの AWS CLI コマンドは、以下の Lambda API オペレーションに対応しています。
+ [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html)
+ [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html)
+ [DeleteAlias](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteAlias.html)
------
# イベントソースとアクセス許可ポリシーでの Lambda エイリアスの使用
各エイリアスには一意の ARN があります。エイリアスは関数のバージョンのみを参照でき、別のエイリアスを参照することはできません。関数の新しいバージョンを指すよう、エイリアスを更新できます。
Amazon Simple Storage Service (Amazon S3) などのイベントソースが、Lambda 関数を呼び出します。これらのイベントソースは、イベント発生時に呼び出す関数を識別するマッピングを維持します。マッピング設定で Lambda 関数のエイリアスを指定する場合、関数のバージョンが変更されたときにマッピングを更新する必要はありません。詳細については、「[Lambda がストリームおよびキューベースのイベントソースからのレコードを処理する方法](invocation-eventsourcemapping.md)」を参照してください。
リソースポリシーでは、Lambda 関数を使用するためのイベントソースにアクセス許可を付与できます。ポリシーでエイリアス ARN を指定した場合、関数のバージョンが変更されたときにポリシーを更新する必要はありません。
## リソースポリシー
[リソースベースのポリシー](access-control-resource-based.md)を使用して、サービス、リソース、またはアカウントに、関数に対するアクセス許可を付与できます。このアクセス許可の範囲は、ポリシーの適用先がエイリアス、バージョン、または関数全体のいずれになるかによって決まります。たとえば、エイリアス名 (`helloworld:PROD` など) を使用する場合は、アクセス許可で、エイリアス ARN (`helloworld`) を使用した `helloworld:PROD` 関数の呼び出しを許可できます。
エイリアスまたは特定のバージョンを使用しないで関数を呼び出そうとすると、アクセス許可エラーが発生します。このアクセス許可エラーは、エイリアスに関連付けられた関数のバージョンを直接呼び出そうとしても発生します。
例えば、以下の AWS CLI コマンドは、Amazon S3 が `amzn-s3-demo-bucket` に代わって動作しているときに、`helloworld` 関数の PROD エイリアスを呼び出すアクセス許可を Amazon S3 に付与します。
```
aws lambda add-permission \
--function-name helloworld \
--qualifier PROD \
--statement-id 1 \
--principal s3.amazonaws.com \
--action lambda:InvokeFunction \
--source-arn arn:aws:s3:::amzn-s3-demo-bucket \
--source-account 123456789012
```
ポリシーでのリソース名の使用の詳細については、「[ポリシーのリソースセクションと条件セクションの微調整](lambda-api-permissions-ref.md)」を参照してください。
# 加重エイリアスを使用して Lambda カナリアデプロイの実装
加重エイリアスを使用し、同じ関数の 2 つの異なる[バージョン](configuration-versions.md)間でトラフィックを分割できます。この方法では、トラフィックの割合が小さい関数の新しいバージョンをテストし、必要に応じてすばやくロールバックできます。これは[カナリアデプロイ](https://docs.aws.amazon.com/whitepapers/latest/overview-deployment-options/canary-deployments.html)と呼ばれます。カナリアデプロイは、すべてのトラフィックを一度に切り替えるのではなく、新しいバージョンをリクエストの一部にのみ公開するため、ブルー/グリーンデプロイとは異なります。
エイリアスは最大 2 つの Lambda 関数バージョンを指すことができます。バージョンは次の基準を満たす必要があります。
+ 両方のバージョンに同じ[実行ロール](lambda-intro-execution-role.md)が必要です。
+ どちらのバージョンも、同じ[配信不能キュー](invocation-async-retain-records.md#invocation-dlq)設定を持つか、配信不能キュー設定がない必要があります。
+ 両方のバージョンを公開する必要があります。エイリアスが `$LATEST` を指すことはできません。
**注記**
Lambda は、単純な確率モデルを使用して 2 つの関数バージョン間でトラフィックを分散します。低いトラフィックレベルでは、各バージョンで設定されたトラフィックの割合と実際の割合の間に大きな差異が生じる場合があります。関数がプロビジョニングされた同時実行を使用する場合、エイリアスルーティングがアクティブである間に、プロビジョニングされた同時実行インスタンスの数を高く設定することで、[過剰呼び出し](monitoring-metrics-types.md#invocation-metrics)を防ぐことができます。
## 加重エイリアスの作成
------
#### [ Console ]
**コンソールを使用してエイリアスのルーティングを設定するには**
**注記**
関数に少なくとも 2 つの公開バージョンがあることを確認します。追加のバージョンを作成するには、「[関数バージョンの作成](configuration-versions.md#configuration-versions-config)」の手順に従います。
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択します。
1. [**エイリアス**]、[** エイリアスの作成 **] の順にクリックします。
1. **[Create alias (エイリアスの作成)] ページ**で、以下の操作を行います。
1. [**Name (名前)**] で、エイリアスの名前を入力します。
1. (オプション) [**Description (説明)**] で、エイリアスの説明を入力します。
1. [**Version (バージョン)**] で、エイリアスが参照する最初の関数のバージョンを選択します。
1. [**Weighted alias (加重エイリアス)**] を展開します。
1. [**Additional version (追加のバージョン)**] で、エイリアスが参照する 2 番目の関数のバージョンを選択します。
1. [**Weight (%) (重み (%))**] で、関数の重み値を入力します。*重み*とは、エイリアスが呼び出されたときにそのバージョンに割り当てられるトラフィックの割合 (%) です。最初のバージョンは残余重みを受け取ります。たとえば、[**Additional version**] に 10 パーセントを指定した場合、最初のバージョンには自動的に 90 パーセントが割り当てられます。
1. **[保存]** を選択します。
------
#### [ AWS CLI ]
[create-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html) および [update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html) AWS CLI コマンドを使用して、2 つの関数バージョン間のトラフィックの重みを設定します。エイリアスを作成または更新するときは、`routing-config` パラメータでトラフィックの重みを指定します。
以下の例では、関数のバージョン 1 を参照する **routing-alias** という名前の Lambda 関数のエイリアスを作成します。関数のバージョン 2 は、トラフィックの 3% を受信します。残りの 97% のトラフィックはバージョン 1 にルーティングされます。
```
aws lambda create-alias \
--name routing-alias \
--function-name my-function \
--function-version 1 \
--routing-config AdditionalVersionWeights={"2"=0.03}
```
バージョン 2 への着信トラフィックのパーセンテージを増やすには、`update-alias` コマンドを使用します。次の例では、トラフィックを 5% に増やします。
```
aws lambda update-alias \
--name routing-alias \
--function-name my-function \
--routing-config AdditionalVersionWeights={"2"=0.05}
```
すべてのトラフィックをバージョン 2 にルーティングするには、`update-alias` コマンドを使用して、エイリアスがバージョン 2 を参照するように `function-version` プロパティを変更します。このコマンドでは、ルーティング設定もリセットされます。
```
aws lambda update-alias \
--name routing-alias \
--function-name my-function \
--function-version 2 \
--routing-config AdditionalVersionWeights={}
```
前のステップの AWS CLI コマンドは、以下の Lambda API オペレーションに対応しています。
+ [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html)
+ [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html)
------
## 呼び出されたバージョンの特定
2 つの関数バージョン間でトラフィックの重みを設定している場合、どちらの Lambda 関数バージョンが呼び出されたかを特定するための 2 つの方法があります。
+ **CloudWatch ログ** – Lambda は、すべての関数呼び出しの呼び出されたバージョン ID を含む `START` ログエントリを自動的に発信します。例:
`START RequestId: 1dh194d3759ed-4v8b-a7b4-1e541f60235f Version: 2`
エイリアスの呼び出しでは、Lambda は`ExecutedVersion`ディメンションを使用して、呼び出されたバージョンでメトリクスデータをフィルタリングします。詳細については、「[Lambda 関数のメトリクスの表示](monitoring-metrics-view.md)」を参照してください。
+ **応答のペイロード (同期呼び出し)** – 同期関数呼び出しの応答には、呼び出された関数バージョンを示す `x-amz-executed-version` ヘッダーが含まれます。
## 加重エイリアスを使用してローリングデプロイを作成する
AWS CodeDeploy および AWS Serverless Application Model (AWS SAM) を使用してローリングデプロイを作成します。これにより、関数コードの変更を自動的に検出し、関数の新しいバージョンをデプロイし、新しいバージョンに流れるトラフィック量を徐々に増やします。トラフィックの量と増加率は、設定可能なパラメータです。
ローリングデプロイでは、AWS SAM は次のタスクを実行します。
+ Lambda 関数を設定してエイリアスを作成します。加重エイリアスのルーティング設定は、ローリングデプロイを実装する基本的な機能です。
+ CodeDeploy アプリケーションおよびデプロイグループを作成します。必要に応じて、デプロイグループはローリングデプロイおよびロールバックを管理します。
+ Lambda 関数の新しいバージョンを作成したときに検出します。
+ CodeDeploy をトリガーして新しいバージョンのデプロイを開始します。
### AWS SAM テンプレートの例
次の例では、単純なローリングデプロイの [AWS SAM テンプレート](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html)を示しています。
```
AWSTemplateFormatVersion : '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: A sample SAM template for deploying Lambda functions
Resources:
# Details about the myDateTimeFunction Lambda function
myDateTimeFunction:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Handler: myDateTimeFunction.handler
Runtime: nodejs24.x
# Creates an alias named "live" for the function, and automatically publishes when you update the function.
AutoPublishAlias: live
DeploymentPreference:
# Specifies the deployment configuration
Type: Linear10PercentEvery2Minutes
```
このテンプレートは、次のプロパティを持つ `myDateTimeFunction` という名前の Lambda 関数を定義します。
**AutoPublishAlias **
`AutoPublishAlias` プロパティは、`live` という名前のエイリアスを作成します。さらに、関数の新しいコードを保存するときに、AWS SAM フレームワークが自動的に検出します。その後、フレームワークは新しい関数バージョンを公開して、新しいバージョンを指すように `live` エイリアスを更新します。
**DeploymentPreference**
`DeploymentPreference` プロパティにより、CodeDeploy アプリケーションが Lambda 関数の元のバージョンから新しいバージョンにトラフィックを移行するレートが決まります。この値 `Linear10PercentEvery2Minutes` により、トラフィックの追加 10% が 2 分ごとに新しいバージョンにシフトされます。
事前設定されたデプロイ設定の一覧については、「[デプロイ設定](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations.html)」を参照してください。
CodeDeploy および AWS SAM でローリングデプロイを作成する方法の詳細については、次を参照してください。
+ [チュートリアル: CodeDeploy および AWS Serverless Application Modelで更新された Lambda 関数のデプロイ](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-lambda-sam.html)
+ [AWS SAM を使用したサーバーレスアプリケーションの段階的なデプロイ](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/automating-updates-to-serverless-apps.html)
# Lambda 関数のバージョンを管理する
バージョンを使用して、関数のデプロイを管理できます。たとえば、安定した実稼働バージョンのユーザーに影響を与えることなく、ベータテスト用の新しいバージョンの関数を公開できます。Lambda は、関数を公開するたびに新しいバージョンの関数を作成します。新しいバージョンは、関数の未公開バージョンのコピーです。未公開バージョンの名前は `$LATEST` です。
重要なのは、関数コードをデプロイするたびに、`$LATEST` で現在のコードを上書きすることです。`$LATEST` の現在のイテレーションを保存するには、新しい関数バージョンを作成します。`$LATEST` が以前に公開されたバージョンと同じ場合、変更を `$LATEST` にデプロイするまで新しいバージョンを作成することはできません。これらの変更には、コードの更新や関数設定の変更が含まれます。
関数のバージョンを公開すると、そのコード、ランタイム、アーキテクチャ、メモリ、レイヤー、その他のほとんどの設定はイミュータブルになります。つまり、`$LATEST` から新しいバージョンを公開しないと、これらの設定を変更することはできません。公開済みの関数のバージョンには、次の項目を設定できます。
+ [トリガー](lambda-services.md#lambda-invocation-trigger)
+ [送信先](invocation-async-retain-records.md#create-destination)
+ [プロビジョニングされた同時実行](provisioned-concurrency.md)
+ [非同期呼び出し](invocation-async.md)
+ [データベース接続とプロキシ](services-rds.md#rds-configuration)
**注記**
**[自動]** モードで[ランタイム管理コントロール](runtimes-update.md#runtime-management-controls)を使用している場合は、関数のバージョンで使用されるランタイムバージョンが自動的に更新されます。**[Function update]** (関数の更新) または **[Manual]** (手動) モードを使用している場合、ランタイムバージョンは更新されません。詳細については、「[Lambda がランタイムバージョンの更新を管理する方法を理解する](runtimes-update.md)」を参照してください。
**Topics**
+ [
## 関数バージョンの作成
](#configuration-versions-config)
+ [
## バージョンの使用
](#versioning-versions-using)
+ [
## アクセス許可の付与
](#versioning-permissions)
## 関数バージョンの作成
関数コードと設定は、未公開バージョンの関数でのみ変更できます。バージョンを公開すると、Lambda は、そのバージョンのユーザー向けに一貫したエクスペリエンスを保つためにコードとほとんどの設定をロックします。
Lambda コンソールを使用して、関数のバージョンを作成できます。
**新しい関数バージョンを作成するには**
1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。
1. 関数を選択し、**[バージョン]** タブをクリックします。
1. バージョンの設定ページで、[**新しいバージョンを発行**] をクリックします。
1. (オプション) バージョンの説明を入力します。
1. **[Publish]** (発行) を選択します。
代替手段として、[PublishVersion](https://docs.aws.amazon.com/lambda/latest/api/API_PublishVersion.html) API 操作を使用して関数のバージョンを発行できます。
以下の AWS CLI コマンドは、関数の新しいバージョンを発行します。レスポンスは、バージョン番号およびバージョンがサフィックスとしてついた関数 ARN を含む、新しいバージョンの設定情報を返します。
```
aws lambda publish-version --function-name my-function
```
以下の出力が表示されます。
```
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function:1",
"Version": "1",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "function.handler",
"Runtime": "nodejs24.x",
...
}
```
**注記**
Lambda は、バージョニングのために単調増加するシーケンス番号を割り当てます。関数を削除して再作成した後でも、Lambda がバージョン番号を再利用することは一切ありません。
## バージョンの使用
修飾 ARN または非修飾 ARN を使用して、Lambda 関数を参照できます。
+ **修飾 ARN** － バージョンのサフィックスが付いた関数 ARN です。以下の例では、`helloworld` 関数のバージョン 42 を参照しています。
```
arn:aws:lambda:aws-region:acct-id:function:helloworld:42
```
+ **非修飾 ARN** － バージョンのサフィックスが付いていない関数 ARN です。
```
arn:aws:lambda:aws-region:acct-id:function:helloworld
```
関連するすべての API オペレーションで、修飾 ARN または非修飾 ARN を使用できます。ただし、非修飾 ARN を使用してエイリアスを作成することはできません。
関数のバージョンを公開しないことにした場合、関数を呼び出すには、修飾 ARN または非修飾 ARN を[イベントソースマッピング](invocation-eventsourcemapping.md)で使用します。非修飾 ARN を使用して関数を呼び出すと、Lambda によって暗黙的に `$LATEST` が呼び出されます。
各 Lambda 関数のバージョンの修飾 ARN は一意です。バージョンを公開した後は、ARN または関数コードを変更することはできません。
コードが公開されたことがない場合、またはコードが最後に公開されたバージョンから変更された場合にのみ、Lambda によって新しい関数のバージョンが公開されます。変更がない場合、関数のバージョンは最後に公開されたバージョンのままです。
バージョンを公開すると、Lambda は関数のコードと設定の変更不可能なスナップショットを作成します。すべての設定変更が新しいバージョンの公開をトリガーするわけではありません。次の設定変更は、バージョン公開の対象となる関数を認定します。
+ 関数コード
+ 環境変数
+ ランタイム
+ Handler
+ レイヤー
+ メモリサイズ
+ タイムアウト
+ VPC の設定
+ デッドレターキュー (DLQ) の構成
+ IAM ロール
+ 説明
+ アーキテクチャ (x86\$164 または AMD64)
+ エフェメラルストレージサイズ
+ パッケージタイプ
+ ログ記録の設定
+ ファイルシステム設定
+ SnapStart
+ トレース設定
[予約された同時実行](configuration-concurrency.md)などの運用設定は、変更時に新しいバージョンの公開をトリガーしません。
## アクセス許可の付与
[リソースベースのポリシー](access-control-resource-based.md)または[アイデンティティベースのポリシー](access-control-identity-based.md)を使用して、関数へのアクセスを許可できます。このアクセス許可の範囲は、ポリシーの適用先が関数になるか、関数の 1 つのバージョンになるかによって決まります。ポリシーでの関数のリソース名の詳細については、「[ポリシーのリソースセクションと条件セクションの微調整](lambda-api-permissions-ref.md)」を参照してください。
関数のエイリアスを使用すると、イベントソースおよび AWS Identity and Access Management (IAM) ポリシーの管理を簡素化することができます。詳細については、「[Lambda 関数のエイリアスの作成](configuration-aliases.md)」を参照してください。
# Lambda 関数でのタグの使用
関数にタグを付けて、リソースを整理および管理できます。タグは、AWS のサービス間でサポートされているリソースに関連付けられた自由形式のキーと値のペアです。タグのユースケースの詳細については、「*タグ付け AWS リソースとタグエディタガイド*」の「[一般的なタグ付け戦略](https://docs.aws.amazon.com//tag-editor/latest/userguide/best-practices-and-strats.html#tag-strategies)」を参照してください。
タグは、バージョンやエイリアスではなく、関数レベルで適用されます。タグは、(バージョンの公開時に AWS Lambda がスナップショットを作成する) バージョン固有の設定には含まれません。Lambda API を使用して、タグを表示および更新できます。Lambda コンソールで特定の関数を管理しながら、タグを表示および更新することもできます。
**Topics**
+ [
## タグの操作に必要なアクセス許可
](#fxn-tags-required-permissions)
+ [
## Lambda コンソールでのタグの使用
](#using-tags-with-the-console)
+ [
## AWS CLIでのタグの使用
](#configuration-tags-cli)
## タグの操作に必要なアクセス許可
AWS Identity and Access Management (IAM) ID (ユーザー、グループ、ロール) がリソースのタグを読み取るまたは設定できるようにするには、以下の対応するアクセス許可を付与します。
+ **lambda:ListTags** – リソースがタグ付けされている場合は、そのリソースで `ListTags` を呼び出す必要があるすべてのユーザーに対し、このアクセス許可を付与します。タグ付き関数の場合、このアクセス許可は `GetFunction` にも必要です。
+ **lambda:TagResource** – 作成時に `TagResource` を呼び出すかタグを実行する必要があるすべてのユーザーにこのアクセス許可を付与します。
必要に応じて、**Lambda:UntagResource** アクセス許可も付与して、リソースへの `UntagResource` 呼び出しを許可することを検討してください。
詳細については、「[Lambda のアイデンティティベースの IAM ポリシー](access-control-identity-based.md)」を参照してください。
## Lambda コンソールでのタグの使用
Lambda コンソールを使用すると、タグ付けをしながら関数を作成したり、既存の関数にタグを追加したり、追加したタグで関数をフィルタリングしたりできます。
**関数の作成時にタグを追加するには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. [**関数の作成**] を選択してください。
1. **[Author from scratch]** (一から作成) または **[Container image]** (コンテナイメージ) をクリックします。
1. **[基本情報]** で、関数を設定します。関数の設定の詳細については、「[AWS Lambda 関数の設定](lambda-functions.md)」を参照してください。
1. **[Advanced settings]** (詳細設定) を展開した上で、**[Enable tags]** (タグの有効化) を選択します。
1. これを行うには、**[Add new tag]** (タグの追加) を選択してから、**キー**とオプションの**値**を入力します。さらにタグを追加するには、この手順を繰り返します。
1. **[関数を作成]** を選択します。
**既存の関数にタグを追加するには**
1. Lambda コンソールの[関数ページ](https://console.aws.amazon.com/lambda/home#/functions)を開きます。
1. 関数の名前を選択します。
1. **[Configuration]** (設定)、**[Tags]** (タグ) の順に選択します。
1. **[タグ]** の項目で、**[タグの管理]** を選択します。
1. これを行うには、**[Add new tag]** (タグの追加) を選択してから、**キー**とオプションの**値**を入力します。さらにタグを追加するには、この手順を繰り返します。
1. **[保存]** を選択します。
**タグを使用して関数をフィルタするには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 検索ボックスを選択すると、関数のプロパティとタグキーのリストが表示されます。
1. タグキーを選択すると、現在の AWS リージョンで使用中の値のリストが表示されます。
1. **[使用: "tag-name"]** を選択して、このキーでタグ付けされたすべての関数を表示するか、**[演算子]** を選択して、値でさらにフィルタリングします。
1. タグキーと値の組み合わせでフィルタリングするタグ値を選択します。
検索バーは、タグキーの検索もサポートしています。タグキーのリストのみを表示するには `tag` と入力します。また、キーの名前を入力すると、それをリスト内で検索することもできます。
## AWS CLIでのタグの使用
Lambda API を使用して、関数を含む既存の Lambda リソースにタグを追加および削除できます。関数の作成時にタグを追加することもできます。これにより、ライフサイクル全体を通じてリソースにタグを付けることができます。
### Lambda タグ API を使用したタグの更新
サポートされている Lambda リソースのタグを追加または削除するには、[TagResource](https://docs.aws.amazon.com/lambda/latest/api/API_TagResource.html) および [UntagResource](https://docs.aws.amazon.com/lambda/latest/api/API_UntagResource.html) API オペレーションを使用します。
これらの操作は AWS CLI を使用して呼び出すことができます。既存のリソースにタグを追加するには、`tag-resource` コマンドを使用します。この例では、2 つのタグを追加します。1 つはキー *Department* を持つタグで、もう 1 つはキー *CostCenter* を持つタグです。
```
aws lambda tag-resource \
--resource arn:aws:lambda:us-east-2:123456789012:resource-type:my-resource \
--tags Department=Marketing,CostCenter=1234ABCD
```
タグを削除するには、`untag-resource` コマンドを使用します。この例では、キー *Department* を持つタグを削除します。
```
aws lambda untag-resource --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier \
--tag-keys Department
```
### 関数の作成時にタグを追加する
タグを使用して新しい Lambda 関数を作成するには、[CreateFunction](https://docs.aws.amazon.com//lambda/latest/api/API_CreateFunction.html) API オペレーションを使用します。`Tags` パラメータを指定します。このオペレーションは、`create-function` CLI コマンドと --tags オプションを使用して呼び出すことができます。`CreateFunction` でタグパラメータを使用する前に、このオペレーションに必要な通常のアクセス許可と、共にリソースにタグを付けるアクセス許可をロールが有していることを確認してください。タグ付けのアクセス許可の詳細については、「[タグの操作に必要なアクセス許可](#fxn-tags-required-permissions)」を参照してください。この例では、2 つのタグを追加します。1 つはキー *Department* を持つタグで、もう 1 つはキー *CostCenter* を持つタグです。
```
aws lambda create-function --function-name my-function
--handler index.js --runtime nodejs24.x \
--role arn:aws:iam::123456789012:role/lambda-role \
--tags Department=Marketing,CostCenter=1234ABCD
```
### 関数のタグの表示
特定の Lambda リソースに適用されるタグを表示するには、`ListTags` API オペレーションを使用します。詳細については、「[ListTags](https://docs.aws.amazon.com/lambda/latest/api/API_ListTags.html)」を参照してください。
このオペレーションは、ARN (Amazon リソースネーム) を指定することで `list-tags` AWS CLI コマンドで呼び出すことができます。
```
aws lambda list-tags --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier
```
[GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html) API オペレーションを使用して、特定のリソースに適用されるタグを表示できます。同等の機能は、他のリソースタイプでは使用できません。
このオペレーションは、`get-function` CLI コマンドを使用して呼び出すことができます。
```
aws lambda get-function --function-name my-function
```
### タグによるリソースのフィルタリング
AWS Resource Groups Tagging API [GetResources](https://docs.aws.amazon.com/resourcegroupstagging/latest/APIReference/API_GetResources.html) API オペレーションを使用すると、リソースをタグでフィルタリングできます。この `GetResources` オペレーションは、それぞれにタグキーと最大 10 個のタグ値が含まれているフィルタを、最大 10 個まで受け取ります。特定のリソースタイプでフィルタリングするには、`GetResources` で `ResourceType` を指定します。
このオペレーションは、`get-resources` AWS CLI コマンドを使用して呼び出すことができます。`get-resources` の使用例については、「*AWS CLI コマンドリファレンス*」の「[get-resources](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/resourcegroupstaggingapi/get-resources.html#examples)」を参照してください。
# Lambda 関数のレスポンスストリーミング
[Lambda 関数 URL](urls-configuration.md) 経由か、[InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html) API (AWS SDK または直接的な API コール経由) を使用することで、Lambda 関数はレスポンスペイロードをクライアントにストリーミングし、ネイティブに返すことができます。Lambda 関数は、[InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html) API を使用して関数を呼び出す [Amazon API Gateway プロキシ統合](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html)を介してレスポンスペイロードをストリーミングすることもできます。レスポンスストリーミングは、最初のバイトまでの時間 (TTFB) のパフォーマンスを向上させることで、レイテンシーの影響を受けやすいアプリケーションに役立ちます。これは、レスポンスの一部が利用可能になったときにクライアントに返送できるためです。さらに、レスポンスストリーミング関数は、バッファされたレスポンスに対する最大 6 MB と比較して、最大 200 MB のペイロードを返すことができます。レスポンスをストリーミングするということは、関数がレスポンス全体をメモリに収める必要がないことも意味します。レスポンスサイズが非常に大きい場合は、関数に設定する必要のあるメモリ量を減らすことができます。
**注記**
Lambda レスポンスストリーミングは、すべての AWS リージョン ではまだ利用できません。リージョン別の利用可能な機能については、ビルダーセンターの「[リージョン別の AWS 機能](https://builder.aws.com/build/capabilities)」を参照してください。
Lambda が応答をストリーミングする速度は、レスポンスのサイズに応じて異なります。関数のレスポンスでは、最初の 6 MB に対するストリーミングレートに上限が課されません。レスポンスが 6 MB を超える場合、残りのレスポンスには帯域幅上限が適用されます。ストリーミング帯域幅の詳細については、[レスポンスストリーミングの帯域幅制限](#config-rs-bandwidth-cap) を参照してください。
ストリーミングレスポンスにはコストが発生し、呼び出しているクライアントの接続が切断された際、ストリーミングレスポンスは中断または停止されることはありません。お客様は関数の全機能を利用した期間に対して課金されるため、関数のタイムアウトを長く設定する場合はご注意ください。
Lambda は Node.js マネージドランタイムでのレスポンスストリーミングをサポートしています。Python を含むその他の言語の場合、[カスタムランタイム API 統合を備えたカスタムランタイムを使用](runtimes-custom.md#runtimes-custom-response-streaming)してレスポンスをストリーミングするか、[Lambda Web Adapter](https://github.com/awslabs/aws-lambda-web-adapter) を使用できます。
**注記**
Lambda コンソールで関数をテストするとき、レスポンスは常にバッファリングされた状態で表示されます。
**Topics**
+ [
## レスポンスストリーミングの帯域幅制限
](#config-rs-bandwidth-cap)
+ [
## VPC とレスポンスストリーミングの互換性
](#config-rs-vpc-compatibility)
+ [
# レスポンスストリーミング対応 Lambda 関数の記述
](config-rs-write-functions.md)
+ [
# Lambda 関数 URL を使用してレスポンスストリーミング対応関数を呼び出す
](config-rs-invoke-furls.md)
+ [
# チュートリアル: 関数 URL を使用してレスポンスストリーミング Lambda 関数を作成する
](response-streaming-tutorial.md)
## レスポンスストリーミングの帯域幅制限
関数のレスポンスペイロードにおける最初の 6 MB には帯域幅上限がありません。この最初のバースト後、Lambda はレスポンスを最大 2 MBps のレートでストリーミングします。関数のレスポンスが 6 MB を超えないならば、この帯域幅制限が適用されることもありません。
**注記**
帯域幅制限は関数のレスポンスペイロードにのみ適用され、関数によるネットワークアクセスには適用されません。
上限のない帯域幅は、関数の処理速度を含む多くの要素によって異なります。通常、関数のレスポンスにおける最初の 6 MB には 2 MBps より高いレートを期待できます。関数が AWS 外部の宛先にレスポンスをストリーミングする場合、ストリーミングレートは外部インターネット接続の速度にも依存します。
## VPC とレスポンスストリーミングの互換性
VPC 環境で Lambda 関数を使用する場合は、レスポンスストリーミングに関する重要な考慮事項があります。
+ Lambda 関数 URL は、VPC 環境内でのレスポンスストリーミングをサポートしていません。
+ `InvokeWithResponseStream` API を使用して AWS SDK を介して Lambda 関数を呼び出すことで、VPC 内のレスポンスストリーミングを使用できます。これを使用するには、Lambda 用の適切な VPC エンドポイントを設定する必要があります。
+ VPC 環境の場合、VPC 内のリソースと Lambda サービス間の通信を可能にするには、Lambda 用のインターフェイス VPC エンドポイントを作成する必要があります。
VPC でのレスポンスストリーミングの一般的なアーキテクチャには、次のようなものがあります。
```
Client in VPC -> Interface VPC endpoint for Lambda -> Lambda function -> Response streaming back through the same path
```
# レスポンスストリーミング対応 Lambda 関数の記述
レスポンスストリーミング関数のハンドラー記述は、一般的なハンドラーパターンとは異なります。ストリーミング関数の作成時は、必ず次の事項を確認してください。
+ 関数を `awslambda.streamifyResponse()` デコレーターでラップします。`awslambda` グローバルオブジェクトは、Lambda の Node.js ランタイム環境で提供されます。
+ 確実にすべてのデータ処理を完了させるため、ストリームを正常に終了させます。
## ストリームレスポンスにハンドラー関数を設定する
Lambda が関数のレスポンスをストリーミングする必要があることをランタイムに示すには、関数を `streamifyResponse()` デコレーターでラップする必要があります。これにより、レスポンスをストリーミングするために適切なロジックパスを使用するようランタイムに指示し、関数がレスポンスをストリーミングできるようにします。
`streamifyResponse()` デコレーターは、次のパラメータを受けつける関数を受けつけます。
+ `event` — HTTP メソッド、クエリパラメータ、リクエスト本文など、関数 URL の呼び出しイベントに関する情報を提供します。
+ `responseStream` — 書き込み可能なストリームを提供します。
+ `context` – 呼び出し、関数、実行環境に関する情報を含むメソッドおよびプロパティを提供します。
`responseStream` オブジェクトは「[Node.js `writableStream`](https://nodesource.com/blog/understanding-streams-in-nodejs/)」です。他のこのようなストリームと同様に、`pipeline()` メソッドを使用する必要があります。
**注記**
`awslambda` グローバルオブジェクトは Lambda の Node.js ランタイムにより自動的に提供され、インポートは不要です。
**Example レスポンスストリーミング対応ハンドラー**
```
import { pipeline } from 'node:stream/promises';
import { Readable } from 'node:stream';
export const echo = awslambda.streamifyResponse(async (event, responseStream, _context) => {
// As an example, convert event to a readable stream.
const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
await pipeline(requestStream, responseStream);
});
```
`responseStream` にはストリームに書き込む `write()` メソッドが用意されていますが、「[https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback](https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback)」を可能な限り使用することをお勧めします。`pipeline()` を使用すると、書き込み可能なストリームが読み取り速度の速いストリームによって抑制されることがなくなります。
## ストリームを終了する
ハンドラーが戻る前にストリームが適切に終了することを確認してください。`pipeline()` メソッドはこれを自動的に処理します。
他のユースケースでは、`responseStream.end()` メソッドを呼び出してストリームを適切に終了させます。このメソッドは、ストリームにこれ以上データを書き込む必要がないことを通知します。`pipeline()` または `pipe()` でストリームに書き込む場合、このメソッドは不要です。
Node.js 24 以降、ハンドラーが返すか、レスポンスストリームが終了した後、Lambda は未解決の約束が完了するまで待機しなくなりました。関数が追加の非同期オペレーション (タイマーやフェッチなど) に依存している場合、ハンドラーで `await` を行う必要があります。
**Example pipeline() でストリームを終了する例**
```
import { pipeline } from 'node:stream/promises';
export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
await pipeline(requestStream, responseStream);
});
```
**Example pipeline() なしでストリームを終了する例**
```
export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
responseStream.write("Hello ");
responseStream.write("world ");
responseStream.write("from ");
responseStream.write("Lambda!");
responseStream.end();
});
```
# Lambda 関数 URL を使用してレスポンスストリーミング対応関数を呼び出す
**注記**
Lambda 関数は、[Amazon API Gateway プロキシ統合](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html)を通じてレスポンスペイロードのストリーミングができるようになりました。
関数 URL の呼び出しモードを変更することで、レスポンスストリーミング対応関数を呼び出すことができます。呼び出しモードは、Lambda が関数を呼び出すために使用する API オペレーションを決定します。利用可能な呼び出しモードは以下のとおりです。
+ `BUFFERED` – これはデフォルトのオプションです。Lambda は `Invoke` API オペレーションを使用して関数を呼び出します。ペイロードが完了すると、呼び出し結果が表示されます。最大ペイロードサイズは 6 MB です。
+ `RESPONSE_STREAM` — ペイロード結果が利用可能になったら、関数がそれをストリーミングできるようにします。Lambda は `InvokeWithResponseStream` API オペレーションを使用して関数を呼び出します。レスポンスペイロードの最大サイズは 200 MB です。
`Invoke` API オペレーションを直接呼び出すことにより、レスポンスストリーミングなしで関数を呼び出すことができます。ただし、呼び出しモードを `BUFFERED` に変更しない限り、Lambda は関数 URL を経由するすべての呼び出しレスポンスペイロードをストリーミングします。
------
#### [ Console ]
**関数 URL の呼び出しモードを設定するには (コンソール)**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 呼び出しモードを設定する関数の名前を選択します。
1. **[設定]** タブを開き、次に **[関数 URL]** をクリックします。
1. **[編集]** を選択し、次に **[追加設定]** を選択します。
1. **[呼び出しモード]** で目的の呼び出しモードを選択します。
1. **[保存]** をクリックします。
------
#### [ AWS CLI ]
**関数の URL の呼び出しモードを設定するには (AWS CLI)**
```
aws lambda update-function-url-config \
--function-name my-function \
--invoke-mode RESPONSE_STREAM
```
------
#### [ CloudFormation ]
**関数の URL の呼び出しモードを設定するには (CloudFormation)**
```
MyFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: AWS_IAM
InvokeMode: RESPONSE_STREAM
```
------
関数 URL の設定の詳細については、「[Lambda 関数 URL](urls-configuration.md)」を参照してください。
# チュートリアル: 関数 URL を使用してレスポンスストリーミング Lambda 関数を作成する
このチュートリアルでは、レスポンスストリームを返す関数 URL エンドポイントを持つ .zip ファイルアーカイブとして定義された Lambda 関数を作成します。関数 URL の設定の詳細については、「[関数 URL](urls-configuration.md)」を参照してください。
## 前提条件
このチュートリアルでは、基本的な Lambda オペレーションと Lambda コンソールについてある程度の知識があることを前提としています。初めての方は、[コンソールで Lambda の関数の作成](getting-started.md#getting-started-create-function) の手順に従って最初の Lambda 関数を作成してください。
以下の手順を完了するには、[AWS CLI バージョン 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) が必要です。コマンドと予想される出力は、別々のブロックにリストされます。
```
aws --version
```
次のような出力が表示されます。
```
aws-cli/2.13.27 Python/3.11.6 Linux/4.14.328-248.540.amzn2.x86_64 exe/x86_64.amzn.2
```
コマンドが長い場合、コマンドを複数行に分割するためにエスケープ文字 (`\`) が使用されます。
Linux および macOS では、任意のシェルとパッケージマネージャーを使用します。
**注記**
Windows では、Lambda でよく使用される一部の Bash CLI コマンド (`zip` など) が、オペレーティングシステムの組み込みターミナルでサポートされていません。Ubuntu および Bash の Windows 統合バージョンを取得するには、[Windows Subsystem for Linux をインストール](https://docs.microsoft.com/en-us/windows/wsl/install-win10)します。このガイドの CLI コマンドの例では、Linux フォーマットを使用しています。Windows CLI を使用している場合、インライン JSON ドキュメントを含むコマンドを再フォーマットする必要があります。
## 実行ロールを作成する
AWS リソースにアクセスするためのアクセス権限を Lambda 関数に付与する[実行ロール](lambda-intro-execution-role.md)を作成します。
**実行ロールを作成するには**
1. AWS Identity and Access Management (IAM) コンソールの [ロールページ](https://console.aws.amazon.com/iam/home#/roles)を開きます。
1. [**ロールの作成**] を選択してください。
1. 次のプロパティでロールを作成します。
+ **[信頼できるエンティティタイプ]** – **[AWS のサービス]**
+ **[ユースケース]** – **[Lambda]**
+ **アクセス許可** - **AWSLambdaBasicExecutionRole**。
+ **[ロール名]** – **response-streaming-role**
**AWSLambdaBasicExecutionRole** ポリシーには、ログを Amazon CloudWatch Logs に書き込むために関数が必要とするアクセス許可が含まれています。ロールを作成した後、Amazon リソースネーム (ARN) を書き留めてください。これは次のステップで必要になります。
## レスポンスストリーミング関数を作成する (AWS CLI)
AWS Command Line Interface (AWS CLI) を使用して、関数 URL エンドポイントでレスポンスストリーミング Lambda 関数を作成します。
**レスポンスをストリーミングできる関数を作成するには**
1. 以下のコード例を `index.js` という名前のファイルにコピーします。この関数は、1 秒で区切られた 3 つのレスポンスをストリーミングします。
```
exports.handler = awslambda.streamifyResponse(
async (event, responseStream, _context) => {
// Metadata is a JSON serializable JS object. Its shape is not defined here.
const metadata = {
statusCode: 200,
headers: {
"Content-Type": "application/json",
"CustomHeader": "outerspace"
}
};
// Assign to the responseStream parameter to prevent accidental reuse of the non-wrapped stream.
responseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
responseStream.write("Streaming with Helper \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 0 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 1 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 2 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.end();
await responseStream.finished();
}
);
```
1. デプロイパッケージを作成します。
```
zip function.zip index.js
```
1. `create-function` コマンドを使用して Lambda 関数を作成します。`--role` の値を、前のステップで書き留めたロールの ARN に置き換えます。このコマンドは、関数のタイムアウトを 10 秒に設定し、関数が 3 つのレスポンスをストリーミングできるようにします。
```
aws lambda create-function \
--function-name my-streaming-function \
--runtime nodejs24.x \
--zip-file fileb://function.zip \
--handler index.handler \
--timeout 10 \
--role arn:aws:iam::123456789012:role/response-streaming-role
```
**関数 URL を作成するには**
1. `lambda:InvokeFunctionUrl` および `lambda:InvokeFunction` のアクセス許可を付与するリソースベースのポリシーを関数に追加します。各ステートメントは、個別のコマンドで追加する必要があります。`--principal` の値を AWS アカウント ID に置き換えます。
```
aws lambda add-permission \
--function-name my-streaming-function \
--action lambda:InvokeFunctionUrl \
--statement-id UrlPolicyInvokeURL \
--principal 123456789012 \
--function-url-auth-type AWS_IAM
```
```
aws lambda add-permission \
--function-name my-streaming-function \
--action lambda:InvokeFunction \
--statement-id UrlPolicyInvokeFunction \
--principal 123456789012
```
1. `create-function-url-config` コマンドを使用して、関数の URL エンドポイントを作成します。
```
aws lambda create-function-url-config \
--function-name my-streaming-function \
--auth-type AWS_IAM \
--invoke-mode RESPONSE_STREAM
```
**注記**
`--invoke-mode` に関するエラーが発生した場合は、[AWS CLI の新しいバージョン](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)にアップグレードする必要がある場合があります。
## 関数 URL エンドポイントをテストする
関数を呼び出して統合をテストします。関数 URL をブラウザで開くことも、curl を使用することもできます。
```
curl --request GET "https://abcdefghijklm7nop7qrs740abcd.lambda-url.us-east-1.on.aws/" --user "AKIAIOSFODNN7EXAMPLE" --aws-sigv4 "aws:amz:us-east-1:lambda" --no-buffer
```
関数 URL では、認証タイプ `IAM_AUTH` を使用します。つまり、[AWS アクセスキーとシークレットキー](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)の両方でリクエストに署名する必要があります。前のコマンドで、`AKIAIOSFODNN7EXAMPLE` を AWS アクセスキー ID に置き換えます。プロンプトが表示されたら、AWS シークレットキーを入力します。AWS シークレットキーがない場合は、代わりに[一時的な AWS 認証情報](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)を使用できます。
次のような結果が表示されます。
```
Streaming with Helper
Hello 0
Hello 1
Hello 2
```
## リソースのクリーンアップ
このチュートリアル用に作成したリソースは、保持しない場合は削除できます。使用しなくなった AWS リソースを削除することで、AWS アカウント アカウントに請求される料金の発生を防ぎます。
**実行ロールを削除する**
1. IAM コンソールの [[ロール]](https://console.aws.amazon.com/iam/home#/roles) ページを開きます。
1. 作成した実行ロールを選択します。
1. **[削除]** を選択します。
1. テキスト入力フィールドにロールの名前を入力し、**[削除]** を選択します。
**Lambda 関数を削除するには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 作成した関数を選択します。
1. **[アクション]** で、**[削除]** を選択します。
1. テキスト入力フィールドに **confirm** と入力し、**[Delete]** (削除) を選択します。
# Lambda メタデータエンドポイントの使用
Lambda メタデータエンドポイントを使用すると、関数は実行中のアベイラビリティーゾーン (AZ) を検出できるため、Amazon ElastiCache や Amazon RDS エンドポイントなどの同じ AZ リソースにルーティングしてレイテンシーを最適化し、AZ 対応のレジリエンスパターンを実装できます。
エンドポイントは、実行環境内の localhost HTTP API を介してシンプルな JSON 形式でメタデータを返し、ランタイムと拡張機能の両方からアクセス可能です。
**Topics**
+ [
## 開始方法
](#metadata-endpoint-getting-started)
+ [
## アベイラビリティーゾーン ID
](#metadata-endpoint-az-ids)
+ [
## API リファレンス
](#metadata-endpoint-api-reference)
## 開始方法
[Powertools for AWS Lambda](https://docs.aws.amazon.com/powertools/) は、Python、TypeScript、Java、および .NET で Lambda メタデータエンドポイントにアクセスするためのユーティリティを提供します。ユーティリティは、最初の呼び出し後にレスポンスをキャッシュし、SnapStart キャッシュの無効化を自動的に処理します。
Powertools for AWS Lambda メタデータユーティリティを使用するか、メタデータエンドポイントを直接呼び出す
------
#### [ Python ]
Powertools パッケージをインストールする:
```
pip install "aws-lambda-powertools"
```
ハンドラーでメタデータユーティリティを使用する:
**Example Powertools を使用した AZ ID の取得 (Python)**
```
from aws_lambda_powertools.utilities.lambda_metadata import get_lambda_metadata
def handler(event, context):
metadata = get_lambda_metadata()
az_id = metadata.availability_zone_id # e.g., "use1-az1"
return {"az_id": az_id}
```
------
#### [ TypeScript ]
Powertools パッケージをインストールする:
```
npm install @aws-lambda-powertools/commons
```
ハンドラーでメタデータユーティリティを使用する:
**Example Powertools を使用した AZ ID の取得 (TypeScript)**
```
import { getMetadata } from '@aws-lambda-powertools/commons/utils/metadata';
const metadata = await getMetadata();
export const handler = async () => {
const { AvailabilityZoneID: azId } = metadata;
return azId;
};
```
------
#### [ Java ]
Powertools の依存関係を `pom.xml` に追加する:
```
software.amazon.lambda
powertools-lambda-metadata
2.10.0
```
ハンドラーでメタデータクライアントを使用する:
**Example Powertools を使用した AZ ID の取得 (Java)**
```
import software.amazon.lambda.powertools.metadata.LambdaMetadata;
import software.amazon.lambda.powertools.metadata.LambdaMetadataClient;
public class App implements RequestHandler {
@Override
public String handleRequest(Object input, Context context) {
LambdaMetadata metadata = LambdaMetadataClient.get();
String azId = metadata.getAvailabilityZoneId(); // e.g., "use1-az1"
return "{\"azId\": \"" + azId + "\"}";
}
}
```
------
#### [ .NET ]
Powertools パッケージをインストールする:
```
dotnet add package AWS.Lambda.Powertools.Metadata
```
ハンドラーでメタデータクラスを使用する:
**Example Powertools (.NET) を使用した AZ ID の取得**
```
using AWS.Lambda.Powertools.Metadata;
public class Function
{
public string Handler(object input, ILambdaContext context)
{
var azId = LambdaMetadata.AvailabilityZoneId;
return $"Running in AZ: {azId}";
}
}
```
------
#### [ All Runtimes ]
すべての Lambda ランタイムは、カスタムランタイムやコンテナイメージを含むメタデータエンドポイントをサポートします。Lambda が実行環境で自動的に設定する環境変数を使用して、関数から直接メタデータ API にアクセスするには、次の例を使用してください。
**Example メタデータエンドポイントへの直接アクセス**
```
# Variables are automatically set by Lambda
METADATA_ENDPOINT="http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment"
# Make the request
RESPONSE=$(curl -s -H "Authorization: Bearer ${AWS_LAMBDA_METADATA_TOKEN}" "$METADATA_ENDPOINT")
# Parse the AZ ID
AZ_ID=$(echo "$RESPONSE" | jq -r '.AvailabilityZoneID')
echo "Function is running in AZ ID: $AZ_ID"
```
------
## アベイラビリティーゾーン ID
AZ ID (`use1-az1` など) は常にすべての AWS アカウントで同じ物理的な場所を参照しますが、AZ 名 (`us-east-1a` など) は特定のリージョンの各 AWS アカウントの異なる物理インフラストラクチャにマッピングされる場合があります。詳細については、「[クロスアカウントの一貫性を確保するための AZ ID](https://docs.aws.amazon.com/global-infrastructure/latest/regions/az-ids.html)」を参照してください。
**AZ ID を AZ 名に変換する:**
AZ ID を AZ 名に変換するには、Amazon EC2 [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html) API を使用します。この API を使用するには、関数の実行ロールに `ec2:DescribeAvailabilityZones` アクセス許可を追加します。
## API リファレンス
### 環境変数
Lambda はすべての実行環境で次の環境変数を自動的に設定する:
+ `AWS_LAMBDA_METADATA_API` – `{ipv4_address}:{port}` 形式のメタデータサーバーアドレス (例: `169.254.100.1:9001`)。
+ `AWS_LAMBDA_METADATA_TOKEN` – 現在の実行環境の一意の認証トークン。Lambda は、初期化時にこのトークンを自動的に生成します。すべてのメタデータ API リクエストに含めます。
### Endpoint
`GET http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment`
### リクエスト
**必要なヘッダー:**
+ `Authorization` – ベアラースキームの `AWS_LAMBDA_METADATA_TOKEN` 環境変数のトークン値: `Bearer `。このトークンベースの認証は、サーバー側のリクエスト偽造 (SSRF) の脆弱性に対する多層防御を提供します。各実行環境は、初期化時にランダムに生成された一意のトークンを受け取ります。
### 応答
**Status:** `200 OK`
**Content-Type:** `application/json`
**Cache-Control:** `private, max-age=43200, immutable`
レスポンスは実行環境内で変更できません。クライアントはレスポンスをキャッシュし、`Cache-Control` TTL を尊重する必要があります。SnapStart 関数の場合、TTL は初期化中に減少するため、実行環境が別の AZ にある可能性がある場合に、クライアントは復元後にメタデータを更新します。Powertools を使用する場合、キャッシュと SnapStart の無効化は自動的に処理されます。
**本文:**
```
{
"AvailabilityZoneID": "use1-az1"
}
```
`AvailabilityZoneID` フィールドには、実行環境が実行されているアベイラビリティーゾーンの一意の識別子が含まれます。
**注記**
今後の更新でレスポンスに追加のフィールドが追加される場合があります。クライアントは不明なフィールドを無視し、新しいフィールドが表示されても失敗しないようにする必要があります。
### エラーレスポンス
+ **401 Unauthorized** – `Authorization` ヘッダーがないか、無効なトークンが含まれています。`Bearer ${AWS_LAMBDA_METADATA_TOKEN}` を渡すことを確認します。
+ **405 メソッドは許可されていません** – リクエストメソッドは `GET` ではありません。
+ **500 内部サーバーエラー** – サーバー側の処理エラー。