Aws-lambda-quick-guide

Aws-lambda-overview Aws-lambda-environment-setup

AWS Lambda –はじめに

AWS Lambdaは、サーバーなしでコードの計算を行うサービスです。 サーバーレスコンピューティングと言われています。 コードは、S3バケットへのファイルの追加/削除、Amazon DynamoDBtablesの更新、Amazon ApiゲートウェイからのHTTPリクエストなど、AWSサービスのイベントの応答に基づいて実行されます。

AWS LambdaコードはNodeJS、Java、C＃、Python、Goで記述できます。 この章では、AWSコンソールでのAWS Lambda関数の作成について詳しく説明します。

AWSコンソール

リンクhttps://aws.amazon.com/consoleでAWSコンソールにログインします。 ログインすると、AWSサービスが表示される画面にリダイレクトされます。

AWSコンソール

例：関数の作成

例の助けを借りて、AWSコンソールの機能を理解しましょう。 Lambda（上記のマーク）をクリックすると、以下に示すように機能を作成するためにリダイレクトされます-

関数の作成

[関数の作成]ボタンをクリックすると、画面に次の詳細が表示されます-

関数表示の作成

デフォルトでは、オプションは*最初から作成*であることに注意してください。 このオプションを使用すると、Lambdaコードをゼロから作成できます。 hello world メッセージを含む単純な関数があります。

2番目のオプション*ブループリント*には次の詳細があります。

ブループリント

AWS Lambdaで利用可能な言語でawsサービスの一部用にすでに記述されたコードの詳細を提供します。 blue prints でチェックして開始できるサービスのAWS Lambdaコードを記述する必要がある場合。

3番目のオプション*サーバーレスアプリケーションリポジトリ*には、AWS Lambdaコードのデプロイに役立つサーバーレスアプリケーションのセットアップがあります。

さらに説明する際には、 Author from scratch を使用してAWSラムダ関数を作成する最初のオプションに取り組みます。

Lambda関数を作成する前に、ロール、つまりAWSサービスとaws lambdaを使用するためのアクセス許可が必要です。 後で、ロールをawsラムダ関数に割り当てる必要があります。

AWSコンソールでのロール作成

AWSコンソールでロールを作成するには、AWSコンソールサービスに移動し、以下に示すようにIAMをクリックします-

ロール作成

さて、 IAM をクリックすると、以下の画面が表示されます-

ダッシュボード

• ロール*を選択すると、画面に次のボタンが表示されます-

役割ボタンの作成

ここで、[ Create role ]をクリックします。 作成されたロールを使用する必要があるサービスを選択するように求められます。

役割サービスの作成

このロールをAWS Lambdaで使用する必要があるため、 Lambda を選択し、上記のように Next：Permissions ボタンをクリックします。 次の画面には、AWSサービスごとに使用可能なポリシー名が表示されます。 ここからポリシーを選択できます-

許可ポリシーの添付

たとえば、AWS LambdaがS3およびDynamoDBで動作するアクセス許可が必要な場合、ポリシーを選択する必要があります。 検索ボックスにAWSサービスを入力し、チェックボックスをクリックします。 複数のポリシーを選択し、後で Next：Review をクリックできます。

独自のポリシーを作成することもできます。 たとえば、dynamodbテーブルがあり、そのテーブルにのみ許可を与える必要があります。そのような場合、ポリシーを作成できます。

上記の画面に示すように、 Create policy ボタンをクリックします。 画面に表示される詳細は次のとおりです。

ポリシーの作成

ポリシーを作成する*サービス*を選択します。 後で、アクション、リソース、*リクエスト条件*のデータが表示されます。

リクエスト条件

ここで、サービスを選択する必要があります。 検索から AWS Dynamodb を選択してみましょう。 *アクション*には次の詳細があります-

AWS Dynamodb

ここで、DynamoDBに付与する*アクセスレベル*を入力します。 次に、*リソース*は次の詳細を表示します-

リソース

次に、テーブルリソースタイプを選択します。 次の出力を見ることができます-

テーブル再ソース

テーブルの許可を得るには、* ARNを追加する必要があります。 ARNは、AWS DynamoDBで作成されたテーブルに固有の詳細です。 dynamodbでテーブルを作成すると、詳細が表示されます。

*Add ARN* をクリックすると、次の詳細が表示されます-

Add ARN

ここで、 ARN と Region、Account および Table の名前を入力すると、入力されます。 ポリシーを追加するには、[追加]ボタンをクリックする必要があります。 同様に、他のサービスのポリシーを作成できます。

ロールの説明

ここでは、2つのポリシー AmazonS3FullAccess および AmazonDynamoDBFullACcess を選択しました。 その役割でS3とDynamoDBへのフルアクセスを許可しました。 ただし、必要なバケットとテーブルにのみ許可を与えることをお勧めします。

前述の手順に従って、 ARN を使用してポリシーを作成できます。

ステップ1

[ロールを作成]ボタンをクリックして、ロールを作成します。 作成されたすべてのロールが表示されるように表示されます-

ロール表示の作成

ステップ2

作成されたロールを変更する必要がある場合は、必要なロールを選択できます。 * Author from scratchオプション*を選択した場合、 Name、Runtime、およびRole を入力する必要があります。

最初から作成者

ステップ3

あなたは*ランタイム*ドロップダウンで次の詳細を観察することができます-

ランタイム

ステップ4

選択したランタイムを選択し、図のように続行できます。

選択する

• ロール*ドロップダウンには次のオプションがあります-

• *既存のロールを選択します-*これにより、IAMロールで作成されたすべてのロールが表示されます。
• *テンプレートから新しいロールを作成します-*これにより、ロールを作成でき、そのロールに対して選択される権限が表示されます。 よりよく理解するためにスクリーンショットを観察してください。
• *カスタムロールの作成-*これにより、ユーザーは前述のようにポリシーを作成できます。

ステップ5

*runtime、role* を選択して、関数を追加します。 *Create function* ボタンをクリックして、ラムダ関数を作成します。 表示される次の画面は次のとおりです-

機能ボタンの作成

AWS Lambda関数の一部

AWS Lambda関数には、*構成*と*監視*の2つの部分があります。 それぞれについて詳しく説明しましょう。

設定

次の機能が構成に含まれています。

トリガーを追加

AWS Lambda関数に追加する必要があるトリガーは次のように表示されます-

トリガーの追加

トリガーを選択する場合、そのトリガーの構成の詳細を追加する必要があることに注意してください。 S3トリガーの例では、バケット名を選択する必要があります。 Dynamodbトリガーの場合、テーブル名を選択する必要があります。

例

私たちはS3トリガーの構成の詳細の例を見てみましょう-

構成

今、追加されたS3トリガーの構成の詳細を追加します-

構成の詳細

ここでは、Lambdaをトリガーする* bucket名、イベントタイプ*、プレフィックスがある場合はフィルターパターンを選択し、トリガーを*追加*する必要があります。

Lambdaにコードを追加する

次に、作成するLambdaコードに焦点を当てる必要があります。 AWSラムダにコードを追加するには、3つのオプションがあります-

• インラインエディターの使用
• .zipファイルを使用する
• Amazon S3からファイルをアップロードする

以下のスクリーンショットに示されています-

スクリーンショット

それぞれについて詳しく説明します。

インラインエディタを使用する

あなたがあなたのコードを書くことができるインラインコードエディタは次のとおりです-

inline_editor

任意の言語を選択して、コードを記述できます。 ここで再度ランタイムを選択できます。

より良い理解のために、次のスクリーンショットを観察します-

ランタイムメニュー

コードは index.js.Handler で作成する必要があります。 詳細は実行時間によって異なります。 nodejs の場合、* index.lambdaハンドラ*である filename.export function です。

• .ZIPファイルをアップロード*
• .ZIPファイルをアップロード*を選択して、最初にコードを記述し、それを圧縮し、zipファイルをアップロードできます。
• Amazon S3からファイルをアップロード*

S3バケットにファイルをアップロードし、* Amazon S3からファイルをアップロード*オプションを選択できます。

*_。ZIP_* および *_S3_* の場合、ランタイムを変更できないことに注意してください。

環境変数

キーと値のペアを受け取り、AWS Lambdaコードと共有します。 AWS Lambdaの環境変数を使用して、データベース接続の詳細、出力を保存するファイルの詳細、ログファイルの詳細などを保存できます。

環境変数

Tags

これらは、異なるリージョンで使用する場合に機能をより適切に整理するためにAWS Lambdaに追加されたキーと値のペアです。 単純なユースケースの場合、必須ではありません。 作成されたLambda関数が多数ある場合、タグ付けはLambda関数のフィルタリングと管理に役立ちます。

タグ

実行役割

Lambda関数の作成の開始時に適切に行われなかった場合、ここでロールを再度変更できます。 ここで新しいロールを更新または作成できます。 Lambda関数の作成の開始時に表示されたものと同じオプションを提供します。

実行ロール

基本設定

ここで、Lambda関数が実行していることの短い説明を入力する必要があります。 Lambda関数に必要なメモリとタイムアウトを選択します。

基本設定

ネットワーク

これにより、VPCを選択して、VPCからLambda関数にアクセスできるようになります。 デフォルトでは、VPCは選択されていません。

ネットワーク

デバッグとエラー処理

デバッグとエラー処理のために、AWSサービスを選択して詳細を送信できます。 使用可能なオプションは、なし、SNS *および *SQS です。

デバッグとエラー処理

並行性

これにより、この機能に許可される同時実行の特定の制限を割り当てることができます。

同時実行性

監査とコンプライアンス

これには、AWS CloudTrailを使用して管理されるログが含まれます。

監査とコンプライアンス

完了したら、ここに示すように[保存]ボタンを使用して変更を保存する必要があります-

Save Button.jpg

ここで、*テスト*ボタンをクリックすると、テストイベントが要求されます。 次のようにサンプルテストイベントを渡すことができます-

作成されたテストイベントは次のとおりです-

テストイベントの設定

ここで、テストイベントを保存し、テストボタンをクリックして、AWS Lambda関数の実行を確認します-

実行結果

*index.js* のコードは次のとおりです-

exports.lambdahandler = (event, context, callback) => {
  //TODO implement
   console.log(event.key1);
   console.log(event.key2);
   console.log(event.key3);
   callback(null, 'Lambda test');
};

エラーまたは成功がある場合、コールバック関数が呼び出されることに注意してください。 成功すると、 Lambda test が表示されます。

モニタリング

[監視]タブを選択して、Lambda関数の実行の詳細を表示します。 グラフには、実行時間、発生したエラーなどの詳細が表示されます。

モニタリング

Cloudwatchでログを表示することもできます。 このためには、AWSサービスに移動し、示されているようにcloudwatchを選択します-

管理ツール

今、左側からログを選択し、フィルターに関数名を入力します-

クラウドウォッチ Aws-lambda-building-the-lambda-function

AWS Lambda – NODEJSの機能

Nodejsは、AWS Lambda関数がサポートする言語の1つです。 nodejsでサポートされるバージョンはv6.10およびv8.10です。 この章では、NODEJSのAWS Lambda関数のさまざまな機能について詳しく学習します。

NodeJSのハンドラー

nodejsでAWS Lambda関数を作成するには、最初にハンドラーを宣言する必要があります。 nodejsのハンドラーは、ファイルの名前とエクスポート関数の名前です。 たとえば、ファイルの名前は index.js で、エクスポート関数名は lambda handler であるため、対応するハンドラーは index.lambdahandler です

ここに示されているサンプルハンドラーを観察します-

