# Node.js による Lambda 関数の構築
<a name="lambda-nodejs"></a>

AWS Lambda の Node.js を使用して JavaScript コードを実行できます。Lambda は Node.js の[ランタイム](lambda-runtimes.md)を指定して、イベントを処理するコードを実行します。コードは、管理している AWS Identity and Access Management (IAM) ロールの認証情報を使用して、AWS SDK for JavaScript を含む環境で実行されます。Node.js ランタイムに含まれている SDK バージョンの詳細については、「[ランタイムに含まれる SDK バージョン](#nodejs-sdk-included)」を参照してください。

Lambda は、以下の Node.js ランタイムをサポートしています。<a name="nodejs-supported-runtimes"></a>


| 名前 | 識別子 | オペレーティングシステム | 廃止日 | 関数の作成をブロックする | 関数の更新をブロックする | 
| --- | --- | --- | --- | --- | --- | 
|  Node.js 24  |  `nodejs24.x`  |  Amazon Linux 2023  |   2028 年 4 月 30 日   |   2028 年 6 月 1 日   |   2028 年 7 月 1 日   | 
|  Node.js 22  |  `nodejs22.x`  |  Amazon Linux 2023  |   2027 年 4 月 30 日   |   2027 年 6 月 1 日   |   2027 年 7 月 1 日   | 
|  Node.js 20  |  `nodejs20.x`  |  Amazon Linux 2023  |   2026 年 4 月 30 日   |   2026 年 8 月 31 日   |   Sep 30, 2026   | 

**Node.js 関数を作成するには**

1. [Lambda コンソール](https://console.aws.amazon.com/lambda)を開きます。

1. [**Create function**] (関数の作成) をクリックします。

1. 以下の設定を行います。
   + **[関数名]**: 関数名を入力します。
   + **[ランタイム]**: **[Node.js 24.x]** を選択します。

1. [**関数の作成**] を選択してください。

コンソールで、`index.mjs` という名前の単一のソースファイルを含む Lambda 関数が作成されます。このファイルを編集し、組み込みのコードエディタでファイルをさらに追加することができます。**[DEPLOY]** セクションで **[デプロイ]** を選択して関数のコードを更新します。次に、コードを実行するには、**[TEST EVENTS]** セクションで **[テストイベントを作成]** を選択します。

`index.mjs` ファイルは、イベントオブジェクトおよびコンテキストオブジェクトを取得する `handler` という名前の関数をエクスポートします。これは、関数が呼び出されるときに Lambda が呼び出す[ハンドラー関数](nodejs-handler.md)です。Node.js 関数のランタイムは、Lambda から呼び出しイベントを取得し、ハンドラに渡します。関数設定で、ハンドラ値は `index.handler` です。

関数コードを保存すると、Lambda コンソールは .zip ファイルアーカイブのデプロイパッケージを作成します。コンソール外で (SDE を使用して) 関数コードを開発するときは、[デプロイパッケージを作成](nodejs-package.md)して、Lambda 関数にコードをアップロードします。

関数のランタイムによって、呼び出しイベントに加えて、コンテキストオブジェクトがハンドラに渡されます。[コンテキストオブジェクト](nodejs-context.md)には、呼び出し、関数、および実行環境に関する追加情報が含まれます。詳細情報は、環境変数から入手できます。

Lambda 関数には CloudWatch Logs ロググループが付属しています。関数のランタイムは、各呼び出しに関する詳細を CloudWatch Logs に送信します。これは呼び出し時に、任意の[関数が出力するログ](nodejs-logging.md)を中継します。関数がエラーを返す場合、Lambda はエラー形式を整え、それを呼び出し元に返します。

**Topics**
+ [

## ランタイムに含まれる SDK バージョン
](#nodejs-sdk-included)
+ [

## TCP 接続にキープアライブを使用
](#nodejs-keep-alive)
+ [

## CA 証明書のロード
](#nodejs-certificate-loading)
+ [

## 実験的 Node.js 機能
](#nodejs-experimental-features)
+ [

# Node.js の Lambda 関数ハンドラーの定義
](nodejs-handler.md)
+ [

# .zip ファイルアーカイブで Node.js Lambda 関数をデプロイする
](nodejs-package.md)
+ [

# Node.js Lambda 関数をコンテナイメージとともにデプロイする
](nodejs-image.md)
+ [

# Node.js Lambda 関数のレイヤーを操作する
](nodejs-layers.md)
+ [

# Lambda コンテキストオブジェクトを使用して Node.js 関数の情報を取得する
](nodejs-context.md)
+ [

# Node.js Lambda 関数のログ記録とモニタリング
](nodejs-logging.md)
+ [

# AWS Lambda での Node.js コードの作成
](nodejs-tracing.md)

## ランタイムに含まれる SDK バージョン
<a name="nodejs-sdk-included"></a>

すべての[サポートされている Lambda Node.js ランタイム](#nodejs-supported-runtimes)には、AWS SDK for JavaScript v3 の[最新バージョン](https://github.com/aws/aws-sdk-js-v3/releases)ではなく、特定のマイナーバージョンが含まれています。ランタイムに含まれる特定のマイナーバージョンは、AWS リージョン のランタイムバージョンによって異なります。使用しているランタイムに含まれている SDK の特定のバージョンを確認するには、次のコードを使用して Lambda 関数を作成します。

**Example index.mjs**  

```
import packageJson from '@aws-sdk/client-s3/package.json' with { type: 'json' };

export const handler = async () => ({ version: packageJson.version });
```
これにより、次の形式で応答が返されます。  

```
{
  "version": "3.632.0"
}
```

詳細については、「[ハンドラーでの SDK for JavaScript v3 の使用](nodejs-handler.md#nodejs-example-sdk-usage)」を参照してください。

## TCP 接続にキープアライブを使用
<a name="nodejs-keep-alive"></a>

デフォルトの Node.js HTTP/HTTPS エージェントは新しいリクエストがあるたびに新しい TCP 接続を作成します。新しい接続を確立するコストが発生しないように、キープアライブは[サポートされた Node.js ランタイム](#nodejs-supported-runtimes)のすべてで、デフォルトで有効になっています。キープアライブは、SDK を使用して複数の API コールを行う Lambda 関数のリクエスト時間を短縮することができます。

キープアライブを無効にするには、「*AWS SDK for JavaScript 3.x デベロッパーガイド*」の「[Node.js のキープアライブによる接続の再利用](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html)」を参照してください。キープアライブの使用の詳細については、AWS 開発者ツールブログの「[HTTP キープアライブはモジュラー AWS SDK for JavaScript でデフォルトでオンになっています](https://aws.amazon.com/blogs/developer/http-keep-alive-is-on-by-default-in-modular-aws-sdk-for-javascript/)」を参照してください。

## CA 証明書のロード
<a name="nodejs-certificate-loading"></a>

Node.js 18 までのバージョンの Node.js ランタイムでは、他の AWS のサービスと相互作用する関数を簡単に作成できるように、Lambda が Amazon 固有の CA (認証局) 証明書を自動的にロードします。例えば、Lambda には、Amazon RDS データベースにインストールされている[サーバー ID 証明書](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html)を検証するために必要な Amazon RDS 証明書が含まれています。この動作は、コールドスタート時のパフォーマンスに影響を与える可能性があります。

Node.js 20 以降では、Lambda がデフォルトで追加の CA 証明書をロードすることはありません。Node.js 20 ランタイムには、`/var/runtime/ca-cert.pem` にあるすべての Amazon CA 証明書を含む証明書ファイルが含まれています。Node.js 18 以前のランタイムと同じ動作を復元するには、`NODE_EXTRA_CA_CERTS` [環境変数](configuration-envvars.md)を `/var/runtime/ca-cert.pem` に設定します。

最適なパフォーマンスを得るには、必要な証明書のみをデプロイパッケージにバンドルし、`NODE_EXTRA_CA_CERTS` 環境変数を使用してロードすることをお勧めします。証明書ファイルには、1 つ以上の信頼できるルート CA 証明書または中間 CA 証明書が PEM 形式で含まれている必要があります。例えば RDS の場合は、必要な証明書をコードと共に `certificates/rds.pem` として含めてください。次に、`NODE_EXTRA_CA_CERTS` を `/var/task/certificates/rds.pem` に設定して証明書をロードします。

## 実験的 Node.js 機能
<a name="nodejs-experimental-features"></a>

アップストリームの Node.js 言語リリースでは、デフォルトで実験的な機能が有効になります。Lambda は、ランタイムの安定性と一貫したパフォーマンスを確保するために、これらの機能を無効にします。次の表は、Lambda が無効にする実験的な機能を示します。


| 実験機能 | サポートされている Node.js バージョン | Lambda によって適用される Node.js フラグ | 再有効化する Lambda フラグ | 
| --- | --- | --- | --- | 
|  ES モジュールでの require を使用したモジュールのインポートのサポート  |  Node.js 20、Node.js 22  |  `--no-experimental-require-module`  |  `--experimental-require-module`  | 
|  ES モジュールと CommonJS モジュールの自動検出のサポート  |  Node.js 22  |  `--no-experimental-detect-module`  |  `--experimental-detect-module`  | 

無効な実験機能を有効にするには、`NODE_OPTIONS` 環境変数で再有効化フラグを設定します。例えば、ES モジュールの require サポートを有効にするには、`NODE_OPTIONS` を `--experimental-require-module` に設定します。Lambda はこのオーバーライドを検出し、対応する disable フラグを削除します。

**重要**  
 実験的な機能を使用すると、不安定さやパフォーマンスの問題が発生する可能性があります。これらの機能は、今後の Node.js バージョンで変更または削除される可能性があります。実験的な機能を使用する関数は、Lambda サービスレベルアグリーメント (SLA) または AWS サポート の対象外です。

# Node.js の Lambda 関数ハンドラーの定義
<a name="nodejs-handler"></a>

Lambda 関数*ハンドラー*は、イベントを処理する関数コード内のメソッドです。関数が呼び出されると、Lambda はハンドラーメソッドを実行します。関数は、ハンドラーが応答を返すか、終了するか、タイムアウトするまで実行されます。

このページでは、プロジェクトのセットアップオプション、命名規則、ベストプラクティスなど、Node.js で Lambda 関数ハンドラーを使用する方法について説明します。このページには、注文に関する情報を取得し、テキストファイル受信を生成し、このファイルを Amazon Simple Storage Service (Amazon S3) バケットに配置する Node.js Lambda 関数の例も含まれています。関数を書き込んだ後にデプロイする方法については、「[.zip ファイルアーカイブで Node.js Lambda 関数をデプロイする](nodejs-package.md)」または「[Node.js Lambda 関数をコンテナイメージとともにデプロイする](nodejs-image.md)」を参照してください。

**Topics**
+ [

## Node.js ハンドラープロジェクトのセットアップ
](#nodejs-handler-setup)
+ [

## Node.js Lambda 関数のコードの例
](#nodejs-example-code)
+ [

## CommonJS および ES モジュール
](#nodejs-commonjs-es-modules)
+ [

## Node.js の初期化
](#nodejs-initialization)
+ [

## ハンドラーの命名規則
](#nodejs-handler-naming)
+ [

## 入力イベントオブジェクトの定義とアクセス
](#nodejs-example-input)
+ [

## Node.js 関数の有効なハンドラーパターン
](#nodejs-handler-signatures)
+ [

## ハンドラーでの SDK for JavaScript v3 の使用
](#nodejs-example-sdk-usage)
+ [

## 環境変数にアクセスする
](#nodejs-example-envvars)
+ [

## グローバルな状態を使用する
](#nodejs-handler-state)
+ [

## Node.js Lambda 関数のコードのベストプラクティス
](#nodejs-best-practices)

## Node.js ハンドラープロジェクトのセットアップ
<a name="nodejs-handler-setup"></a>

Node.js Lambda プロジェクトを初期化するには、複数の方法があります。例えば、`npm` を使用して標準の Node.js プロジェクト、[AWS SAM アプリケーション](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/using-sam-cli-init.html#using-sam-cli-init-new)、[AWS CDK アプリケーション](lambda-cdk-tutorial.md#lambda-cdk-step-1)などを作成できます。

`npm` を使用してプロジェクトを作成するには:

```
npm init
```

このコマンドはプロジェクトを初期化し、プロジェクトのメタデータと依存関係を管理する `package.json` ファイルを生成します。

関数コードは `.js` または `.mjs` JavaScript ファイルにあります。次の例では、ES モジュールハンドラーを使用するため、このファイルに `index.mjs` という名前を付けます。Lambda は、ES モジュールと CommonJS ハンドラーの両方をサポートしています。詳細については、「[CommonJS および ES モジュール](#nodejs-commonjs-es-modules)」を参照してください。

一般的な Node.js Lambda 関数プロジェクトは、次の一般的な構造に従います。

```
/project-root
  ├── index.mjs — Contains main handler
  ├── package.json — Project metadata and dependencies
  ├── package-lock.json — Dependency lock file
  └── node_modules/ — Installed dependencies
```

## Node.js Lambda 関数のコードの例
<a name="nodejs-example-code"></a>

以下の Lambda 関数コードの例では、注文に関する情報を取得し、テキストファイル受信を生成し、このファイルを Amazon S3 バケットに配置します。

**Example index.mjs Lambda 関数**  

```
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';

// Initialize the S3 client outside the handler for reuse
const s3Client = new S3Client();

/**
 * Lambda handler for processing orders and storing receipts in S3.
 * @param {Object} event - Input event containing order details
 * @param {string} event.order_id - The unique identifier for the order
 * @param {number} event.amount - The order amount
 * @param {string} event.item - The item purchased
 * @returns {Promise<string>} Success message
 */
export const handler = async(event) => {
    try {
        // Access environment variables
        const bucketName = process.env.RECEIPT_BUCKET;
        if (!bucketName) {
            throw new Error('RECEIPT_BUCKET environment variable is not set');
        }

        // Create the receipt content and key destination
        const receiptContent = `OrderID: ${event.order_id}\nAmount: $${event.amount.toFixed(2)}\nItem: ${event.item}`;
        const key = `receipts/${event.order_id}.txt`;

        // Upload the receipt to S3
        await uploadReceiptToS3(bucketName, key, receiptContent);

        console.log(`Successfully processed order ${event.order_id} and stored receipt in S3 bucket ${bucketName}`);
        return 'Success';
    } catch (error) {
        console.error(`Failed to process order: ${error.message}`);
        throw error;
    }
};

/**
 * Helper function to upload receipt to S3
 * @param {string} bucketName - The S3 bucket name
 * @param {string} key - The S3 object key
 * @param {string} receiptContent - The content to upload
 * @returns {Promise<void>}
 */
async function uploadReceiptToS3(bucketName, key, receiptContent) {
    try {
        const command = new PutObjectCommand({
            Bucket: bucketName,
            Key: key,
            Body: receiptContent
        });

        await s3Client.send(command);
    } catch (error) {
        throw new Error(`Failed to upload receipt to S3: ${error.message}`);
    }
}
```

この `index.mjs` ファイルには以下のコードのセクションが含まれます:
+ `import` ブロック: このブロックを使用して、[AWS SDK クライアント](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/the-request-object.html)などの Lambda 関数に必要なライブラリを含めます。
+ `const s3Client` 宣言: ハンドラー関数の外部で [Amazon S3 クライアント](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/)を初期化します。これにより、Lambda は[初期化フェーズ](lambda-runtime-environment.md#runtimes-lifecycle-ib)中にこのコードを実行します。またクライアントは、[複数の呼び出しで再利用](lambda-runtime-environment.md#execution-environment-reuse)できるように保持されます。
+ JSDoc コメントブロック: [JSDoc アノテーション](https://jsdoc.app/about-getting-started)を使用してハンドラーの入力タイプと出力タイプを定義します。
+ `export const handler`: Lambda が呼び出すメインハンドラー関数です。関数をデプロイするときは、[ハンドラー](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-Handler)プロパティに `index.handler` を指定します。`Handler` プロパティの値は、エクスポートされたハンドラーメソッドのファイル名と名前で、ドットで区切られます。
+ `uploadReceiptToS3` 関数: これは、メインハンドラー関数によって参照されるヘルパー関数です。

この関数が正しく機能するには、[実行ロール](lambda-intro-execution-role.md)で `s3:PutObject` アクションを許可する必要があります。また、必ず `RECEIPT_BUCKET` 環境変数を定義してください。呼び出しに成功したら、Amazon S3 バケットに受信ファイルが含まれているはずです。

## CommonJS および ES モジュール
<a name="nodejs-commonjs-es-modules"></a>

Node.js は CommonJS モジュールと ECMAScript モジュール (ES モジュール) の 2 つのモジュールシステムに対応しています。Lambda では、top-level await をサポートしている ES モジュールを使用することをお勧めします。これにより、[実行環境の初期化](#nodejs-initialization)中に非同期タスクを完了できます。

Node.js は `.cjs` ファイル名拡張子を持つファイルを CommonJS モジュールとして扱い、`.mjs` 拡張子は ES モジュールを示します。デフォルトでは、Node.js は `.js` ファイル名拡張子を持つファイルを CommonJS モジュールとして扱います。関数の `package.json` ファイルで `type` を `module` として指定することで、`.js` ファイルを ES モジュールとして扱うように Node.js を設定できます。`NODE_OPTIONS` 環境変数に `—experimental-detect-module` フラグを追加することで、`.js` ファイルを CommonJS として扱うか ES モジュールとして扱うかを自動的に検出するように、Lambda で Node.js を設定できます。詳細については、「[Experimental Node.js features](lambda-nodejs.md#nodejs-experimental-features)」を参照してください。

次の例は、ES モジュールと CommonJS モジュールの両方を使用して記述された関数ハンドラーを示しています。このページの残りの例では、すべて ES モジュールを使用しています。

------
#### [ ES module example ]

**Example – ES モジュールハンドラー**  

```
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;
    }
};
```

------
#### [ CommonJS module example ]

**Example – CommonJS モジュールハンドラー**  

```
const https = require("https");
let url = "https://aws.amazon.com/";

exports.handler = async function (event) {
  let statusCode;
  await new Promise(function (resolve, reject) {
    https.get(url, (res) => {
        statusCode = res.statusCode;
        resolve(statusCode);
      }).on("error", (e) => {
        reject(Error(e));
      });
  });
  console.log(statusCode);
  return statusCode;
};
```

------

## Node.js の初期化
<a name="nodejs-initialization"></a>

Node.js は、イベントループを使用して効率的な非同期操作をサポートするノンブロッキング I/O モデルを使用します。例えば、Node.js がネットワーク呼び出しを行った場合、関数はネットワークレスポンスをブロックすることなく他のオペレーションを処理し続けます。ネットワークレスポンスを受信すると、コールバックキューに配置されます。キューからのタスクは、現在のタスクが完了すると処理されます。

Lambda では、実行環境の初期化中に開始された非同期タスクが初期化中に完了するように、top-level await を使用することをお勧めします。初期化中に完了しない非同期タスクは通常、最初の関数の呼び出し中に実行されます。これにより、予期しない動作またはエラーが引き起こされる可能性があります。例えば、関数の初期化は、AWS Parameter Store からパラメータを取得するためにネットワーク呼び出しを行う場合があります。初期化中にこのタスクが完了しない場合、呼び出し中に値は null になる可能性があります。初期化と呼び出しの間にも遅延が生じる可能性があり、時間的な制約がある操作でエラーが発生する可能性があります。特に、AWS のサービス呼び出しは時間的制約のあるリクエスト署名に依存する可能性があるため、初期化フェーズ中に呼び出しが完了しない場合、サービス呼び出しは失敗します。初期化中にタスクを完了すると、通常、コールドスタートのパフォーマンスが向上し、プロビジョニングされた同時実行の使用時に最初にパフォーマンスが呼び出されます。詳細情報については、ブログ投稿「[Using Node.js ES modules and top-level await in AWS Lambda](https://aws.amazon.com/blogs/compute/using-node-js-es-modules-and-top-level-await-in-aws-lambda)」を参照してください。

## ハンドラーの命名規則
<a name="nodejs-handler-naming"></a>

関数を設定すると、[ハンドラー](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-Handler)設定の値はファイル名とエクスポートしたハンドラーメソッドの名前をドットで区切ったものになります。コンソールで作成された関数のデフォルトと、このガイドの例では、`index.handler` です。これは、`index.js` または `index.mjs` ファイルからエクスポートされた `handler` メソッドを示します。

異なるファイル名または関数ハンドラー名を使用してコンソールで関数を作成する場合は、デフォルトのハンドラー名を編集する必要があります。

**関数ハンドラー名を変更するには (コンソール)**

1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開き、関数を選択します。

1. **[コード]** タブを選択します。

1. **[ランタイム設定]** ペインまでスクロールして、**[編集]** を選択します。

1. **[ハンドラー]** には、関数ハンドラーの新しい名前を入力します。

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

## 入力イベントオブジェクトの定義とアクセス
<a name="nodejs-example-input"></a>

JSON は Lambda 関数の最も一般的な標準入力形式です。この例では、関数は以下のような入力を想定しています:

```
{
    "order_id": "12345",
    "amount": 199.99,
    "item": "Wireless Headphones"
}
```

Node.js で Lambda 関数を使用する場合、JSDoc アノテーションを使用して予想される入力イベントの形状を定義できます。この例では、ハンドラーの JSDoc コメントで入力構造を定義します。

```
/**
 * Lambda handler for processing orders and storing receipts in S3.
 * @param {Object} event - Input event containing order details
 * @param {string} event.order_id - The unique identifier for the order
 * @param {number} event.amount - The order amount
 * @param {string} event.item - The item purchased
 * @returns {Promise<string>} Success message
 */
```

JSDoc コメントでこれらのタイプを定義すると、コード内のイベントオブジェクトのフィールドに直接アクセスできます。例えば、`event.order_id` は元の入力から `order_id` の値を取得します。

## Node.js 関数の有効なハンドラーパターン
<a name="nodejs-handler-signatures"></a>

[コールバック](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/using-a-callback-function.html)を使用する代わりに、[async/await](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/using-async-await.html) を使用して関数ハンドラーを宣言することをお勧めします。async/await は、非同期コードを記述するための簡潔で読みやすい方法であり、ネストされたコールバックや連鎖する promise を必要としません。async/await を使用すると、非同期かつノンブロッキングでありながら、同期コードのように読み取るコードを記述できます。

### 非同期関数ハンドラー (推奨)
<a name="nodejs-handler-async"></a>

`async` キーワードは関数を非同期としてマークし、`await` キーワードは `Promise` が解決されるまで関数の実行を一時停止します。ハンドラーは次の引数を取ります。
+ `event`: 関数に渡された入力データが含まれます。
+ `context`: 呼び出し、関数、および実行環境に関する情報が含まれます。詳細については、「[Lambda コンテキストオブジェクトを使用して Node.js 関数の情報を取得する](nodejs-context.md)」を参照してください。

async/await パターンの有効な署名は次のとおりです。

```
export const handler = async (event) => { };
```

```
export const handler = async (event, context) => { };
```

### 同期関数ハンドラー
<a name="nodejs-handler-synchronous"></a>

関数が非同期タスクを実行しない場合は、次のいずれかの関数署名を使用して、同期関数ハンドラーを使用できます。

```
export const handler = (event) => { };
```

```
export const handler = (event, context) => { };
```

### レスポンスストリーミング関数ハンドラー
<a name="nodejs-handler-response-streaming"></a>

Lambda は Node.js によるレスポンスストリーミングをサポートしています。レスポンスストリーミング関数ハンドラーは `awslambda.streamifyResponse()` デコレータを使用し、`event`、`responseStream`、`context` の 3 つのパラメータを使用します。関数の署名は次のとおりです。

```
export const handler = awslambda.streamifyResponse(async (event, responseStream, context) => { });
```

詳細については、「[Lambda 関数のレスポンスストリーミング](configuration-response-streaming.md)」を参照してください。

### コールバックベースの関数ハンドラー
<a name="nodejs-handler-callback"></a>

**注記**  
コールバックベースの関数ハンドラーは、Node.js 22 までのみサポートされています。Node.js 24 以降では、非同期タスクは非同期関数ハンドラーを使用して実装する必要があります。

コールバックベースの関数ハンドラーは、イベント、コンテキスト、コールバック引数を使用する必要があります。例:

```
export const handler = (event, context, callback) => { };
```

コールバック関数は、`Error` とレスポンスを想定しており、JSON シリアル化可能である必要があります。関数は、[イベントループ](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/)が空になるか、関数がタイムアウトするまで実行を続けます。レスポンスは、すべてのイベントループタスクが完了するまで、呼び出し元に送信されません。関数がタイムアウトした場合は、エラーが返ります。すぐにレスポンスが返るようにランタイムを設定するには、[context.callbackWaitsForEmptyEventLoop](nodejs-context.md) を false に設定します。

**Example – callback を使用した HTTP リクエスト**  
次の例の関数では、URL をチェックし、ステータスコードを呼び出し元に返します。  

```
import https from "https";
let url = "https://aws.amazon.com/";

export const handler = (event, context, callback) => {
  https.get(url, (res) => {
    callback(null, res.statusCode);
  }).on("error", (e) => {
    callback(Error(e));
  });
};
```

## ハンドラーでの SDK for JavaScript v3 の使用
<a name="nodejs-example-sdk-usage"></a>

多くの場合、Lambda 関数を使用して、他の AWS リソースとやり取りしたり、更新したりします。これらのリソースとインターフェイスする最も簡単な方法は、AWS SDK for JavaScript を使用することです。[サポートされているすべての Lambda Node.js ランタイム](lambda-nodejs.md#nodejs-supported-runtimes)には、[SDK for JavaScript バージョン 3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/introduction/) が含まれています。ただし、デプロイパッケージに必要な AWS SDK クライアントを含めることを強くお勧めします。こうすることで、将来的に Lambda ランタイムを更新する際の[下位互換性](runtimes-update.md#runtime-update-compatibility)が最大限保持されます。追加のパッケージを含めることができない場合にのみ、ランタイム提供の SDK を使用します (例えば、Lambda コンソールコードエディタまたはインラインコードを AWS CloudFormation テンプレートで使用する場合)。

SDK 依存関係を関数に追加するには、必要な特定の SDK クライアントに `npm install` コマンドを使用します。サンプルコードでは、[Amazon S3 クライアント](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/)を使用しました。この依存関係を追加するには、`package.json` ファイルが格納されているディレクトリで以下のコマンドを実行します。

```
npm install @aws-sdk/client-s3
```

関数コードで、関数の例で示すように、必要なクライアントとコマンドをインポートします。

```
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
```

次に、[Amazon S3 クライアント](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/)を初期化します。

```
const s3Client = new S3Client();
```

この例では、関数を呼び出すたびに Amazon S3 クライアントを初期化する必要がないように、メインハンドラー関数の外で Amazon S3 クライアントを初期化しました。SDK クライアントを初期化したら、それを使用してその AWS サービスの API コールを行うことができます。サンプルコードは、以下のように Amazon S3 [PutObject](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectCommand/) API アクションを呼び出します。

```
const command = new PutObjectCommand({
    Bucket: bucketName,
    Key: key,
    Body: receiptContent
});
```

## 環境変数にアクセスする
<a name="nodejs-example-envvars"></a>

ハンドラーコードでは、`process.env` を使用して任意の[環境変数](configuration-envvars.md)を参照できます。この例では、以下のコード行を使用して、定義された `RECEIPT_BUCKET` 環境変数を参照します:

```
// Access environment variables
const bucketName = process.env.RECEIPT_BUCKET;
if (!bucketName) {
    throw new Error('RECEIPT_BUCKET environment variable is not set');
}
```

## グローバルな状態を使用する
<a name="nodejs-handler-state"></a>

Lambda は、関数を初めて呼び出す前の[初期化フェーズ](lambda-runtime-environment.md#runtimes-lifecycle-ib)で静的コードを実行します。初期化中に作成されたリソースは呼び出し間でメモリに保持されるため、関数を呼び出すたびにリソースを作成する必要がなくなります。

コード例では、S3 クライアント初期化コードはハンドラーの外にあります。ランタイムは、関数が最初のイベントを処理する前にクライアントを初期化します。このクライアントはすべての呼び出しで再利用できます。

## Node.js Lambda 関数のコードのベストプラクティス
<a name="nodejs-best-practices"></a>

Lambda 関数を構築するときは、次のガイドラインに従ってください。
+ **Lambda ハンドラーをコアロジックから分離します。**これにより、関数の単体テストが実行しやすくなります。
+ **関数のデプロイパッケージ内で依存関係を制御します。**AWS Lambda 実行環境には多数のライブラリが含まれています。Node.js および Python ランタイムの場合、ライブラリには AWS SDK が含まれます。最新の機能やセキュリティ更新プログラムを有効にするために、Lambda はこれらのライブラリを定期的に更新します。この更新により、Lambda 関数の動作が微妙に変化する場合があります。関数で使用する依存関係を完全に制御するには、すべての依存関係をデプロイパッケージでパッケージングします。
+ **依存関係の複雑さを最小限に抑えます。**フレームワークを単純化して、[実行環境](lambda-runtime-environment.md)起動時のロードを高速化します。
+ **デプロイパッケージをランタイムに必要な最小限のサイズにします。**これにより、呼び出しに先立ってデプロイパッケージをダウンロードして解凍する所要時間が短縮されます。

**実行環境の再利用を活用して関数のパフォーマンスを向上させます。**関数ハンドラー外で SDK クライアントとデータベース接続を初期化し、静的なアセットを `/tmp` ディレクトリにローカルにキャッシュします。関数の同じインスタンスで処理された後続の呼び出しは、これらのリソースを再利用できます。これにより、関数の実行時間が短縮され、コストが節約されます。

呼び出し間でデータが漏れるのを防ぐため、実行環境を使用してセキュリティ上の懸念があるユーザーデータ、イベント、またはその他の情報を保存しないでください。関数がハンドラー内のメモリに保存できない変更可能な状態に依存している場合は、ユーザーごとに個別の関数または個別のバージョンの関数を作成することを検討してください。

**keep-alive ディレクティブを使用して永続的な接続を維持します。**Lambda は、時間の経過とともにアイドル状態の接続を消去します。関数を呼び出すときにアイドル状態の接続を再利用しようとすると、接続エラーが発生します。永続的な接続を維持するには、ランタイムに関連付けられている keep-alive ディレクティブを使用します。例については、「[Node.js で Keep-alive を使用して接続を再利用する](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html)」を参照してください。

**[環境変数](configuration-envvars.md)を使用して、オペレーショナルパラメータを関数に渡します。**たとえば、Amazon S3 バケットに書き込む場合、書き込み先のバケット名はハードコーディングせずに、環境変数として設定します。

Lambda 関数では、**再帰呼び出しを使用しないでください**。関数が自身を呼び出すこともあれば、新たに開始されたプロセスで関数が再度呼び出される可能性もあります。これを行うと意図しないボリュームで関数が呼び出され、料金が急増する可能性があります。意図しない呼び出しがいくつも見つかった場合は、すぐに関数の予約済同時実行数を `0` に設定して、コードを更新している間のすべての関数の呼び出しをスロットリングします。

Lambda 関数コードで**文書化されていない非公開の API を使用しないでください**。AWS Lambda マネージドランタイムでは、Lambda が Lambda の内部 API にセキュリティと機能面の更新を定期的に適用します。これらの内部 API 更新には後方互換性がないことがあり、関数にこれらの非公開 API に対する依存関係がある場合、呼び出しの失敗などの意図しない結果につながります。公開されている API のリストについては、「[API リファレンス](https://docs.aws.amazon.com/lambda/latest/api/welcome.html)」を参照してください。

**冪等性コードを記述します**。関数の記述に冪等性コードを使用すると、重複するイベントが同じ方法で処理されるようになります。コードでは、イベントを適切に検証し、重複するイベントを適切に処理する必要があります。詳細については、「[Lambda 関数を冪等にするにはどうすればよいですか?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/)」を参照してください。

# .zip ファイルアーカイブで Node.js Lambda 関数をデプロイする
<a name="nodejs-package"></a>

 AWS Lambda 関数のコードは、関数のハンドラーコードと、そのコードが依存するその他のパッケージやモジュールを含む .js または .mjs ファイルで構成されています。この関数コードを Lambda にデプロイするには、*デプロイパッケージ*を使用します。このパッケージは、.zip ファイルアーカイブでもコンテナイメージでもかまいません。Node.js でコンテナイメージを使用する方法の詳細については、「[コンテナイメージで Node.js Lambda 関数をデプロイする](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-image.html)」を参照してください。

 .zip ファイルのデプロイパッケージを .zip ファイルアーカイブとして作成するには、コマンドラインツール用の組み込み .zip ファイルアーカイブユーティリティ、または他の .zip ファイルユーティリティ ([7zip](https://www.7-zip.org/download.html) など) を使用します。次のセクションに示す例では、Linux または macOS 環境でコマンドライン `zip` ツールを使用していることを前提としています。Windows で同じコマンドを使用するには、[Windows Subsystem for Linux をインストールして](https://docs.microsoft.com/en-us/windows/wsl/install-win10)、Windows 統合バージョンの Ubuntu と Bash を取得します 

 Lambda は POSIX ファイルアクセス許可を使用するため、.zip ファイルアーカイブを作成する前に、[デプロイパッケージフォルダのアクセス許可を設定する](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/)ことが必要になる場合があります。

**Topics**
+ [

## Node.js でのランタイム依存関係
](#nodejs-package-dependencies)
+ [

## 依存関係のない .zip デプロイパッケージを作成する
](#nodejs-package-create-no-dependencies)
+ [

## 依存関係を含めて .zip デプロイパッケージを作成する
](#nodejs-package-create-dependencies)
+ [

## 依存関係の Node.js レイヤーを作成する
](#nodejs-package-dependencies-layers)
+ [

## 依存関係検索パスおよびランタイムを含むライブラリ
](#nodejs-package-searchpath)
+ [

## .zip ファイルを使用した Node.js Lambda 関数の作成と更新
](#nodejs-package-create-update)

## Node.js でのランタイム依存関係
<a name="nodejs-package-dependencies"></a>

 Node.js ランタイムを使用する Lambda 関数の場合、依存関係はどの Node.js モジュールでもかまいません。Node.js ランタイムには、多くの共通ライブラリに加えて、あるバージョンの AWS SDK for JavaScript が含まれています。[サポートされているすべての Lambda Node.js ランタイム](lambda-nodejs.md#nodejs-supported-runtimes)には、SDK バージョン 3 が含まれています。SDK バージョン 2 を使用するには、SDK を .zip ファイルのデプロイパッケージに追加する必要があります。使用しているランタイムに含まれている SDK の特定のバージョンを確認するには、「[ランタイムに含まれる SDK バージョン](lambda-nodejs.md#nodejs-sdk-included)」を参照してください。

 Lambda は Node.js ランタイムの SDK ライブラリを定期的に更新して、最新機能とセキュリティアップグレードを適用します。Lambda は、ランタイムに含まれる他のライブラリにもセキュリティパッチとアップデートを適用します。パッケージ内の依存関係を完全に制御するには、ランタイムに含まれる依存関係の任意のバージョンをデプロイパッケージに追加できます。例えば、特定のバージョンの JavaScript 用 SDK を使用する場合は、そのバージョンを依存関係として .zip ファイルに含めることができます。ランタイムに含まれる依存関係を .zip ファイルに追加する方法の詳細については、[依存関係検索パスおよびランタイムを含むライブラリ](#nodejs-package-searchpath) を参照してください。

 [AWS 責任分担モデル](lambda-runtimes.md#runtimes-shared-responsibility)では、関数のデプロイパッケージに含まれる依存関係を管理する責任があります。これには、更新とセキュリティパッチの適用が含まれます。関数のデプロイパッケージ内の依存関係を更新するには、まず新しい .zip ファイルを作成し、そのファイルを Lambda にアップロードします。詳細については、「[依存関係を含めて .zip デプロイパッケージを作成する](#nodejs-package-create-dependencies)」と「[.zip ファイルを使用した Node.js Lambda 関数の作成と更新](#nodejs-package-create-update)」を参照してください。

## 依存関係のない .zip デプロイパッケージを作成する
<a name="nodejs-package-create-no-dependencies"></a>

 関数コードに、Lambda ランタイムに含まれるライブラリ以外の依存関係がない場合、.zip ファイルには関数のハンドラーコードを含む `index.js` または `index.mjs` ファイルのみが含まれます。任意の zip ユーティリティを使用して、`index.js` または `index.mjs` ファイルをルートに置く .zip ファイルを作成します。関数のハンドラーコードを含むファイルが .zip ファイルのルートにない場合、Lambda はコードを実行できません。

 .zip ファイルをデプロイして新しい Lambda 関数を作成する方法の詳細、既存の Lambda 関数を更新する方法の詳細については、「[.zip ファイルを使用した Node.js Lambda 関数の作成と更新](#nodejs-package-create-update)」を参照してください。

## 依存関係を含めて .zip デプロイパッケージを作成する
<a name="nodejs-package-create-dependencies"></a>

関数コードが Lambda Node.js ランタイムに含まれていないパッケージやモジュールに依存している場合、これらの依存関係を関数コードとともに .zip ファイルに追加するか、[Lambda レイヤー](chapter-layers.md)を使用できます。このセクションでは、依存関係を .zip デプロイパッケージに含める方法について説明します。依存関係をレイヤーに含める方法については、「[依存関係の Node.js レイヤーを作成する](#nodejs-package-dependencies-layers)」を参照してください。

次の CLI コマンドの例では、関数のハンドラーコードとその依存関係を含む `index.js` または `index.mjs` ファイルを格納する `my_deployment_package.zip` という名前の .zip ファイルを作成します。この例では、npm パッケージマネージャーを使用して依存関係をインストールします。

**デプロイパッケージを作成するには**

1. `index.js` または `index.mjs` ソースコードファイルを含むプロジェクトディレクトリに移動します。この例では、ディレクトリ名は `my_function` です。

   ```
   cd my_function
   ```

1. `npm install` コマンドを使用して、`node_modules` ディレクトリに関数に必要なライブラリをインストールします。この例では、AWS X-Ray SDK for Node.js をインストールします。

   ```
   npm install aws-xray-sdk
   ```

   次のようなフォルダ構造が作成されます。

   ```
   ~/my_function
   ├── index.mjs
   └── node_modules
       ├── async
       ├── async-listener
       ├── atomic-batcher
       ├── aws-sdk
       ├── aws-xray-sdk
       ├── aws-xray-sdk-core
   ```

   自分で作成したカスタムモジュールをデプロイパッケージに追加することもできます。モジュールの名前を使用して `node_modules` にディレクトリを作成し、そこにカスタムで作成したパッケージを保存します。

1. プロジェクトフォルダの内容を含む .zip ファイルをルートに作成します。`r` (再帰的) オプションを使用して、zip がサブフォルダを確実に圧縮するようにします。

   ```
   zip -r my_deployment_package.zip .
   ```

## 依存関係の Node.js レイヤーを作成する
<a name="nodejs-package-dependencies-layers"></a>

このセクションでは、依存関係をレイヤーに含める方法について説明します。依存関係をデプロイパッケージに含める方法については、「[依存関係を含めて .zip デプロイパッケージを作成する](#nodejs-package-create-dependencies)」を参照してください。

関数にレイヤーを追加すると、Lambda はレイヤーのコンテンツをその実行環境の `/opt` ディレクトリに読み込みます。Lambda ランタイムごとに、`PATH` 変数には `/opt` ディレクトリ内の特定のフォルダパスがあらかじめ含まれます。Lambda がレイヤーコンテンツを確実に取得できるようにするには、レイヤーの .zip ファイルの依存関係が次のフォルダパスにある必要があります。
+ `nodejs/node_modules`
+ `nodejs/node18/node_modules (NODE_PATH)`
+ `nodejs/node20/node_modules (NODE_PATH)`
+ `nodejs/node22/node_modules (NODE_PATH)`

例えば、レイヤーの.zip ファイルの構造は次のようになります。

```
xray-sdk.zip
└ nodejs/node_modules/aws-xray-sdk
```

さらに、Lambda は `/opt/lib` ディレクトリ内のライブラリ、および `/opt/bin` ディレクトリ内のバイナリを自動的に検出します。Lambda がレイヤーのコンテンツを正しく検出できるように、次の構造でレイヤーを作成することもできます。

```
custom-layer.zip
└ lib
    | lib_1
    | lib_2
└ bin
    | bin_1
    | bin_2
```

レイヤーをパッケージ化したら、「[Lambda でのレイヤーの作成と削除](creating-deleting-layers.md)」および「[関数へのレイヤーの追加](adding-layers.md)」を参照してレイヤーの設定を完了してください。

## 依存関係検索パスおよびランタイムを含むライブラリ
<a name="nodejs-package-searchpath"></a>

Node.js ランタイムには、多くの共通ライブラリに加えて、あるバージョンの AWS SDK for JavaScript が含まれています。ランタイムに含まれるライブラリの別のバージョンを使用する場合は、それを関数にバンドルするか、デプロイパッケージに依存関係として追加することで対応できます。例えば、別のバージョンの SDK を .zip デプロイパッケージに追加して使用できます。関数の [Lambda レイヤー](chapter-layers.md)に含めることもできます。

コードで `import` または `require` ステートメントを使用すると、Node.js ランタイムはモジュールが見つかるまで `NODE_PATH` パス内のディレクトリを検索します。デフォルトでは、ランタイムが最初に検索する場所は、.zip デプロイパッケージを解凍してマウントするディレクトリ (`/var/task`) です。ランタイムに含まれるライブラリのバージョンをデプロイパッケージに含める場合、そのバージョンが、ランタイムに含まれるバージョンよりも優先されます。デプロイパッケージ内の依存関係も、レイヤー内の依存関係よりも優先されます。

レイヤーに依存関係を追加すると、Lambda はこれを `/opt/nodejs/nodexx/node_modules` に抽出します。ここで `nodexx` は使用しているランタイムのバージョンを表します。検索パスでは、このディレクトリはランタイムに含まれるライブラリを含むディレクトリ () よりも優先されます`/var/lang/lib/node_modules` このため、関数レイヤー内のライブラリは、ランタイムに含まれるバージョンよりも優先されます。

次のコード行を追加すると、Lambda 関数の完全な検索パスを確認できます。

```
console.log(process.env.NODE_PATH)
```

.zip パッケージ内の個別のフォルダに依存関係を追加することもできます。例えば、カスタムモジュールを .zip パッケージ内の `common` というフォルダに追加できます。.zip パッケージを解凍してマウントすると、このフォルダは `/var/task` ディレクトリ内に配置されます。コード内の.zip デプロイパッケージにあるフォルダの依存関係を使用するには、CJS または ESM のどちらのモジュール解決を使用しているかに応じて、`import { } from` か `const { } = require()` ステートメントを使用します。例えば、次のようになります。

```
import { myModule } from './common'
```

コードを `esbuild`、`rollup` または同様のものでバンドルすると、関数で使用される依存関係が 1 つ以上のファイルにバンドルされます。可能な限り、この方法を使用して依存関係を提供することをお勧めします。デプロイパッケージに依存関係を追加する場合と比較して、コードをバンドルすると I/O 操作が減るため、パフォーマンスが向上します。

## .zip ファイルを使用した Node.js Lambda 関数の作成と更新
<a name="nodejs-package-create-update"></a>

 .zip デプロイパッケージを作成したら、このパッケージを使用して新しい Lambda 関数を作成するか、既存の関数を更新できます。.zip パッケージをデプロイするには、Lambda コンソール、AWS Command Line Interface、Lambda API を使用します。AWS Serverless Application Model (AWS SAM) および CloudFormation を使用して、Lambda 関数を作成および更新することもできます。

Lambda の .zip デプロイパッケージの最大サイズは  250 MB (解凍) です。この制限は、Lambda レイヤーを含む、更新するすべてのファイルの合計サイズに適用されることに注意してください。

Lambda ランタイムには、デプロイパッケージ内のファイルを読み取るアクセス許可が必要です。Linux のアクセス権限の 8 進表記では、Lambda には非実行ファイル用に 644 のアクセス権限 (rw-r--r--) が必要であり、ディレクトリと実行可能ファイル用に 755 のアクセス権限 (rwxr-xr-x) が必要です。

Linux と MacOS で、デプロイパッケージ内のファイルやディレクトリのファイルアクセス権限を変更するには、`chmod` コマンドを使用します。例えば、実行可能でないファイルに正しいアクセス許可を付与するには、次のコマンドを実行します。

```
chmod 644 <filepath>
```

Windows でファイルアクセス許可を変更するには、「Microsoft Windows ドキュメント」の「[Set, View, Change, or Remove Permissions on an Object](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10))」を参照してください。

**注記**  
デプロイパッケージのディレクトリにアクセスするために必要なアクセス許可を Lambda に付与しない場合、Lambda はそれらのディレクトリのアクセス許可を 755 (rwxr-xr-x) に設定します。

### コンソールを使用して .zip ファイルの関数を作成、更新する
<a name="nodejs-package-create-console"></a>

 新しい関数を作成するには、まずコンソールで関数を作成し、次に .zip アーカイブをアップロードする必要があります。既存の関数を更新するには、その関数のページを開き、同じ手順に従って更新した .zip ファイルを追加します。

 .zip ファイルが 50 MB 未満の場合は、ローカルマシンから直接ファイルをアップロードして関数を作成または更新できます。50 MB を超える .zip ファイルの場合は、まず  Amazon S3 バケットにパッケージをアップロードする必要があります。AWS マネジメントコンソール を使用して Amazon S3 バケットにファイルをアップロードする手順については、「[Amazon S3 の開始方法](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html)」を参照してください。AWS CLI を使用してファイルをアップロードするには、「*AWS CLI ユーザーガイド*」の「[オブジェクトの移動](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move)」を参照してください。

**注記**  
既存の関数の[デプロイパッケージタイプ](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip またはコンテナイメージ) を変更することはできません。例えば、既存のコンテナイメージ関数を、.zip ファイルアーカイブを使用するように変換することはできません。この場合は、新しい関数を作成する必要があります。

**新しい関数を作成するには (コンソール)**

1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開き、**[関数の作成]** を選択します。

1. **[一から作成]** を選択します。

1. **[基本的な情報]** で、以下を行います。

   1. **[関数名]** に、関数名を入力します。

   1. **[ランタイム]** で、使用するランタイムを選択します。

   1. (オプション) **[アーキテクチャ]**で、関数の命令セットアーキテクチャを選択します。デフォルトのアーキテクチャは x86\$164 です。関数用の .zip デプロイパッケージと選択した命令セットのアーキテクチャに互換性があることを確認してください。

1. (オプション) **[アクセス権限]** で、**[デフォルトの実行ロールの変更]** を展開します。新しい **[実行ロール]** を作成することも、既存のロールを使用することもできます。

1. **[関数の作成]**を選択します。Lambda は、選択したランタイムを使用して基本的な「Hello world」関数を作成します。

**ローカルマシンから  zip アーカイブをアップロードするには (コンソール)**

1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) で、.zip ファイルをアップロードする関数を選択します。

1. **[コード]** タブを選択します。

1. **[コードソース]** ペインで、**[アップロード元]** をクリックします。

1. **[.zip ファイル]** をクリックします。

1. .zip ファイルをアップロードするには、次の操作を行います。

   1. **[アップロード]** をクリックし、ファイルセレクターで .zip ファイルを選択します。

   1. **[開く]** をクリックします。

   1. **[保存]** をクリックします。

**Amazon S3 バケットから .zip アーカイブをアップロードするには (コンソール)**

1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) で、新しい .zip ファイルをアップロードする関数を選択します。

1. **[コード]** タブを選択します。

1. **[コードソース]** ペインで、**[アップロード元]** をクリックします。

1. **[Amazon S3 ロケーション]** を選択します。

1. .zip ファイルの Amazon S3 リンク URL を貼り付けて、**[保存]** を選択します。

### コンソールコードエディタを使用して .zip ファイル関数を更新する
<a name="nodejs-package-console-edit"></a>

 .zip デプロイパッケージを使用する一部の関数では、Lambda コンソールの組み込みコードエディタを使用して、関数コードを直接更新できます。この機能を使用するには、関数が次の基準を満たしている必要があります。
+ 関数が、インタープリター言語ランタイムのいずれか (Python、Node.js、Ruby) を使用する必要があります。
+ 関数のデプロイパッケージが 50 MB (解凍時)未満である必要があります。

コンテナイメージデプロイパッケージを含む関数の関数コードは、コンソールで直接編集することはできません。

**コンソールのコードエディタを使用して関数コードを更新するには**

1. Lambda コンソールの「[関数ページ](https://console.aws.amazon.com/lambda/home#/functions)」を開き、関数を選択します。

1. **[コード]** タブを選択します。

1. **[コードソース]** ペインでソースコードファイルを選択し、統合コードエディタで編集します。

1. **[DEPLOY]** セクションで、**[デプロイ]** を選択して関数のコードを更新します。  
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)

### AWS CLI を使用して .zip ファイルで関数を作成、更新する
<a name="nodejs-package-create-cli"></a>

 [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) を使用して新しい関数を作成したり、.zip ファイルを使用して既存の関数を更新したりできます。[create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) コマンドと [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) を使用して、.zip パッケージをデプロイします。.zip ファイルが 50 MB 未満の場合は、ローカルビルドマシン上のファイルの場所から .zip パッケージをアップロードできます。サイズの大きいファイルの場合は、Amazon S3 バケットから .zip パッケージをアップロードする必要があります。AWS CLI を使用して Amazon S3 バケットにファイルをアップロードする方法については、「*AWS CLI ユーザーガイド*」の「[オブジェクトの移動](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move)」を参照してください。

**注記**  
AWS CLI を使用して Amazon S3 バケットから .zip ファイルをアップロードする場合、このバケットは関数と同じ AWS リージョン に配置する必要があります。

 AWS CLI を含む .zip ファイルを使用して新しい関数を作成するには、以下を指定する必要があります。
+ 関数の名前 (`--function-name`)
+ 関数のランタイム (`--runtime`)
+ 関数の[実行ロール](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) (`--role`) の Amazon リソースネーム (ARN)
+ 関数コード内のハンドラーメソッド (`--handler`) の名前

 .zip ファイルの場所も指定する必要があります。.zip ファイルがローカルビルドマシン上のフォルダにある場合は、次のコマンド例に示すように、`--zip-file` オプションを使用してファイルパスを指定します。

```
aws lambda create-function --function-name myFunction \
--runtime nodejs24.x --handler index.handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```

 Amazon S3 バケット内の .zip ファイルの場所を指定するには、以下のコマンド例にある `--code` オプションを使用します。`S3ObjectVersion` パラメータは、バージョン管理下のオブジェクトにのみ使用する必要があります。

```
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
```

 CLI を使用して既存の関数を更新するには、`--function-name` パラメータを使用して関数の名前を指定します。関数コードの更新に使用する .zip ファイルの場所も指定する必要があります。.zip ファイルがローカルビルドマシン上のフォルダにある場合は、次のコマンド例に示すように、`--zip-file` オプションを使用してファイルパスを指定します。

```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```

 Amazon S3 バケット内の .zip ファイルの場所を指定するには、以下のコマンド例にある `--s3-bucket` および `--s3-key` オプションを使用します。`--s3-object-version` パラメータは、バージョン管理下のオブジェクトにのみ使用する必要があります。

```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```

### Lambda API を使用して .zip ファイルで関数を作成、更新する
<a name="nodejs-package-create-api"></a>

 .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)

### AWS SAM を使用して .zip ファイルで関数を作成、更新する
<a name="nodejs-package-create-sam"></a>

 AWS Serverless Application Model (AWS SAM) は、AWS のサーバーレスアプリケーションの構築と実行のプロセスを合理化するのに役立つツールキットです。YAML または JSON テンプレートでアプリケーションのリソースを定義し、AWS SAM コマンドラインインターフェイス (AWS SAM CLI) を使用して、アプリケーションを構築、パッケージ化、デプロイします。AWS SAM テンプレートから Lambda 関数を構築すると、AWS SAM は関数コードと指定した任意の依存関係を含む .zip デプロイパッケージまたはコンテナイメージを自動的に作成します。AWS SAM を使用して Lambda 関数を構築およびデプロイする方法の詳細については、「*AWS Serverless Application Model デベロッパーガイド*」の「[Getting started with AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html)」を参照してください。

AWS SAM を使用して、既存の .zip ファイルアーカイブを使用する Lambda 関数を作成できます。AWS SAM を使用して Lambda 関数を作成するには、.zip  ファイルを Amazon S3 バケットまたはビルドマシンのローカルフォルダに保存します。AWS CLI を使用して Amazon S3 バケットにファイルをアップロードする方法については、「*AWS CLI ユーザーガイド*」の「[オブジェクトの移動](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move)」を参照してください。

 AWS SAM テンプレートでは、Lambda 関数は `AWS::Serverless::Function` のリソースにより指定されます。このリソースで次のプロパティを設定し、.zip ファイルアーカイブを使用して関数を作成します。
+ `PackageType` - `Zip` に設定
+ `CodeUri` - 関数コードの Amazon S3 URI、ローカルフォルダへのパス、または [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html) オブジェクトに設定
+ `Runtime` - 選択したランタイムに設定

 AWS SAM では、.zip ファイルが 50 MB を超える場合、この .zip ファイルを最初に Amazon S3 バケットにアップロードする必要はありません。AWS SAM では、ローカルビルドマシン上の場所から、最大許容サイズ 250 MB (解凍) の .zip パッケージをアップロードできます。

 AWS SAM で .zip ファイルを使用して関数をデプロイする方法の詳細については、「*AWS SAM デベロッパーガイド*」の「[AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)」を参照してください。

### CloudFormation を使用して .zip ファイルで関数を作成、更新する
<a name="nodejs-package-create-cfn"></a>

 CloudFormation を使用して、.zip ファイルアーカイブを使用する Lambda 関数を作成できます。.zip ファイルから Lambda 関数を作成するには、最初にファイルを Amazon S3 バケットにアップロードする必要があります。AWS CLI を使用して Amazon S3 バケットにファイルをアップロードする方法については、「*AWS CLI ユーザーガイド*」の「[オブジェクトの移動](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move)」を参照してください。

CloudFormation テンプレートでは、Lambda 関数は `AWS::Lambda::Function` のリソースにより指定されます。このリソースで次のプロパティを設定し、.zip ファイルアーカイブを使用して関数を作成します。
+ `PackageType` - `Zip` に設定
+ `Code` - `S3Bucket` および `S3Key` フィールドに Amazon S3 バケット名と .zip ファイル名を入力
+ `Runtime` - 選択したランタイムに設定

 CloudFormation が生成する .zip ファイルは、4 MB を超えることはできません。CloudFormation で .zip ファイルを使用して関数をデプロイする方法の詳細については、「*CloudFormation ユーザーガイド*」の「[AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)」を参照してください。

# Node.js Lambda 関数をコンテナイメージとともにデプロイする
<a name="nodejs-image"></a>

Node.js Lambda 関数のコンテナイメージを構築するには 3 つの方法があります。
+ [Node.js の AWS ベースイメージを使用する](#nodejs-image-instructions)

  [AWS ベースイメージ](images-create.md#runtimes-images-lp)には、言語ランタイム、Lambda と関数コード間のやり取りを管理するランタイムインターフェースクライアント、ローカルテスト用のランタイムインターフェースエミュレーターがあらかじめロードされています。
+ [AWS の OS 専用ベースイメージを使用する](images-create.md#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 との互換性を持たせるには、[Node.js のランタイムインターフェイスクライアント](#nodejs-image-clients)をイメージに含める必要があります。
+ [非 AWS ベースイメージを使用する](#nodejs-image-clients)

  Alpine Linux や Debian など、別のコンテナレジストリの代替ベースイメージを使用することもできます。組織が作成したカスタムイメージを使用することもできます。イメージに Lambda との互換性を持たせるには、[Node.js のランタイムインターフェイスクライアント](#nodejs-image-clients)をイメージに含める必要があります。

**ヒント**  
Lambda コンテナ関数がアクティブになるまでの時間を短縮するには、「Docker ドキュメント」の「[マルチステージビルドを使用する](https://docs.docker.com/build/building/multi-stage/)」を参照してください。効率的なコンテナイメージを構築するには、「[Dockerfiles を記述するためのベストプラクティス](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/)」に従ってください。

このページでは、Lambda のコンテナイメージを構築、テスト、デプロイする方法について説明します。

**Topics**
+ [

## Node.js の AWS ベースイメージ
](#nodejs-image-base)
+ [

## Node.js の AWS ベースイメージを使用する
](#nodejs-image-instructions)
+ [

## ランタイムインターフェイスクライアントで代替ベースイメージを使用する
](#nodejs-image-clients)

## Node.js の AWS ベースイメージ
<a name="nodejs-image-base"></a>

AWS では、Node.js 用の以下のベースイメージが利用できます。


| タグ | ランタイム | オペレーティングシステム | Dockerfile | 非推奨 | 
| --- | --- | --- | --- | --- | 
| 24 | Node.js 24 | Amazon Linux 2023 | [GitHub にある Node.js 24 用の Dockerfile](https://github.com/aws/aws-lambda-base-images/blob/nodejs24.x/Dockerfile.nodejs24.x) |   2028 年 4 月 30 日   | 
| 22 | Node.js 22 | Amazon Linux 2023 | [GitHub にある Node.js 22 用の Dockerfile](https://github.com/aws/aws-lambda-base-images/blob/nodejs22.x/Dockerfile.nodejs22.x) |   2027 年 4 月 30 日   | 
| 20 | Node.js 20 | Amazon Linux 2023 | [GitHub にある Node.js 20 用の Dockerfile](https://github.com/aws/aws-lambda-base-images/blob/nodejs20.x/Dockerfile.nodejs20.x) |   2026 年 4 月 30 日   | 

Amazon ECR リポジトリ: [gallery.ecr.aws/lambda/nodejs](https://gallery.ecr.aws/lambda/nodejs)

Node.js 20 以降のベースイメージは、[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 以降を使用する必要があります。

## Node.js の AWS ベースイメージを使用する
<a name="nodejs-image-instructions"></a>

### 前提条件
<a name="nodejs-image-prerequisites"></a>

このセクションの手順を完了するには、以下が必要です。
+ [AWS CLI バージョン 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (最小バージョン 25.0.0)
+ Docker [buildx プラグイン](https://github.com/docker/buildx/blob/master/README.md)。
+ Node.js

### ベースイメージからイメージを作成する
<a name="nodejs-image-create"></a>

**Node.js の AWS ベースイメージからコンテナイメージを作成する方法**

1. プロジェクト用のディレクトリを作成し、そのディレクトリに切り替えます。

   ```
   mkdir example
   cd example
   ```

1. `npm` で新しい Node.js プロジェクトを作成します。インタラクティブな形式で提供されるデフォルトオプションを受け入れるには、`Enter` を押します。

   ```
   npm init
   ```

1. `index.js` という名前の新しいファイルを作成します。テスト用に次のサンプル関数コードをファイルに追加することも、独自のコードを使用することもできます。  
**Example CommonJS ハンドラー**  

   ```
   exports.handler = async (event) => {
       const response = {
           statusCode: 200,
           body: JSON.stringify('Hello from Lambda!'),
       };
       return response;
   };
   ```

1. 関数が AWS SDK for JavaScript 以外のライブラリに依存している場合、「[npm](https://www.npmjs.com/)」を使用してパッケージに追加します。

1. 次の設定で新しい Dockerfile を作成します。
   + `FROM` プロパティを「[ベースイメージの URI](https://gallery.ecr.aws/lambda/nodejs)」に設定します。
   + COPY コマンドを使用し、関数コードおよびランタイムの依存関係を `{LAMBDA_TASK_ROOT}` ([Lambda 定義の環境変数](configuration-envvars.md#configuration-envvars-runtime)) にコピーします。
   + `CMD` 引数を Lambda 関数ハンドラーに設定します。

   この例の Dockerfile には [USER 命令](https://docs.docker.com/reference/dockerfile/#user)が含まれていないことに注意してください。コンテナイメージを Lambda にデプロイすると、最小特権のアクセス許可を付与したデフォルトの Linux ユーザーを Lambda が自動的に定義します。これは標準の Docker 動作とは異なります。標準の動作とは、`USER` 命令を指定しなかったときに `root` ユーザーのデフォルトとなる動作のことです。  
**Example Dockerfile**  

   ```
   FROM public.ecr.aws/lambda/nodejs:22
   
   # Copy function code
   COPY index.js ${LAMBDA_TASK_ROOT}
     
   # Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
   CMD [ "index.handler" ]
   ```

1. Docker イメージを「[Docker の構築](https://docs.docker.com/engine/reference/commandline/build/)」コマンドで構築します。次の例では、イメージを `docker-image` と名付けて `test` [タグ](https://docs.docker.com/engine/reference/commandline/build/#tag)を付けます。Lambda互換のイメージを作成するには、 `--provenance=false` オプションを使用する必要があります。

   ```
   docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
   ```
**注記**  
このコマンドは、ビルドマシンのアーキテクチャに関係なく、コンテナが Lambda の実行環境と互換性があることを確認する `--platform linux/amd64` オプションを特定します。ARM64 命令セットアーキテクチャを使用して Lambda 関数を作成する場合は、代わりに `--platform linux/arm64` オプションを使用するようにコマンドを変更してください。

### (オプション) イメージをローカルでテストする
<a name="nodejs-image-test"></a>

1. **docker run** コマンドを使用して、Docker イメージを起動します。この例では、`docker-image` はイメージ名、`test` はタグです。

   ```
   docker run --platform linux/amd64 -p 9000:8080 docker-image:test
   ```

   このコマンドはイメージをコンテナとして実行し、`localhost:9000/2015-03-31/functions/function/invocations` でローカルエンドポイントを作成します。
**注記**  
ARM64 命令セットアーキテクチャ用に Docker イメージをビルドした場合は、`--platform linux/amd64` の代わりに `--platform linux/arm64` オプションを使用してください。

1. 新しいターミナルウィンドウから、イベントをローカルエンドポイントにポストします。

------
#### [ Linux/macOS ]

   Linux および macOS では、次の `curl` コマンドを実行します。

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
   ```

   このコマンドは、空のイベントで関数を呼び出し、応答を返します。サンプル関数コードではなく独自の関数コードを使用している場合は、JSON ペイロードを使用して関数を呼び出すことをお勧めします。例:

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
   ```

------
#### [ PowerShell ]

   PowerShell で次の `Invoke-WebRequest` コマンドを実行します。

   ```
   Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
   ```

   このコマンドは、空のイベントで関数を呼び出し、応答を返します。サンプル関数コードではなく独自の関数コードを使用している場合は、JSON ペイロードを使用して関数を呼び出すことをお勧めします。例:

   ```
   Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
   ```

------

1. コンテナ ID を取得します。

   ```
   docker ps
   ```

1. 「[docker kill](https://docs.docker.com/engine/reference/commandline/kill/)」コマンドを使用してコンテナを停止します。このコマンドでは、`3766c4ab331c` を前のステップのコンテナ ID で置き換えます。

   ```
   docker kill 3766c4ab331c
   ```

### イメージのデプロイ
<a name="nodejs-image-deploy"></a>

**Amazon ECR にイメージをアップロードして Lambda 関数を作成するには**

1. 「[get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)」コマンドを実行して Amazon ECR レジストリに Docker CLI を認証します。
   + `--region` 値を Amazon ECR リポジトリを作成する AWS リージョン に設定します。
   + `111122223333` を AWS アカウント ID に置き換えます。

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
   ```

1. 「[create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html)」コマンドを使用して Amazon ECR にリポジトリを作成します。

   ```
   aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
   ```
**注記**  
Amazon ECR リポジトリは Lambda 関数と同じ AWS リージョン に配置されている必要があります。

   成功すると、次のようなレスポンスが表示されます。

   ```
   {
       "repository": {
           "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
           "registryId": "111122223333",
           "repositoryName": "hello-world",
           "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
           "createdAt": "2023-03-09T10:39:01+00:00",
           "imageTagMutability": "MUTABLE",
           "imageScanningConfiguration": {
               "scanOnPush": true
           },
           "encryptionConfiguration": {
               "encryptionType": "AES256"
           }
       }
   }
   ```

1. 前のステップの出力から `repositoryUri` をコピーします。

1. 「[docker tag](https://docs.docker.com/engine/reference/commandline/tag/)」コマンドを実行して、最新バージョンとしてローカルイメージを Amazon ECR リポジトリにタグ付けします。このコマンドで:
   + `docker-image:test` は、Docker イメージの名前と[タグ](https://docs.docker.com/engine/reference/commandline/build/#tag)です。これは、`docker build` コマンドに指定したイメージの名前とタグです。
   + `<ECRrepositoryUri>` を、コピーした `repositoryUri` に置き換えます。URI の末尾には必ず `:latest` を含めてください。

   ```
   docker tag docker-image:test <ECRrepositoryUri>:latest
   ```

   例:

   ```
   docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. 「[docker push](https://docs.docker.com/engine/reference/commandline/push/)」コマンドを実行して Amazon ECR リポジトリにローカルイメージをデプロイします リポジトリ URI の末尾には必ず `:latest` を含めてください。

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. まだ作成済みでない場合、関数に「[実行ロールの作成](lambda-intro-execution-role.md#permissions-executionrole-api)」を実行してください。次のステップではロールの Amazon リソースネーム (ARN) が必要です。

1. Lambda 関数を作成します。`ImageUri` には、先ほど使用したリポジトリ URI を指定します。URI の末尾には必ず `:latest` を含めてください。

   ```
   aws lambda create-function \
     --function-name hello-world \
     --package-type Image \
     --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
     --role arn:aws:iam::111122223333:role/lambda-ex
   ```
**注記**  
イメージが Lambda 関数と同じリージョンに配置されていれば、別の AWS アカウントのイメージを使用して関数を作成することができます。詳細については、「[Amazon ECR クロスアカウント許可](images-create.md#configuration-images-xaccount-permissions)」を参照してください。

1. 関数を呼び出します。

   ```
   aws lambda invoke --function-name hello-world response.json
   ```

   次のような結果が表示されます。

   ```
   {
     "ExecutedVersion": "$LATEST", 
     "StatusCode": 200
   }
   ```

1. 関数の出力を確認するには、`response.json` ファイルをチェックします。

関数コードを更新するには、イメージを再構築し、新しいイメージを Amazon ECR リポジトリにアップロードしてから、[update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) コマンドを使用してイメージを Lambda 関数にデプロイする必要があります。

Lambda は、イメージタグを特定のイメージダイジェストに解決します。これは、関数のデプロイに使用されたイメージタグを Amazon ECR 内の新しいイメージを指すように変更しても、Lambda は新しいイメージを使用するように自動的に関数を更新しないことを意味します。

新しいイメージを同じ Lambda 関数にデプロイするには、Amazon ECR のイメージタグが同じままであっても、[update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) コマンドを使用する必要があります。次の例では、`--publish` オプションが最新のコンテナイメージを使用して関数の新しいバージョンを作成しています。

```
aws lambda update-function-code \
  --function-name hello-world \
  --image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --publish
```

## ランタイムインターフェイスクライアントで代替ベースイメージを使用する
<a name="nodejs-image-clients"></a>

[OS 専用ベースイメージ](images-create.md#runtimes-images-provided)または代替のベースイメージを使用する場合、イメージにランタイムインターフェイスクライアントを含める必要があります。ランタイムインターフェイスクライアントは、Lambda と関数コード間の相互作用を管理する [ランタイム API](runtimes-api.md) を拡張します。

npm パッケージマネージャーを使用して、[Node.js 用のランタイムインターフェイスクライアント](https://www.npmjs.com/package/aws-lambda-ric)をインストールします。

```
npm install aws-lambda-ric
```

[Node.js のランタイムインターフェイスクライアント](https://github.com/aws/aws-lambda-nodejs-runtime-interface-client)を GitHub からダウンロードすることもできます。

次の例は、非 AWS ベースイメージを使用して、 Node.js 用のコンテナイメージを構築する方法について説明しています。`bookworm` ベースイメージを使用した Dockerfile の例を示します。Dockerfile には、ランタイムインターフェイスクライアントが含まれています。

### 前提条件
<a name="nodejs-alt-prerequisites"></a>

このセクションの手順を完了するには、以下が必要です。
+ [AWS CLI バージョン 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (最小バージョン 25.0.0)
+ Docker [buildx プラグイン](https://github.com/docker/buildx/blob/master/README.md)。
+ Node.js

### 代替ベースイメージからイメージを作成する
<a name="nodejs-alt-create"></a>

**非 AWS ベースイメージからコンテナイメージを作成するには**

1. プロジェクト用のディレクトリを作成し、そのディレクトリに切り替えます。

   ```
   mkdir example
   cd example
   ```

1. `npm` で新しい Node.js プロジェクトを作成します。インタラクティブな形式で提供されるデフォルトオプションを受け入れるには、`Enter` を押します。

   ```
   npm init
   ```

1. `index.js` という名前の新しいファイルを作成します。テスト用に次のサンプル関数コードをファイルに追加することも、独自のコードを使用することもできます。  
**Example CommonJS ハンドラー**  

   ```
   exports.handler = async (event) => {
       const response = {
           statusCode: 200,
           body: JSON.stringify('Hello from Lambda!'),
       };
       return response;
   };
   ```

1. 新しい Dockerfile を作成します。次の Dockerfile では、[AWS ベースイメージ](images-create.md#runtimes-images-lp)の代わりに `bookworm` ベースイメージを使用します。Dockerfile には、イメージに Lambda との互換性を持たせる[ランタイムインターフェイスクライアント](https://www.npmjs.com/package/aws-lambda-ric)が含まれています。Dockerfile では、[マルチステージビルド](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds)を使用します。第 1 段階では、関数の依存関係がインストールされた標準の Node.js 環境であるビルドイメージを作成します。第2段階では、関数コードとその依存関係を含むスリムなイメージを作成します。これにより、最終的なイメージサイズが小さくなります。
   + ベースイメージ識別子に `FROM` プロパティを設定します。
   + `COPY` コマンドを使用して、関数コードおよびランタイムの依存関係をコピーします。
   + `ENTRYPOINT` を、Docker コンテナの起動時に実行させるモジュールに設定します。この場合、モジュールはランタイムインターフェイスクライアントです。
   + `CMD` 引数を Lambda 関数ハンドラーに設定します。

   この例の Dockerfile には [USER 命令](https://docs.docker.com/reference/dockerfile/#user)が含まれていないことに注意してください。コンテナイメージを Lambda にデプロイすると、最小特権のアクセス許可を付与したデフォルトの Linux ユーザーを Lambda が自動的に定義します。これは標準の Docker 動作とは異なります。標準の動作とは、`USER` 命令を指定しなかったときに `root` ユーザーのデフォルトとなる動作のことです。  
**Example Dockerfile**  

   ```
   # Define custom function directory
   ARG FUNCTION_DIR="/function"
   
   FROM node:20-bookworm as build-image
   
   # Include global arg in this stage of the build
   ARG FUNCTION_DIR
   
   # Install build dependencies
   RUN apt-get update && \
       apt-get install -y \
       g++ \
       make \
       cmake \
       unzip \
       libcurl4-openssl-dev
   
   # Copy function code
   RUN mkdir -p ${FUNCTION_DIR}
   COPY . ${FUNCTION_DIR}
   
   WORKDIR ${FUNCTION_DIR}
   
   # Install Node.js dependencies
   RUN npm install
   
   # Install the runtime interface client
   RUN npm install aws-lambda-ric
   
   # Grab a fresh slim copy of the image to reduce the final size
   FROM node:20-bookworm-slim
   
   # Required for Node runtimes which use npm@8.6.0+ because
   # by default npm writes logs under /home/.npm and Lambda fs is read-only
   ENV NPM_CONFIG_CACHE=/tmp/.npm
   
   # Include global arg in this stage of the build
   ARG FUNCTION_DIR
   
   # Set working directory to function root directory
   WORKDIR ${FUNCTION_DIR}
   
   # Copy in the built dependencies
   COPY --from=build-image ${FUNCTION_DIR} ${FUNCTION_DIR}
   
   # Set runtime interface client as default command for the container runtime
   ENTRYPOINT ["/usr/local/bin/npx", "aws-lambda-ric"]
   # Pass the name of the function handler as an argument to the runtime
   CMD ["index.handler"]
   ```

1. Docker イメージを「[Docker の構築](https://docs.docker.com/engine/reference/commandline/build/)」コマンドで構築します。次の例では、イメージを `docker-image` と名付けて `test` [タグ](https://docs.docker.com/engine/reference/commandline/build/#tag)を付けます。Lambda互換のイメージを作成するには、 `--provenance=false` オプションを使用する必要があります。

   ```
   docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
   ```
**注記**  
このコマンドは、ビルドマシンのアーキテクチャに関係なく、コンテナが Lambda の実行環境と互換性があることを確認する `--platform linux/amd64` オプションを特定します。ARM64 命令セットアーキテクチャを使用して Lambda 関数を作成する場合は、代わりに `--platform linux/arm64` オプションを使用するようにコマンドを変更してください。

### (オプション) イメージをローカルでテストする
<a name="nodejs-alt-test"></a>

[ランタイムインターフェイスエミュレーター](https://github.com/aws/aws-lambda-runtime-interface-emulator/)を使用して、イメージをローカルでテストします。[エミュレーターはイメージに組み込むことも](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image)、次の手順を使用してローカルマシンにインストールすることもできます。

**ローカルマシンにランタイムインターフェイスエミュレーターをインストールして実行するには**

1. プロジェクトディレクトリから次のコマンドを実行して、GitHub からランタイムインターフェイスエミュレーター (x86-64 アーキテクチャ) をダウンロードし、ローカルマシンにインストールします。

------
#### [ Linux/macOS ]

   ```
   mkdir -p ~/.aws-lambda-rie && \
       curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
       chmod +x ~/.aws-lambda-rie/aws-lambda-rie
   ```

   arm64 エミュレータをインストールするには、前のコマンドの GitHub リポジトリ URL を次のように置き換えます。

   ```
   https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
   ```

------
#### [ PowerShell ]

   ```
   $dirPath = "$HOME\.aws-lambda-rie"
   if (-not (Test-Path $dirPath)) {
       New-Item -Path $dirPath -ItemType Directory
   }
         
   $downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
   $destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
   Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
   ```

   arm64 エミュレーターをインストールするには、`$downloadLink` を次のように置き換えます。

   ```
   https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
   ```

------

1. **docker run** コマンドを使用して、Docker イメージを起動します。次の点に注意してください。
   + `docker-image` はイメージ名、`test` はタグです。
   + `/usr/local/bin/npx aws-lambda-ric index.handler` は `ENTRYPOINT` で、その後に Dockerfile の `CMD` が続きます。

------
#### [ Linux/macOS ]

   ```
   docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
       --entrypoint /aws-lambda/aws-lambda-rie \
       docker-image:test \
           /usr/local/bin/npx aws-lambda-ric index.handler
   ```

------
#### [ PowerShell ]

   ```
   docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
   --entrypoint /aws-lambda/aws-lambda-rie `
   docker-image:test `
       /usr/local/bin/npx aws-lambda-ric index.handler
   ```

------

   このコマンドはイメージをコンテナとして実行し、`localhost:9000/2015-03-31/functions/function/invocations` でローカルエンドポイントを作成します。
**注記**  
ARM64 命令セットアーキテクチャ用に Docker イメージをビルドした場合は、`--platform linux/amd64` の代わりに `--platform linux/arm64` オプションを使用してください。

1. イベントをローカルエンドポイントにポストします。

------
#### [ Linux/macOS ]

   Linux および macOS では、次の `curl` コマンドを実行します。

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
   ```

   このコマンドは、空のイベントで関数を呼び出し、応答を返します。サンプル関数コードではなく独自の関数コードを使用している場合は、JSON ペイロードを使用して関数を呼び出すことをお勧めします。例:

   ```
   curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
   ```

------
#### [ PowerShell ]

   PowerShell で次の `Invoke-WebRequest` コマンドを実行します。

   ```
   Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
   ```

   このコマンドは、空のイベントで関数を呼び出し、応答を返します。サンプル関数コードではなく独自の関数コードを使用している場合は、JSON ペイロードを使用して関数を呼び出すことをお勧めします。例:

   ```
   Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
   ```

------

1. コンテナ ID を取得します。

   ```
   docker ps
   ```

1. 「[docker kill](https://docs.docker.com/engine/reference/commandline/kill/)」コマンドを使用してコンテナを停止します。このコマンドでは、`3766c4ab331c` を前のステップのコンテナ ID で置き換えます。

   ```
   docker kill 3766c4ab331c
   ```

### イメージのデプロイ
<a name="nodejs-alt-deploy"></a>

**Amazon ECR にイメージをアップロードして Lambda 関数を作成するには**

1. 「[get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)」コマンドを実行して Amazon ECR レジストリに Docker CLI を認証します。
   + `--region` 値を Amazon ECR リポジトリを作成する AWS リージョン に設定します。
   + `111122223333` を AWS アカウント ID に置き換えます。

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
   ```

1. 「[create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html)」コマンドを使用して Amazon ECR にリポジトリを作成します。

   ```
   aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
   ```
**注記**  
Amazon ECR リポジトリは Lambda 関数と同じ AWS リージョン に配置されている必要があります。

   成功すると、次のようなレスポンスが表示されます。

   ```
   {
       "repository": {
           "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
           "registryId": "111122223333",
           "repositoryName": "hello-world",
           "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
           "createdAt": "2023-03-09T10:39:01+00:00",
           "imageTagMutability": "MUTABLE",
           "imageScanningConfiguration": {
               "scanOnPush": true
           },
           "encryptionConfiguration": {
               "encryptionType": "AES256"
           }
       }
   }
   ```

1. 前のステップの出力から `repositoryUri` をコピーします。

1. 「[docker tag](https://docs.docker.com/engine/reference/commandline/tag/)」コマンドを実行して、最新バージョンとしてローカルイメージを Amazon ECR リポジトリにタグ付けします。このコマンドで:
   + `docker-image:test` は、Docker イメージの名前と[タグ](https://docs.docker.com/engine/reference/commandline/build/#tag)です。これは、`docker build` コマンドに指定したイメージの名前とタグです。
   + `<ECRrepositoryUri>` を、コピーした `repositoryUri` に置き換えます。URI の末尾には必ず `:latest` を含めてください。

   ```
   docker tag docker-image:test <ECRrepositoryUri>:latest
   ```

   例:

   ```
   docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. 「[docker push](https://docs.docker.com/engine/reference/commandline/push/)」コマンドを実行して Amazon ECR リポジトリにローカルイメージをデプロイします リポジトリ URI の末尾には必ず `:latest` を含めてください。

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
   ```

1. まだ作成済みでない場合、関数に「[実行ロールの作成](lambda-intro-execution-role.md#permissions-executionrole-api)」を実行してください。次のステップではロールの Amazon リソースネーム (ARN) が必要です。

1. Lambda 関数を作成します。`ImageUri` には、先ほど使用したリポジトリ URI を指定します。URI の末尾には必ず `:latest` を含めてください。

   ```
   aws lambda create-function \
     --function-name hello-world \
     --package-type Image \
     --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
     --role arn:aws:iam::111122223333:role/lambda-ex
   ```
**注記**  
イメージが Lambda 関数と同じリージョンに配置されていれば、別の AWS アカウントのイメージを使用して関数を作成することができます。詳細については、「[Amazon ECR クロスアカウント許可](images-create.md#configuration-images-xaccount-permissions)」を参照してください。

1. 関数を呼び出します。

   ```
   aws lambda invoke --function-name hello-world response.json
   ```

   次のような結果が表示されます。

   ```
   {
     "ExecutedVersion": "$LATEST", 
     "StatusCode": 200
   }
   ```

1. 関数の出力を確認するには、`response.json` ファイルをチェックします。

関数コードを更新するには、イメージを再構築し、新しいイメージを Amazon ECR リポジトリにアップロードしてから、[update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) コマンドを使用してイメージを Lambda 関数にデプロイする必要があります。

Lambda は、イメージタグを特定のイメージダイジェストに解決します。これは、関数のデプロイに使用されたイメージタグを Amazon ECR 内の新しいイメージを指すように変更しても、Lambda は新しいイメージを使用するように自動的に関数を更新しないことを意味します。

新しいイメージを同じ Lambda 関数にデプロイするには、Amazon ECR のイメージタグが同じままであっても、[update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) コマンドを使用する必要があります。次の例では、`--publish` オプションが最新のコンテナイメージを使用して関数の新しいバージョンを作成しています。

```
aws lambda update-function-code \
  --function-name hello-world \
  --image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --publish
```

# Node.js Lambda 関数のレイヤーを操作する
<a name="nodejs-layers"></a>

[Lambda レイヤー](chapter-layers.md)を使用して、複数の関数間で再利用するコードおよび依存関係をパッケージ化できます。レイヤーには通常、ライブラリの依存関係、[カスタムランタイム](runtimes-custom.md)、または設定ファイルが含まれています。レイヤーの作成には、次の 3 つの一般的な手順が含まれます。

1. レイヤーコンテンツのパッケージ化。これは、関数で使用する依存関係を含む .zip ファイルアーカイブを作成することを意味します。

1. Lambda でレイヤーを作成します。

1. レイヤーを関数に追加します。

**Topics**
+ [

## レイヤーコンテンツのパッケージ化
](#nodejs-layers-package)
+ [

## Lambda でレイヤーを作成する
](#publishing-layer)
+ [

## レイヤーを関数に追加する
](#nodejs-layer-adding)
+ [

## サンプルアプリ
](#nodejs-layer-sample-app)

## レイヤーコンテンツのパッケージ化
<a name="nodejs-layers-package"></a>

レイヤーを作成するには、次の要件を満たす .zip ファイルのアーカイブにパッケージをバンドルします。
+ Lambda 関数に使用するのと同じ Node.js バージョンを使用してレイヤーを構築します。例えば、Node.js 24 を使用してレイヤーを構築する場合、関数に Node.js 24 ランタイムを使用してください。
+ Layer の .zip ファイルは、次のいずれかのディレクトリ構造を使用する必要があります。
  + `nodejs/node_modules`
  + `nodejs/nodeX/node_modules` (*X* は Node.js バージョン。例: `node22`）

  詳細については、「[各 Lambda ランタイムのレイヤーパス](packaging-layers.md#packaging-layers-paths)」を参照してください。
+ レイヤーのパッケージは Linux と互換性がある必要があります。Lambda 関数は Amazon Linux 上で動作します。

`npm` がインストールされたサードパーティ Node ライブラリ (`axios` や `lodash` など) か、ユーザー独自の JavaScript モジュールやパッケージのいずれかを含むレイヤーを作成できます。

### サードパーティーへの依存関係
<a name="nodejs-layers-third-party-dependencies"></a>

**npm パッケージを使用してレイヤーを作成する方法**

1. 必要なディレクトリ構造を作成し、パッケージを直接インストールします。

   ```
   mkdir -p nodejs
   npm install --prefix nodejs lodash axios
   ```

   このコマンドは、Lambda が必要とする構造である `nodejs/node_modules` ディレクトリにパッケージを直接インストールします。
**注記**  
ネイティブ依存関係またはコンポーネントを含むパッケージの場合 (例: [sharp](https://www.npmjs.com/package/sharp)、[bcrypt](https://www.npmjs.com/package/bcrypt) など)、それらが Lambda Linux 環境および関数の[アーキテクチャ](foundation-arch.md)と互換性があることを確認してください。`--platform` フラグを使用する必要がある場合があります。  

   ```
   npm install --prefix nodejs --platform=linux --arch=x64 sharp
   ```
より複雑なネイティブ依存関係については、Lambda ランタイムに一致する Linux 環境でコンパイルする必要がある場合があります。この目的で Docker を使用できます。

1. レイヤーコンテンツを圧縮します。

------
#### [ Linux/macOS ]

   ```
   zip -r layer.zip nodejs/
   ```

------
#### [ PowerShell ]

   ```
   Compress-Archive -Path .\nodejs -DestinationPath .\layer.zip
   ```

------

   .zip ファイルのディレクトリ構造は次のようになります。

   ```
   nodejs/
   ├── package.json
   ├── package-lock.json
   └── node_modules/
       ├── lodash/
       ├── axios/
       └── (dependencies of the other packages)
   ```
**注記**  
zip ファイルには、ルートレベルに `nodejs` ディレクトリを含み、その中に `node_modules` ディレクトリがあることを確認してください。この構造により、Lambda がパッケージを検出し、インポートできます。
`nodejs/` ディレクトリ内の `package.json` ファイルと `package-lock.json` ファイルは npm が依存関係管理に使用するファイルですが、Lambda はレイヤー機能のためにこれらを必要としません。インストールされた各パッケージには、Lambda がパッケージをインポートする方法を定義する独自の `package.json` ファイルが既に含まれています。

### カスタム JavaScript モジュール
<a name="custom-nodejs-modules"></a>

**ユーザー独自のコードを使用してレイヤーを作成する方法**

1. レイヤーに必要なディレクトリ構造を作成します。

   ```
   mkdir -p nodejs/node_modules/validator
   cd nodejs/node_modules/validator
   ```

1. 独自のモジュールをインポートする方法を定義するため、`package.json` ファイルを作成します。  
**Example nodejs/node\$1modules/validator/package.json**  

   ```
   {
     "name": "validator",
     "version": "1.0.0",
     "type": "module",
     "main": "index.mjs"
   }
   ```

1. JavaScript モジュール ファイルを作成します。  
**Example nodejs/node\$1modules/validator/index.mjs**  

   ```
   export function validateOrder(orderData) {
     // Validates an order and returns formatted data
     const requiredFields = ['productId', 'quantity'];
     
     // Check required fields
     const missingFields = requiredFields.filter(field => !(field in orderData));
     if (missingFields.length > 0) {
       throw new Error(`Missing required fields: ${missingFields.join(', ')}`);
     }
     
     // Validate quantity
     const quantity = orderData.quantity;
     if (!Number.isInteger(quantity) || quantity < 1) {
       throw new Error('Quantity must be a positive integer');
     }
     
     // Format and return the validated data
     return {
       productId: String(orderData.productId),
       quantity: quantity,
       shippingPriority: orderData.priority || 'standard'
     };
   }
   
   export function formatResponse(statusCode, body) {
     // Formats the API response
     return {
       statusCode: statusCode,
       body: JSON.stringify(body)
     };
   }
   ```

1. レイヤーコンテンツを圧縮します。

------
#### [ Linux/macOS ]

   ```
   zip -r layer.zip nodejs/
   ```

------
#### [ PowerShell ]

   ```
   Compress-Archive -Path .\nodejs -DestinationPath .\layer.zip
   ```

------

   .zip ファイルのディレクトリ構造は次のようになります。

   ```
   nodejs/              
   └── node_modules/
       └── validator/
           ├── package.json
           └── index.mjs
   ```

1. 関数内でモジュールをインポートして使用します。例:

   ```
   import { validateOrder, formatResponse } from 'validator';
   
   export const handler = async (event) => {
     try {
       // Parse the order data from the event body
       const orderData = JSON.parse(event.body || '{}');
       
       // Validate and format the order
       const validatedOrder = validateOrder(orderData);
       
       return formatResponse(200, {
         message: 'Order validated successfully',
         order: validatedOrder
       });
     } catch (error) {
       if (error instanceof Error && error.message.includes('Missing required fields')) {
         return formatResponse(400, {
           error: error.message
         });
       }
       
       return formatResponse(500, {
         error: 'Internal server error'
       });
     }
   };
   ```

   次の[テストイベント](testing-functions.md#invoke-with-event)を使用して関数を呼び出すことができます。

   ```
   {
       "body": "{\"productId\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
   }
   ```

   予想されるレスポンス

   ```
   {
     "statusCode": 200,
     "body": "{\"message\":\"Order validated successfully\",\"order\":{\"productId\":\"ABC123\",\"quantity\":2,\"shippingPriority\":\"express\"}}"
   }
   ```

## Lambda でレイヤーを作成する
<a name="publishing-layer"></a>

AWS CLI または Lambda コンソールを使用して、レイヤーを発行できます。

------
#### [ AWS CLI ]

[publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) AWS CLI コマンドを実行して Lambda レイヤーを作成します。

```
aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes nodejs24.x
```

[互換性のあるランタイム](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes)パラメータの使用は任意です。指定すると、Lambda はこのパラメータを使用して Lambda コンソールのレイヤーをフィルタリングします。

------
#### [ Console ]

**レイヤーを作成するには (コンソール)**

1. Lambda コンソールの [[Layers (レイヤー)] ページ](https://console.aws.amazon.com/lambda/home#/layers)を開きます。

1. [**Create layer**] (レイヤーの作成) を選択します。

1. **[.zip ファイルをアップロードする]**を選択し、前の手順で作成しておいた .zip アーカイブをアップロードします。

1. (オプション) **[互換性のあるランタイム]**には、レイヤーの構築に使用した Node.js バージョンに対応する Node.js ランタイムを選択できます。

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

------

## レイヤーを関数に追加する
<a name="nodejs-layer-adding"></a>

------
#### [ AWS CLI ]

レイヤーを関数にアタッチするには、[update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) AWS CLI コマンドを実行します。`--layers` パラメータには、レイヤー ARN を使用します。ARN はバージョンを指定する必要があります (`arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1` など)。詳細については、「[レイヤーとレイヤーバージョン](chapter-layers.md#lambda-layer-versions)」を参照してください。

```
aws lambda update-function-configuration --function-name my-function --cli-binary-format raw-in-base64-out --layers "arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1"
```

AWS CLI バージョン 2 を使用している場合、**cli-binary-format** オプションは必須です。これをデフォルト設定にするには、`aws configure set cli-binary-format raw-in-base64-out` を実行します。詳細については、「*AWS Command Line Interface バージョン 2 用ユーザーガイド*」の「[AWS CLI でサポートされているグローバルコマンドラインオプション](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list)」を参照してください。

------
#### [ Console ]

**関数にレイヤーを追加する方法**

1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。

1. 関数を選択します。

1. **[レイヤー]** セクションまで下にスクロールし、**[レイヤーの追加]** を選択します。

1. **[レイヤーの選択]** で **[カスタムレイヤー]** を選択し、レイヤーを指定します。
**注記**  
レイヤーの作成時に[互換性のあるランタイム](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes)を追加しなかった場合、レイヤーはここには表示されません。代わりにレイヤー ARN を指定できます。

1. **[Add]** (追加) を選択します。

------

## サンプルアプリ
<a name="nodejs-layer-sample-app"></a>

Lambda レイヤーの使用方法のその他の例については、「AWS Lambda デベロッパーガイド」の GitHub リポジトリ内の [layer-nodejs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-nodejs) サンプルアプリケーションを参照してください。このアプリケーションには、[lodash](https://www.npmjs.com/package/lodash) ライブラリを含むレイヤーが含まれています。各レイヤーを作成したら、対応する関数をデプロイして呼び出し、レイヤーが期待どおりに動作するかどうかを確認できます。

# Lambda コンテキストオブジェクトを使用して Node.js 関数の情報を取得する
<a name="nodejs-context"></a>

Lambda で関数が実行されると、コンテキストオブジェクトが[ハンドラー](nodejs-handler.md)に渡されます。このオブジェクトは、呼び出し、関数、および実行関数に関する情報を示すメソッドおよびプロパティを提供します。

**context メソッド**
+ `getRemainingTimeInMillis()` — 実行がタイムアウトするまでの残り時間をミリ秒で返します。

**context プロパティ**
+ `functionName` － Lambda 関数の名前。
+ `functionVersion` － 関数の[バージョン](configuration-versions.md)。
+ `invokedFunctionArn` － 関数を呼び出すために使用される Amazon リソースネーム (ARN)。呼び出し元でバージョン番号またはエイリアスが指定されているかどうかを示します。
+ `memoryLimitInMB` － 関数に割り当てられたメモリの量。
+ `awsRequestId` － 呼び出しリクエストの ID。
+ `logGroupName` － 関数のロググループ。
+ `logStreamName` — 関数インスタンスのログストリーム。
+ `identity` — (モバイルアプリケーション) リクエストを認可した Amazon Cognito ID に関する情報。
  + `cognitoIdentityId` - 認証された Amazon Cognito ID
  + `cognitoIdentityPoolId` — 呼び出しを承認した Amazon Cognito ID プール。
+ `clientContext` —（モバイルアプリケーション）クライアントアプリケーションが Lambda に提供したクライアントコンテキスト。
  + `client.installation_id`
  + `client.app_title`
  + `client.app_version_name`
  + `client.app_version_code`
  + `client.app_package_name`
  + `env.platform_version`
  + `env.platform`
  + `env.make`
  + `env.model`
  + `env.locale`
  + `custom` - クライアントアプリケーションで設定されたカスタム値。
+ `callbackWaitsForEmptyEventLoop` – デフォルト (`true`) では、コールバックベースの関数ハンドラーを使用する場合、Lambda はコールバックの実行後にイベントループが空になるまで待機してから、関数の呼び出しを終了します。`false` に設定してレスポンスを送信し、イベントループが空になるまで待機するのではなく、コールバックの実行直後に呼び出しを終了します。未完了のイベントは、次の呼び出し中に実行され続けます。Lambda は Node.js 22 以前のランタイムのコールバックベースの関数ハンドラーのみをサポートすることに注意してください。

次の例の関数はコンテキスト情報をログに記録して、そのログの場所を返します。

**Example index.js ファイル**  

```
exports.handler = async function(event, context) {
  console.log('Remaining time: ', context.getRemainingTimeInMillis())
  console.log('Function name: ', context.functionName)
  return context.logStreamName
}
```

# Node.js Lambda 関数のログ記録とモニタリング
<a name="nodejs-logging"></a>

AWS Lambda は、ユーザーに代わって Lambda 関数を自動的にモニタリングし、Amazon CloudWatch にログを送信します。Lambda 関数には、関数のインスタンスごとに CloudWatch Logs ロググループとログストリームが用意されています。Lambda ランタイム環境は、各呼び出しの詳細をログストリームに送信し、関数のコードからのログやその他の出力を中継します。詳細については、「[Lambda 関数ログを CloudWatch Logs に送信する](monitoring-cloudwatchlogs.md)」を参照してください。

このページでは、AWS Command Line Interface、Lambda コンソール、または CloudWatch コンソールを使用して、Lambda 関数のコードからログ出力を生成する方法、およびアクセスログを生成する方法について説明します。

**Topics**
+ [

## ログを返す関数の作成
](#node-logging-output)
+ [

## Node.js での Lambda の高度なログ記録コントロールの使用
](#node-js-logging-advanced)
+ [

## Lambda コンソールでログを表示する
](#nodejs-logging-console)
+ [

## CloudWatch コンソールでの ログの表示
](#nodejs-logging-cwconsole)
+ [

## AWS Command Line Interface (AWS CLI) を使用してログを表示する
](#nodejs-logging-cli)
+ [

## ログの削除
](#nodejs-logging-delete)

## ログを返す関数の作成
<a name="node-logging-output"></a>

関数コードからログを出力するには、[コンソールオブジェクト](https://developer.mozilla.org/en-US/docs/Web/API/Console)のメソッドか、`stdout` または `stderr` に書き込む任意のログ記録のライブラリを使用します。次の例では、環境変数の値とイベントオブジェクトをログに記録します。

**注記**  
入力をログに記録するときは、入力の検証や出力エンコーディングなどの手法を使用することをお勧めします。入力データを直接ログに記録する場合、攻撃者がコードを使用して改ざんを検出しにくくしたり、ログエントリを偽造したり、ログモニタをバイパスしたりできる可能性があります。詳細については、「*Common Weakness Enumeration*」の「[Improper Output Neutralization for Logs](https://cwe.mitre.org/data/definitions/117.html)」を参照してください。

**Example index.js ファイル - ログ記録**  

```
exports.handler = async function(event, context) {
  console.log("ENVIRONMENT VARIABLES\n" + JSON.stringify(process.env, null, 2))
  console.info("EVENT\n" + JSON.stringify(event, null, 2))
  console.warn("Event not processed.")
  return context.logStreamName
}
```

**Example ログの形式**  

```
START RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac Version: $LATEST
2019-06-07T19:11:20.562Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	INFO	ENVIRONMENT VARIABLES
{
  "AWS_LAMBDA_FUNCTION_VERSION": "$LATEST",
  "AWS_LAMBDA_LOG_GROUP_NAME": "/aws/lambda/my-function",
  "AWS_LAMBDA_LOG_STREAM_NAME": "2019/06/07/[$LATEST]e6f4a0c4241adcd70c262d34c0bbc85c",
  "AWS_EXECUTION_ENV": "AWS_Lambda_nodejs12.x",
  "AWS_LAMBDA_FUNCTION_NAME": "my-function",
  "PATH": "/var/lang/bin:/usr/local/bin:/usr/bin/:/bin:/opt/bin",
  "NODE_PATH": "/opt/nodejs/node10/node_modules:/opt/nodejs/node_modules:/var/runtime/node_modules",
  ...
}
2019-06-07T19:11:20.563Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	INFO	EVENT
{
  "key": "value"
}
2019-06-07T19:11:20.564Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	WARN	Event not processed.
END RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac
REPORT RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac	Duration: 128.83 ms	Billed Duration: 296 ms	Memory Size: 128 MB	Max Memory Used: 74 MB	Init Duration: 166.62 ms	XRAY TraceId: 1-5d9d007f-0a8c7fd02xmpl480aed55ef0	SegmentId: 3d752xmpl1bbe37e	Sampled: true
```

Node.js ランタイムは、呼び出しごとに `START`、`END`、および `REPORT` の各行を記録します。関数によってログに記録される各エントリに、タイムスタンプ、リクエスト ID、およびログレベルを追加します。レポート行には、次の詳細が示されます。

**REPORT 行のデータフィールド**
+ **RequestId** － 呼び出しの一意のリクエスト ID。
+ **所要時間** － 関数のハンドラーメソッドがイベントの処理に要した時間。
+ **課金期間** － 呼び出しの課金対象の時間。
+ **メモリサイズ** － 関数に割り当てられたメモリの量。
+ **使用中の最大メモリ** － 関数によって使用されているメモリの量。呼び出しが実行環境を共有すると、Lambda はすべての呼び出しで使用される最大メモリを報告します。この動作により、予想よりも高い報告値が発生する可能性があります。
+ **初期所要時間** － 最初に処理されたリクエストについて、ハンドラーメソッド外で関数をロードしてコードを実行するためにランタイムにかかった時間。
+ **XRAY TraceId** － トレースされたリクエストの場合、[AWS X-Ray のトレース ID](services-xray.md)。
+ **SegmentId** － トレースされたリクエストの場合、X-Ray のセグメント ID。
+ **サンプリング済み** － トレースされたリクエストの場合、サンプリング結果。

ログは、Lambda コンソール、CloudWatch Logs コンソール、またはコマンドラインで表示することができます。

## Node.js での Lambda の高度なログ記録コントロールの使用
<a name="node-js-logging-advanced"></a>

関数のログのキャプチャ、処理、使用方法をより細かく制御できるように、サポートされている Node.js ランタイムに以下のログ記録オプションを設定できます。
+ **ログの形式** - 関数のログをプレーンテキスト形式と構造化された JSON 形式から選択します
+ **ログレベル** - JSON 形式のログの場合、Lambda が Amazon CloudWatch に送信するログの詳細レベル (ERROR、DEBUG、INFO など) を選択します。
+ **ロググループ** - 関数がログを送信する CloudWatch ロググループを選択します

これらのログ記録オプションの詳細と、それらのオプションを使用するように関数を設定する方法については、「[Lambda 関数の高度なログ記録コントロールの設定](monitoring-logs.md#monitoring-cloudwatchlogs-advanced)」を参照してください。

Node.js Lambda 関数でログ形式とログレベルのオプションを使用するには、以下のセクションのガイダンスを参照してください。

### Node.js での構造化 JSON ログの使用
<a name="nodejs-logging-advanced-JSON"></a>

関数のログ形式として JSON を選択した場合、Lambda は `console.trace`、`console.debug`、`console.log`、`console.info`、`console.error`、および `console.warn` のコンソールメソッドを使用してログ出力を構造化された JSON として CloudWatch に送信します。各 JSON ログオブジェクトには、以下のキーを含む少なくとも 4 つのキーと値のペアが含まれます。
+ `"timestamp"` - ログメッセージが生成された時刻
+ `"level"` - メッセージに割り当てられたログレベル
+ `"message"` - ログメッセージの内容
+ `"requestId"` - 関数呼び出しの一意のリクエスト ID

関数が使用するログ記録方法によっては、この JSON オブジェクトに追加のキーペアが含まれる場合もあります。例えば、関数が `console` メソッドを使用して複数の引数を使用しているエラーオブジェクトをログに記録する場合、JSON オブジェクトには、`errorMessage`、`errorType`、`stackTrace` というキーを含む追加のキーと値のペアが含まれます。

コードで既に Powertools for AWS Lambda などの別のログ記録ライブラリを使用して JSON 構造化ログを生成している場合は、変更を加える必要はありません。Lambda は既に JSON でエンコードされたログを二重にエンコードしないため、関数のアプリケーションログは以前と同様にキャプチャされます。

Powertools for AWS Lambda ログ記録パッケージを使用して Node.js ランタイムで JSON 構造化ログを作成する方法の詳細については、「[TypeScript Lambda 関数のログ記録とモニタリング](typescript-logging.md)」を参照してください。

#### JSON 形式のログ出力の例
<a name="nodejs-logging-examples"></a>

次の例は、関数のログ形式を JSON に設定したときに、単一および複数の引数を持つ `console` メソッドを使用して生成されたさまざまなログ出力が CloudWatch Logs にどのようにキャプチャされるかを示しています。

最初の例では、`console.error` メソッドを使用して単純な文字列を出力します。

**Example Node.js ログ記録コード**  

```
export const handler = async (event) => {
  console.error("This is a warning message");
  ...
}
```

**Example JSON ログレコード**  

```
{
    "timestamp":"2025-11-01T00:21:51.358Z",
    "level":"ERROR",
    "message":"This is a warning message",
    "requestId":"93f25699-2cbf-4976-8f94-336a0aa98c6f"
}
```

`console` メソッドでは、1 つまたは複数の引数を使用して、より複雑な構造化されたログメッセージを出力することもできます。次の例では、`console.log` を使用して、1 つの引数を使用して 2 つのキーと値のペアを出力します。Lambda が CloudWatch Logs に送信する JSON オブジェクトの `"message"` フィールドは、文字列化されていないことに注意してください。

**Example Node.js ログ記録コード**  

```
export const handler = async (event) => {
  console.log({data: 12.3, flag: false});
  ...
}
```

**Example JSON ログレコード**  

```
{
    "timestamp": "2025-12-08T23:21:04.664Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": {
        "data": 12.3,
        "flag": false
    }
}
```

次の例では、`console.log` メソッドを再度使用してログ出力を作成します。今回このメソッドは、2 つのキーと値のペアを含むマップと 1 つの識別文字列の 2 つの引数を取得します。この場合、2 つの引数を指定したため、Lambda は `"message"` フィールドを文字列化することに注意してください。

**Example Node.js ログ記録コード**  

```
export const handler = async (event) => {
  console.log('Some object - ', {data: 12.3, flag: false});
  ...
}
```

**Example JSON ログレコード**  

```
{
    "timestamp": "2025-12-08T23:21:04.664Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": "Some object -  { data: 12.3, flag: false }"
}
```

Lambda は、`console.log` を使用して生成された出力にログレベル INFO を割り当てます。

最後の例は、`console` メソッドを使用してエラーオブジェクトを CloudWatch Logs に出力する方法を示しています。複数の引数を使用してエラーオブジェクトをログに記録すると、Lambda はフィールド `errorMessage`、`errorType`、`stackTrace` をログ出力に追加することに注意してください。

**Example Node.js ログ記録コード**  

```
export const handler = async (event) => {
  let e1 = new ReferenceError("some reference error");
  let e2 = new SyntaxError("some syntax error");
  console.log(e1);
  console.log("errors logged - ", e1, e2);
};
```

**Example JSON ログレコード**  

```
{
    "timestamp": "2025-12-08T23:21:04.632Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": {
        "errorType": "ReferenceError",
        "errorMessage": "some reference error",
        "stackTrace": [
            "ReferenceError: some reference error",
            "    at Runtime.handler (file:///var/task/index.mjs:3:12)",
            "    at Runtime.handleOnceNonStreaming (file:///var/runtime/index.mjs:1173:29)"
        ]
    }
}

{
    "timestamp": "2025-12-08T23:21:04.646Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": "errors logged -  ReferenceError: some reference error\n    at Runtime.handler (file:///var/task/index.mjs:3:12)\n    at Runtime.handleOnceNonStreaming 
    (file:///var/runtime/index.mjs:1173:29) SyntaxError: some syntax error\n    at Runtime.handler (file:///var/task/index.mjs:4:12)\n    at Runtime.handleOnceNonStreaming 
    (file:///var/runtime/index.mjs:1173:29)",
    "errorType": "ReferenceError",
    "errorMessage": "some reference error",
    "stackTrace": [
        "ReferenceError: some reference error",
        "    at Runtime.handler (file:///var/task/index.mjs:3:12)",
        "    at Runtime.handleOnceNonStreaming (file:///var/runtime/index.mjs:1173:29)"
    ]
}
```

複数のエラータイプをログに記録する場合、追加のフィールド `errorMessage`、`errorType`、`stackTrace` は `console` メソッドに最初に渡されたエラータイプから抽出されます。

### 構造化された JSON ログでの埋め込みメトリクスフォーマット (EMF、Embedded Metric Format) クライアントライブラリの使用
<a name="nodejs-logging-advanced-emf"></a>

AWS では、[埋め込みメトリクスフォーマット](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Libraries.html) (EMF、Embedded Metric Format) ログの作成に使用できるオープンソースのクライアントライブラリを提供しています。これらのライブラリを使用する既存の関数があり、関数のログ形式を JSON に変更すると、CloudWatch はコードによって生成されたメトリクスを認識しなくなる可能性があります。

コードが現在、`console.log` または Powertools for AWS Lambda (TypeScript) を使用して EMF ログを直接出力している場合でも、関数のログ形式を JSON に変更すると、CloudWatch はこれらを解析できなくなります。

**重要**  
関数の EMF ログが引き続き CloudWatch によって適切に解析されるようにするには、[EMF](https://www.npmjs.com/package/aws-embedded-metrics) および [Powertools for AWS Lambda](https://github.com/aws-powertools/powertools-lambda-typescript) ライブラリを最新バージョンに更新してください。JSON ログ形式に切り替える場合は、関数に埋め込まれているメトリクスとの互換性を確認するためのテストを実施することもお勧めします。`console.log` を使用してコードが EMF ログを直接出力する場合は、以下のコード例のように、これらのメトリクスを `stdout` に直接出力するようにコードを変更してください。

**Example 埋め込みメトリクスを `stdout` に出力するコード**  

```
process.stdout.write(JSON.stringify(
    {
        "_aws": {
            "Timestamp": Date.now(),
            "CloudWatchMetrics": [{
                "Namespace": "lambda-function-metrics",
                "Dimensions": [["functionVersion"]],
                "Metrics": [{
                    "Name": "time",
                    "Unit": "Milliseconds",
                    "StorageResolution": 60
                }]
            }]
        },
        "functionVersion": "$LATEST",
        "time": 100,
        "requestId": context.awsRequestId
    }
) + "\n")
```

### Node.js でのログレベルフィルタリングの使用
<a name="nodejs-logging-advanced-level"></a>

AWS Lambda でログレベルに従ってアプリケーションログをフィルタリングするには、関数で JSON 形式のログを使用する必要があります。このためには以下の 2 つの方法があります。
+ 標準のコンソールメソッドを使用してログ出力を作成し、JSON ログ形式を使用するように関数を設定します。その後、AWS Lambda は「[Node.js での構造化 JSON ログの使用](#nodejs-logging-advanced-JSON)」で説明されている JSON オブジェクトの「level」キー値のペアを使用してログ出力をフィルタリングします。関数のログ形式を設定する方法については、「[Lambda 関数の高度なログ記録コントロールの設定](monitoring-logs.md#monitoring-cloudwatchlogs-advanced)」を参照してください。
+ 別のログ記録ライブラリまたはメソッドを使用して、ログ出力のレベルを定義する「level」キーと値のペアを含む JSON 構造化ログをコード内に作成する。例えば、Powertools for AWS Lambda を使用してコードから JSON 構造化されたログ出力を生成できます。Node.js ランタイムで Powertools を使用する方法の詳細については、「[TypeScript Lambda 関数のログ記録とモニタリング](typescript-logging.md)」を参照してください。

  Lambda で関数のログをフィルタリングするには、JSON ログ出力に `"timestamp"` のキーと値のペアも含める必要があります。時間は、有効な [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) タイムスタンプ形式で指定する必要があります。有効なタイムスタンプを指定しない場合、Lambda はログに INFO レベルを割り当ててタイムスタンプを追加します。

ログレベルのフィルタリングを使用するように関数を設定する場合、AWS Lambda が CloudWatch Logs に送信するログのレベルを以下のオプションから選択します。


| ログレベル | 標準的な使用状況 | 
| --- | --- | 
| TRACE (最も詳細) | コードの実行パスを追跡するために使用される最も詳細な情報 | 
| DEBUG | システムデバッグの詳細情報 | 
| 情報 | 関数の通常の動作を記録するメッセージ | 
| WARN | 対処しないと予期しない動作を引き起こす可能性がある潜在的なエラーに関するメッセージ | 
| エラー | コードが期待どおりに動作しなくなる問題に関するメッセージ | 
| FATAL (詳細度が最も低い) | アプリケーションの機能停止を引き起こす重大なエラーに関するメッセージ | 

Lambda は、選択したレベル以下のログを CloudWatch に送信します。例えば、ログレベルを WARN に設定すると、Lambda は WARN、ERROR、FATAL の各レベルに対応するログを送信します。

## Lambda コンソールでログを表示する
<a name="nodejs-logging-console"></a>

Lambda コンソールを使用して、Lambda 関数を呼び出した後のログ出力を表示できます。

組み込み **Code** エディタからコードがテスト可能である場合、**[実行結果]** でログを確認できます。コンソールのテスト機能を使用して関数を呼び出すと、**[詳細]** セクションで **[ログ出力]** を確認できます。

## CloudWatch コンソールでの ログの表示
<a name="nodejs-logging-cwconsole"></a>

Amazon CloudWatch コンソールを使用して、すべての Lambda 関数呼び出しのログを表示できます。

**CloudWatch コンソールでログを表示するには**

1. CloudWatch コンソールの [[Log groups (ロググループ)] ページ](https://console.aws.amazon.com/cloudwatch/home?#logs:)を開きます。

1. 機能のロググループを選択します( **/aws/lambda/*関数名***)

1. ログストリームを選択します

各ログストリームは、[関数のインスタンス](lambda-runtime-environment.md)に相当します。ログストリームは、Lambda 関数を更新したとき、および同時呼び出しを処理するために追加のインスタンスが作成されたときに表示されます。特定の呼び出しのログを検索するために、AWS X-Ray を使って関数をインストルメント化することをお勧めします。　 X-Ray は、リクエストとログストリームの詳細をトレースに記録します。

## AWS Command Line Interface (AWS CLI) を使用してログを表示する
<a name="nodejs-logging-cli"></a>

AWS CLI は、コマンドラインシェルでコマンドを使用して AWS サービスとやり取りするためのオープンソースツールです。このセクションの手順を完了するには、[AWS CLIバージョン 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) が必要です。

[AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) および `--log-type` コマンドオプションを使用して、呼び出しのログを取得します。レスポンスには、`LogResult`フィールドが含まれ、このフィールドには、呼び出しから base64 コードされた最大 4 KB のログが含まれます。

**Example ログ ID を取得します**  
次の例は、`LogResult`という名前の関数の`my-function`フィールドから*ログ ID * を取得する方法を示しています。  

```
aws lambda invoke --function-name my-function out --log-type Tail
```
次のような出力が表示されます。  

```
{
    "StatusCode": 200,
    "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
    "ExecutedVersion": "$LATEST"
}
```

**Example ログをデコードします**  
同じコマンドプロンプトで、`base64` ユーティリティを使用してログをデコードします。次の例は、`my-function`の base64 でエンコードされたログを取得する方法を示しています 。  

```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
AWS CLI バージョン 2 を使用している場合、**cli-binary-format** オプションは必須です。これをデフォルト設定にするには、`aws configure set cli-binary-format raw-in-base64-out` を実行します。詳細については、「*AWS Command Line Interface バージョン 2 用ユーザーガイド*」の「[AWS CLI でサポートされているグローバルコマンドラインオプション](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list)」を参照してください。  
以下の出力が表示されます。  

```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8  Duration: 79.67 ms      Billed Duration: 80 ms         Memory Size: 128 MB     Max Memory Used: 73 MB
```
`base64`このユーティリティは、Linux、macOS、および [ Windows の Ubuntu ](https://docs.microsoft.com/en-us/windows/wsl/install-win10) で使用できます。macOS ユーザーは、`base64 -D`を使用する必要があります 。

**Example get-logs.sh スクリプト**  
同じコマンドプロンプトで、次のスクリプトを使用して、最後の 5 つのログイベントをダウンロードします。このスクリプトは `sed` を使用して出力ファイルから引用符を削除し、ログが使用可能になるまで 15 秒待機します。この出力には Lambda からのレスポンスと、`get-log-events` コマンドからの出力が含まれます。  
次のコードサンプルの内容をコピーし、Lambda プロジェクトディレクトリに `get-logs.sh` として保存します。  
AWS CLI バージョン 2 を使用している場合、**cli-binary-format** オプションは必須です。これをデフォルト設定にするには、`aws configure set cli-binary-format raw-in-base64-out` を実行します。詳細については、「*AWS Command Line Interface バージョン 2 用ユーザーガイド*」の「[AWS CLI でサポートされているグローバルコマンドラインオプション](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list)」を参照してください。  

```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```

**Example macOS および Linux (専用)**  
同じコマンドプロンプトで、macOS と Linux ユーザーが次のコマンドを実行して、スクリプトが実行可能であることを確認する必要があります。  

```
chmod -R 755 get-logs.sh
```

**Example 最後の 5 つのログイベントを取得します**  
同じコマンドプロンプトで、次のスクリプトを実行して、最後の 5 つのログイベントを取得します。  

```
./get-logs.sh
```
次のような出力が表示されます。  

```
{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
{
    "events": [
        {
            "timestamp": 1559763003171,
            "message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
            "ingestionTime": 1559763003309
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r  \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r  \"key\": \"value\"\r}\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
            "ingestionTime": 1559763018353
        }
    ],
    "nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
    "nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```

## ログの削除
<a name="nodejs-logging-delete"></a>

関数を削除しても、ロググループは自動的には削除されません。ログが無期限に保存されないようにするには、ロググループを削除するか、ログが自動的に削除されるまでの[保存期間を設定](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention)します。

# AWS Lambda での Node.js コードの作成
<a name="nodejs-tracing"></a>

Lambda アプリケーションのトレース、デバッグ、最適化を行うために、Lambda は AWS X-Ray と統合されています。X-Ray を使用すると、Lambda 関数や他の AWS のサービスが含まれるアプリケーション内で、リソースを横断するリクエストをトレースできます。

トレースされたデータを X-Ray に送信するには、以下の 2 つの SDK ライブラリのいずれかを使用します。
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel) – 安全で、本番環境に対応し、AWS でサポートされている OpenTelemetry (OTel) SDK のディストリビューションです。
+ [AWS X-Ray SDK for Node.js](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-nodejs.html) - トレースデータを生成して X-Ray に送信するための SDK です。

各 SDK は、テレメトリデータを X-Ray サービスに送信する方法を提供します。続いて、X-Ray を使用してアプリケーションのパフォーマンスメトリクスの表示やフィルタリングを行い、インサイトを取得することで、問題点や最適化の機会を特定できます。

**重要**  
X-Ray および Powertools for AWS Lambda SDK は、AWS が提供する、密接に統合された計測ソリューションの一部です。ADOT Lambda レイヤーは、一般的により多くのデータを収集するトレーシング計測の業界標準の一部ですが、すべてのユースケースに適しているわけではありません。これらのソリューションのいずれかを使用して、X-Ray でエンドツーエンドのトレーシングを実装することができます。選択方法の詳細については、「[Choosing between the AWS Distro for Open Telemetry and X-Ray SDKs](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing)」( Distro for Open Telemetry または X-Ray SDK の選択) を参照してください。

**Topics**
+ [

## Node.js 関数の計測での ADOT の使用
](#nodejs-adot)
+ [

## X-Ray SDK を使用した Node.js 関数の計測
](#nodejs-xray-sdk)
+ [

## Lambda コンソールを使用してトレースを有効化する
](#nodejs-tracing-console)
+ [

## Lambda API でのトレースのアクティブ化
](#nodejs-tracing-api)
+ [

## CloudFormation によるトレースのアクティブ化
](#nodejs-tracing-cloudformation)
+ [

## X-Ray トレースの解釈
](#nodejs-tracing-interpretation)
+ [

## ランタイムの依存関係をレイヤー (X-Ray SDK) に保存する
](#nodejs-tracing-layers)

## Node.js 関数の計測での ADOT の使用
<a name="nodejs-adot"></a>

ADOT はフルマネージド型の Lambda [レイヤー](chapter-layers.md)を提供します。これにより、OTel SDK を使用してテレメトリデータを収集するために必要なすべてがパッケージ化されます。このレイヤーを使用すると、関数コードを変更する必要はなしで、Lambda 関数を計測できます。また、このレイヤーは、OTel でのカスタムな初期化を実行するように構成することもできます。詳細については、ADOT のドキュメントにある「[Lambda 上での ADOT Collector のカスタム設定](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda)」を参照してください。

Node.js ランタイムの場合は、**ADOT Javascript 向け AWS マネージド Lambda レイヤー** を追加して、関数を自動的に計測できます。このレイヤーを追加する方法の詳しい手順については、「ADOT ドキュメント」で「[JavaScript に対する AWS Distro for OpenTelemetry Lambda のサポート](https://aws-otel.github.io/docs/getting-started/lambda/lambda-js)」を参照してください。

## X-Ray SDK を使用した Node.js 関数の計測
<a name="nodejs-xray-sdk"></a>

Lambda 関数がアプリケーション内の他のリソースに対して行う呼び出しの詳細を記録するために、AWS X-Ray SDK for Node.js を使用することもできます。SDK を取得するには、アプリケーションの依存関係に `aws-xray-sdk-core` パッケージを追加します。

**Example [blank-nodejs/package.json](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/package.json)**  

```
{
  "name": "blank-nodejs",
  "version": "1.0.0",
  "private": true,
  "devDependencies": {
    "jest": "29.7.0"
  },
  "dependencies": {
    "@aws-sdk/client-lambda": "3.345.0",
    "aws-xray-sdk-core": "3.5.3"
  },
  "scripts": {
    "test": "jest"
  }
}
```

AWS SDK クライアントを [AWS SDK for JavaScript v3](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/welcome.html) で計測するには、`captureAWSv3Client` メソッドでクライアントインスタンスをラップします。

**Example [blank-nodejs/function/index.js](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/function/index.js) - AWS SDK クライアントのトレース**  

```
const AWSXRay = require('aws-xray-sdk-core');
const { LambdaClient, GetAccountSettingsCommand } = require('@aws-sdk/client-lambda');

// Create client outside of handler to reuse
const lambda = AWSXRay.captureAWSv3Client(new LambdaClient());

// Handler
exports.handler = async function(event, context) {
    event.Records.forEach(record => {
  ...
```

Lambda ランタイムは、 X-Ray SDK を設定するための環境変数をいくつか設定します。例えば、Lambda は、X-Ray SDK からランタイムエラーがスローされないように、`LOG_ERROR` に `AWS_XRAY_CONTEXT_MISSING` をセットします。カスタムのコンテキストミッシング戦略を設定するには、関数設定の環境変数をオーバーライドして値を持たせないようにします。その後、コンテキストミッシング戦略をプログラムで設定できます。

**Example 初期化コードの例**  

```
const AWSXRay = require('aws-xray-sdk-core');

// Configure the context missing strategy to do nothing
AWSXRay.setContextMissingStrategy(() => {});
```

詳細については、「[Lambda 環境変数の操作](configuration-envvars.md)」を参照してください。

正しい依存関係を追加し、必要なコード変更を行った後で、Lambda コンソールまたはAPIを介して、関数の設定でトレースをアクティブにします。

## Lambda コンソールを使用してトレースを有効化する
<a name="nodejs-tracing-console"></a>

コンソールを使用して、Lambda 関数のアクティブトレースをオンにするには、次のステップに従います。

**アクティブトレースをオンにするには**

1. Lambda コンソールの [[関数ページ]](https://console.aws.amazon.com/lambda/home#/functions) を開きます。

1. 関数を選択します。

1. **[設定]** を選択してから、**[モニタリングおよび運用ツール]** を選択します。

1. **[その他の監視ツール]** で、**[編集]** を選択します。

1. **[CloudWatch Application Signals と AWS X-Ray]** で、**[Lambda サービストレース]** の **[有効]** を選択します。

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

## Lambda API でのトレースのアクティブ化
<a name="nodejs-tracing-api"></a>

AWS CLI または AWS SDK で Lambda 関数のトレースを設定するには、次の 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 CLI コマンドは、**my-function** という名前の関数に対するアクティブトレースを有効にします。

```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```

トレースモードは、関数のバージョンを公開するときのバージョン固有の設定の一部です。公開後のバージョンのトレースモードを変更することはできません。

## CloudFormation によるトレースのアクティブ化
<a name="nodejs-tracing-cloudformation"></a>

CloudFormation テンプレート内で `AWS::Lambda::Function` リソースに対するアクティブトレースを有効化するには、`TracingConfig` プロパティを使用します。

**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) － トレース設定**  

```
Resources:
  function:
    Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
    Properties:
      TracingConfig:
        Mode: Active
      ...
```

AWS Serverless Application Model (AWS SAM) `AWS::Serverless::Function` リソースに、`Tracing` プロパティを使用します。

**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) － トレース設定**  

```
Resources:
  function:
    Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
    Properties:
      Tracing: Active
      ...
```

## X-Ray トレースの解釈
<a name="nodejs-tracing-interpretation"></a>

関数には、トレースデータを X-Ray にアップロードするためのアクセス許可が必要です。Lambda コンソールでトレースを有効にすると、Lambda は必要な権限を関数の [[実行ロール]](lambda-intro-execution-role.md) に追加します。それ以外の場合は、[AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess) ポリシーを実行ロールに追加します。

アクティブトレースの設定後は、アプリケーションを通じて特定のリクエストの観測が行えるようになります。[[X-Ray サービスグラフ]](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) には、アプリケーションとそのすべてのコンポーネントに関する情報が表示されます。次の例は、2 つの関数を持つアプリケーションを示しています。プライマリ関数はイベントを処理し、エラーを返す場合があります。上位 2 番目の関数は、最初のロググループに表示されるエラーを処理し、AWS SDK を使用して X-Ray、Amazon Simple Storage Service (Amazon S3)、および Amazon CloudWatch Logs を呼び出します。

![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)


X-Ray は、アプリケーションへのすべてのリクエストをトレースするわけではありません。X-Ray は、サンプリングアルゴリズムを適用することで効率的なトレースを行うと同時に、すべてのリクエストについての代表的なサンプルを示します。サンプルレートは 1 秒あたり 1 回のリクエストで、追加リクエストの 5％ です。関数の X-Ray サンプルレートを設定することはできません。

X-Ray では、*トレース*は 1 つ以上の*サービス*によって処理されるリクエストに関する情報を記録します。Lambda はトレースごとに 2 つのセグメントを記録します。これにより、サービスグラフに 2 つのノードが作成されます。次の図は、これら 2 つのノードを強調表示しています。

![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/xray-servicemap-function.png)


左に示された 1 つめのノードは、呼び出しリクエストを受信する Lambda サービスを表しています。2 つめのノードは、特定の Lambda 関数を表しています。次の例は、これら 2 つのセグメントを使用したトレースを示しています。いずれも **my-function** と名付けられていますが、1 つは `AWS::Lambda` の起点があり、もう 1 つは `AWS::Lambda::Function` の起点があります。`AWS::Lambda` セグメントにエラーが表示される場合は、Lambda サービスに問題があります。`AWS::Lambda::Function` セグメントにエラーが表示される場合、関数に問題があります。

![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)


この例では、`AWS::Lambda::Function` セグメントを展開して、それの 3 つのサブセグメントが表示されています。

**注記**  
AWS は現在、Lambda サービスに変更を実装しています。これらの変更により、AWS アカウント のさまざまな Lambda 関数によって出力されるシステムログメッセージとトレースセグメントの構造と内容にわずかな違いが生じる場合があります。  
ここで示すトレースの例は、古いスタイルの関数セグメントを示しています。古いスタイルのセグメントと新しいスタイルのセグメントの違いについては、次の段落で説明します。  
これらの変更は今後数週間に実装され、中国および GovCloud リージョンを除くすべての AWS リージョンのすべての関数は、新しい形式のログメッセージとトレースセグメントを使用するように移行されます。

古いスタイルの関数セグメントには、次のサブセグメントが含まれます。
+ **初期化** － 関数のロードと[初期化コード](foundation-progmodel.md)の実行に要した時間を表します。このサブセグメントは、関数の各インスタンスが処理する最初のイベントに対してのみ表示されます。
+ **[呼び出し]** - ハンドラーコードの実行に要した時間を表します。
+ **[オーバーヘッド]** - Lambda ランタイムが次のイベントを処理するための準備に要する時間を表します。

新しいスタイルの関数セグメントには `Invocation` サブセグメントが含まれていません。代わりに、顧客サブセグメントが関数セグメントに直接アタッチされます。古いスタイルの関数セグメントと新しいスタイルの関数セグメントの構造の詳細については、「」を参照してください[X-Ray トレースを理解する](services-xray.md#services-xray-traces)。

HTTP クライアントをインストルメント化し、SQL クエリを記録して、注釈とメタデータからカスタムサブセグメントを作成することもできます。詳細については、「AWS X-Ray デベロッパーガイド」の「[AWS X-Ray SDK for Node.js](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-nodejs.html)」を参照してください。

**料金**  
X-Ray トレースは、毎月、AWS 無料利用枠で設定された一定限度まで無料で利用できます。X-Ray の利用がこの上限を超えた場合は、トレースによる保存と取得に対する料金が発生します。詳細については、「[AWS X-Ray 料金表](https://aws.amazon.com/xray/pricing/)」を参照してください。

## ランタイムの依存関係をレイヤー (X-Ray SDK) に保存する
<a name="nodejs-tracing-layers"></a>

X-Ray SDK を使用して AWS SDK クライアントを関数コードに埋め込むと、デプロイパッケージが巨大になる可能性があります。関数コードを更新するたびにランタイムの依存関係がアップロードされないようにするには、X-Ray SDK を「[Lambda レイヤー](chapter-layers.md)」にパッケージ化します。

次に、AWS X-Ray SDK for Node.js を保存している `AWS::Serverless::LayerVersion` リソースの例を示します。

**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) － 依存関係レイヤー**  

```
Resources:
  function:
    Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
    Properties:
      CodeUri: function/.
      Tracing: Active
      Layers:
        - !Ref libs
      ...
  libs:
    Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
    Properties:
      LayerName: blank-nodejs-lib
      Description: Dependencies for the blank sample app.
      ContentUri: lib/.
      CompatibleRuntimes:
        - nodejs24.x
```

この設定では、ランタイム依存関係を変更した場合にのみ、ライブラリレイヤーの更新が必要です。関数のデプロイパッケージにはユーザーのコードのみが含まれるため、アップロード時間を短縮できます。

依存関係のレイヤーを作成するには、デプロイ前にレイヤーアーカイブを生成するようにビルドを変更する必要があります。実際の例については、[blank-nodejs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs) サンプルアプリケーションを参照してください。