"` |
| `requestContext.http` | HTTP リクエストの詳細を含むオブジェクト。 | |
| `requestContext.http.method` | リクエストで使用されている HTTP メソッド。有効な値には、`GET`、`POST`、`PUT`、`HEAD`、`OPTIONS`、`PATCH` および `DELETE` があります。 | `GET` |
| `requestContext.http.path` | リクエストパス。例えば、リクエスト URL が `https://{url-id}.lambda-url.{region}.on.aws/example/test/demo` であれば、パス値は `/example/test/demo` となります。 | `/example/test/demo` |
| `requestContext.http.protocol` | リクエストのプロトコル。 | `HTTP/1.1` |
| `requestContext.http.sourceIp` | リクエストを発行した即時 TCP 接続のソース IP アドレス。 | `123.123.123.123` |
| `requestContext.http.userAgent` | User-Agent リクエストヘッダー値。 | `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Gecko/20100101 Firefox/42.0` |
| `requestContext.requestId` | 呼び出しリクエストの ID。この ID は、関数に関連する呼び出しログをトレースするために使用できます。 | `e1506fd5-9e7b-434f-bd42-4f8fa224b599` |
| `requestContext.routeKey` | 関数 URL ではこのパラメーターを使用しません。Lambda は、プレースホルダーとしてこの値に `$default` を設定します。 | `$default` |
| `requestContext.stage` | 関数 URL ではこのパラメーターを使用しません。Lambda は、プレースホルダーとしてこの値に `$default` を設定します。 | `$default` |
| `requestContext.time` | リクエストのタイムスタンプです。 | `"07/Sep/2021:22:50:22 +0000"` |
| `requestContext.timeEpoch` | リクエストのタイムスタンプ (Unix エポック秒)。 | `"1631055022677"` |
| `body` | リクエスト本文。リクエストのコンテンツタイプがバイナリの場合、本文は base64 でエンコードされます。 | `{"key1": "value1", "key2": "value2"}` |
| `pathParameters` | 関数 URL ではこのパラメーターを使用しません。Lambda は、この値に `null` を設定するか、JSON からこれを除外します。 | `null` |
| `isBase64Encoded` | ボディがバイナリペイロードで base64 でエンコードされている場合は `TRUE`、それ以外の場合は `FALSE` です。 | `FALSE` |
| `stageVariables` | 関数 URL ではこのパラメーターを使用しません。Lambda は、この値に `null` を設定するか、JSON からこれを除外します。 | `null` |
### レスポンスペイロードの形式
関数からレスポンスが返されると、Lambda はそのレスポンスを解析し HTTP の形式に変換します。関数レスポンスペイロードの形式は以下のとおりです。
```
{
"statusCode": 201,
"headers": {
"Content-Type": "application/json",
"My-Custom-Header": "Custom Value"
},
"body": "{ \"message\": \"Hello, world!\" }",
"cookies": [
"Cookie_1=Value1; Expires=21 Oct 2021 07:48 GMT",
"Cookie_2=Value2; Max-Age=78000"
],
"isBase64Encoded": false
}
```
Lambda は自動的にレスポンス形式を推定します。関数が有効な JSON を返し、かつ `statusCode` を返さない場合、Lambda は以下のような想定を立てます。
+ `statusCode`is(`200` )
**注記**
有効な `statusCode` は 100～599 の範囲内です。
+ `content-type`is(`application/json` )
+ `body` は関数のレスポンス。
+ `isBase64Encoded`is(`false` )
次の例は、Lambda 関数の出力がレスポンスペイロードにどのようにマッピングされるか、また、レスポンスペイロードが最終的な HTTP レスポンスにどのようにマッピングされるかを示しています。関数の URL を呼び出したクライアントには、HTTP 応答が表示されます。
**文字列によるレスポンスの出力例**
| Lambda 関数出力 | インタプリティングされたレスポンス出力 | HTTP レスポンス (クライアントに表示されるもの) |
| --- | --- | --- |
| "Hello, world!"
| {
"statusCode": 200,
"body": "Hello, world!",
"headers": {
"content-type": "application/json"
},
"isBase64Encoded": false
} | HTTP/2 200
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 15
"Hello, world!"
|
**JSON によるレスポンスの出力例**
| Lambda 関数出力 | インタプリティングされたレスポンス出力 | HTTP レスポンス (クライアントに表示されるもの) |
| --- | --- | --- |
| {
"message": "Hello, world!"
} | {
"statusCode": 200,
"body": {
"message": "Hello, world!"
},
"headers": {
"content-type": "application/json"
},
"isBase64Encoded": false
} | HTTP/2 200
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 34
{
"message": "Hello, world!"
}
|
**カスタムレスポンスの出力例**
| Lambda 関数出力 | インタプリティングされたレスポンス出力 | HTTP レスポンス (クライアントに表示されるもの) |
| --- | --- | --- |
| {
"statusCode": 201,
"headers": {
"Content-Type": "application/json",
"My-Custom-Header": "Custom Value"
},
"body": JSON.stringify({
"message": "Hello, world!"
}),
"isBase64Encoded": false
} | {
"statusCode": 201,
"headers": {
"Content-Type": "application/json",
"My-Custom-Header": "Custom Value"
},
"body": JSON.stringify({
"message": "Hello, world!"
}),
"isBase64Encoded": false
} | HTTP/2 201
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 27
my-custom-header: Custom Value
{
"message": "Hello, world!"
}
|
### Cookie
関数から Cookie を返す場合、手動で `set-cookie` ヘッダーを追加しないでください。代わりに、レスポンスペイロードオブジェクトに Cookie を含めます。Lambda はこれを自動的に解釈し、次の例のように HTTP レスポンスの `set-cookie` ヘッダーとして追加します。
| Lambda 関数出力 | HTTP レスポンス (クライアントに表示されるもの) |
| --- | --- |
| {
"statusCode": 201,
"headers": {
"Content-Type": "application/json",
"My-Custom-Header": "Custom Value"
},
"body": JSON.stringify({
"message": "Hello, world!"
}),
"cookies": [
"Cookie_1=Value1; Expires=21 Oct 2021 07:48 GMT",
"Cookie_2=Value2; Max-Age=78000"
],
"isBase64Encoded": false
} | HTTP/2 201
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 27
my-custom-header: Custom Value
set-cookie: Cookie_1=Value2; Expires=21 Oct 2021 07:48 GMT
set-cookie: Cookie_2=Value2; Max-Age=78000
{
"message": "Hello, world!"
}
|
# Lambda 関数 URL のモニタリング
関数 URL のモニタリングには、AWS CloudTrail および Amazon CloudWatch が使用できます。
**Topics**
+ [CloudTrail による関数 URL のモニタリング](#urls-cloudtrail)
+ [関数 URL 用の CloudWatch メトリクス](#urls-cloudwatch)
## CloudTrail による関数 URL のモニタリング
Lambda は、以下の関数 URL 用 API オペレーションのログを、CloudTrail ログファイル内のイベントとして自動的に記録します。
+ [CreateFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunctionUrlConfig.html)
+ [UpdateFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionUrlConfig.html)
+ [DeleteFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteFunctionUrlConfig.html)
+ [GetFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionUrlConfig.html)
+ [ListFunctionUrlConfigs](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctionUrlConfigs.html)
各ログエントリには、発信者 ID、リクエストが発行された日時、およびその他の詳細に関する情報が含まれます。CloudTrail で **[Event history]** (イベント履歴) を表示することで、過去 90 日以内のすべてのイベントを確認できます。90 日より前のレコードを保持するには、追跡を作成します。
CloudTrail のデフォルトでは、データイベントと見なされる `InvokeFunctionUrl` リクエストのログ記録は行われません。ただし、CloudTrail でデータイベントのログ記録を有効化することは可能です 詳細については、**「AWS CloudTrail ユーザーガイド」の「[証跡のデータイベントの記録](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html)」を参照してください。
## 関数 URL 用の CloudWatch メトリクス
Lambda は、関数 URL リクエストに関して集計されたメトリクスを、CloudWatch に送信します。CloudWatch コンソールでは、これらのメトリクスを使用して、関数 URL のモニタリング、ダッシュボードの作成、アラームの設定を行うことができます。
関数 URL では、呼び出しに関する以下のメトリクスをサポートしています。これらのメトリクスの表示には、`Sum` 統計を使用することをお勧めします。
+ `UrlRequestCount` – この関数 URL に対し発行されたリクエストの数。
+ `Url4xxCount` – 4xx HTTP ステータスコードを返したリクエストの数。4xx シリーズのコードは、不正なリクエストなど、クライアント側で発生したエラーを表します。
+ `Url5xxCount` – 5xx HTTP ステータスコードを返したリクエストの数。5xx シリーズのコードは、機能エラーやタイムアウトなど、サーバー側で発生したエラーを表します。
関数 URL では、パフォーマンスに関する以下のメトリクスもサポートしています。このメトリクスの表示には、`Average` または `Max` 統計を使用することをお勧めします。
+ `UrlRequestLatency` – 関数 URL がリクエストを受信してから関数 URL がレスポンスを返すまでの時間。
呼び出しとパフォーマンスに関するこれらのメトリクスは、それぞれ以下のディメンションをサポートしています。
+ `FunctionName` – 未公開な関数の `$LATEST` バージョン (あるいは関数の任意のエイリアス) に割り当てられている、関数 URL の集計メトリクスを表示します。例えば、`hello-world-function` と指定します。
+ `Resource` – 特定の関数 URL のメトリクスを表示します。この値は、未公開な関数の `$LATEST` バージョン (または関数のいずれかエイリアス) とならんで、関数の名前により定義されます 例えば、`hello-world-function:$LATEST` と指定します。
+ `ExecutedVersion` – 特定の関数 URL のメトリクスを、実行されたバージョンに基づいて表示します。このディメンションは、主に、未公開な `$LATEST` バージョンに割り当てられた関数 URL を追跡するために使用します。
# HTTP リクエストを使用して Lambda 関数を呼び出す方法を選択する
Lambda の一般的なユースケースの多くでは、HTTP リクエストを使用した関数の呼び出しを行います。例えば、ウェブアプリケーションがブラウザリクエストを通じて関数を呼び出すようにしたい場合があります。Lambda 関数を使用して、完全な REST API の作成、モバイルアプリからのユーザーインタラクションの処理、HTTP コールによる外部サービスからのデータの処理、カスタムウェブフックの作成を行うこともできます。
以下のセクションでは、HTTP によって Lambda を呼び出す際の選択について説明し、特定のユースケースに適した意思決定に役立つ情報を提供します。
## HTTP 呼び出し方法を選択する場合、どのような選択肢がありますか
Lambda には、HTTP リクエストを使用して関数を呼び出す方法として、主に[関数 URL](urls-configuration.md) と [API Gateway](services-apigateway.md) の 2 つがあります。両者の主な違いは以下のとおりです。
+ **Lambda 関数 URL** は、Lambda 関数のシンプルで直接的な HTTP エンドポイントを提供します。シンプルさとコスト効率のために最適化されており、HTTP 経由で Lambda 関数を公開するための最速のパスを提供します。
+ **API Gateway** は、豊富な機能を備えた API をビルドするためのより高度なサービスです。API Gateway は、本番環境 API を大規模にビルドおよび管理することに最適化されており、セキュリティ、モニタリング、トラフィック管理の包括的なツールを提供します。
## 要件が既にわかっている場合の推奨事項
要件が既に明確な場合は、基本的な推奨事項を以下に示します。
基本認証方式とリクエスト/レスポンス処理のみが必要で、コストと複雑さを最小限に抑えたいシンプルなアプリケーションやプロトタイプには、**[関数 URL](urls-configuration.md)** をお勧めします。
**[API Gateway](services-apigateway.md)** は、大規模な本稼働用アプリケーションや、[OpenAPI Description](https://www.openapis.org/) サポート、認証オプションの選択、カスタムドメイン名、またはスロットリング、キャッシュ、リクエスト/レスポンス変換を含む豊富なリクエスト/レスポンス処理など、より高度な機能が必要な場合に適しています。
## Lambda 関数を呼び出す方法を選択する際の考慮事項
関数 URL と API Gateway から選択する場合、次の要素を考慮する必要があります。
+ ユーザーの認証に OAuth または Amazon Cognito が必要かどうかなど、認証のニーズ
+ スケーリング要件と実装する API の複雑さ
+ リクエストの検証やリクエスト/レスポンスのフォーマットなどの高度な機能が必要かどうか
+ モニタリング要件
+ コスト目標
これらの要素を理解することで、セキュリティ、複雑さ、コスト要件のバランスを取るのに最適なオプションを選択できます。
次の情報は、2 つのオプションの主な違いをまとめたものです。
### 認証
+ **関数 URL** は AWS Identity and Access Management (IAM) を通じて基本的な認証オプションを提供します。エンドポイントは、パブリック (認証なし) にするか、IAM 認証を要求するように設定できます。IAM 認証では、標準の AWS 認証情報または IAM ロールを使用してアクセスを制御できます。設定は簡単ですが、このアプローチでは、他の認証方式に比べてオプションが限られています。
+ **API Gateway** では、より包括的な認証オプションが使用できます。IAM 認証に加えて、[Lambda オーソライザー](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) (カスタム認証ロジック)、[Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) ユーザープール、および OAuth2.0 フローを使用できます。この柔軟性により、サードパーティー認証プロバイダー、トークンベースの認証、多要素認証などの複雑な認証スキームを実装できます。
### リクエスト/レスポンス処理
+ **関数 URL** は、基本的な HTTP リクエストとレスポンスの処理を提供します。標準 HTTP メソッドがサポートされており、組み込みの Cross-Origin Resource Sharing (CORS) サポートが含まれています。JSON ペイロードとクエリパラメータは処理できますが、リクエスト変換や検証機能は提供されません。レスポンス処理も同様にシンプルです。クライアントは Lambda が返すのとまったく同じように、Lambda 関数からレスポンスを受け取ります。
+ **API Gateway** では、高度なリクエストおよびレスポンス処理機能が提供されます。リクエスト検証機能の定義、マッピングテンプレートを使用したリクエストとレスポンスの変換、リクエスト/レスポンスヘッダーの設定、およびレスポンスキャッシュの実装ができます。API Gateway はバイナリペイロードとカスタムドメイン名もサポートしており、クライアントに到達する前にレスポンスを変更できます。JSON スキーマを使用して、リクエスト/レスポンスの検証と変換のモデルを設定できます。
### スケーリング
+ **関数 URL** は、Lambda 関数の同時実行数の制限に合わせて直接スケーリングし、設定された同時実行数の上限まで関数をスケールアップすることでトラフィックの急増を処理します。この制限に達すると、Lambda は HTTP 429 レスポンスで追加のリクエストに応答します。組み込みのキューイングメカニズムがないため、スケーリングの処理は Lambda 関数の設定に完全に依存します。デフォルトでは、Lambda 関数の同時実行数は AWS リージョンあたり 1,000 に制限されています。
+ **API Gateway** には、Lambda 独自のスケーリングに加えて追加のスケーリング機能があります。リクエストキューイングとスロットリング制御が組み込まれているため、トラフィックの急増をより適切に管理できます。API Gateway は、デフォルトでリージョンごとに 1 秒あたり最大 10,000 件のリクエストを処理できます。バーストキャパシティは 1 秒あたり 5,000 件のリクエストです。また、バックエンドを保護するために、さまざまなレベル (API、ステージ、またはメソッド) でリクエストを調整するツールも提供します。
### モニタリング
+ **関数 URL** は、リクエスト数、レイテンシー、エラー率など、Amazon CloudWatch メトリクスによる基本的なモニタリングを提供します。標準の Lambda メトリクスとログにアクセスでき、関数に送信される未加工のリクエストが表示されます。これにより運用上の重要な可視性が得られますが、メトリクスは主に関数の実行に関するものになります。
+ **API Gateway** では、詳細なメトリクス、ログ記録、トレースオプションなど、包括的なモニタリング機能が提供されます。CloudWatch を使用して、API コール、レイテンシー、エラー率、キャッシュヒット/ミス率をモニタリングできます。また、API Gateway は AWS X-Ray と統合して分散型トレースを行い、ログ形式のカスタマイズが可能です。
### Cost
+ **関数 URL** は、標準の Lambda 料金モデルに従います。関数の呼び出しと計算時間についてのみ料金が発生します。URL エンドポイント自体には追加料金はかかりません。これにより、API Gateway の追加機能が必要ない場合は、シンプルな API またはトラフィックの少ないアプリケーションに対して費用対効果の高い選択肢になります。
+ **API Gateway** には、REST API で受信される 100 万回の API コールと、HTTP API で受信される 100 万回の API コールを含む[無料利用枠](https://aws.amazon.com/api-gateway/pricing/#Free_Tier)が用意されています。無料利用枠を超えると、API Gateway では API コール、データ転送、キャッシュ (有効になっている場合) に対して料金が発生します。独自のユースケースのコストについては、API Gateway の[料金ページ](https://aws.amazon.com/api-gateway/pricing/)を参照してください。
### その他の機能
+ **関数 URL** は、簡単に利用でき、Lambda と直接統合できるように設計されています。HTTP エンドポイントと HTTPS エンドポイントの両方をサポートし、組み込みの CORS サポートとデュアルスタック (IPv4 および IPv6) エンドポイントを提供します。高度な機能はありませんが、HTTP 経由で Lambda 関数を公開する迅速かつシンプルな方法が必要なシナリオに適しています。
+ **API Gateway** には、API バージョニング、ステージ管理、使用量プランの API キー、Swagger/OpenAPI による API ドキュメント、WebSocket API、VPC 内のプライベート API、セキュリティを強化するための WAF 統合など、さまざまな追加機能が含まれています。また、カナリアデプロイ、テスト用のモック統合、Lambda 以外の他の AWS のサービスとの統合もサポートされています。
## Lambda 関数を呼び出す方法を選択する
Lambda 関数 URL と API Gateway の選択基準とその主な違いについて確認した後は、ニーズに最適なオプションを選択し、以下のリソースを使用して利用を開始できます。
------
#### [ Function URLs ]
**以下のリソースを使用して関数 URL の使用を開始する**
+ 「[チュートリアル: 関数 URL を使用する Lambda 関数の作成](urls-webhook-tutorial.md)」に従います。
+ 関数 URL の詳細については、このガイドの「[Lambda 関数 URL の作成と管理](urls-configuration.md)」の章を参照してください。
+ 次の操作を実行して、コンソール内ガイド付きチュートリアル「**シンプルなウェブアプリケーションを作成**」を試します。
1. Lambda コンソールの[関数ページ](https://console.aws.amazon.com/lambda/home#/functions)を開きます。
1. 画面の右上にあるアイコンを選択して、ヘルプパネルを開きます。
![\[\]](http://docs.aws.amazon.com/ja_jp/lambda/latest/dg/images/console_help_screenshot.png)
1. **[チュートリアル]** を選択します。
1. **[シンプルなウェブアプリケーションを作成]** で、**[チュートリアルを開始]** を選択します。
------
#### [ API Gateway ]
**以下のリソースを使用して Lambda と API Gateway の使用を開始する**
+ 「[チュートリアル: API Gateway で Lambda を使用する](services-apigateway-tutorial.md)」に従って、バックエンド Lambda 関数と統合した REST API を作成します。
+ API Gateway が提供するさまざまな種類の API の詳細については、「*Amazon API Gateway デベロッパーガイド*」の以下のセクションを参照してください。
+ [API Gateway REST API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html)
+ [API Gateway HTTP API](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html)
+ [API Gateway WebSocket API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html)
+ 「*Amazon API Gateway デベロッパーガイド*」の「[Amazon API Gateway のチュートリアルとワークショップ](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-tutorials.html)」セクションで 1 つまたは複数の例を試してください。
------
# チュートリアル: Lambda 関数 URL を使用したウェブフックエンドポイントの作成
このチュートリアルでは、ウェブフックエンドポイントを実装するための Lambda 関数 URL を作成します。ウェブフックは、HTTP を使用してアプリケーション間でデータを自動的に送信する、軽量のイベント駆動型通信です。ウェブフックを使用すると、新しい顧客がウェブサイトにサインアップしたとき、支払いが処理されたとき、ファイルのアップロードされたときなど、別のシステムで発生したイベントに関する最新情報をすぐに受け取ることができます。
Lambda では、Lambda 関数 URL または API Gateway を使用してウェブフックを実装できます。関数 URL は、高度な認可やリクエストの検証などの機能を必要としないシンプルなウェブフックに適しています。
**ヒント**
ユースケースに最適なソリューションがわからない場合、「[HTTP リクエストを使用して Lambda 関数を呼び出す方法を選択する](furls-http-invoke-decision.md)」を参照してください。
## 前提条件
このチュートリアルを完了するには、ローカルマシンに Python (バージョン 3.8 以降) または Node.js (バージョン 18 以降) がインストールされている必要があります。
HTTP リクエストを使用してエンドポイントをテストするために、チュートリアルでは [curl](https://curl.se/) を使用します。curl は、さまざまなネットワークプロトコルを使用してデータを転送するために使用できるコマンドラインツールです。ツールをまだお持ちでない場合は、[curl ドキュメント](https://curl.se/docs/install.html)を参照してください。
## Lambda 関数を作成する
まず、HTTP リクエストがウェブフックエンドポイントに送信されたときに実行される Lambda 関数を作成します。この例では、送信側アプリケーションは、支払いが送信されるたびに更新を送信し、支払いが成功したかどうかを HTTP リクエストの本文に表示します。Lambda 関数はリクエストを解析し、支払いのステータスに従ってアクションを実行します。この例では、コードは支払いの注文 ID を出力しますが、実際のアプリケーションでは、注文をデータベースに追加するか、通知を送信できます。
この関数は、ウェブフックに使用される最も一般的な認証方法である、ハッシュベースのメッセージ認証 (HMAC) も実装します。この方法では、送信側アプリケーションと受信側アプリケーションの両方がシークレットキーを共有します。送信アプリケーションは、ハッシュアルゴリズムを使用して、このキーとメッセージコンテンツを使用して一意の署名を生成し、HTTP ヘッダーとしてウェブフックリクエストに署名を含めます。次に、受信側アプリケーションはこのステップを繰り返し、シークレットキーを使用して署名を生成し、結果の値をリクエストヘッダーで送信された署名と比較します。結果が一致すると、リクエストは正当であると見なされます。
Python または Node.js ランタイムで Lambda コンソールを使用して関数を作成します。
------
#### [ Python ]
**Lambda 関数を作成する**
1. Lambda コンソールの「[関数](https://console.aws.amazon.com/lambda/home#/functions)」ページを開きます。
1. 次の操作を行って、基本的な「Hello world」関数を作成します。
1. [**関数の作成**] を選択してください。
1. **[一から作成]** を選択します。
1. **[関数名]** に「**myLambdaWebhook**」と入力します。
1. **[ランタイム]** で **[python3.14]** を選択します。
1. [**関数の作成**] を選択してください。
1. **[コードソース]** ペインで、以下をコピーして貼り付けて既存のコードを置き換えます。
```
import json
import hmac
import hashlib
import os
def lambda_handler(event, context):
# Get the webhook secret from environment variables
webhook_secret = os.environ['WEBHOOK_SECRET']
# Verify the webhook signature
if not verify_signature(event, webhook_secret):
return {
'statusCode': 401,
'body': json.dumps({'error': 'Invalid signature'})
}
try:
# Parse the webhook payload
payload = json.loads(event['body'])
# Handle different event types
event_type = payload.get('type')
if event_type == 'payment.success':
# Handle successful payment
order_id = payload.get('orderId')
print(f"Processing successful payment for order {order_id}")
# Add your business logic here
# For example, update database, send notifications, etc.
elif event_type == 'payment.failed':
# Handle failed payment
order_id = payload.get('orderId')
print(f"Processing failed payment for order {order_id}")
# Add your business logic here
else:
print(f"Received unhandled event type: {event_type}")
# Return success response
return {
'statusCode': 200,
'body': json.dumps({'received': True})
}
except json.JSONDecodeError:
return {
'statusCode': 400,
'body': json.dumps({'error': 'Invalid JSON payload'})
}
except Exception as e:
print(f"Error processing webhook: {e}")
return {
'statusCode': 500,
'body': json.dumps({'error': 'Internal server error'})
}
def verify_signature(event, webhook_secret):
"""
Verify the webhook signature using HMAC
"""
try:
# Get the signature from headers
signature = event['headers'].get('x-webhook-signature')
if not signature:
print("Error: Missing webhook signature in headers")
return False
# Get the raw body (return an empty string if the body key doesn't exist)
body = event.get('body', '')
# Create HMAC using the secret key
expected_signature = hmac.new(
webhook_secret.encode('utf-8'),
body.encode('utf-8'),
hashlib.sha256
).hexdigest()
# Compare the expected signature with the received signature to authenticate the message
is_valid = hmac.compare_digest(signature, expected_signature)
if not is_valid:
print(f"Error: Invalid signature. Received: {signature}, Expected: {expected_signature}")
return False
return True
except Exception as e:
print(f"Error verifying signature: {e}")
return False
```
1. **[DEPLOY]** セクションで **[デプロイ]** を選択して関数のコードを更新します。
------
#### [ Node.js ]
**Lambda 関数を作成する**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 次の操作を行って、基本的な「Hello world」関数を作成します。
1. [**関数の作成**] を選択してください。
1. **[一から作成]** を選択します。
1. **[関数名]** に「**myLambdaWebhook**」と入力します。
1. **[ランタイム]** で、**[nodejs24.x]** を選択します。
1. [**関数の作成**] を選択してください。
1. **[コードソース]** ペインで、以下をコピーして貼り付けて既存のコードを置き換えます。
```
import crypto from 'crypto';
export const handler = async (event, context) => {
// Get the webhook secret from environment variables
const webhookSecret = process.env.WEBHOOK_SECRET;
// Verify the webhook signature
if (!verifySignature(event, webhookSecret)) {
return {
statusCode: 401,
body: JSON.stringify({ error: 'Invalid signature' })
};
}
try {
// Parse the webhook payload
const payload = JSON.parse(event.body);
// Handle different event types
const eventType = payload.type;
switch (eventType) {
case 'payment.success': {
// Handle successful payment
const orderId = payload.orderId;
console.log(`Processing successful payment for order ${orderId}`);
// Add your business logic here
// For example, update database, send notifications, etc.
break;
}
case 'payment.failed': {
// Handle failed payment
const orderId = payload.orderId;
console.log(`Processing failed payment for order ${orderId}`);
// Add your business logic here
break;
}
default:
console.log(`Received unhandled event type: ${eventType}`);
}
// Return success response
return {
statusCode: 200,
body: JSON.stringify({ received: true })
};
} catch (error) {
if (error instanceof SyntaxError) {
// Handle JSON parsing errors
return {
statusCode: 400,
body: JSON.stringify({ error: 'Invalid JSON payload' })
};
}
// Handle all other errors
console.error('Error processing webhook:', error);
return {
statusCode: 500,
body: JSON.stringify({ error: 'Internal server error' })
};
}
};
// Verify the webhook signature using HMAC
const verifySignature = (event, webhookSecret) => {
try {
// Get the signature from headers
const signature = event.headers['x-webhook-signature'];
if (!signature) {
console.log('No signature found in headers:', event.headers);
return false;
}
// Get the raw body (return an empty string if the body key doesn't exist)
const body = event.body || '';
// Create HMAC using the secret key
const hmac = crypto.createHmac('sha256', webhookSecret);
const expectedSignature = hmac.update(body).digest('hex');
// Compare expected and received signatures
const isValid = signature === expectedSignature;
if (!isValid) {
console.log(`Invalid signature. Received: ${signature}, Expected: ${expectedSignature}`);
return false;
}
return true;
} catch (error) {
console.error('Error during signature verification:', error);
return false;
}
};
```
1. **[DEPLOY]** セクションで **[デプロイ]** を選択して関数のコードを更新します。
------
## シークレットキーを作成する
Lambda 関数がウェブフックリクエストを認証するには、呼び出し元のアプリケーションと共有されるシークレットキーを使用します。この例では、キーは環境変数に保存されています。本番環境のアプリケーションでは、関数コードにパスワードなどの機密情報を含めないでください。代わりに、[AWS Secrets Manager シークレットを作成](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)し、[AWS パラメータとシークレット Lambda 拡張機能を使用](with-secrets-manager.md)して Lambda 関数の認証情報を取得します。
**ウェブフックシークレットキーを作成および保存する**
1. 暗号的に安全な乱数ジェネレーターを使用して、長いランダムな文字列を生成します。Python または Node.js で次のコードスニペットを使用して 32 文字のシークレットを生成して出力することも、独自の方法を使用することもできます。
------
#### [ Python ]
**Example シークレットを生成するコード**
```
import secrets
webhook_secret = secrets.token_urlsafe(32)
print(webhook_secret)
```
------
#### [ Node.js ]
**Example シークレットを生成するコード (ES モジュール形式)**
```
import crypto from 'crypto';
let webhookSecret = crypto.randomBytes(32).toString('base64');
console.log(webhookSecret)
```
------
1. 次の手順を実行して、生成された文字列を関数の環境変数として保存します。
1. 関数の **[設定]** タブで、**[環境変数]** を選択します。
1. **[編集]** を選択します。
1. **[環境変数の追加]** を選択します。
1. **[キー]** に **WEBHOOK\$1SECRET** を入力し、**[値]** に前のステップで生成したシークレットを入力します。
1. **[保存]** を選択します。
このシークレットは、チュートリアルの後半で関数をテストするためにもう一度使用する必要があるため、ここで書き留めておきます。
## 関数 URL エンドポイントを作成する
Lambda 関数 URL を使用して、ウェブフックのエンドポイントを作成します。`NONE` の認証タイプを使用してパブリックアクセスを持つエンドポイントを作成するため、URL を持つすべてのユーザーが関数を呼び出すことができます。関数 URL へのアクセス制御の詳細については、「[Lambda 関数 URL へのアクセスの制御](urls-auth.md)」を参照してください。ウェブフックに高度な認証オプションが必要な場合は、API Gateway の使用を検討してください。
**関数 URL エンドポイントを作成する**
1. 関数の **[設定]** タブで、**[関数 URL]** を選択します。
1. **[関数 URL を作成]** をクリックします。
1. **[認証タイプ]** で、**[なし]** を選択します。
1. **[保存]** を選択します。
先ほど作成した関数 URL のエンドポイントが **[関数 URL]** ペインに表示されます。チュートリアルの後半で使用するエンドポイントをコピーします。
## コンソールで関数をテストする
HTTP リクエストを使用して URL エンドポイントによって関数を呼び出す前に、コンソールでテストしてコードが期待どおりに動作していることを確認します。
コンソールで関数を検証するには、まずチュートリアルの前半で生成したシークレットを使用してウェブフック署名を計算し、次のテスト JSON ペイロードを使用します。
```
{
"type": "payment.success",
"orderId": "1234",
"amount": "99.99"
}
```
次の Python コードまたは Node.js コードの例のいずれかを使用して、独自のシークレットを使用してウェブフック署名を計算します。
------
#### [ Python ]
**ウェブフック署名を計算する**
1. 次のコードを `calculate_signature.py` という名前のファイルとして保存します。コード内のウェブフックシークレットを独自の値に置き換えます。
```
import secrets
import hmac
import json
import hashlib
webhook_secret = "arlbSDCP86n_1H90s0fL_Qb2NAHBIBQOyGI0X4Zay4M"
body = json.dumps({"type": "payment.success", "orderId": "1234", "amount": "99.99"})
signature = hmac.new(
webhook_secret.encode('utf-8'),
body.encode('utf-8'),
hashlib.sha256
).hexdigest()
print(signature)
```
1. コードを保存したのと同じディレクトリから次のコマンドを実行して、署名を計算します。コード出力の署名をコピーします。
```
python calculate_signature.py
```
------
#### [ Node.js ]
**ウェブフック署名を計算する**
1. 次のコードを `calculate_signature.mjs` という名前のファイルとして保存します。コード内のウェブフックシークレットを独自の値に置き換えます。
```
import crypto from 'crypto';
const webhookSecret = "arlbSDCP86n_1H90s0fL_Qb2NAHBIBQOyGI0X4Zay4M"
const body = "{\"type\": \"payment.success\", \"orderId\": \"1234\", \"amount\": \"99.99\"}";
let hmac = crypto.createHmac('sha256', webhookSecret);
let signature = hmac.update(body).digest('hex');
console.log(signature);
```
1. コードを保存したのと同じディレクトリから次のコマンドを実行して、署名を計算します。コード出力の署名をコピーします。
```
node calculate_signature.mjs
```
------
コンソールでテスト HTTP リクエストを使用して関数コードをテストできるようになりました。
**コンソールで関数をテストする**
1. 関数の **[コード]** タブを選択します。
1. **[TEST EVENTS]** セクションで、**[新しいテストイベントの作成]** を選択します。
1. **[イベント名]** で、「**myEvent**」と入力します。
1. 以下をコピーして **[イベント JSON]** ペインに貼り付け、既存の JSON を置き換えます。ウェブフック署名を、前のステップで計算した値に置き換えます。
```
{
"headers": {
"Content-Type": "application/json",
"x-webhook-signature": "2d672e7a0423fab740fbc040e801d1241f2df32d2ffd8989617a599486553e2a"
},
"body": "{\"type\": \"payment.success\", \"orderId\": \"1234\", \"amount\": \"99.99\"}"
}
```
1. **[保存]** を選択します。
1. **[呼び出し]** を選択します。
次のような出力が表示されます:
------
#### [ Python ]
```
Status: Succeeded
Test Event Name: myEvent
Response:
{
"statusCode": 200,
"body": "{\"received\": true}"
}
Function Logs:
START RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6 Version: $LATEST
Processing successful payment for order 1234
END RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6
REPORT RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6 Duration: 1.55 ms Billed Duration: 2 ms Memory Size: 128 MB Max Memory Used: 36 MB Init Duration: 136.32 ms
```
------
#### [ Node.js ]
```
Status: Succeeded
Test Event Name: myEvent
Response:
{
"statusCode": 200,
"body": "{\"received\":true}"
}
Function Logs:
START RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 Version: $LATEST
2025-01-10T18:05:42.062Z e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 INFO Processing successful payment for order 1234
END RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4
REPORT RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 Duration: 60.10 ms Billed Duration: 61 ms Memory Size: 128 MB Max Memory Used: 72 MB Init Duration: 174.46 ms
Request ID: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4
```
------
## HTTP リクエストを使用して関数をテストする
curl コマンドラインツールを使用して、ウェブフックエンドポイントをテストします。
**HTTP リクエストを使用して関数をテストする**
1. ターミナルまたはシェルプログラムで、次の curl コマンドを実行します。URL を独自の関数 URL エンドポイントの値に置き換え、ウェブフック署名を独自のシークレットキーを使用して計算した署名に置き換えます。
```
curl -X POST https://ryqgmbx5xjzxahif6frvzikpre0bpvpf.lambda-url.us-west-2.on.aws/ \
-H "Content-Type: application/json" \
-H "x-webhook-signature: d5f52b76ffba65ff60ea73da67bdf1fc5825d4db56b5d3ffa0b64b7cb85ef48b" \
-d '{"type": "payment.success", "orderId": "1234", "amount": "99.99"}'
```
以下の出力が表示されます。
```
{"received": true}
```
1. 次の手順を実行して、関数の CloudWatch ログを検査し、ペイロードが正しく解析されたことを確認します。
1. Amazon CloudWatch コンソールで、[[ロググループ]](https://console.aws.amazon.com/cloudwatch/home#logsV2:log-groups) ページを開きます。
1. 関数のロググループ (`/aws/lambda/myLambdaWebhook`) を選択します。
1. 最新のログストリームを選択します。
関数のログには、次のような出力が表示されます。
------
#### [ Python ]
```
Processing successful payment for order 1234
```
------
#### [ Node.js ]
```
2025-01-10T18:05:42.062Z e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 INFO Processing successful payment for order 1234
```
------
1. 次の curl コマンドを実行して、コードが無効な署名を検出したことを確認します。URL を独自の関数 URL エンドポイントに置き換えます。
```
curl -X POST https://ryqgmbx5xjzxahif6frvzikpre0bpvpf.lambda-url.us-west-2.on.aws/ \
-H "Content-Type: application/json" \
-H "x-webhook-signature: abcdefg" \
-d '{"type": "payment.success", "orderId": "1234", "amount": "99.99"}'
```
以下の出力が表示されます。
```
{"error": "Invalid signature"}
```
## リソースのクリーンアップ
このチュートリアル用に作成したリソースは、保持しない場合は削除できます。使用しなくなった AWS リソースを削除することで、AWS アカウント アカウントに請求される料金の発生を防ぎます。
**Lambda 関数を削除するには**
1. Lambda コンソールの [[関数]](https://console.aws.amazon.com/lambda/home#/functions) ページを開きます。
1. 作成した関数を選択します。
1. **[アクション]** で、**[削除]** を選択します。
1. テキスト入力フィールドに **confirm** と入力し、**[削除]** を選択します。
コンソールで Lambda 関数を作成すると、Lambda は関数の[実行ロール](lambda-intro-execution-role.md)も作成します。
**実行ロールを削除する**
1. IAM コンソールの [[ロール]](https://console.aws.amazon.com/iam/home#/roles) ページを開きます。
1. Lambda が作成した実行ロールを選択します。ロールの名前の形式は `myLambdaWebhook-role-` になります。
1. **[削除]** を選択します。
1. テキスト入力フィールドにロールの名前を入力し、**[削除]** を選択します。