exports.lambdahandler = function(event, context, callback) {  //code goes here}

ハンドラーへのパラメーター

ハンドラーは、Lambda関数を構築するための主要なコアです。 ハンドラーは、 event、context 、および callback の3つのパラメーターを取ります。

イベントパラメータ

トリガーされたイベントのすべての詳細が含まれます。 たとえば、S3でトリガーされるLambda関数を使用している場合、イベントにはS3オブジェクトの詳細が含まれます。

コンテキストパラメータ

Lambda関数のプロパティや設定の詳細など、コンテキストの詳細が含まれています。

コールバック関数

発信者に詳細を返すのに役立ちます。 コールバックの構造は次のようになります-

callback(error, result);

コールバック関数のパラメータは以下に与えられて説明されています-

エラー- Lambda関数の実行中にエラーが発生した場合、詳細が表示されます。 Lambda関数が成功した場合、コールバック関数の最初のパラメーターとして null を渡すことができます。

• 結果-*これは、ラムダ関数の正常な実行の詳細を提供します。 エラーが発生した場合、結果のパラメーターは無視されます。

注意- AWS Lambdaでコールバック関数を使用することは必須ではありません。 コールバック関数がない場合、ハンドラーはそれをnullとして返します。

有効なコールバック署名は以下のとおりです-

callback();               //It will return success, but no indication to the caller
callback(null);           //It will return success, but no indication to the caller
callback(null, "success");//It will return the success indication to the caller
callback(error);          // It will return the error indication to the caller

AWS Lambdaが実行されるたびに、エラーや成功などのコールバックの詳細が、コンソールメッセージ（存在する場合）とともにAWS CloudWatchに記録されます。

Nodejs8.10でAWS Lambdaを使用する

nodejs8.10でAWS Lambdaを操作し、同期および非同期で関数を呼び出す方法を理解しましょう。

同期方法でLambda関数を呼び出す

次の例では、同期方法でラムダ関数を呼び出すことについてのアイデアを提供します-

exports.handler = function(event, context, callback) {
   let arrItems = [4,5,6,8,9,10,35,70,80,31];
   function countevennumbers (items) {
      return new Promise(resolve => {
         setTimeout(() => {
            let a = 0;
            for (var i in items) {
               if (items[i] % 2 == 0) {
                  a++;
               }
            }
            resolve(a);
         },2000);
      });
   }
   let evennumber = countevennumbers(arrItems);
   callback(null,'even numbers equals ='+evennumber);
};

AWSコンソールでこのコードをテストした後、次の出力を確認できます-

偶数番号カウント

上記のコードからの出力はpromiseオブジェクトであることに注意してください。 カウントはsetTimeout内でインクリメントされ、関数呼び出しはsetTimeout内で実行を待機せず、promiseオブジェクトを返すため、カウントは提供されません。

ハンドラー関数に async/await がある場合、ラムダ関数からの正確な出力を取得します。

非同期の方法でハンドラーを呼び出す

次の例では、非同期の方法でラムダ関数を呼び出すことについてのアイデアを提供します-

exports.handler = async function(event, context, callback) {
   let arrItems = [4,5,6,8,9,10,35,70,80,31];
   function countevennumbers (items) {
      return new Promise(resolve => {
         setTimeout(() => {
            let a = 0;
            for (var i in items) {
               if (items[i] % 2 == 0) {
                  a++;
               }
            }
            resolve(a);
         }, 2000);
      });
   }
   let evennumber = await countevennumbers(arrItems);
   callback(null,'even numbers equals ='+evennumber);
};

上記のコードに async と await を追加しました。 関数呼び出しの横に await を使用すると、関数内のプロミスが解決されるまで実行が一時停止します。 await は async 関数でのみ有効であることに注意してください。

AWSコンソールでこのコードをテストした後、次の出力を確認できます-

偶数カウント出力

NodeJSのContextDetails

Contextオブジェクトは、Lambda関数の名前、ミリ秒単位の残り時間、リクエストID、クラウドウォッチグループ名、タイムアウトの詳細などの詳細を提供します。

次の表は、コンテキストオブジェクトで利用可能なメソッドと属性のリストを示しています-

コンテキストオブジェクトに使用できるメソッド

Sr.No	Method Name & Description
1	getRemainingTimeInMillis() このメソッドは、Lambda関数が関数を終了するまでの残り時間をミリ秒で示します

コンテキストオブジェクトに使用できる属性

Sr.No	Attribute name & Description
1	functionName これにより、AWS Lambda関数名が与えられます
2	functionVersion これにより、実行中のAWS Lambda関数のバージョンが得られます
3	nvokedFunctionArn これにより、ARNの詳細が表示されます。
4	memoryLimitInMB これは、Lambda関数の作成中に追加されたメモリ制限を示しています
5	awsRequestId これにより、AWSリクエストIDが提供されます。
6	logGroupName これにより、クラウドウォッチグループの名前が表示されます。
7	logStreamName これにより、ログが書き込まれるcloudwatchログストリーム名がわかります。
8	identity これにより、aws mobile sdkで使用した場合のAmazon Cognito IDプロバイダーに関する詳細が提供されます。 与えられた詳細は次のとおりです- identity.cognito_identity_id *identity.cognito_identity_pool_id
9	clientContext* これは、aws mobile sdkで使用した場合のクライアントアプリケーションの詳細です。 与えられた詳細は次のとおりです- client_context.client.installation_id client_context.client.app_title client_context.client.app_version_name client_context.client.app_version_code client_context.client.app_package_name client_context.custom-モバイルクライアントアプリからのカスタム値の辞書があります client_context.env-AWS Mobile SDKの環境の詳細が含まれています

コンテキストオブジェクトについてのより良いアイデアを得るために、次の例を見てください-

exports.handler = (event, context, callback) => {
  //TODO implement
   console.log('Remaining time =>', context.getRemainingTimeInMillis());
   console.log('functionName =>', context.functionName);
   console.log('AWSrequestID =>', context.awsRequestId);
   console.log('logGroupName =>', context.log_group_name);
   console.log('logStreamName =>', context.log_stream_name);
   console.log('clientContext =>', context.clientContext);
   callback(null, 'Name of aws Lambda is=>'+context.functionName);
};

AWSコンソールでこのコードをテストした後、次の出力を確認できます-

成功したログ

AWSコンソールでこのコードをテストした後、次のログ出力を確認できます-

ログ出力テスト

NodeJSへのログイン

console.logを使用してNodeJSにログインできます。ログの詳細は、Lambda関数に対してCloudWatchサービスから取得できます。

より良い理解のために次の例を観察してください-

exports.handler = (event, context, callback) => {
  //TODO implement
   console.log('Logging for AWS Lamnda in NodeJS');
   callback(null, 'Name of aws Lambda is=>'+context.functionName);
};

AWSコンソールでこのコードをテストした後、次の出力を確認できます-

テスト後の出力

CloudWatchから次のスクリーンショットを見ることができます-

スクリーンショットクラウドウォッチ

NodeJSのエラー処理

NodeJSでエラー通知が行われる方法を理解しましょう。 次のコードを観察してください-

exports.handler = function(event, context, callback) {
  //This Source code only throws error.
   var error = new Error("something is wrong");
   callback(error);
};

実行結果の詳細

あなたはログ出力で次を観察することができます-

ログ出力監視

エラーの詳細は、次のようにコールバックで提供されます-

{
   "errorMessage": "something is wrong",
   "errorType": "Error",
   "stackTrace": [    "exports.handler (/var/task/index.js:2:17)"  ]
}

Aws-lambda-function-in-java

AWS Lambda – Pythonの関数

この章では、Pythonで簡単なAWS Lambda関数を作成し、詳細に従ってその動作概念を理解します。

AWSでのLambda関数の作成に進む前に、PythonのAWSツールキットサポートが必要です。 この目的のために、以下の手順に従って、添付の対応するスクリーンショットを観察します-

ステップ1

AWSコンソールにログインしてLambda関数を作成し、言語をPythonとして選択します。

Lambda Function Python

ステップ2

次に、[関数を作成]ボタンをクリックして、Pythonで簡単なAWS Lambdaを作成するための詳細を入力します。 このコードは、Pythonを使用してLambdaからメッセージ* Helloを返し、ここに示すように見えます-

関数Pythonの作成

ステップ3

次に、変更を保存し、コードをテストして出力を確認します。 UIのテストボタンを使用してAWSコンソールでテストすると、次の出力とログが表示されます。

AWS_console_Python

ステップ4

これで、任意のエディターまたはPython用IDE内でコードを作成できます。 ここでは、コードの記述にVisual Studioコードを使用しています。 後でファイルを圧縮し、AWSコンソールでアップロードする必要があります。

PythonのIDE。

ここでは、コードを圧縮し、AWSコンソールを使用しています。

ステップ5

次に、以下に示すように、*。ZIPファイル*アップロードオプションを選択します-

ファイルのアップロード

Pythonのハンドラーの詳細

ハンドラーは、関数の名前が後に続くファイルの名前でなければならないことに注意してください。 上記の場合、ファイル名は hellopython.py で、関数の名前は my_handler; なので、ハンドラーは hellopython.my_handler になります。

アップロードが完了して変更が保存されると、AWS Lambdaコンソールのオンラインエディターにzipファイルの詳細が実際に表示されます。 次に、コードをテストして出力とログを確認します。

Pythonハンドラーの詳細

さて、次のサンプルコードを使用してLambda関数の詳細を理解しましょう-

def my_handler(event, context):
   return "aws lambda in python using zip file"

上記のコードでは、関数名my_handlerには、イベントとコンテキストの2つのパラメーターがあります。

Pythonのコンテキストオブジェクト

Contextオブジェクトは、Lambda関数の名前、ミリ秒単位の残り時間、リクエストID、クラウドウォッチグループ名、タイムアウトの詳細などの詳細を提供します。

コンテキストオブジェクトで利用可能なメソッドと属性は、以下の表に示されています-

Sr.No	Method Name & Description
1	get_remaining_time_in_millis() このメソッドは、ラムダ関数が関数を終了するまでの残り時間をミリ秒で示します

Sr.No	Attribute & Description
1	function_name これはawsラムダ関数名を与えます
2	function_version これは、実行するawsラムダ関数のバージョンを提供します
3	invoked_function_arn これにより、ARNの詳細が表示されます。
4	memory_limit_in_mb これは、ラムダ関数の作成中に追加されたメモリ制限を示しています
5	aws_request_id これにより、awsリクエストIDが得られます。
6	og_group_name これにより、クラウドウォッチグループの名前が表示されます。
7	log_stream_name これにより、ログが書き込まれるcloudwatchログストリーム名がわかります。
8	identity これにより、aws mobile sdkで使用した場合のAmazon Cognito IDプロバイダーに関する詳細が提供されます。 与えられた詳細は次のとおりです- identity.cognito_identity_id *identity.cognito_identity_pool_id
9	client_context* これは、aws mobile sdkで使用した場合のクライアントアプリケーションの詳細です。 与えられた詳細は次のとおりです- client_context.client.installation_id client_context.client.app_title client_context.client.app_version_name client_context.client.app_version_code client_context.client.app_package_name client_context.custom-モバイルクライアントアプリからのカスタム値の辞書があります client_context.env-AWS Mobile SDKからの環境詳細の辞書があります

コンテキストの詳細を出力するPythonの実用的な例を見てみましょう。 以下のコードを確認してください-

def my_handler(event, context):
   print("Log stream name:", context.log_stream_name)
   print("Log group name:",  context.log_group_name)
   print("Request ID:",context.aws_request_id)
   print("Mem. limits(MB):", context.memory_limit_in_mb)
   print("Time remaining (MS):", context.get_remaining_time_in_millis())
   return "aws lambda in python using zip file"

上記のコードの対応する出力は以下のとおりです-

対応する出力

Pythonを使用したロギング

Pythonを使用して情報を記録するには、使用可能なprintまたはlogger機能を使用できます。 上記のコンテキストの例を使用し、inCloudWatchをチェックして、ログが出力されるかどうかを確認します。 次のコードを観察してください-

def my_handler(event, context):
   print("Log stream name:", context.log_stream_name)
   print("Log group name:",  context.log_group_name)
   print("Request ID:",context.aws_request_id)
   print("Mem. limits(MB):", context.memory_limit_in_mb)
   print("Time remaining (MS):", context.get_remaining_time_in_millis())
   return "aws lambda in python using zip file"

CloudWatchでのこのコードの出力は以下のとおりです-

Pythonを使用したロギング

ロガーを使用してログをCloudWatchに出力する方法を理解するには、次の例をご覧ください-

import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
def my_handler(event, context):
   logger.info('Using logger to print messages to cloudwatch logs')
   return "aws lambda in python using zip file"

このための出力は、以下のスクリーンショットに示すようになります-

Cloudwatch Python

Python for Lambda関数のエラー処理

このセクションでは、Pythonでエラーを処理する方法を示す実用的な例を見てみましょう。 ここで与えられたコードの一部を観察します-

def error_handler(event, context):
   raise Exception('Error Occured!')

Pythonでのエラー処理

ログ表示は、ここの画像に示されているとおりです-

Python出力でのエラー処理

AWS Lambda – Goの機能

Go言語サポートは、AWSに最近追加されたものです。 Goを使用するには、AWS Lambda関数の作成中にAWSコンソールから言語を選択する必要があります。 この章では、Go言語のAWS Lambda関数について詳しく説明します。

Goのインストール

開始するには、Go言語のサポートが必要です。 このセクションでは、GoでAWS Lambdaの使用を開始するために次の詳細を確認します。 これはGoダウンロードの公式サイトです：https://golang.org/dl/

Go Programming

次に、オペレーティングシステムごとにパッケージをダウンロードします。 ここに記載されている手順に従って、Goを各オペレーティングシステムにインストールします。

Windowsへのインストール

Windowsの場合、32ビットおよび64ビットのダウンロードが利用可能であることに注意してください。 zipファイルをダウンロードして内容を抽出し、選択したディレクトリに保存します。

• ControlPanel --→ System --→ Advanced system settings。*で利用可能な環境変数を追加します。

システムのプロパティ

今、*環境変数*ボタンをクリックし、ここに示すようにディレクトリパスを追加します-

環境変数Go

ここに示すようにシステム変数を編集することもできます-

システム変数の編集

これらの手順が完了すると、Goでの作業を開始できるはずです。 コマンドプロンプトを開き、Goコマンドのバージョンを確認します。 同じものについては、次のスクリーンショットをご覧ください。

コマンドプロンプト

LinuxおよびMac OSのインストール

LinuxおよびMac OSにパッケージをインストールするには、以下に示す指示に従ってください-

パッケージを解凍し、 /usr/local/go の場所に保存します。 次に、 /usr/local/go/bin をPATH環境変数に追加します。 /etc/profile または $ HOME/.profile を使用して実行できます。

この目的のために、次のコマンドを使用できます

export PATH=$PATH:/usr/local/go/bin

Windows、Linux、およびMacにAWSサポートを追加するには、gitコマンドラインで次を使用します-

go.exe get -u github.com/aws/aws-lambda-go/lambda
go.exe get -u github.com/aws/aws-lambda-go/lambdacontext
go.exe get -u github.com/aws/aws-lambda-go/cmd/build-lambda-zip

コードのWindows/Linux/Macをコンパイルするには、次のコマンドを使用します-

GOOS=linux GOARCH=amd64 go build -o main main.go
%GOPATH%\bin\build-lambda-zip.exe -o main.zip main

GOを使用したAWS Lambda関数

ビルドが実行可能ファイルを提供するときにGoで返されるプログラム。 以下は、AWS LambdaをサポートするGoの簡単なプログラムです。 これにはLambdaプログラミング機能があるため、 github.com/aws/aws-lambda-go/lambda をインポートする必要があります。AWSLambdaのもう1つの重要なニーズはハンドラーです。

Main.go

//main.go
package main

import (
   "github.com/aws/aws-lambda-go/lambda"
)
func hello() (string, error) {
   return "Hello Lambda", nil
}
func main() {
  //Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

*Go* プログラムの実行は、メインwhere lambdaから開始されることに注意してください。 startはハンドラー関数で呼び出されます。 以下に示すコードを観察します-

func main() {
  //Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

次に、Goコマンドを使用して上記のファイルを実行し、実行可能ファイルを圧縮します。

私たちが使用しているファイルの構造はここに示されているとおりです-

構造ファイル

構造ファイルの出力

*go build* を使用すると、main.exeという実行可能ファイルが作成されます。 ファイルを圧縮してAWS Lambdaにアップロードするには、次の手順を使用できます-

コードのWindows/Linux/Macをコンパイルするには、次のコマンドを使用します-

GOOS=linux GOARCH=amd64 go build -o main main.go
%GOPATH%\bin\build-lambda-zip.exe -o main.zip main

次に、AWSコンソールにログインし、 Go をランタイムとして使用してLambda関数を作成します-

APIws Console Go

関数が作成されたら、上記で作成した実行可能zipファイルをアップロードします。

Goを使用したLambda関数ハンドラー

ハンドラーは、Goプログラムの実行を開始する場所です。 lambda.start のメイン呼び出しから、ハンドラー関数を使用して実行が呼び出されます。 追加されるハンドラーは main になることに注意してください。

理解のためにここのコードを観察してください-

func main() {
  //Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

以下のスクリーンショットに従ってください-

関数コード

実行ロールGo

次に、関数を保存してテストします。 ここに示すように実行結果を見ることができます。

実行結果Go

対応するログ出力は、次のようになります-

ログ出力Go

Goを使用したコンテキストオブジェクト

GoのAWS Lambdaは、コンテキストに次のグローバル変数とプロパティを提供します。

• MemoryLimitInMB -AWSラムダで設定されるメモリ制限（MB）。
• FunctionName -AWSラムダ関数の名前。
• FunctionVersion -実行しているawsラムダ関数のバージョン。
• LogStreamName -クラウドウォッチログストリーム名。
• LogGroupName -クラウドウォッチグループ名。

コンテキストで利用可能なプロパティは以下のように与えられます-

AwsRequestID

これは、AWS Lambda関数が呼び出されたときに取得するAWSリクエストIDです。

ClientContext

これには、AWS Mobile SDKを介して呼び出されたときのクライアントアプリケーションとデバイスに関する詳細が含まれます。 nullでもかまいません。 クライアントコンテキストは、クライアントID、アプリケーションタイトル、バージョン名、バージョンコード、アプリケーションパッケージ名などの詳細を提供します。

InvokedFunctionArn

呼び出された関数のARN。 修飾されていないARNは$ LATESTバージョンを実行し、エイリアスはそれが指す関数バージョンを実行します。

身元

AWSモバイルSDKで使用すると、Amazon Cognito IDプロバイダーに関する詳細が提供されます。

コンテキストの詳細を出力するために main.go に追加された変更-

//main.go
package main

import (
   "context"
   "log"
   "github.com/aws/aws-lambda-go/lambda"
   "github.com/aws/aws-lambda-go/lambdacontext"
)

func hello(ctx context.Context) (string, error) {
   lc, _ := lambdacontext.FromContext(ctx);
   log.Print(lc);
   log.Print(lc.AwsRequestID);
   log.Print(lc.InvokedFunctionArn);
   return "Hello Lambda", nil
}

func main() {
  //Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

Goで使用するには、 log および lambda context をインポートする必要があります。 コンテキストの詳細は次のとおりです-

func hello(ctx context.Context) (string, error) {
   lc, _ := lambdacontext.FromContext(ctx);
   log.Print(lc);
   log.Print(lc.AwsRequestID);
   log.Print(lc.InvokedFunctionArn);
   return "Hello Lambda", nil
}

上記のコードをテストすると、次の出力を確認できます-

実行結果出力

ロギングデータ

*Go* を使用すると、以下に示すようにlogまたはfmtモジュールを使用してデータを記録できます-

//main.go
package main

import (
   "log"
   "fmt"
   "github.com/aws/aws-lambda-go/lambda"
)

func hello() (string, error) {
   log.Print("Hello from Lambda Go using log");
   fmt.Print("Hello from Lambda Go using fmt");
   return "Hello Lambda", nil
}

func main() {
  //Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

同じための出力は以下に示すとおりです-

ロギングデータ

CloudWatchでログを確認する

CloudWatchでもログを確認できます。 このためには、AWSサービスに移動してcloudwatchを選択し、左側の[ Logs ]をクリックします。 今、ログを見るためにリストでラムダ関数を検索します-

ログの確認

関数エラー

以下のコードに示すように、エラーモジュールを使用してAWS Lambdaでカスタムエラー処理を作成できます-

//main.go
package main
import (
   "errors"
   "github.com/aws/aws-lambda-go/lambda"
)

func hello() error  {
   return errors.New("There is an error in the code!")
}

func main() {
  //Make the handler available for Remote Procedure Call by AWS Lambda
   lambda.Start(hello)
}

上記のコードの出力は以下のとおりです-

関数エラー Aws-lambda-function-in-csharp

AWS Lambda – Lambda関数の構成

前の章では、AWSコンソールでAWS Lambda関数を作成する方法を学びました。 ただし、Lambda関数を作成するための他のパラメーターがあります。 これらには、メモリ割り当て、タイムアウトなどが含まれます。

この章では、AWS Lambdaの次の設定プロパティについて詳しく理解しましょう。

メモリ割り当て

AWSコンソールにログインし、既存のラムダ関数を作成または選択します。 [構成]タブをクリックして、割り当てられたメモリの詳細を取得します。 以下に示すスクリーンショットを見てください-

メモリ割り当て

デフォルトで割り当てられるメモリは 128MB であることに注意してください。 メモリを増やしたい場合は、スライダーをクリックします。

スライダーを動かすと、メモリは 64MB に増加します。 使用可能な最大メモリが 3008MB であることを確認してください。 以下に示すスクリーンショットを見てください-

最大メモリ

コマンドプロンプトから aws cli を使用して、メモリ制限を増やすこともできます。 64MB単位でメモリを割り当てる必要があります。

ここで、： myfirstlambdafunction という名前でAWS Lambdaのメモリ制限を増やしましょう。

関数のメモリの詳細は、以下のスクリーンショットに示されています-

メモリの詳細

*aws cli* を使用してメモリを変更するために使用されるコマンドは次のとおりです-

aws lambda update-function-configuration --function-name your function name --
region region where your function resides --memory-size memory amount --
profile admin user

AWSコンソールでのAWS Lambda関数 myfirstlambdafunction の対応する出力を次に示します。 メモリが128MBから256MBに変更されたことを確認します。

メモリコマンド

最大実行時間

タイムアウトは、タイムアウトが発生した場合にAWS Lambda関数が終了するために割り当てられた時間です。 AWS Lambda関数は、割り当てられた時間内に実行されるか、指定されたタイムアウトを超えると終了します。 関数の実行に必要な時間を評価し、それに応じて以下に示すようにAWSコンソールの[構成]タブで時間を選択する必要があります-

最大実行時間

IAMロール

AWS Lambda関数を作成する場合、ロールまたはアクセス許可を割り当てる必要があります。 S3またはdynamoDB用のAWS Lambdaが必要な場合は、lambdaのサービスに関する許可を割り当てる必要があります。 割り当てられたロールに基づいて、AWS Lambdaは実行する手順を決定します。 たとえば、dynamodbのフルアクセスを許可する場合、dynamodbテーブルの行を追加、更新、削除できます。

ハンドラー名

これがAWS Lambda関数の実行の開始です。 ハンドラー関数には、トリガーされたイベント、コンテキストオブジェクト、およびAWS Lambdaの success または error で送り返す必要があるコールバックの詳細が含まれます。

nodejsのハンドラ関数の形式はここに示されています-

exports.handler = (event, context, callback) => {
   callback(null, "hello from lambda");
};

環境変数を使用したLambda関数

このセクションでは、設定セクションで追加された環境変数を使用して簡単なLambda関数を作成します。 この目的のために、以下の手順に従って、それぞれのスクリーンショットを参照してください-

ステップ1

AWSコンソールに移動し、示されているようにLambdaで関数を作成します。

ラムダ変数

ステップ2

次に、示されているように環境変数を追加します-

ラムダ環境

ステップ3

さて、次のようにLambdaコードで同じものをフェッチしましょう-

exports.handler = (event, context, callback) => {
   var hostName = process.env.host;
   var userName = process.env.username;
   callback(null, "Environment Variables =>"+hostName+" and "+userName);
};

ステップ4

環境変数から詳細を取得するには、示されているように process.env を使用する必要があります。 この構文は NodeJS ランタイム用であることに注意してください。

var hostName = process.env.host;
var userName = process.env.username;

ステップ5

実行時のラムダ関数の出力は次のようになります-

Lambda関数の実行 Aws-lambda-creating-and-deploying-using-aws-console

AWS CLIを使用して作成およびデプロイする

*AWS CLI* は、AWSサービスを操作するのに役立つコマンドラインツールです。 これを使用して、awsラムダ関数を作成、更新、削除、呼び出すことができます。 この章では、AWS CLIのインストールと使用について詳しく説明します。

AWS CLIのインストール

このセクションでは、さまざまなオペレーティングシステムでのAWS CLIのインストールについて説明します。 指定された手順に従い、接続されている場所に対応するスクリーンショットを観察します。

Windowsの場合

Windows設定を確認し、AWS CLI MSIをインストールするための次のリンクのいずれかを選択します-

• Windows 64ビットの場合-https://s3.amazonaws.com/aws-cli/AWSCLI64.msi[Windows用のAWS CLI MSIインストール（64ビット）] *Windows 32ビットの場合-https://s3.amazonaws.com/aws-cli/AWSCLI32.msi[AWS CLI MSI install for windows（32）]

対応するリンクを選択してクリックすると、ここに示すようにウィンドウを見つけることができます-

AWSのインストール

次に、以下のスクリーンショットに示されているように、Windows* 環境のパスを設定します-

環境パス

完了したら、コマンドプロンプトで次のコマンドを使用して、 aws cli がインストールされているかどうかを確認できます-

aws --version

次のスクリーンショットに示すように、aws-cliバージョンの詳細が表示されます-

AWS Cliバージョン

Linux/Macの場合

LinuxおよびMacにインストールするには、Python 2.6.3以降のバージョンが必要です。 その後、さらにインストールプロセスのために次のコマンドを使用します-

$ curl "https://s3.amazonaws.com/aws-cli/awscli-bundle.zip" -o "awscli-bundle.zip"
$ unzip awscli-bundle.zip
$ sudo ./awscli-bundle/install -i/usr/local/aws -b/usr/local/bin/aws

次に、AWSの設定を構成する必要があります。 この目的のために次のコマンドを使用できます-

aws configure

この目的のために、それは次のような詳細が必要です-

• AWSアクセスキーID
• AWSシークレットアクセスキー
• デフォルトの地域名
• フォーマットからのデフォルト出力

これらの詳細は、awsコンソールから取得できます。 示されているように、右上隅にあるアカウント名に移動します-

役立つヒント

次に、[ My Security Credentials ]をクリックして、左側からユーザーを選択します。 尋ねられた詳細でユーザーを追加します。

セキュリティ資格情報

ユーザーを追加し、アクセスキーとシークレットキーを取得します。 新しいアクセスキーを表示するには、*表示*を選択します。 資格情報は次のようになります-

• アクセスキーID-AOSAIOSFOCDD7Example *

• シークレットアクセスキー-aJuirCVtnROUN/K7MDENG/bPxRfiCYExampleKEY *

アクセスキー

AWS CLISのリファレンスコマンド

次の表に、 aws cli で使用できるコマンドリファレンスを示します。

Name of aws cli command	Command reference
create-function	create-function --function-name <value> --runtime <value> --role <value> --handler <value> [--code <value>] [--description <value>] [--timeout <value>] [--memory-size <value>] [--environment <value>] [--kms-key-arn <value>] [--tags <value>] [--zip-file <value>] [--cli-input-json <value>]
list-functions	list-functions [--master-region <value>] [--function-version <value>] [--max-items <value>] [--cli-input-json <value>] [--starting-token <value>] [--page-size <value>] [--generate-cli-skeleton <value>]
get-function	get-function --function-name <value> [--qualifier <value>] [--cli-input-json <value>] [--generate-cli-skeleton <value>]
get-function-configuration	get-function-configuration --function-name <value> [--qualifier <value>] [--cli-input-json <value>] [--generate-cli-skeleton <value>]
get-account-settings	get-account-settings [--cli-input-json <value>] [--generate-cli-skeleton <value>]
update-function-configuration	update-function-configuration --function-name <value> [--role <value>] [--handler <value>] [--description <value>] [--timeout <value>] [--memory-size <value>] [--vpc-config <value>] [--environment <value>] [--runtime <value>] [--dead-letter-config <value>] [--kms-key-arn <value>] [--tracing-config <value>] [--revision-id <value>] [--cli-input-json <value>] [--generate-cli-skeleton <value>]
update-function-code	update-function-code --function-name <value> [--zip-file <value>] [--s3-bucket<value>] [--s3-key <value>] [--s3-object-version <value>] [--publish
--no-publish] [--dry-run	--no-dry-run] [--revision-id <value>][--cli-input-json <value>][--generate-cli-skeleton <value>]
delete-function	delete-function --function-name <value> [--qualifier <value>] [--cli-input-json <value>] [--generate-cli-skeleton <value>]

次に、これらのコマンドを1つずつ詳細に説明します。

作成機能

このAPIは、新しいラムダ関数を作成します。 コードはzip形式で提供する必要があります。 作成する関数が既に存在する場合、APIは失敗します。 関数名では大文字と小文字が区別されることに注意してください。

含まれるコマンド

あなたが作成機能で使用できるコマンドのリストはここに与えられています-

create-function
--function-name <value>
--runtime <value>
--role <value>
--handler <value>
[--code <value>]
[--description <value>]
[--timeout <value>]
[--memory-size <value>]
[--environment <value>]
[--kms-key-arn <value>]
[--tags <value>]
[--zip-file <value>]
[--cli-input-json <value>]

含まれるオプション

上記の機能で使用できるさまざまなオプションは次のとおりです-

-function-name（string）-これは関数の名前を取ります。 名前は64ビット文字にすることができます。

-runtime（string）-ここでは、ランタイム環境、つまり言語選択を指定する必要があります。 ランタイムの詳細は以下のとおりです-

Options available	runtime
Python v3.6	python3.6
Python v2.7	python2.7
NodeJS v6.10	nodejs6.10
NodeJS v8.10	nodejs8.10
Java	java8
C# 1	dotnetcore1.0
C# 2	dotnetcore2.0
Go	go1.x

-role（string）-これは、ラムダポリシーの名前、つまり、他のサービスにアクセスするためにラムダ関数に付与されるロールになります。 指定されたロールごとに許可が与えられます。

-handler（string）-これは、ラムダコードの実行が開始されるハンドラの名前です。

• nodejsの場合、ハンドラー名はエクスポートするモジュール名です。
• Javaの場合、package.classname :: handlerまたはpackage.classnameです。
• Pythonの場合、ハンドラーはnameofthefileです。

-コード（構造） -AWS Lambdaコード

-description（string）-AWS Lambda関数の説明

-timeout（integer）-timeoutは、ラムダ関数が実行を終了しなければならない時間を持ちます。 デフォルトは3秒です。

-memory-size（integer）-これはawsラムダ関数に与えられるメモリです。 AWSは、指定されたメモリに基づいてCPUとメモリの割り当てを割り当てます。

-環境（構造）-awsラムダ関数で必要な環境の詳細を持つオブジェクト。

e.g : Variables = {Name1 = string, Name2 = string}

-kms-key-arn（string）-これは環境変数の暗号化に使用されるAmazonリソースネーム（ARN）です。 指定されない場合、暗号化するためにデフォルト設定が使用されます。

-zip-file（blob）-コードの詳細を含むzipファイルのパス。

-cli-input-json（string）：指定されたJSON文字列に基づいてサービス操作を実行します。 JSON文字列は、-generate-cli-skeletonで提供される形式に従います。 コマンドラインで他の引数が指定されている場合、CLI値はJSONが提供する値を上書きします。

ここで、nodejとしてランタイムを使用して簡単なAWS Lambda関数を作成し、印刷するconsole.logを追加しましょう。

同じを理解するためのサンプルコードを検討してください-

exports.handler = async (event) => {
   console.log("Using aws cli");
   return 'Hello from Lambda from aws cli!'
};

ここで、ファイルを圧縮し、 awscli.zip として保存します。

ARNを取得する

ロールには、作成した既存のロールの arn を使用しましょう。 ARNを取得するには、次の手順に従う必要があります。 接続されている場合は、それぞれのスクリーンショットを確認します-

ステップ1

IAMに移動し、ロール*から目的のロールを選択します。 以下に示すように、ロールのARN詳細が表示されます。 *aws cli の create-function で Role ARN を使用します。

サマリーCli

ここで、役割arnがarn：aws：iam

625297745038：role/lambdaapipolicyであることを確認します

• 作成機能*の値を持つコマンドは次のとおりです-

aws lambda create-function
--function-name "awslambdausingcli"
--runtime "nodejs8.10"
--role "arn:aws:iam::625297745038:role/lambdaapipolicy"
--handler "awscli.handler"
--timeout 5
--memory-size 256
--zip-file "fileb://awscli.zip"

これで、aws cliでコマンドを実行すると、次のように出力を見つけることができます-

Command Cli

AWSコンソールでは、以下に示すようにLambda関数が表示されます-

Cli関数

機能の詳細はここに示されているとおりです-

Cli Code

構成の詳細は以下のとおりです-

Cli Role

あなたが示すように機能をテストし、出力を確認することができます-

Cli Execution

対応するログ出力はここに示されています-

Cli出力

リスト関数

このAPIは、AWS Lambdaでこれまでに作成された関数のリストを提供します。

含まれるコマンド

以下は、このAPIに関連付けられているコマンドです-

list-functions
[--master-region <value>]
[--function-version <value>]
[--max-items <value>]
[--cli-input-json <value>]

リスト関数の下のオプション

以下は、このリスト関数APIの下で使用できるさまざまなオプションです-

-master-region（string）-オプション。 関数を表示する必要がある領域。

-function-version（string）-オプション。 これにより、関数のバージョンが示されます。

-max-items（integer）-オプション。 これにより、指定された値ごとにアイテムが提供されます。

-cli-input-json（string）-オプション。 提供されたjsonファイルに基づいて操作を実行します。

値 list-functions を持つコマンドは次のとおりです-

aws lambda list-functions --max-items 3

コマンドは次のように詳細を表示します-

Cli Display

取得機能

このAPIは、関数の詳細と、create-functionを使用してzipファイルをアップロードしたURLリンクを提供します。 zipの詳細を含むURLは10分間のみ有効です。

含まれるコマンド

以下は、このAPIに関連付けられているコマンドです-

get-function
--function-name <value>
[--qualifier <value>]
[--cli-input-json <value>]
[--generate-cli-skeleton <value>]

含まれるオプション

• -function-name *-AWS Lambda関数の名前。 関数のAmazonリソースネームを指定することもできます。

-qualifier（string）-オプション。 関数のバージョンを使用して、関数の詳細を取得できます。

関数を取得する値を持つコマンドは次のとおりです-

aws lambda get-function --function-name awslambdausingcli

コマンド表示の詳細は次のとおりです-

含まれるオプション

郵便番号がアップロードされたURLを提供します。 上記の場合、URLは-

https://prod-04-2014-
tasks.s3.amazonaws.com/snapshots/625297745038/awslambdausingcli-97048f8d-4a08
-4ed9-99d9-acb00d2063d2?versionId=d04HKvPu9S2zz8pzjbW6Rmf5o5fxnc_r&X-Amz-Security
-Token=FQoDYXdzEKT%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEaDCpTmGvtwKToPBiWcyK3A96UcJEnwvYDhMbbxu
%2Bg2gffK2ocfnlEeiCHak8QqqE1RFpbKrdks9NzxP9gNbagL4M9RValxJ1a9PUY%2FOdAekscRHOiX00MVAxUlI8
2pKryhdOwLJWSj0uRzqvOxCcBwJenHrSNPeG6lMa2ZDo0qZFEUDONSaTg4nuSnJK1f6t3pMAKu4vF9wPvf92G%2BU
60rUxwleggigISmD9l1IlZse3%2BVF1JlNuN%2F5d85v0y2Q%2F%2BO515CybcZpn91sHPYG8JMJ00LsrkQ2Ww4VU
9Zz5c5QYH4JYPj0CyEgSz9b%2FMceMPpOoPUAMjctb%2FEwQqcShZeqAr9%2Fcd2ZI%2BXl2%2Bs4ri0ucgPvQQvs
eGIIiZbX3GqdwR2jb1nylrAEIfiuFMoSWfcFYoYtuL0MZnjGR9jy2GNkp6MB%2BlHHr7%2BnuFRUzU26rgDYmdE1w
Rb3%2B21Jm49WGDa9opRLvUxFaux57Or70haib2FuKzN6Gf3Vzzk5KPdWsYUpaLyf%2B1ovEytOZhB1JEXuCs%2FG
IlOXS88yxT%2BpOKmyxweiezpGgI%2FAkSAQTbSRsYQKIOFyIJNHzplwrJKhy28vy60numIBIo9Zqq2AU%3D
&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20180527T112426Z&X-Amz-
SignedHeaders=host&X-Amz-Expires=600&X-Amz-
Credential=ASIAICSQHLSBWFP37U4Q%2F20180527%2Fus-
east-1%2Fs3%2Faws4_request&X-Amz-Signature=
8b97e7d6d7da13313068e027894d2c875be5e50a0c5a62550f55307985bdc1aa

get-function-configuration

これにより、AWS Lambda関数の構成の詳細が表示されます。

以下は、このAPIと一緒に使用されるコマンドです-

get-function-configuration
--function-name <value>
[--qualifier <value>]

• 以下は*で使用されるオプションです

-function-name（string）- awsラムダ関数の名前。 関数のAmazonリソースネームを指定することもできます。

• -qualifier（string）-*オプション。関数のバージョンを使用して、関数の詳細を取得できます。

関数を取得する値を持つコマンドは次のとおりです-

aws lambda get-function-configuration --function-name awslambdausingcli

コマンドは次のように詳細を表示します-

Get Function。

アカウント設定の取得

このAPIはアカウント設定を提供します。

関与するコマンド

このAPIで使用できるコマンドは次のとおりです-

get-account-settings
[--cli-input-json <value>]
[--generate-cli-skeleton <value>]

関係するオプション

このAPIで次のオプションを使用できます-

• -cli-input-json（string）-*指定されたjson文字列に基づいてサービスを実行します。

-generate-cli-skeleton（string）- APIリクエストを送信せずにjson出力を出力します。

あなたは、get-account-settingsに次のコマンドを使用できます-

aws lambda get-account-settings

上記のコマンドを実行すると、次の出力が表示されます-

関与するオプション

更新機能の構成

このAPIは、作成されたAWS Lambda関数の構成の詳細を更新するのに役立ちます。 メモリ、タイムアウト、ハンドラー、ロール、ランタイム、説明などを変更できます。

関与するコマンド

以下は、更新機能設定APIに関連するコマンドです-

update-function-configuration
--function-name <value>
[--role <value>]
[--handler <value>]
[--description <value>]
[--timeout <value>]
[--memory-size <value>]
[--environment <value>]
[--runtime <value>]
[--cli-input-json <value>]
[--generate-cli-skeleton <value>]

関係するオプション

以下は、更新機能設定APIに含まれるオプションです-

-関数名- awsラムダ関数の名前

• -role（string）-*オプション。 ロールのARNを更新する必要があります。

• -handler（string）-*オプション。 awsラムダ関数のハンドラーの詳細。

• -description（string）-*オプション。 関数の説明。

• -timeout（integer）-*オプション。 awsラムダ関数を終了するために必要な時間。

• -memory-size（integer）-*オプション。 これは、awsラムダ関数に与えられるメモリです。 AWSは、指定されたメモリに基づいてCPUとメモリの割り当てを割り当てます。

• -環境（構造）-*オプション。 これは、awsラムダ関数で必要な環境の詳細を持つオブジェクトです。

e.g: Variables = {Name1 = string, Name2 = string}

• -runtime（string）− *ここでは、ランタイム環境、つまり言語選択を指定する必要があります。

ランタイムの詳細は、以下の表に示されています-

Options available	runtime
Python v3.6	python3.6
Python v2.7	python2.7
NodeJS v6.10	nodejs6.10
NodeJS v8.10	nodejs8.10
Java	java8
C# 1	dotnetcore1.0
C# 2	dotnetcore2.0
Go	go1.x

• -cli-input-json（string）-*オプション。 これにより、提供されたjson文字列で指定されたAPIで操作が実行されます。

-generate-cli-skeleton（string）-*オプション。 これにより、APIを実行せずにすべての詳細のJSONスケルトンが出力されます。 出力は、-cli-input-json。*への入力として使用できます。

さて、先ほど作成したAWS Lambda関数のメモリとタイムアウトを変更しましょう。 以下の手順に従って、この目的のために添付された対応するスクリーンショットを観察します-

ステップ1

変更が発生する前のメモリとタイムアウトは次のとおりです-

タイムアウト

ステップ2

*update-function-configuration* を使用して、メモリとタイムアウトを320MBに、タイムアウトを10秒に変更しましょう。 この目的のために、値を指定して次のコマンドを使用します-

aws lambda update-function-configuration --function-name “awslambdusingcli”
--timeout 10 --memory-size 320

ステップ3

その後、ディスプレイとして次の出力を見ることができます-

Cli更新

ステップ4

*update-function-configuration* を使用した後のAWSコンソールの表示は次のとおりです-

Cli Configuration

更新機能コード

このAPIは、既存のAWS Lambda関数のコードを更新します。

関与するコマンド

update-function-code
--function-name <value>
[--zip-file <value>]
[--s3-bucket <value>]
[--s3-key <value>]
[--s3-object-version <value>]
[--cli-input-json <value>]
[--generate-cli-skeleton <value>]

関係するオプション

以下は、更新機能コードAPIに関連するオプションです-

-function-name（string）- awsラムダ関数の名前

• -zip-file（blob）-*オプション。 更新するコードを含むzipファイルのパス。

• -s3-bucket（string）-*オプション。 コードがアップロードされたzipファイルを持つS3バケット名。

• -s3-key（string）-*オプション。 アップロードする必要があるAWS s3オブジェクトキー名。

• -s3-object-version（string）-*オプション。 AWS s3オブジェクトバージョン。

• -cli-input-json（string）-*オプション。 これにより、提供されたjson文字列で指定されたAPIで操作が実行されます。

• -generate-cli-skeleton（string）-*オプション。 これにより、APIを実行せずにすべての詳細のJSONスケルトンが出力されます。 出力は、-cli-input-jsonへの入力として使用できます。

更新されたコードは以下のとおりです-

exports.handler = async (event, context) => {
   console.log("Using aws cli");
   console.log()
   return 'Hello from Lambda from aws cli!'
};

あなたはこの目的のための値で次の*コマンドを使用することができます-

aws lambda update-function-code --function-name "awslambdausingcli"
--zip-file "fileb://awscli.zip"

対応する出力はここに示されているとおりです-

Cli Purpose

AWSコンソールからの表示はここに示されているようです-

AWS Cliコンソール

対応するログ出力は以下のとおりです-

Cli Log

削除機能

*delete* aws cli apiは指定された関数を削除します。

含まれるコマンド

同じためのコマンドの詳細はここに与えられています-

delete-function
--function-name <value>
[--qualifier <value>]
[--cli-input-json <value>]
[--generate-cli-skeleton <value>]

含まれるオプション

このAPIに含まれるオプションは以下のとおりです-

• -function-name（string）-*これは、ラムダ関数名またはawsラムダ関数のarnを取ります。

• -qualifier（string）-*これはオプションです。 ここで、削除する必要があるaws lambdaのバージョンを指定できます。

• cli-input-json（string）-*提供されたJSON文字列に基づいてサービス操作を実行します。 JSON文字列は、-generate-cli-skeletonで提供される形式に従います。 コマンドラインで他の引数が指定されている場合、CLI値はJSONが提供する値を上書きします。

-generate-cli-skeleton（string）- APIリクエストを送信せずにjsonスケルトンを標準出力に出力します。

aws lambda delete-function --function-name "lambdatestcli"

関数の削除

今、関数がAWS Lambda関数リストに表示されないことを観察します-

Cliキーワード Aws-lambda-creating-and-deploying-using-serverless-framework

Lambda関数の実行と呼び出し

この章では、Lambda関数の実行と呼び出しのプロセスとそれに関連する手順について詳しく説明します。

AWS Lambda実行モデル

AWSの実行は、AWS Lambda Functionに追加された設定の詳細に依存します。 関数が作成されると、AWS Lambda関数の実行に使用される memory と* timeが割り当てられます*があります。

設定の詳細を利用して、AWS Lambdaは実行コンテキストを作成します。 実行コンテキストは一時的なランタイム環境であり、データベース接続、httpエンドポイント、サードパーティライブラリなどの外部依存関係があれば準備が完了しています。

AWS Lambda関数が初めて呼び出されたとき、またはラムダ関数が更新された場合、実行コンテキストのセットアップのために遅延がほとんど追加されません。 ただし、後続の呼び出しは最初の呼び出しに比べて高速です。 AWS Lambdaは、Lambda関数の呼び出し時間が短くなると、実行コンテキストの再利用を再試行します。

実行コンテキストの再利用には、次の意味があります-

• Lambdaの実行のために行われたデータベース接続がある場合、その接続は再利用のために維持されます。 そのため、Lambdaコードは、接続が最初にチェックされ、存在し、再利用されるようにする必要があります。それ以外の場合は、新しい接続を新しく作成する必要があります。
• 実行コンテキストは、 /tmp ディレクトリに500MBのディスク容量を維持します。 必要なデータはこのディレクトリにキャッシュされます。 コードに追加のチェックを行って、データが存在するかどうかを確認できます。
• Lambda関数が呼び出されたときにコールバックまたはバックグラウンドプロセスが完了していない場合、ラムダ関数が再度呼び出されたときに実行が開始されます。 そのようなことを行う必要がない場合は、関数の実行が完了したときにプロセスがすべて正しく終了することを確認してください。

実行コンテキストと、tmpディレクトリに保存されているデータを使用する必要があります。 新しいデータを作成する前に、コードに必要なチェックを追加して、必要なデータが存在するかどうかを確認する必要があります。 これにより、実行中の時間が節約され、より高速になります。

AWS Lambda関数を呼び出す

*aws cli* を使用してAWSを手動で呼び出すことができます。 *cli* を使用してAWS Lambdaを作成およびデプロイする方法は既に説明しました。 ここでは、まず *aws cli* を使用して関数を作成し、同じ関数を呼び出します。

AWS CLIを使用してAWS Lambda関数を作成する

*aws cli* を使用してAWS Lambda関数を作成するには、次のコマンドを使用できます-

コマンド

create-function
--function-name <value>
--runtime <value>
--role <value>
--handler <value>
[--code <value>]
[--description <value>]
[--timeout <value>]
[--memory-size <value>]
[--environment <value>]
[--kms-key-arn <value>]
[--tags <value>]
[--zip-file <value>]
[--cli-input-json <value>]

値を指定したコマンド

aws lambda create-function
--function-name "lambdainvoke"
--runtime "nodejs8.10"
--role "arn:aws:iam::625297745038:role/lambdaapipolicy"
--handler "index.handler"
--timeout 5
--memory-size 256
--zip-file "fileb://C:\nodeproject\index.zip"

出力は次のようになります-

値を持つコマンド

AWSコンソールで作成された関数は以下のとおりです-

作成された関数

コードエントリタイプ 既存のロール

これで、次のコマンドを使用して関数を呼び出すことができます： invoke

--function-name <value>
[--invocation-type <value>]
[--log-type <value>]
[--client-context <value>]
[--payload <value>]
[--qualifier <value>]
outfile <value>

オプション

• -function-name-*呼び出す関数の名前を指定します。

-invocation-type（string）-*デフォルトでは、invokation-typeは *requestresponse です。 invokation-typeで使用できる値は、 RequestResponse、Event 、および DryRun です。

• イベント呼び出しタイプは、非同期応答に使用されます。
• DryRunは、Lambda関数を実行せずに検証する場合に使用します。

-log-type-*呼び出しタイプがRequestResponseの場合、 *Tail になります。 最後の4KBのbase64でエンコードされたログデータを提供します。 可能な値は Tail および None です。

• -client-context-*クライアント固有の詳細をLambda関数に渡すことができます。 clientcontextは、json形式でbase64エンコードされている必要があります。 最大ファイルサイズは3583バイトです。

• -payload-*ラムダ関数へのjson形式の入力。

-qualifier- Lambda関数のバージョンまたはエイリアス名を指定できます。 関数バージョンを渡すと、apiは修飾された関数arnを使用してLambda関数を呼び出します。 エイリアス名を指定すると、APIはエイリアスARNを使用してLambda関数を呼び出します。

• outfile-*これは、コンテンツが保存されるファイル名です。

値を指定したコマンド

aws lambda invoke --function-name "lambdainvoke" --log-type
Tail C:\nodeproject\outputfile.txt

コマンド値

ペイロードオプションを使用して、以下に示すように、json形式でダミーイベントをラムダ関数に送信できます。

関連するAWS Lambdaコードは次のとおりです-

exports.handler = async (event, callback) => {
   console.log("Hello => "+ event.name);
   console.log("Address =>"+ event.addr);
   callback(null, 'Hello '+event.name +" and address is "+ event.addr);
};

コードにコンソール event.name と event.addr があることに注意してください。 さて、次のように名前とアドレスでイベントを送信するためにaws cliでペイロードオプションを使用してみましょう-

aws lambda invoke --function-name "lambdainvoke" --log-type
Tail --payload file://C:\clioutput\input.txt C:\clioutput\outputfile.txt

その後、payloadは、示されているようにjson入力を持つファイルパスとして入力を取ります-

{"name":"Roy Singh", "addr":"Mumbai"}

対応する出力は以下のとおりです-

対応する出力

出力は次のようにファイル C：\ clioutput \ outputfile.txt に保存されます-

"Hello Roy Singh and address is Mumbai"

サンプルイベント

サンプルイベントを渡すことで、AWS Lambda関数をテストできます。 このセクションでは、AWSサービスのサンプルイベントをいくつか示します。 invoke コマンドを使用して、いずれかのサービスでトリガーされたときに出力をテストできます。 以下の対応するサンプルイベントに指定されたコードを観察します-

Amazon S3 Putサンプルイベント

{
  "Records": [{
      "eventVersion": "2.0",
      "eventTime": "1970-01-01T00:00:00.000Z",
      "requestParameters": {
         "SourceIPAddress": "127.0.0.1"
      },
      "s3": {
         "configurationId": "testConfigRule",
         "object": {
            "eTag": "0123456789abcdef0123456789abcdef",
            "sequencer": "0A1B2C3D4E5F678901",
            "key": "HappyFace.jpg",
            "size": 1024
         },
         "bucket": {
            "arn": bucketarn,
            "name": "Sourcebucket",
            "ownerIdentity": {
               "principalId": "EXAMPLE"
            }
         },
         "s3SchemaVersion": "1.0"
      },
      "responseElements": {
         "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH",
         "x-amz-request-id": "EXAMPLE123456789"
      },
      "awsRegion": "us-east-1",
      "eventName": "ObjectCreated:Put",
      "userIdentity": {
         "principalId": "EXAMPLE"
      },
      "eventSource": "aws:s3"
   }]
}

s3プットイベントからファイルの*詳細を取得するには、次のコマンドを使用できます-

event.Records[0].s3.object.key  //will display the name of the file

バケット名を取得するには、次のコマンドを使用できます-

event.Records[0].s3.bucket.name //will give the name of the bucket.

*EventName* を参照するには、次のコマンドを使用できます-

event.Records[0].eventName   //will display the eventname

Amazon S3サンプルイベントの削除

{
   "Records": [{
      "eventVersion": "2.0",
      "eventTime": "1970-01-01T00:00:00.000Z",
      "requestParameters": {
         "SourceIPAddress": "127.0.0.1"
      },
      "s3": {
         "configurationId": "testConfigRule",
         "object": {
            "sequencer": "0A1B2C3D4E5F678901",
            "key": "HappyFace.jpg"
         },
         "bucket": {
            "arn": bucketarn,
            "name": "Sourcebucket",
            "ownerIdentity": {
               "principalId": "EXAMPLE"
            }
         },
        "s3SchemaVersion": "1.0"
      },
      "responseElements": {
         "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH",
         "x-amz-request-id": "EXAMPLE123456789"
      },
      "awsRegion": "us-east-1",
      "eventName": "ObjectRemoved:Delete",
      "userIdentity": {
         "principalId": "EXAMPLE"
      },
      "eventSource": "aws:s3"
   }]
}

Amazon DynamoDB

Amazon DynamoDBは、DynamoDBテーブルに変更が加えられた場合、AWS Lambdaのイベントになります。 DynamodDBテーブルのエントリの追加、レコードの更新、削除などの操作を実行できます。

DynamoDBの追加、挿入、削除イベントのサンプルイベントを次に示します-

{
  "Records": [{
      "eventID": "1",
      "eventVersion": "1.0",
      "dynamodb": {
         "Keys": {
            "Id": {
               "N": "101"
            }
         },
         "NewImage": {
            "Message": {
               "S": "New item!"
            },
            "Id": {
               "N": "101"
            }
         },
         "StreamViewType": "NEW_AND_OLD_IMAGES",
         "SequenceNumber": "111",
         "SizeBytes": 26
      },
      "awsRegion": "us-west-2",
      "eventName": "INSERT",
      "eventSourceARN": eventSourcearn,
      "eventSource": "aws:dynamodb"
   },
   {
      "eventID": "2",
      "eventVersion": "1.0",
      "dynamodb": {
         "OldImage": {
            "Message": {
               "S": "New item!"
            },
            "Id": {
               "N": "101"
            }
         },
        "SequenceNumber": "222",
        "Keys": {
            "Id": {
               "N": "101"
            }
         },
        "SizeBytes": 59,
        "NewImage": {
            "Message": {
               "S": "This item has changed"
            },
            "Id": {
                   "N": "101"
            }
         },
         "StreamViewType": "NEW_AND_OLD_IMAGES"
      },
      "awsRegion": "us-west-2",
      "eventName": "MODIFY",
      "eventSourceARN": Sourcearn,
      "eventSource": "aws:dynamodb"
   },
   {
   "eventID": "3",
      "eventVersion": "1.0",
      "dynamodb": {
         "Keys": {
            "Id": {
               "N": "101"
            }
         },
         "SizeBytes": 38,
         "SequenceNumber": "333",
         "OldImage": {
            "Message": {
               "S": "This item has changed"
            },
            "Id": {
               "N": "101"
            }
         },
         "StreamViewType": "NEW_AND_OLD_IMAGES"
      },      "awsRegion": "us-west-2",
      "eventName": "REMOVE",
      "eventSourceARN": Sourcearn,
      "eventSource": "aws:dynamodb"
   }]
}

Amazon簡易通知サービス

AWS Lambdaは、* Simple Notification Service（SNS）*で作成された通知の処理に役立ちます。 SNSにメッセージが公開されるたびに、メッセージの詳細を含むSNSイベントでLambda関数をトリガーできます。 このメッセージはLambda関数内で処理でき、要件に従って他のサービスにさらに送信できます。

メッセージが入力されると、SNSはLambda関数をトリガーします。 エラーがLambda関数を呼び出そうとすると、SNSは最大3回までラムダ関数の呼び出しを再試行します。

Amazon SNSサンプルイベント

AWS Lambda関数で利用可能なすべての詳細を備えたサンプルイベントは、さらにプロセスを実行するために以下に示されています-

{
  "Records": [{
      "EventVersion": "1.0",
      "EventSubscriptionArn": eventsubscriptionarn,
      "EventSource": "aws:sns",
      "Sns": {
         "SignatureVersion": "1",
         "Timestamp": "1970-01-01T00:00:00.000Z",
         "Signature": "EXAMPLE",
         "SigningCertUrl": "EXAMPLE",
         "MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e",
         "Message": "Hello from SNS!",
         "MessageAttributes": {
            "Test": {
               "Type": "String",
               "Value": "TestString"
            },
            "TestBinary": {
               "Type": "Binary",
               "Value": "TestBinary"
            }
         },
         "Type": "Notification",
         "UnsubscribeUrl": "EXAMPLE",
         "TopicArn": topicarn,
         "Subject": "TestInvoke"
      }
   }]
}

Amazon Simple Mail Service

Amazon Simple Mail Serviceは、メッセージの送信とメッセージの受信に使用できます。 AWS Lambda関数は、メッセージの受信時にSimple Mail Serviceで呼び出すことができます。

Amazon SES Eメール受信サンプルイベント

AWS Lambda内で使用される場合のSESイベントの詳細を以下に示します-

{
  "Records": [{
      "eventVersion": "1.0",
      "ses": {
         "mail": {
            "commonHeaders": {
               "from": [
                  "Jane Doe <[email protected]>"
               ],
            "to": [
               "[email protected]"
            ],
            "returnPath": "[email protected]",
            "messageId": "<0123456789Source.com>",
            "date": "Wed, 7 Oct 2015 12:34:56 -0700",
            "subject": "Test Subject"
         },
         "example": "[email protected]",
         "timestamp": "1970-01-01T00:00:00.000Z",
         "destination": [
            "[email protected]"
         ],
         "headers": [{
            "name": "Return-Path",
            "value": "<[email protected]>"
         },
         {
            "name": "Received",
            "value": "from mailer.example.com (mailer.example.com [203.0.113.1]) by inbound-smtp.us-west-2.amazonaws.com with SMTP id o3vrnil0e2ic for [email protected]; Wed, 07 Oct 2015 12:34:56 +0000 (UTC)"
         },
         {
            "name": "DKIM-Signature",
            "value": "v=1; a=rsa-sha256; c=relaxed/relaxed; d=example.com; s=example; h=mime-version:from:date:message-id:subject:to:content-type; bh=jX3F0bCAI7sIbkHyy3mLYO28ieDQz2R0P8HwQkklFj4=; b=sQwJ+LMe9RjkesGu+vqU56asvMhrLRRYrWCbV"
         },
         {
            "name": "MIME-Version",
            "value": "1.0"
         },
         {
            "name": "From",
            "value": "Jane Doe <[email protected]>"
         },
         {
            "name": "Date",
            "value": "Wed, 7 Oct 2015 12:34:56 -0700"
         },
         {
            "name": "Message-ID",
            "value": "<0123456789example.com>"
         },
         {
            "name": "Subject",
            "value": "Test Subject"
         },
         {
            "name": "To",
            "value": "[email protected]"
         },
         {
            "name": "Content-Type",
            "value": "text/plain; charset=UTF-8"
         }],
         "headersTruncated": false,
         "messageId": "o3vrnil0e2ic28tr"
      },
      "receipt": {
         "recipients": [
            "[email protected]"
         ],
         "timestamp": "1970-01-01T00:00:00.000Z",
         "spamVerdict": {
            "status": "PASS"
         },
         "dkimVerdict": {
            "status": "PASS"
         },
         "processingTimeMillis": 574,
         "action": {
            "type": "Lambda",
            "invocationType": "Event",
            "functionArn": "arn:aws:lambda:us-west-2:012345678912:function:example"
         },
         "spfVerdict": {
            "status": "PASS"
         },
         "virusVerdict": {
            "status": "PASS"
         }
      }
   },
   "eventexample": "aws:ses"
   }]
}

Amazon Cloudwatchログ

AWS Lambdaは、 CloudWatch Logs Subscriptions を使用してAmazon CloudWatch Logsからトリガーできます。 CloudWatch Logsサブスクリプションには、AWS Lambda内で処理および分析できる、または他のシステムへのロードに使用できるログに関するデータのリアルタイムデータがあります。

Amazon CloudWatch Logsサンプルイベント

{
   "awslogs": {
      "data": "H4sIAAAAAAAAAHWPwQqCQBCGX0Xm7EFtK+smZBEUgXoLCdMhFtKV3akI8d0bLYmibvPPN3wz00CJxmQnTO41whwW
      QRIctmEcB6sQbFC3CjW3XW8kxpOpP+OC22d1Wml1qZkQGtoMsScxaczKN3plG8zlaHIta5KqWsozoTYw3/djzwhpL
      wivWFGHGpAFe7DL68JlBUk+l7KSN7tCOEJ4M3/qOI49vMHj+zCKdlFqLaU2ZHV2a4Ct/an0/ivdX8oYc1UVX860fQ
      DQiMdxRQEAAA=="
   }
}

Amazon API Gateway

AWS Lambda関数は、 https URLで呼び出すことができます。 ITは GET、POST、PUT で実行できます。 https URLが呼び出されると、AWS Lambda関数もトリガーされ、get/postを使用してhttpsに渡されたデータをAWS Lambda内で使用可能にして、DynamoDBへの挿入やメールの送信などに使用できます。

API Gatewayプロキシリクエストイベント

{
   "path": "/test/hello",
   "headers": {
      "Accept":  "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
      "Accept-Encoding": "gzip, deflate, lzma, sdch, br",
      "Accept-Language": "en-US,en;q=0.8",
      "CloudFront-Forwarded-Proto": "https",
      "CloudFront-Is-Desktop-Viewer": "true",
      "CloudFront-Is-Mobile-Viewer": "false",
      "CloudFront-Is-SmartTV-Viewer": "false",
      "CloudFront-Is-Tablet-Viewer": "false",
      "CloudFront-Viewer-Country": "US",
      "Host": "wt6mne2s9k.execute-api.us-west-2.amazonaws.com",
      "Upgrade-Insecure-Requests": "1",
      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48",
      "Via": "1.1 fb7cca60f0ecd82ce07790c9c5eef16c.cloudfront.net (CloudFront)",
      "X-Amz-Cf-Id": "nBsWBOrSHMgnaROZJK1wGCZ9PcRcSpq_oSXZNQwQ10OTZL4cimZo3g==",
      "X-Forwarded-For": "192.168.100.1, 192.168.1.1",
      "X-Forwarded-Port": "443",
      "X-Forwarded-Proto": "https"
   },
   "pathParameters": {
      "proxy": "hello"
   },
   "requestContext": {
      "accountId": "123456789012",
      "reexampleId": "us4z18",
      "stage": "test",
      "requestId": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9",
       "identity": {
         "cognitoIdentityPoolId": "",
         "accountId": "",
         "cognitoIdentityId": "",
         "caller": "",
         "apiKey": "",
         "exampleIp": "192.168.100.1",
         "cognitoAuthenticationType": "",
         "cognitoAuthenticationProvider": "",
         "userArn": "",
         "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48",
         "user": ""
      },
      "reexamplePath": "/{proxy+}",
      "httpMethod": "GET",
      "apiId": "wt6mne2s9k"
   },
   "reexample": "/{proxy+}",
   "httpMethod": "GET",
   "queryStringParameters": {
      "name": "me"
   },
   "stageVariables": {
      "stageVarName": "stageVarValue"
   }
}

API Gatewayプロキシ応答イベント

{
   "statusCode": 200,
   "headers": {
      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
      "Accept-Encoding": "gzip, deflate, lzma, sdch, br",
      "Accept-Language": "en-US,en;q=0.8",
      "CloudFront-Forwarded-Proto": "https",
      "CloudFront-Is-Desktop-Viewer": "true",
      "CloudFront-Is-Mobile-Viewer": "false",
      "CloudFront-Is-SmartTV-Viewer": "false",
      "CloudFront-Is-Tablet-Viewer": "false",
      "CloudFront-Viewer-Country": "US",
      "Host": "wt6mne2s9k.execute-api.us-west-2.amazonaws.com",
      "Upgrade-Insecure-Requests": "1",
      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48",
      "Via": "1.1 fb7cca60f0ecd82ce07790c9c5eef16c.cloudfront.net (CloudFront)",
      "X-Amz-Cf-Id": "nBsWBOrSHMgnaROZJK1wGCZ9PcRcSpq_oSXZNQwQ10OTZL4cimZo3g==",
      "X-Forwarded-For": "192.168.100.1, 192.168.1.1",
      "X-Forwarded-Port": "443",
      "X-Forwarded-Proto": "https"
   },
   "body": "Hello World"
}

Aws-lambda-deleting-lambda-function

Amazon API Gatewayでの作業

AWS Lambda関数は、 HTTPS URLで呼び出すことができます。 GET、POST、PUTで​​実行できます。 HTTPS URLが呼び出されると、AWS Lambda関数もトリガーでき、 get/post を使用してHTTPSに渡されたデータをAWS Lambda内で使用可能にして、DynamoDBに挿入したり、メールを送信したりできます。

この章では、AWS lambdaおよびAPI Gatewayでの作業に関係するさまざまなプロセスについて詳しく説明します。

関係するプロセス

以下は、AWS lambdaおよびAPI Gatewayの操作に関係するプロセスです-

• 許可用のIAMロールを作成する
• AWSラムダ関数を作成する
• APIゲートウェイを作成する
• ラムダ関数をAPIゲートウェイにリンクする
• APIゲートウェイにデータを渡す

APIゲートウェイとAWS Lambdaの動作を説明する基本図をここに示します-

関与するプロセス

これらのプロセスについては、関連するスクリーンショットとともに、この章で詳しく説明します。

許可用のIAMロールを作成する

以下に示すように、Amazonサービスから、Lambda関数で使用されるロールを作成するためのIAMを選択します。

Create Iam

IAMに移動し、以下に示すように左側のセクションから*ロール*を選択します-

ダッシュボードメニュー

Lambda関数の[ロールの作成]をクリックします。

追加リソース

Lambdaを選択し、下部にある[許可]をクリックします。 API GatewayとLambdaに必要な権限を選択します。

タイプを選択

検索でAPIゲートウェイを検索すると、関連するすべての権限がリストされます。 ここでは、以下に示すように、APIゲートウェイへのフルアクセスを選択しました-

接続許可

ここで、APIゲートウェイを検索すると、関連するすべての権限がリストされます。 ここでは、以下に示すように、APIゲートウェイへのフルアクセスを選択しました-

Api Gateway

ポリシーについても同じプロセスを繰り返す必要があります。

ポリシー

必要なポリシーの選択が完了したら、次のステップのために*レビュー*をクリックします。 以下に示すように、選択に応じて役割の名前を入力します-

レビュー

ロールに添付されたポリシーを表示します。 [ロールの作成]をクリックすると、ロールの作成が完了し、ラムダ関数を続行できます。

AWS Lambda関数を作成する

AWSサービスに移動し、ラムダサービスをクリックして、APIゲートウェイに接続するための関数を作成します。

計算

Lambda関数のUI画面を以下に示します。 [関数の作成]ボタンをクリックして、Lambda関数の作成を続行します。

UI画面

関数の名前を入力し、上で作成した既存のロールを選択します。

名前を入力

*lambdawithapigateway* という名前の関数が正常に作成されたことを示すメッセージが点滅します。

Lambda Gateway

ここでは、 nodejs ランタイムを使用してコードを記述します。 helloworld メッセージを含むAWSコードは以下のとおりです-

環境

AWS Lambdaコードは index.js ファイルにあります。 ハンドラーと呼ばれる関数には、パラメーター、つまり events、context および callback があります。

コールバック関数には基本的にエラーと成功メッセージがあります。 ここではエラーに関連するコードがないため、nullが渡され、成功メッセージは* HelloWorld from lambda。*であることに注意してください。

最後に、追加した変更を保存し、Lambda関数をAPIゲートウェイに追加します。

APIゲートウェイを作成する

以下に示すように、AWSアカウントにログインし、API Gatewayを開きます-

コンテンツ配信

[APIゲートウェイ]をクリックすると、新しいAPIゲートウェイを作成できる画面に移動します。

Amazon Gateway

*Create API* をクリックし、以下に示すように詳細を追加します-

新規作成

画面の右側にある[ Create API ]ボタンをクリックします。 これにより、新しく作成されたAPIが画面の左側に表示されます。

新しいApiを作成

[アクション]ドロップダウンをクリックして、APIの新しいリソースを作成します。

アクションドロップダウン

次に、以下に示すように新しいリソースを作成します-

リソースグループ

以下に示すように、*リソース名*を入力します。 最後に作成されたURLに入力されたリソースの名前が表示されます。 *リソースの作成*をクリックすると、次のように画面に表示されます-

子リソース

リソースサービス

以下に示すように、作成されたリソースに GET/POST メソッドを追加します。 *アクション*ドロップダウンからメソッドを選択します。

メソッドの取得

*GET* メソッドをクリックして、APIにメソッドを追加します。

Apiメソッド

次のステップは、Lambda関数と統合する統合です。 次に、以下に示すようにLambda関数を追加します-

Get Setup

Lambda関数をAPI Gatewayにリンクする

前に作成したラムダ関数を選択します。

hello Setup

変更を保存すると、以下に示すように許可を求めるダイアログボックスが表示されます-

許可の追加

許可のために[OK]をクリックします。 これは、APIゲートウェイHTTPリクエストとLambda関数間の実行の詳細です-

メソッド実行

次に、APIゲートウェイの変更をデプロイします。 この目的のために、以下に示すように、 Actions ドロップダウンから Deploy API を選択する必要があります-

Deploy API

*Deploy API* を選択します。 展開状態を尋ねます。 [展開ステージ]ドロップダウンから[新しいステージ]を選択し、ステージ名を[生産]として追加します。

デプロイの選択

• デプロイ*ボタンをクリックすると、以下に示すようにURLにリダイレクトされます-

クリックデプロイ

左側から GET メソッドを選択して、URLを取得します。 新しいタブでURLを開き、Lambda関数からのメッセージを確認します。

Select Get

これは、AWS LambdaとAWS API Gatewayを使用した基本的な例です。 上記の例では、Lambda関数でメッセージをハードコーディングしました。

次に、API Gatewayからメッセージの詳細を取得します。 APIへのAJAX呼び出しなど、HTTPS呼び出しを別のドメインから呼び出す必要がある場合、作成されたAPIゲートウェイのCORSを有効にする必要があります。

API用に作成されたreSourceを選択し、[アクション]ドロップダウンをクリックします-

Helloメソッド

今、 Enable CORS は次の画面を開きます-

Corsを有効にする

CORSを有効にする方法はほとんどありません。 Access-Control-Allow-Origin は*としてマークされています。これは、任意のドメインのAPIゲートウェイからコンテンツを取得できることを意味します。

APIを使用するドメイン名を指定することもできます。 *[CORSを有効にして既存のCORSヘッダーを置き換える]ボタンをクリックすると、以下に示す確認メッセージが表示されます-

適合メソッド

[はい、既存の値を置き換えます]ボタンをクリックして有効にします。* CORSを有効にする画面は次のようになります-

既存の値を置換

API Gatewayにデータを渡す

以下に示すように、API Gateway displayhelloworld で作成されたAPIを開きます-

データの受け渡し

下に示すようにデータを送信するには、*統合要求*をクリックします-

統合リクエスト

*Body Mapping Templates* を選択し、この例の *Content-Type* を *application/json* として追加します。 追加されたコンテンツタイプをクリックして、次のように詳細を追加します-

ボディマッピング

次に、以下に示すようにテンプレートをJSON形式で追加します-

Json

API Gatewayからデータを取得し、AWS Lambdaと共有するためのパラメーターとしてメッセージを受け取ったことを確認します。 詳細を取得する構文は上記のとおりです。

次に、APIをデプロイして、API Gateway URLで変更を利用できるようにします。 このため、Lambda関数を変更して、API Gateway URLに基​​づいてデータを表示する必要があります。 Lambda関数のコードは以下のgivnです。 イベントからメッセージを取得し、コールバックに渡すことに注意してください。

exports.handler = (event, context, callback) => {
   let message = event.message;
   callback(null, message);
};

次に、変更をLambdaに保存し、URLを押して変更を確認します。 以下のスクリーンショットを確認してください-

スクリーンショットを見る

以下に示すようにURLをクリックしてください-

https://rw2ek1xung.execute-api.us-east-
1.amazonaws.com/prod/hello?message=hello%20from%20api%20gateway

ここで、クエリ文字列としてメッセージをGET URLに渡していることに注意してください。 次に、以下に示すように出力を観察できます-

メッセージの受け渡し

URLからメッセージに送信された詳細を読み取り、ブラウザに表示します。

Amazon S3でLambda関数を使用する

Amazon S3サービスは、ファイルをアップロードまたは削除できるファイルストレージに使用されます。 S3バケットにファイルのアップロードがある場合、S3でAWS Lambdaをトリガーできます。 AWS Lambdaには、AWS Lambda関数の開始点として機能するハンドラー関数があります。 ハンドラーにはイベントの詳細があります。 この章では、S3バケットにファイルをアップロードするときにAWS S3を使用してAWS Lambda関数をトリガーする方法を見てみましょう。

Amazon S3でAWS Lambda関数を使用する手順

Amazon S3でAWS Lambdaの使用を開始するには、次のものが必要です-

• S3バケットを作成する
• s3およびlambdaを使用する権限を持つロールを作成します
• ラムダ関数を作成し、トリガーとしてs3を追加します。

例

Amazon S3とAWS Lambdaの基本的な相互作用を示す例の助けを借りて、これらの手順を見てみましょう。

• ユーザーはAmazon S3バケットにファイルをアップロードします
• ファイルがアップロードされると、バックグラウンドでAWS Lambda関数がトリガーされ、ファイルがアップロードされたことを示すコンソールメッセージの形式で出力が表示されます。
• ファイルがアップロードされると、ユーザーはCloudwatchログでメッセージを見ることができます。

例の流れを説明するブロック図はここに示されています-

アップロード関数

S3バケットの作成

以下に示す手順を使用して、AWSコンソールでs3バケットを作成することから始めましょう-

ステップ1

アマゾンサービスに移動し、下の画像で強調表示されているストレージセクションで S3 をクリックします-

S3ストレージ

ステップ2

S3ストレージをクリックし、アップロードされたファイルを保存する*バケットを作成*します。

アップロードされたファイル

ステップ3

• バケットの作成*ボタンをクリックすると、次のような画面が表示されます-

作成をクリック

ステップ4

詳細*バケット名を入力し、地域*を選択して、左下にある*作成*ボタンをクリックします。 したがって、 workingwithlambdaands3 という名前のバケットを作成しました。

地域の選択

ステップ5

今、バケット名をクリックすると、以下に示すようにファイルをアップロードするように求められます-

バケットのアップロード

したがって、S3でのバケットの作成は完了です。

S3およびLambdaで機能するロールを作成する

S3とラムダで動作するロールを作成するには、以下の手順に従ってください-

ステップ1

以下に示すように、AWSサービスに移動し、IAMを選択します-

Work With S3

ステップ2

次に、以下に示すように、 IAM→ Roles をクリックします-

Iam Roles

ステップ3

ここで、 Create role をクリックして、このロールを使用するサービスを選択します。 Lambdaを選択し、 Permission ボタンをクリックします。

許可ボタン

ステップ4

下から許可を追加し、[レビュー]をクリックします。

レビューをクリック

ステップ5

次のアクセス許可を選択したことを確認します-

以下の許可

選択したポリシーが AmazonS3FullAccess、AWSLambdaFullAccess および CloudWatchFullAccess であることに注意してください。

ステップ6

ここで、ロール名、ロールの説明を入力し、下部の Create Role ボタンをクリックします。

役割の作成

したがって、 lambdawiths3service という名前のロールが作成されます。

Lambda関数を作成し、S3トリガーを追加する

このセクションでは、Lambda関数を作成してS3トリガーを追加する方法を見てみましょう。 この目的のために、あなたは以下に与えられた番目のステップに従う必要があります-

ステップ1

AWSサービスに移動し、以下に示すようにLambdaを選択します-

Select Lambda

ステップ2

*Lambda* をクリックして、 *Name* を追加するプロセスに従います。 *Runtime、Role* などを選択します。 関数を作成します。 作成したLambda関数は、以下のスクリーンショットに示されています-

ランタイムの選択

ステップ3

次に、S3トリガーを追加します。

S3を追加

ステップ4

上からトリガーを選択し、以下に示すように詳細を追加します-

トリガーを選択

ステップ5

バケットのドロップダウンから作成されたバケットを選択します。 イベントタイプには次の詳細があります-

バケットダウンドロップ

ファイルのアップロード、削除などのときにAWS Lambdaトリガーが必要になるため、* Object Created（All）*を選択します。

ステップ6

追加したファイルのフィルタリングに使用されるプレフィックスとファイルパターンを追加できます。 たとえば、.jpgイメージに対してのみラムダをトリガーします。 アップロードされたすべてのファイルに対してLambdaをトリガーする必要があるため、ここでは空白のままにします。 [追加]ボタンをクリックして、トリガーを追加します。

ファイルパターン

ステップ7

以下に示すように、ラムダ関数のトリガー表示を見つけることができます-

トリガー表示

aws lambda関数の詳細を追加しましょう。 ここでは、オンラインエディターを使用してコードを追加し、nodejsをランタイム環境として使用します。

ステップ8

AWS LambdaでS3をトリガーするには、以下に示すようにコードでS3イベントを使用する必要があります-

exports.handler = function(event, context, callback) {
   console.log("Incoming Event: ", event);
   const bucket = event.Records[0].s3.bucket.name;
   const filename = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
   const message = `File is uploaded in - ${bucket} -> ${filename}`;
   console.log(message);
   callback(null, message);
};

イベントパラメータには、S3eventの詳細が含まれていることに注意してください。 S3bucketで画像をアップロードするときにログに記録されるバケット名とファイル名をコンソールに表示しました。

ステップ9

次に、変更を保存し、S3uploadを使用してラムダ関数をテストします。 以下はAWS Lambdaに追加されたコードの詳細です-

コードの詳細

ステップ10

次に、ロール、メモリ、およびタイムアウトを追加しましょう。

メモリタイムアウト

手順11

次に、Lambda関数を保存します。 AmazonサービスからS3を開き、先ほど作成したバケット workingwithlambdaands3 を開きます。

以下に示すように、その中に画像をアップロードします-

画像のアップロード

手順12

示されているようにファイルを追加するには、*アップロード*ボタンをクリックします-

アップロードをクリック

ステップ13

[ファイルの追加]をクリックして、ファイルを追加します。 ファイルをドラッグアンドドロップすることもできます。 次に、[*アップロード]ボタンをクリックします。

ファイルの追加

したがって、S3バケットに1つの画像をアップロードしました。

ステップ14

トリガーの詳細を確認するには、AWSサービスに移動し、 CloudWatch を選択します。 Lambda関数のログを開き、次のコードを使用します-

exports.handler = function(event, context, callback) {
   console.log("Incoming Event: ", event);
   const bucket = event.Records[0].s3.bucket.name;
   const filename = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
   const message = `File is uploaded in - ${bucket} -> ${filename}`;
   console.log(message);
   callback(null, message);
};

Cloudwatchで確認できる出力は次のとおりです-

クラウドウォッチを監視

ファイルがS3バケットにアップロードされ、詳細が以下に示すようにCloudwatchに記録されると、AWS Lambda関数がトリガーされます-

S3バケット Aws-lambda-using-lambda-function-with-amazon-dynamodb

スケジュールされたイベントでのLambda関数の使用

スケジュールされたイベントは、ルールセットに基づいて定期的に発生することを想定しています。 スケジュールされたイベントは、cloudwatchサービスで定義された間隔後にLambda関数を実行するために使用されます。 これらは、AWS Lambdaとともにcronジョブでの作業に最適です。 この章では、スケジュールされたイベントとAWS Lambdaを使用して5分ごとにメールを送信する方法を簡単な例で説明します。

必要条件

スケジュールされたイベントでLambda関数を使用するための要件は次のとおりです-

• AWS SESを使用してメールIDを確認する
• AWS SES、Cloudwatch、AWS Lambdaを使用するロールを作成します
• メールを送信するLambda関数を作成する
• AWS CloudWatchからスケジュールされたイベントのルールを追加する

例

検討する例では、CloudWatchイベントをAWS Lambda関数に追加します。 Cloudwatchは、アタッチされた時間パターンに基づいてAWS Lambdaをトリガーします。 たとえば、次の例では、トリガーとして5分を使用しています。 つまり、5分ごとにAWS Lambdaがトリガーされ、トリガーされるたびにAWS Lambdaがメールを送信します。

同じための基本的なブロック図は以下に示されています-

基本ブロック図

AWS SESを使用してメールIDを確認する

以下に示すように、AWSにログインし、AWS SESサービスにアクセスします-

顧客エンゲージメント

さて、示されているように*シンプルなメール*サービスをクリックしてください-

シンプルなメール

示されているように左側の*メールアドレス*をクリックします-

メールアドレス

ボタン Verify a New Email Address が表示されます。 クリックして。

メールアドレスの確認

確認する*メールアドレス*を入力します。 [このメールアドレスを確認]ボタンをクリックします。 そのメールIDでAWSからメールを受信します。メールの件名は次のとおりです：Amazon Web Services –米国東部（N. バージニア州）

メールに記載されているリンクをクリックして、メールアドレスを確認します。 確認されると、次のように電子メールIDが表示されます-

メールを表示

AWS SES、Cloudwatch、AWS Lambdaを使用するロールを作成します

サービスを使用する許可を与える役割を作成することもできます。 このためには、IAMに移動して[ロール]を選択します。 必要なポリシーを追加して、ロールを作成します。 ここで作成されたロールは、*ラムダ付きイベント*であることに注意してください。

ラムダによるイベント

メールを送信するLambda関数を作成する

nodejsとしてランタイムを使用してLambda関数を作成するには、手順に従う必要があります。

Lambda Event Emails

次に、示されているようにLambdaにトリガーを追加します-

トリガーラムダの追加

以下に示すように、 CloudWatch Events Trigger に詳細を追加します-

Cloudwatch Events

作成されたルールトリガーに従って、イベントは5分ごとにトリガーされることに注意してください。

電子メールを送信するためのラムダコードは以下のとおりです-

var aws = require('aws-sdk');
var ses = new aws.SES({
   region: 'us-east-1'
});
exports.handler = function(event, context, callback) {
   var eParams = {
      Destination: {
         ToAddresses: ["[email protected]"]
      },
      Message: {
         Body: {
            Text: {
               Data: "this mail comes from aws lambda event scheduling"
            }
         },
         Subject: {
            Data: "Event scheduling from aws lambda"
         }
      },
      Source: "[email protected]"
   };
   console.log('===SENDING EMAIL===');
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
      else {
         console.log("===EMAIL SENT===");
         console.log("EMAIL CODE END");
         console.log('EMAIL: ', email);
         context.succeed(event);
         callback(null, "email is send");
      }
   });
};

次に、AWS SESサービスが必要です。 次のように示されているコードを使用してこれを追加できます-

var aws = require('aws-sdk');
var ses = new aws.SES({
   region: 'us-east-1'
});

*nodejs* からメールを送信するために、次のように、* example mailのような詳細を含む *eParams* オブジェクトを作成しました。

var eParams = {
   Destination: {
      ToAddresses: ["[email protected]"]
   },
   Message: {
      Body: {
         Text: {
            Data: "this mail comes from aws lambda event scheduling"
         }
      },
      Subject: {
         Data: "Event scheduling from aws lambda"
      }
   },
   Source: "[email protected]"
};

電子メールを送信するラムダコードは次のとおりです-

var email = ses.sendEmail(eParams, function(err, data) {
   if (err) console.log(err);
   else {
      console.log("===EMAIL SENT===");
      console.log("EMAIL CODE END");
      console.log('EMAIL: ', email);
      context.succeed(event);
      callback(null, "email is send");
   }
});

次に、このLambda関数を保存し、メールのメールIDを確認します。 以下に示すスクリーンショットは、5分ごとにメールがAWS Lambdaから送信されることを示しています。

イベントスケジューリング

Amazon SNSでLambda関数を使用する

Amazon SNSは、プッシュ通知に使用されるサービスです。 この章では、次のアクションを実行する例を使用して、AWS LambdaとAmazon SNSの動作を説明します-

• SNSサービスでトピックを作成し、AWS Lambdaを使用してCloudWatchにトピックを追加する
• 指定された電話番号でSNSテキストメッセージを送信します。

必要条件

SNSサービスでトピックを作成し、AWS Lambdaを使用してCloudWatchにトピックを追加するには、以下の手順に従う必要はありません-

• SNSでトピックを作成
• IAMでアクセス許可のロールを作成する
• AWS Lambda関数を作成する
• トリガーを有効にするためにトピックに公開する
• CloudWatchサービスでメッセージの詳細を確認します。

与えられた電話番号でSNSテキストメッセージを送信するには、次を行う必要があります-

• AWS Lambdaにコードを追加して、携帯電話にメッセージを送信します。

例

この例では、SNSにトピックを作成します。 発行するトピックに詳細が入力されると、AWS Lambdaがトリガーされます。 トピックの詳細はCloudWatchに記録され、AWS Lambdaによって電話でメッセージが送信されます。

ここに同じを説明する基本的なブロック図があります-

ブロック図Sns

SNSでトピックを作成

以下の手順に従って、SNSでトピックを作成する必要があります-

ステップ1

以下に示すように、AWSコンソールにログインし、AmazonのSNSサービスに移動します-

Amazon Snsサービス

ステップ2

[*簡易通知*サービス]をクリックし、*トピックを作成*します。

通知サービス

ステップ3

次に、次のように Create new topic ボタンをクリックする必要があります-

新しいトピック

ステップ4

• トピック名*と*表示名*を入力し、*トピックの作成*をクリックします。 次のようにディスプレイにトピック名が表示されるはずです-

トピック名

IAMでアクセス許可のロールを作成する

AWS LambdaおよびSNSサービスと連携するロールを作成するには、AWSコンソールにログインする必要があります。 次に、AmazonサービスからIAMを選択し、以下に示すように左側のロールをクリックします。

ロールの許可

SNS、Lambda、CloudWatchのポリシーが追加されていることを確認してください。 ロール名を追加し、[ロールの作成]ボタンをクリックして、ロールの作成プロセスを完了します。

追加されたポリシー

AWS Lambda関数を作成する

このセクションでは、nodejsをランタイムとして使用してAWS Lambda関数を作成する方法を理解します。

この目的のために、AWSコンソールにログインし、AWSサービスからAWS Lambdaを選択します。 関数名、ロールの詳細などを追加し、示されているようにAWS Lambda関数を作成します。

ラムダの作成

SNSトリガーを追加

SNSトリガーを追加するには、示されているようにSNS構成の詳細を入力します-

Add Sns

次に、* SNSトピック*を選択し、トリガーをAWS Lambda関数に*追加*します。

Snsトピック

次に、以下に示すAWSラムダコードを追加します-

exports.handler = function(event, context, callback) {
   console.log("AWS lambda and SNS trigger ");
   console.log(event);
   const sns = event.Records[0].Sns.Message;
   console.log(sns)
   callback(null, sns);
};

上記のコードでは、 event.Records [0] .Sns.Message が追加されたメッセージの詳細を提供します。 CloudWatchで表示するためにコンソールログを追加しました。 次に、必要なメモリと時間の割り当てとともにLambda関数を保存します。

トリガーをアクティブ化するトピックに公開

手順1で既にSNSにトピックを作成したことを思い出してください。 ここでトピックで公開し、AWS LambdaによってトリガーされるCloudWatchで詳細を確認します-

トピックに公開

最初に、公開するトピックの名前を選択します。 [トピックに公開]ボタンをクリックします-

トピックの公開

以下に示すように Subject と Message の詳細を入力します-

メッセージの詳細

*JSON* メッセージ形式を選択して、 *JSON* スタイルで送信することもできます。 画面の最後にある[*メッセージを公開する]ボタンをクリックします。

CloudWatchサービスでメッセージの詳細を確認する

AWSコンソールにログインし、CloudWatchサービスを開きます。 左側のログをクリックして、作成されたAWS Lambda関数のログを選択します。 上記のように作成されたメッセージを含むログの次の表示を見つけることができます-

メッセージの確認

AWS Lambdaにコードを追加してメッセージを電話に送信する

ここでは、SNSテキストメッセージングを使用して、AWS Lambdaを使用して電話でメッセージを送信します。 次のコードを使用して、AWS Lambdaコードを次のように更新できます-

const aws =  require("aws-sdk");
const sns = new aws.SNS({
   region:'us-east-1'
});
exports.handler = function(event, context, callback) {
   console.log("AWS lambda and SNS trigger ");
   console.log(event);
   const snsmessage = event.Records[0].Sns.Message;
   console.log(snsmessage);
   sns.publish({
      Message: snsmessage,
      PhoneNumber: '+911212121212'
   }, function (err, data) {
      if (err) {
         console.log(err);
         callback(err, null);
      } else {
         console.log(data);
         callback(null, data);
      }
   });
};

メッセージの送信に使用するAWS SDKとSNSサービスを追加しました。 SNSからのイベントからのメッセージは、指定された電話番号にテキストメッセージとして送信されます。

例のために次のコードを観察します-

sns.publish({
   Message: snsmessage,
   PhoneNumber: '+911212121212'
}, function (err, data) {
   if (err) {
      console.log(err);
      callback(err, null);
   } else {
      console.log(data);
      callback(null, data);
   }
});

ここでトピックを入力して、クラウドウォッチのメッセージと上記の電話番号を確認します。

トピックを入力

[メッセージを公開]をクリックして、メッセージを公開します。 次のように与えられた電話番号にメッセージが表示されます-

メッセージの公開

CloudTrailでLambda関数を使用する

*AWS CloudTrail* はAmazonで利用可能なサービスで、AWSコンソール内で行われたすべてのアクティビティを記録するのに役立ちます。 すべてのAPI呼び出しをログに記録し、履歴を保存します。これは後でデバッグ目的で使用できます。 CloudTrailからLambdaをトリガーできないことに注意してください。 代わりに、CloudTrailはすべての履歴をログの形式でS3バケットに保存し、S3からAWS Lambdaをトリガーできます。 ログが処理されると、S3バケットにログが追加されるたびにAWS Lambdaがトリガーされます。

必要条件

あなたがAWS CloudTrail、S3およびAWS Lambdaで作業を開始する前に、次を実行する必要があります-

• CloudTrailログを保存するS3バケットを作成する
• SNSサービスを作成する
• CloudTrailで証跡を作成し、S3バケットとSNSサービスを割り当てます
• IAMロールを許可付きで作成します。
• AWSラムダ関数を作成する
• AWS Lambda設定

例

AWS CloudTrail、S3、AWS Lambdaの動作を示す例を考えてみましょう。 ここでは、S3でバケットを作成し、AWSコンソールで行われた相互作用のすべてのログを保存します。 SNSトピックを作成して公開しましょう。 このアクションの場合、ログはS3にファイルとして入力されます。 AWSラムダがトリガーされ、Amazon SESサービスを使用してメールが送信されます。

このプロセスを説明するためのブロック図は以下のとおりです-

ブロック図Cloudtrail

CloudTrailログを保存するS3バケットを作成する

AWSコンソールに移動し、S3サービスをクリックします。 [*バケットの作成]をクリックし、示されているようにcloudtrailログを保存するバケットの名前を入力します-

バケットの作成

ここで、ログを保存するためのS3バケット cloudtraillogsaws を作成したことに注意してください。

SNSサービスを作成する

AWSコンソールに移動し、[簡易通知サービス]をクリックします。 左側からトピックを選択し、[新しいトピックを作成]ボタンをクリックします。

簡易通知

トピックを公開する displaytrail というトピックを作成しました。 その詳細は、上記で作成されたS3bucketに保存されます。

Cloudtrailで証跡を作成し、S3バケットとSNSサービスを割り当てます

AWSコンソールに移動し、示されているように管理ツールから CloudTrail サービスをクリックします-

トレイルの作成

以下に示すように、左側から*トレイル*をクリックします-

Trail Dashboard

トレイル

[証跡の作成]ボタンをクリックします。 *トレイル名を入力し、すべてのリージョンにトレイルを適用*し、*はい*を選択します。 その後、ログはすべてのリージョンに適用されます。

トレイル名

読み取り/書き込みイベント*では、*すべて*を選択します。 以下に示すように、 S3バケット*および* SNSトピック*の詳細を追加します。 ここで新しいものを作成するか、既存のものを追加できます。

イベントの読み取り

• ログファイルの暗号化、ログファイルの検証の有効化、ログファイルの配信ごとにsns通知を送信する*などのオプションがあります ここではデフォルト値を使用しました。 ファイルの暗号化を許可すると、暗号化キーが要求されます。 詳細が追加されたら、「証跡の作成」ボタンをクリックします。

暗号化ログ

許可付きのIAMロールを作成する

AWSコンソールに移動し、IAMを選択します。 メールを送信するためのS3、Lambda、CloudTrail、およびSESの権限を持つロールを作成します。 作成された役割は以下のとおりです-

トレイルラムダ

AWS Lambda関数を作成する

AWSサービスに移動し、 Lambda サービスをクリックします。 関数名を追加し、ランタイムを nodejs として選択し、ラムダ関数用に作成されたロールを選択します。 以下は、作成されたラムダ関数です。

ラムダトレイル

AWS Lambda設定

次に、作成されたAWSラムダのトリガーとしてS3を追加する必要があります。

ラムダ構成

S3バケットの詳細を追加してトリガーを追加し、次のAWS Lambdaコードを追加します-

const aws =  require("aws-sdk");
const sns = new aws.SNS({
region:'us-east-1'
});
var ses = new aws.SES({
   region: 'us-east-1'
});
exports.handler = function(event, context, callback) {
   console.log("AWS lambda and SNS trigger ");
   console.log(event);
   const s3message = "Bucket Name:"+event.Records[0].s3.bucket.name+"\nLog details:"+event.Records[0].s3.object.key;
   console.log(s3message);
   var eParams = {
      Destination: {
         ToAddresses: ["[email protected]"]
      },
      Message: {
         Body: {
            Text: {
               Data:s3message
            }
         },
         Subject: {
            Data: "cloudtrail logs"
         }
      },
      Source: "[email protected]"
   };
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
      else {
         console.log("===EMAIL SENT===");
         console.log("EMAIL CODE END");
         console.log('EMAIL: ', email);
         context.succeed(event);
         callback(null, "email is send");
      }
   });
};

上記のように、イベントからS3バケットとログの詳細を取得し、SESサービスを使用してメールを送信していることに注意してください。

AWSコンソールでアクティビティが発生するたびに、ログがS3バケットに送信されると同時に、AWS lambdaがトリガーされ、メールがコードに記載されているメールIDに送信されます。

Cloudtrailログ

AWS Lambdaのニーズに応じてログを処理できることに注意してください。

Amazon KinesisでLambda関数を使用する

*AWS Kinesis* サービスは、ウェブサイトのクリック、ログ、ソーシャルメディアフィードからのリアルタイムトラッキングデータをキャプチャ/保存するために使用されます。 AWS Lambdaをトリガーして、このログで追加の処理を実行できます。

必要条件

KinesisとAWS Lambdaを開始するための基本的な要件は次のとおりです-

• 必要な権限を持つロールを作成します
• Kinesisでデータストリームを作成する
• AWS Lambda関数を作成します。
• AWS Lambdaにコードを追加する
• Kinesisデータストリームにデータを追加する

例

Kinesisからのデータストリームを処理するためにAWS Lambdaをトリガーし、受信したデータでメールを送信する例に取り組みましょう。

プロセスを説明するための簡単なブロック図を以下に示します-

ブロック図キネシス

必要な権限を持つロールを作成する

AWSコンソールに移動し、ロールを作成します。

必要な権限

Kinesisでデータストリームを作成する

AWSコンソールに移動し、kinesisでデータストリームを作成します。

データストリーム

示されているように4つのオプションがあります。 この例では、データストリームの作成に取り組みます。

データストリームの作成

[データストリームの作成]をクリックします。 下記のKinesisストリーム名に名前を入力します。

Kinesis Streamの作成

データストリームのシャードの数を入力します。

推定番号

シャードの詳細は以下のとおりです-

シャード

名前を入力し、下部にある[* Kinesisストリームの作成]ボタンをクリックします。

キネシスストリーム

ストリームがアクティブになるには一定の時間がかかることに注意してください。

AWS Lambda関数を作成する

AWSコンソールに移動し、Lambdaをクリックします。 次のようにAWS Lambda関数を作成します-

キネシスラムダ

画面の最後にある[関数の作成]ボタンをクリックします。 AWS LambdaにトリガーとしてKinesisを追加します。

キネシストリガー

Kinesisトリガーに構成の詳細を追加します-

キネシスの構成

トリガーを追加し、AWS Lambdaにコードを追加します。

AWS Lambdaにコードを追加する

この目的のために、ランタイムとしてnodejsを使用します。 AWS Lambdaがkinesisデータストリームでトリガーされたら、メールを送信します。

const aws =  require("aws-sdk");
var ses = new aws.SES({
   region: 'us-east-1'
});
exports.handler = function(event, context, callback) {
   let payload = "";
   event.Records.forEach(function(record) {
     //Kinesis data is base64 encoded so decode here
      payload = new Buffer(record.kinesis.data, 'base64').toString('ascii');
      console.log('Decoded payload:', payload);
   });
   var eParams = {
      Destination: {
         ToAddresses: ["[email protected]"]
      },
      Message: {
         Body: {
            Text: {
               Data:payload
            }
         },
         Subject: {
            Data: "Kinesis data stream"
         }
      },
      Source: "[email protected]"
   };
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
      else {
         console.log("===EMAIL SENT===");
         console.log("EMAIL CODE END");
         console.log('EMAIL: ', email);
         context.succeed(event);
         callback(null, "email is send");
      }
   });
};

イベントパラメータには、kinesisデータストリームに入力されたデータが含まれます。 上記のawsラムダコードは、kinesisデータストリームにデータが入力されるとアクティブになります。

Kinesis Data Streamにデータを追加する

ここでは、AWS CLIを使用して、以下に示すようにデータキネシスデータストリームを追加します。 この目的のために、次のコマンドを使用できます-

aws kinesis put-record --stream-name kinesisdemo  --data "hello world" --
partition-key "789675"

Data Kinesis

次に、AWS Lambdaがアクティブ化され、メールが送信されます。

メールのアクティブ化

Kinesis Command Kinesis Mail

カスタムユーザーアプリケーションでのLambda関数の使用

次の2つの方法で、AWSラムダ関数を使用して、ユーザーアプリケーションによって生成されたイベントを使用して処理できます-

• AWSコンソールを使用する
• AWS CLIを使用する

AWSコンソールを使用する

AWSコンソールから、イベントとAWS Lambdaを操作します。 この目的のために、AWSコンソールに移動し、ラムダ関数を作成します。

ラムダカスタム

次に、AWS Lambdaのコードを追加しましょう-

exports.handler = (event, context, callback) => {
  //TODO implement
   console.log("Hello => "+ event.name);
   console.log("Address =>"+ event.addr);
   callback(null, 'Hello '+event.name +" and address is "+ event.addr);
};

上記のコードでは、イベントを使用して名前と住所を出力していることに注意してください。

イベントの詳細は、次のように作成されたテストイベントを使用して与えられます-

イベントの設定

次に、イベントを保存してテストします。

イベントを保存

対応するログ出力は次のとおりです-

カスタム出力

AWS CLIを使用する

次のようにAWS CLIを使用して上記の関数を呼び出すことができます-

aws lambda invoke --function-name "lambdauserevent" --log-type Tail --
payload file://C:\clioutput\input.txt C:\clioutput\outputfile.txt

イベントの詳細はペイロードに与えられ、出力は次のように* C：\ clioutput \ outputfile.txt。*に保存されます-

*input.txt*

{"name":"Roy Singh", "addr":"Mumbai"}

AWS CLIを使用してLambdaを呼び出すと、次のような出力が表示されます-

カスタムコマンドプロンプト

同様に、他のAWSサービスについてAWS Lambdaをテストする場合は、AWSコンソールおよびAWS CLIのテストイベントを使用してテストできます。 SNSサービスのサンプルイベントを以下に示します-

{
   "Records": [{
      "EventVersion": "1.0",
      "EventSubscriptionArn": "arnid",
      "EventSource": "aws:sns",
      "Sns": {
         "SignatureVersion": "1",
         "Timestamp": "1970-01-01T00:00:00.000Z",
         "Signature": "EXAMPLE",
         "SigningCertUrl": "EXAMPLE",
         "MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e",
         "Message": "Hello from SNS!",
         "MessageAttributes": {
            "Test": {
               "Type": "String",
               "Value": "TestString"
            },
            "TestBinary": {
               "Type": "Binary",
               "Value": "TestBinary"
            }
         },
         "Type": "Notification",
         "UnsubscribeUrl": "EXAMPLE",
         "TopicArn": "topicarn",
         "Subject": "TestInvoke"
      }
   }]
}

上記のサンプルイベントを追加して、次のようにテストします。

サンプルイベントの設定

AWS Lambdaでは、コードは以下に示す例に示すようにSNSメッセージを出力します-

exports.handler = (event, context, callback) => {
  //TODO implement
   console.log(event.Records[0].Sns.Message);
   callback(null, event.Records[0].Sns.Message);};

Snsメッセージ

AWS CLIを使用して同じものを呼び出しましょう。 イベントをファイルに保存し、示されているコマンドを使用してペイロードに使用します-

aws lambda invoke --function-name "lambdauserevent" --log-type Tail --
payload file://C:\clioutput\sns.txt C:\clioutput\snsoutput.txt

ペイロードコマンド Aws-lambda-using-aws-lambdaedge-with-cloudfront Aws-lambda-monitoring-and-troubleshooting-using-cloudwatch

AWS Lambda –追加の例

これまで、AWS LambdaとAWSサービスの連携を見てきました。 その知識に基づいて、単純なユーザー登録フォームを作成し、AWS LambdaへのAPIゲートウェイを使用してデータを投稿しましょう。 AWS Lambdaは、イベントまたはAPIゲートウェイトリガーからデータを取得し、それらの詳細をDynamoDBテーブルに追加します。

例

私たちは例を考えて、それに対して次の機能を実行しましょう-

• DynamoDBテーブルを作成する
• ユーザー登録用のフォームを作成する
• AWS SNSサービスを使用してメッセージを電話に送信するAWS LambdaとAPIゲートウェイを作成する
• フォームデータをPOSTしてDynamoDbテーブルに挿入するAWS LambdaとAPIゲートウェイを作成する
• Dynamodbテーブルからデータを読み取るためのAWS LambdaとAPIゲートウェイを作成する
• ユーザー登録フォームの最終作業

DynamoDBテーブルを作成する

入力したデータはDynamodDBテーブルに保存されます。 APIゲートウェイを使用して入力されたデータをAWS Lambdaと共有し、AWS Lambdaは詳細をDynamoDBに追加します。

次の詳細を使用して、AWSコンソールでDynamodDBテーブルを作成できます。 最初に、AWSサービスに移動し、 DynamoDB をクリックします。 Table をクリックして、以下に示すようにテーブルを作成します-

DynamoDBテーブルの作成

テーブルデータ

ARNを使用して、AWS Lambdaで使用するDynamoDBのポリシーを作成できます。

IAMに移動し、ポリシー*を選択します。 *Create policy をクリックし、以下に示すようにDynamodDBとしてサービスを選択します-

ポリシーの選択

上記の[*すべてのDynamoDB *アクション]をクリックします。 リソースを選択し、以下に示すようにテーブルのARNを入力します-

すべてのDynamoDB

次に、以下に示すように*追加*をクリックします。

追加をクリック

画面の最後にある Review policy ボタンをクリックすると、次のウィンドウが表示されます-

レビューポリシー

ポリシーの名前を入力し、ページの最後にある[*ポリシーの作成]ボタンをクリックします。 ここで、Lambdaで使用するロールを作成する必要があります。 DynamoDB、APIGateway、およびLambdaのアクセス許可が必要です。

AWSサービスに移動し、IAMを選択します。 左側から[役割]を選択し、必要な役割を追加します。

ポリシーボタンの作成

役割名を入力し、[役割の作成]をクリックします。 作成されるロールは *roleforlambdaexample です。

ユーザー登録用のフォームを作成する

入力して、dynamodbテーブルからデータを読み取るためのユーザー登録フォームの表示を次に示します。

ユーザー登録

AWS LambdaとAPI Gatewayを作成して、SNSサービスを使用して電話にOTPメッセージを送信します

ユーザー登録フォームが表示されている場合は、 validate phone ボタンがあります。 ユーザーは、電話番号を入力し、[電話番号の検証]ボタンをクリックして電話番号を検証することを想定しています。

この目的のために-

ユーザーがこのボタンをクリックすると、電話の詳細を含むAPIゲートウェイのpostメソッドが呼び出され、AWS Lambdaが内部的にトリガーされます。

次に、AWS Lambdaは、AWS SNSサービスを使用して入力された電話番号にOTPを送信します。

ユーザーはOTPを受け取り、このOTP番号を入力する必要があります。

OTPを入力するためのテキストボックスは、電話番号を入力し、[電話の検証]ボタンをクリックすると表示されます。

ユーザーがユーザー登録フォームを送信できるようにするには、AWS Lambdaから受け取ったOTPとユーザーが入力したOTPが一致する必要があります。

電話検証の動作を説明する簡単なブロック図はここに示されています-

Snsサービス

作成されたAWS Lambda関数は次​​のとおりです-

作成されたラムダ関数

対応するAWS Lambdaコードは以下のとおりです-

const aws =  require("aws-sdk");
const sns = new aws.SNS({
   region:'us-east-1'
});
exports.handler = function(event, context, callback) {
   let phoneno = event.mphone;
   let otp = Math.floor(100000 + Math.random() * 900000);
   let snsmessage = "Your otp is : "+otp;
   sns.publish({
      Message: snsmessage,
      PhoneNumber: "+91"+phoneno
   }, function (err, data) {
      if (err) {
         console.log(err);
         callback(err, null);
      } else {
         console.log(data);
         callback(null, otp);
      }
   });
};

SNSサービスを使用してOTPコードを送信していることに注意してください。 このコードは、ユーザーがユーザー登録フォームに入力した携帯電話番号を検証するために使用されます。 上記の電話検証用に作成されたAPIゲートウェイは次のとおりです-

デフォルトのタイムアウト

Application Json

指定されたLambda関数は phonevalidationexample です。 ここで携帯電話の詳細を取得して、AWS Lambda内で使用します。 次に、AWS LambdaはOTPコードを指定された携帯電話番号に送信します。

AWS LambdaとAPI Gatewayを作成してフォームデータをPOSTし、DynamoDBテーブルに挿入する

ユーザー登録フォームの場合、すべてのフィールドは必須です。 フォームに入力されたデータがAPI Gateway URLにポストされるAJAX呼び出しが行われます。

送信ボタンの動作を説明する簡単なブロック図がここに示されています-

ブロック図Dynamodbテーブル

フォームに入力すると、送信ボタンは、AWS LambdaをトリガーするAPIゲートウェイを呼び出します。 AWS LambdaはイベントまたはAPI Gatewayからフォームの詳細を取得し、データはDynamodDBテーブルに挿入されます。

API GatewayとAWS Lambdaの作成について理解しましょう。

まず、AWSサービスに移動し、Lambdaをクリックします。 作成されたラムダ関数はここに示されているとおりです-

ラムダの例

ここで、APIゲートウェイを作成するには、AWSサービスに移動し、 API Gateway を選択します。 以下に示す Create API ボタンをクリックします。

Apiを作成

• API名*を入力し、 Create API ボタンをクリックしてAPIを追加します。

Apiボタンの作成

これで、 registeruser と呼ばれるAPIが作成されます。 APIを選択し、*アクション*ドロップダウンをクリックして*リソース*を作成します。

新しい子リソース

[リソースの作成]をクリックします。 次に、 POST メソッドを追加しましょう。 このためには、左側で作成されたリソースをクリックし、*アクション*ドロップダウンから*メソッドの作成*を選択します。 これは、以下に示すようにドロップダウンを表示します-

メソッドの作成

POSTメソッドを選択し、上記で作成したLambda関数を追加します。

ポストセットアップ

[保存]ボタンをクリックして、メソッドを追加します。 フォームの詳細をLambda関数 lambdaexample に送信するには、以下に示すように Integration Request を追加する必要があります-

統合リクエスト

フォームの詳細を投稿するには、*統合リクエスト*をクリックする必要があります。 詳細が下に表示されます。

ユーザー投稿の追加

*Body Mapping Templates* をクリックして、投稿するフォームフィールドを追加します。

ボディテンプレート

次に、[マッピングテンプレートの追加]をクリックして、コンテンツタイプを入力します。 ここでは、コンテンツタイプとして application/json を追加しました。 それをクリックして、ここで以下に示すようにフィールドをjson形式で入力する必要があります-

マッピングテンプレートの追加

今、*保存*ボタンをクリックして、以下に示すようにAPIをデプロイします-

保存ボタンの展開

以下は、lファイル内で使用するPOST用に作成されたAPIです。 作成されたリソースのCORSを有効にする必要があることに注意してください。 APIゲートウェイURLを使用してajax呼び出しを行うため、CORSを有効にする必要があります。

CORSを有効にするメソッドを選択します。 [* CORSを有効にして既存のCORSヘッダーを置き換える*]をクリックします。

コアヘッダー

次のように確認画面が表示されます-

確認画面

[はい、既存の値を置き換えます] *をクリックして、CORSを有効にします。

はい置換

POST API GatewayのAWS Lambdaコードは次のとおりです-

const aws =  require("aws-sdk");
const docClient = new aws.DynamoDB.DocumentClient({
   region:'us-east-1'
});
exports.handler = function(event, context, callback) {
   console.log(event);
   console.log("Entering Data");
   var data = {
      TableName : "registeruser",
      Item : {
         first_name:event.fname,
         last_name:event.lname,
         emailid:event.emailid,
         mobile_no : event.mphone,
         otp:event.otp,
         username:event.uname,
         password:event.passwd,
         confirm_password:event.cpasswd
      }
   }
   docClient.put(data, function(err, value) {
      if (err) {
         console.log("Error");
         callback(err, null);
      } else {
         console.log("data added successfully");
         callback(null, value);
      }
   });
}

AWS Lambdaハンドラーのイベントパラメーターには、POST統合リクエストで以前に追加されたすべての詳細が含まれます。 コードからわかるように、イベントの詳細がDynamodDBテーブルに追加されます。

次に、以下に示すようにAWS-SDKからサービスの詳細を取得する必要があります-

const aws =  require("aws-sdk");
const docClient = new aws.DynamoDB.DocumentClient({
   region:'us-east-1'
});
var data = {
   TableName : "registeruser",
   Item : {
      first_name:event.fname,
      last_name:event.lname,
      emailid:event.emailid,
      mobile_no : event.mphone,
      otp:event.otp,
      username:event.uname,
      password:event.passwd,
      confirm_password:event.cpasswd
   }
}
docClient.put(data, function(err, value) {
   if (err) {
        console.log("Error");
      callback(err, null);
   } else {
      console.log("data added successfully");
      callback(null, value);
   }
});

DynamodDBテーブルからデータを読み取るためのAWS LambdaとAPI Gatewayを作成する

ここで、DynamoDBテーブルからデータを読み取るAWS Lambda関数を作成します。 データをhtmlフォームに送信するAWS Lambda関数に対してAPIGatewayをトリガーします。

作成されたAWS Lambda関数は以下のとおりです-

データの読み取り

対応するAWS Lambdaコードは次のとおりです-

const aws =  require("aws-sdk");
const docClient = new aws.DynamoDB.DocumentClient({
   region:'us-east-1'
});
exports.handler = function(event, context, callback) {
   var readdata = {
      TableName : "registeruser",
      Limit : 10
   }
   docClient.scan(readdata, function(err, data) {
      if (err) {
         console.log("Error");
         callback(err, null);
      } else {
         console.log("Data is " + data);
         callback(null, data);
      }
   });
}

ここで、データはDynamoDBテーブルから読み取られ、コールバックに渡されます。 ここで、APIGatewayを作成し、AWS Lambda関数をトリガーとして追加します。

前に作成したAPIにgetメソッドを追加します。

Api Created

追加されたLambda関数は lambdareaddataexample です。 [保存]をクリックしてメソッドを保存し、APIをデプロイします。

ユーザー登録フォームの最終作業

フォームの最終的な表示は以下のとおりです-

最終作業

次に、上記のように詳細を入力します。 送信ボタンが無効になっていることに注意してください。 それは示されているようにすべての詳細が入力された場合にのみ有効になります-

詳細を入力

ここで、携帯電話番号を入力し、*電話番号の検証*ボタンをクリックします。 *「OTPがモバイルに送信されています。続行するにはOTPを入力してください」*という警告メッセージが表示されます。 モバイル番号に送信されるOTPは次のとおりです-

Otp

OTPと残りの詳細を入力し、フォームを送信します。

残りの詳細

送信後のDynamoDB registeruser テーブルのデータは次のとおりです-

ユーザー登録

コードの詳細は以下のとおりです-

• 例1l *

<html>
   <head>
      <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
      <script type="text/javascript" src="formdet.js"></script>
      <style>
         input[type=text], input[type=password],button {
            width: 100%;
            padding: 5px 5px;
            margin: 5px 0;
            box-sizing: border-box;
         }
         #maincontainer {
            width: 80%;
            margin: auto;
            padding: 10px;
         }
         div#userregistration {
            width: 60%;
            float: left;
         }
         div#userdisplay {
            margin-left: 60%;
         }
      </style>
   </head>

   <body>
      <div id="maincontainer">
         <div id="userregistration">
            <h1>User Registration Form</h1>
            <table border="0">
               <tr>
                  <td><b>First Name<span style="color:red;">*</span> : </b></td>
                  <td><input type="text" value="" name="fname" id="fname"/></td>
                  <td id="tdfname" style="display:none;"><span style="color:red;">Enter First Name</span></td>
               </tr>
               <tr>
                  <td><b>Last Name<span style="color:red;">*</span> : </b></td>
                  <td><input type="text" value="" name="lname" id="lname"/></td>
                  <td id="tdlname" style="display:none;"><span style="color:red;">Enter Last Name</span></td>
               </tr>
               <tr>
                  <td><b>Email Id<span style="color:red;">*</span> : </b></td>
                  <td><input type="text" value="" name="emailid" id="emailid"/></td>
                  <td id="tdemailid" style="display:none;"><span style="color:red;">Enter Email</span></td>
               </tr>
               <tr>
                  <td><b>Mobile No<span style="color:red;">*</span> : </b></td>
                  <td><input type="text" name="mphone" id="mphone"/></td>
                  <td id="tdmphone" style="display:none;"><span style="color:red;">Enter Mobile Number</span></td>
               </tr>
               <tr>
                  <td></td>
                  <td><button id="validatephone">validate phone</button></td>
                  <td></td>
               </tr>
               <tr id="otpdiv" style="display:none;">
                  <td><b>Enter OTP<span style="color:red;">*</span>:</b></td>
                  <td><input type="text" value="" name="otp" id="otp"/></td>
                  <td id="tdotp" style="display:none;"><span style="color:red;">Enter OTP</span></td>
               </tr>
               <tr>
                  <td><b>Username<span style="color:red;">*</span>: </b></td>
                  <td><input type="text" value="" name="uname" id="uname"/></td>
                  <td id="tduname" style="display:none;"><span style="color:red;">Enter Username</span></td>
               </tr>
                  <tr><td><b>Password<span style="color:red;">*</span> :</b></td>
                  <td><input type="password" value="" name="passwd" id="passwd"/></td>
                  <td id="tdpasswd" style="display:none;"><span style="color:red;">Enter Password</span></td>
               </tr>
                  <tr><td><b>Confirm Password<span style="color:red;">*</span> :</b></td>
                  <td><input type="password" value="" name="cpasswd" id="cpasswd"/></td>
                  <td id="tdcpasswd" style="display:none;"><span style="color:red;">Enter Confirm Password</span></td>
               </tr>
               <tr>
                  <td></td>
                  <td><button name="submit" id="submit" style="display:;" disabled="true">Submit</button></td>
                  <td></td>
               </tr>
            </table>
         </div>

         <div id="userdisplay">
            <h1>User Display</h1>
            <table id="displaydetails" style="display:block;width:80%;padding:5px;margin:5px; border: 1px solid black;">
               <tr>
                  <td></td>
                  <td>FirstName</td>
                  <td>LastName</td>
                  <td>Mobile No</td>
                  <td>EmailID</td>
               </tr>
            </table>
         </div>
      </div>
   </body>
</html>

*formdet.js*

function validateform() {
   var sError="";
   if ($("#fname").val() === "") {
      $("#tdfname").css("display","");
      sError++;
   }
   if ($("#lname").val() === "") {
      $("#tdlname").css("display","");
      sError++;
   }
   if ($("#emailid").val() === "") {
      $("#tdemailid").css("display","");
      sError++;
   }
   if ($("#mphone").val() === "") {
      $("#tdmphone").css("display","");
      sError++;
   }
   if ($("#otp").val() === "") {
      $("#tdotp").css("display","");
      sError++;
   }
   if ($("#uname").val() === "") {
      $("#tduname").css("display","");
      sError++;
   }
   if ($("#passwd").val() === "") {
      $("#tdpasswd").css("display","");
      sError++;
   }
   if ($("#cpasswd").val() === "") {
      $("#tdcpasswd").css("display","");
      sError++;
   }
   if (sError === "") {
      return true;
   } else {
      return false;
   }
}
$("#fname").change(function() {
   if ($("#fname").val() !== "") {
      $("#tdfname").css("display","none");
   } else {
      $("#tdfname").css("display","");
   }
});
$("#lname").change(function() {
   if ($("#lname").val() !== "") {
      $("#tdlname").css("display","none");
   } else {
      $("#tdlname").css("display","");
   }
});
$("#emailid").change(function() {
   if ($("#emailid").val() !== "") {
      $("#tdemailid").css("display","none");
   } else {
      $("#tdemailid").css("display","");
   }
});
$("#mphone").change(function() {
   if ($("#mphone").val() !== "") {
      $("#tdmphone").css("display","none");
   } else {
      $("#tdmphone").css("display","");
   }
});
$("#otp").change(function() {
   if ($("#otp").val() !== "") {
      $("#tdotp").css("display","none");
   } else {
      $("#tdotp").css("display","");
   }
});
$("#uname").change(function() {
   if ($("#uname").val() !== "") {
      $("#tduname").css("display","none");
   } else {
      $("#tduname").css("display","");
   }
});
$("#passwd").change(function() {
   if ($("#passwd").val() !== "") {
      $("#tdpasswd").css("display","none");
   } else {
      $("#tdpasswd").css("display","");
   }
});
$("#cpasswd").change(function() {
   if ($("#cpasswd").val() !== "") {
      $("#tdcpasswd").css("display","none");
   } else {
      $("#tdcpasswd").css("display","");
   }
});

var posturl = "https://4rvwimysc1.execute-api.us-east-1.amazonaws.com/prod/adduser";
var phonevalidationurl = "https://wnvt01y6nc.execute-api.us-east-1.amazonaws.com/prod/validate";
var otpsend = "";
function getdata() {
   var a = 0;
   $.ajax({
      type:'GET',
      url:posturl,
      success: function(data) {
         $("#displaydetails")l('');
         $("#displaydetails").css("display", "");
         console.log(data);
         $("#displaydetails").append('<tr style="padding:5px;margin:5px;background-color:gray;"><td>Name</td><td>Mobile No</td><td>EmailID</td></tr>');
         data.Items.forEach(function(registeruser) {
            var clr = (a%2 === 0) ? "#eee": "white";
            a++;
            $("#displaydetails").append('<tr style="padding:5px;margin:5px;background-color:'+clr+'"><td>'+registeruser.first_name+'-'+registeruser.last_name+'</td><td>'+registeruser.mobile_no+'</td><td>'+registeruser.emailid+'</td></tr>');
         });
      },
      error: function(err) {
         console.log(err);
      }
   });
}

$(document).ready(function() {
   $("#otp").on("change", function() {
      var otpentered = $("#otp").val();
      if (otpsend == otpentered) {
         document.getElementById("submit").disabled = false;
      } else {
         alert("OTP is not valid.Please enter the valid one or validate phone again to continue!");
         document.getElementById("submit").disabled = true;
      }
   });
   $("#validatephone").on("click", function() {
      $.ajax({
         type:'POST',
         url:phonevalidationurl,
         data:JSON.stringify({
            "mphone":$("#mphone").val()
         }),
         success: function(data) {
            $("#otpdiv").css("display", "");
            alert("OTP is send to the mobile, please enter to continue");
            console.log(data);
            otpsend = data;
         },
         error : function(err) {
            $("#otpdiv").css("display", "none");
            alert("Invalid mobile no.");
         }
      });
   });
   $("#submit").on("click", function() {
      if (validateform()) {
         $.ajax({
            type:'POST',
            url:posturl,
            data:JSON.stringify({
               "fname": $("#fname").val(),
               "lname": $("#lname").val(),
               "emailid":$("#emailid").val(),
               "mphone":$("#mphone").val(),
               "otp":$("#otp").val(),
               "uname":$("#uname").val(),
               "passwd":$("#passwd").val(),
               "cpasswd":$("#cpasswd").val()
            }),
            success: function(data) {
               alert("Data added successfully");
               console.log(data);
               getdata();
            }
         });
      }
   });
   getdata();
});

これまで、APIのAJAX呼び出しを実行し、上記のようにデータを作成して投稿しました。

テーブルにデータを追加するためのAJAX呼び出しは次のとおりです-

var posturl = "https://4rvwimysc1.execute-api.us-east-1.amazonaws.com/prod/adduser";
$(document).ready(function() {
   $("#submit").on("click", function() {
      if (validateform()) {
         $.ajax({
            type:'POST',
            url:posturl,
            data:JSON.stringify({
               "fname": $("#fname").val(),
               "lname": $("#lname").val(),
               "emailid":$("#emailid").val(),
               "mphone":$("#mphone").val(),
               "otp":$("#otp").val(),
               "uname":$("#uname").val(),
               "passwd":$("#passwd").val(),
               "cpasswd":$("#cpasswd").val()
            }),
            success: function(data) {
               alert("Data added successfully");
               console.log(data);
               getdata();
            }
         });
      }
   });
});

データを読み取るために、以下のコードが与えられている関数が呼び出されることに注意してください-

function getdata() {
   var a = 0;
   $.ajax({
      type:'GET',
      url:posturl,
      success: function(data) {
         $("#displaydetails")l('');
         $("#displaydetails").css("display", "");
         console.log(data);
         $("#displaydetails").append('<tr style="padding:5px;margin:5px;background-color:gray;"><td>Name</td><td>Mobile No</td><td>EmailID</td></tr>');
         data.Items.forEach(function(registeruser) {
            var clr = (a%2 === 0) ? "#eee": "white";
            a++;
            $("#displaydetails").append('<tr style="padding:5px;margin:5px;background-color:'+clr+'"><td>'+registeruser.first_name+'-'+registeruser.last_name+'</td><td>'+registeruser.mobile_no+'</td><td>'+registeruser.emailid+'</td></tr>');
         });
      },
      error: function(err) {
         console.log(err);
      }
   });
}

あなたが携帯電話番号検証ボタンをクリックすると、次のコードが呼び出され、携帯電話番号を送信します-

var phonevalidationurl = "https://wnvt01y6nc.execute-api.us-east-1.amazonaws.com/prod/validate";
var otpsend = "";
$("#validatephone").on("click", function() {
   $.ajax({
      type:'POST',
      url:phonevalidationurl,
      data:JSON.stringify({
         "mphone":$("#mphone").val()
      }),
      success: function(data) {
         $("#otpdiv").css("display", "");
         alert("OTP is send to the mobile, please enter the OTP to continue");
         console.log(data);
         otpsend = data;
      },
      error : function(err) {
         $("#otpdiv").css("display", "none");
         alert("Invalid mobile no.");
      }
   });
});

//Validate otp
$("#otp").on("change", function() {
   var otpentered = $("#otp").val();
   if (otpsend == otpentered) {
      document.getElementById("submit").disabled = false;
   } else {
      alert("OTP is not valid.Please enter the valid one or validate phone again to continue!");
      document.getElementById("submit").disabled = true;
   }
}