AWS Lambdaサーバーレスコンピューティングを実行するサービスであり、サーバーなしでコンピューティングを行います。コードは、S3バケット内のファイルの追加/削除、Amazon Dynamo dBテーブルの更新、Amazon APIゲートウェイからのHTTPリクエストなど、AWSサービスのイベントの応答に基づいて実行されます。

で作業するために AWS Lambda、AWSLambdaサービスでコードをプッシュする必要があります。インフラストラクチャ、オペレーティングシステム、サーバーのメンテナンス、コードモニタリング、ログ、セキュリティなど、他のすべてのタスクとリソースはAWSによって処理されます。

AWS LambdaJava、NodeJS、Python、C＃、Goなどの言語をサポートします。AWSLambdaはAWSサービスでのみ機能することに注意してください。

AWS Lambdaとは何ですか？

公式ドキュメントに記載されているAWSLambdaの定義は次のとおりです-

AWS Lambdaは、サーバーをプロビジョニングまたは管理せずにコードを実行できるようにするコンピューティングサービスです。AWS Lambdaは、必要な場合にのみコードを実行し、1日あたり数リクエストから1秒あたり数千リクエストまで自動的にスケーリングします。消費した計算時間に対してのみ料金を支払います。コードが実行されていないときは無料です。

AWS Lambdaはどのように機能しますか？

AWSLambdaの動作を5つの簡単なステップで説明するブロック図を以下に示します-

Step 1 − AWSラムダがサポートする任意の言語（NodeJS、Java、Python、C＃、Go）でAWSラムダコードをアップロードします。

Step 2 − これらは、AWSラムダをトリガーできるいくつかのAWSサービスです。

Step 3 −アップロードコードとトリガーが発生したイベントの詳細を含むAWSLambda。たとえば、Amazon S3、Amazon API Gateway、Dynamo dB、Amazon SNS、Amazon Kinesis、CloudFront、Amazon SES、CloudTrail、モバイルアプリなどからのイベント。

Step 4 − −などのシナリオでAWSサービスによってトリガーされた場合にのみAWSLambdaコードを実行します

• ユーザーがS3バケットにファイルをアップロードする
• http get / postエンドポイントURLがヒットしました
• DynamodBテーブルでデータが追加/更新/削除されます
• プッシュ通知
• データストリームコレクション
• ウェブサイトのホスティング
• メール送信
• モバイルアプリなど

Step 5 − AWSは、AWSラムダコードが実行されたときにのみ課金され、それ以外の場合は課金されないことに注意してください。

AWSLambdaを使用する利点

AWS Lambdaは、作業中に複数のメリットを提供します。このセクションでは、それらについて詳しく説明します-

コードの操作のしやすさ

AWS Lambdaは、コードをアップロードするためのインフラストラクチャを提供します。コードの保守を処理し、必要なイベントが発生するたびにコードをトリガーします。これにより、コードに必要なメモリとタイムアウトを選択できます。

AWS Lambdaは、イベントトリガーに従って並列リクエストを実行することもできます。

ログプロビジョニング

AWS Lambdaは、コードが実行された回数と実行にかかった時間、消費されたメモリなどの詳細を提供します。AWSCloudWatchはすべてのログを収集し、実行フローの理解とコードのデバッグに役立ちます。

使用量に基づく請求

AWS Lambdaの課金は、メモリ使用量、行われたリクエスト、実行時に行われ、最小100ミリ秒単位で課金されます。したがって、500ミリ秒の実行の場合、請求は100ミリ秒ごとに行われます。AWSラムダコードを500ミリ秒で実行するように指定し、実行にかかる時間がわずか200ミリ秒の場合、AWSは、500ミリ秒ではなく200ミリ秒の実行時間に対してのみ請求します。AWSは、使用された実行時間に対して常に課金します。関数が実行されない場合は支払う必要はありません。

多言語サポート

AWS Lambdaは、Nodeなどの一般的な言語をサポートしています。js、Python、Java、C＃、Go。これらは広く使用されている言語であり、開発者なら誰でもAWSLambdaのコードを簡単に作成できます。

コードの作成と展開の容易さ

コードをオーサリングおよびデプロイするためにLambdaで利用できる多くのオプションがあります。コードの記述には、AWSオンラインエディター、Visual Studio IDE、またはEclipseIDEを使用できます。また、AWSLambdaコードの記述とデプロイを簡単にするサーバーレスフレームワークもサポートしています。AWSコンソールの他に、コードを作成してデプロイするためのAWS-cliがあります。

その他の機能

AWS無料利用枠にログインすると、AWSLambdaを無料で使用できます。それはあなたに1年間無料でサービスを提供します。AWS無料利用枠が提供する無料サービスをご覧ください。

AWSLambdaを使用するデメリット

多くの利点があるにもかかわらず、AWSLambdaには次の欠点があります-

• 小規模なプロジェクトには適していません。

• コードを注意深く分析し、メモリとタイムアウトを決定する必要があります。関数が割り当てられた時間よりも多くの時間を必要とする場合、関数は指定されたタイムアウトに従って終了し、コードは完全には実行されません。

• AWS LambdaはインフラストラクチャをAWSに完全に依存しているため、コードで必要な場合は追加のソフトウェアをインストールできません。

AWSLambdaをトリガーするイベント

AWSLambdaをトリガーできるイベントは次のとおりです-

• S3オブジェクトへのエントリ
• Dynamo DBテーブルのデータの挿入、更新、削除
• SNSからのプッシュ通知
• APIGatewayへのGET / POST呼び出し
• CloudFrontでのビューアまたはオリジンリクエスト/レスポンスでのヘッダーの変更
• AWSKinesisデータストリームのログエントリ
• CloudTrailのログ履歴

AWSLambdaのユースケース

AWS Lambdaは、主にバックグラウンドプロセスを実行するために使用されるコンピューティングサービスです。他のAWSサービスと併用するとトリガーされる可能性があります。AWSLambdaを使用できるAWSサービスのリストを以下に示します-

S3オブジェクトとAWSLambda

Amazon S3は、S3にファイルがアップロードされると、イベントの詳細をAWSLambdaに渡します。ファイルのアップロードまたはファイルの削除またはファイルの移動の詳細は、AWSLambdaに渡されます。AWS Lambdaのコードは、イベントの詳細を受信するときに必要な手順を実行できます。たとえば、S3に挿入された画像のサムネイルを作成します。

DynamoDBとAWSLambda

DynamoDBは、テーブルにデータが追加、更新、削除されたときにAWSLambdaをトリガーできます。AWS Lambdaイベントには、挿入/更新または削除に関するAWSDynamoDBテーブルのすべての詳細が含まれています。

APIゲートウェイとAWSLambda

API Gatewayは、GET / POSTメソッドでAWSLambdaをトリガーできます。フォームを作成し、API Gatewayエンドポイントと詳細を共有し、AWS Lambdaで使用して、たとえば、DynamoDBテーブルにデータを入力するなどのさらなる処理を行うことができます。

SNSとAWSLambda

SNSは、プッシュ通知、SMSの送信などに使用されます。SNSでプッシュ通知が発生したときにAWSラムダをトリガーできます。トリガーを受信したときに、AWSLambdaから電話番号にSMSを送信することもできます。

スケジュールされたイベントとAWSLambda

スケジュールされたイベントは、cronジョブに使用できます。AWS Lambdaをトリガーして、定期的な時間パターンでタスクを実行できます。

CloudTrailとAWSLambda

CloudTrailは、アカウントのログを監視するのに役立ちます。AWS Lambdaを使用して、CloudTrailログをさらに処理できます。

KinesisとAWSLambda

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

CloudFrontとLambda @ Edge

CloudFrontは、ウェブサイトをホストできるコンテンツ配信ネットワークであり、Lambda @ Edgeを使用して、ビューアリクエスト、オリジンリクエスト、オリジンレスポンス、ビューアレスポンスからのヘッダーを処理できます。ヘッダーの変更には、Cookieデータの変更、URLの書き換え、ユーザーに送信される応答を変更するためのABテスト、セキュリティ目的でのヘッダー情報の追加などのタスクが含まれます。

AWS Lambdaの使用を開始する前に、Amazonコンソールでログインする必要があります。AWSLambdaは2つのIDEをサポートしています。Visual studio そして Eclipse。この章では、AWSLambdaのインストールについて段階的に詳しく説明します。

AWSコンソールでログインを作成します

Amazonの無料利用枠を使用して、AWSコンソールで無料でログインを作成できます。以下の手順に従って、Amazonでログインを作成し、Amazonサービスを利用できます。

ステップ1

に移動 https://aws.amazon.com/free/[無料アカウントの作成]をクリックします。以下のスクリーンショットを見ることができます-

ステップ2

クリック Create a Free Account ボタンを押すと、以下のような画面にリダイレクトされます-

次に、上記のこのフォームに選択したメールアドレス、パスワード、AWSアカウント名の詳細を入力し、[ Continue。

ステップ3

これで、次のような画面が表示されます-

このフォームに必要なすべての詳細を入力します。

選択した国に基づいて支払われる最低料金があることに注意してください。入力した詳細が検証されると、同じものが返金されます。無料アカウントを作成するには、クレジットカードまたはデビットカードの詳細が必要です。インドのユーザー向けRs 2/- 差し引かれ、米国の場合 $1 ユーザーが検証されると、同じことがそれぞれのカードユーザーに返金されます。

アカウントは無料で、サービスの利用には制限がありますのでご注意ください。使用量が制限を超えた場合、ユーザーはそれに対して課金されます。

上記のフォームに詳細を入力したら、をクリックします Create Account and Continue。

以下に示すように、次の画面にリダイレクトされます。

ステップ4

以下に示すように、支払いの詳細（クレジットカードまたはデビットカード）と、その有効期限およびカード所有者の名前を入力する必要があります。

ステップ5

すべての詳細を入力したら、をクリックします Secure Submit そしてそれは銀行でカードを検証し、あなたに OTPカードにリンクされているあなたの携帯電話で。以下のようなウィンドウがあります−

今、入力します OTP 詳細をクリックしてください Make Payment。選択した国に基づいて課金されます。

ステップ6

支払いが完了したら、次のステップは電話による確認です。以下に示すように携帯電話番号を入力する必要があります-

詳細が入力されたら、をクリックします Call Me Now。AWSは、自動システムを使用してすぐに電話をかけます。電話でプロンプトが表示されたら、電話のキーパッドを使用して、AWSサイトに表示される4桁の番号を電話に入力します。これにより、番号が確認され、ログインの作成時に開始時に指定されたメールIDでメールアクティベーションが取得されます。

ステップ7

メールリンクをクリックして、アカウント名またはメールIDとパスワードを入力し、以下に示すようにAWSサービスにログインします-

上記のように、アカウント名が右上隅に表示されます。これで、AWSLambdaサービスの使用を開始できます。AWS Lambdaサービスの場合、サポートされる言語はNodeJS、Python、Java、C＃、およびGoです。

Visual Studio2017のインストール

AWSと互換性のあるIDEは2つあります。 Visual Studio そして Eclipse。このセクションでは、Windows、LinuxMacへのVisualstudio2017のインストールについて説明します。VisualStudioの公式サイトにアクセスします。https://www.visualstudio.com/downloads/。示されているようにウェルカム画面を見つけることができます-

コミュニティバージョンをダウンロードします。 Visual Studio Community 2017今は無料で練習できます。インストールすると、後で使用するパッケージを選択する必要があるインストール手順が実行されます。選択できます nodejs, python, c# 後で作業するためのパッケージ。

Visual Studio2017のAWSToolkitサポート

Visual Studio 2017をインストールしたら、Visual Studio2017のAWSToolkitサポートをインストールするための所定の手順に従う必要があります-

ステップ1

に移動 https://aws.amazon.com/visualstudio/ VisualStudio用のAWSツールキットをダウンロードします。表示は次のとおりです。

Visual Studio2017用にダウンロードされたパッケージは vsixパッケージ。Visual Studioのバージョンが2013年から2015年の間にある場合は、msiインストーラ。クリックDownload 以下に示すボタン。

ステップ2

ダウンロードしたvsixパッケージをダブルクリックすると、以下に示すインストール手順が実行されます。

Visual Studioが正常にインストールされると、次のようなウィンドウが表示されます。

ステップ3

ここで、Visual Studio 2017を開くと、以下に示すようにAWSからのウェルカムページが表示されます。

Visual StudioからAWSサービスを開始して使用するには、アクセスキー、シークレットキー、アカウント番号を追加する必要があることに注意してください。

NodeJS用のAWSLambda BoilerPlate

あなたはそれを使用することができます visual studio code 以下に示すように。

ステップ1

ダウンロードできます Visual studio code 公式ウェブサイトから無料で：https://www.visualstudio.com/downloads/. VisualStudioダウンロードのホームページは次のようになります-

ステップ2

次に、以下に示すようにVisualStudioコードを開きます-

ステップ3

AWSのサポートをインストールするには、 support for nodejsオプションは拡張機能内で利用できます。AWSを検索すると、次のようにオプションが表示されます-

ステップ4

次に、AWSLambdaのボイラープレートをにインストールします nodejs 示されているように-

ステップ5

リポジトリをクリックしてVisualStudioで複製し、VisualStudioでLambda関数の記述を開始します。VisualStudioで複製できるこのリポジトリにリダイレクトされます。https://github.com/loganarnett/vscode-lambda-snippets。次に、からコマンドパレットを開きますView VisualStudioのオプション。

ステップ6

それをクリックして、以下に示すようにgitcloneを選択します-

ステップ7

リポジトリのURLを入力し、選択に従ってローカルに保存します。作成するindex.js ラムダ関数で動作するファイルを以下に示します-

EclipseIDEのインストール

次に、最新のEclipse Java EEIDEをインストールする必要があります。Eclipseの公式サイトからダウンロードできます。https://www.eclipse.org/downloads/

EclipseIDEのAWSToolkitサポート

Eclipseをインストールしたら、次の手順を実行します-

ステップ1

メニューからヘルプに移動し、をクリックします Install New Software。

ステップ2

入る https://aws.amazon.com/eclipse ラベルの付いたテキストボックス内 Work with ダイアログの上部にあります。

ステップ3

次に、必要なものを選択します AWS Core Management Tools および以下に示すリストのその他のオプション項目。

ステップ4

次に、をクリックします Next。Eclipseは、以下に示す追加の手順に示されている残りのインストール手順をガイドします。

ステップ5

以下のスクリーンショットに示すように、AWSコアモジュールは下のグリッドに表示されます-

ステップ6

インストールすると、AWSツールは以下に示すようにEclipseで利用できるようになります-

ステップ7

Amazonサービスをクリックすると、以下の画面が表示されます。

次に、AWS Explorerをクリックして、利用可能なサービスを確認します。インストールされたIDEの操作方法については、次の章で説明します。

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

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

AWSコンソール

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

例：関数の作成

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

クリック Create function ボタンをクリックすると、画面に次の詳細が表示されます-

デフォルトでは、オプションは次のとおりです。 Author from scratch。このオプションを使用すると、Lambdaコードを最初から作成できます。それはただ簡単な機能を持っているでしょうhello world メッセージ。

2番目のオプション Blue prints 以下の詳細があります。

AWSLambdaで利用可能な言語でいくつかのawsサービス用にすでに記述されているコードの詳細を提供します。チェックインできるサービスのAWSLambdaコードを作成する必要がある場合blue prints 始めましょう。

3番目のオプション Serverless Application Repository AWSLambdaコードのデプロイに役立つサーバーレスアプリケーションのセットアップがあります。

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

Lambda関数を作成する前に、ロール、つまりAWSサービスとawslambdaを操作するための権限が必要になります。後で、ロールをawslambda関数に割り当てる必要があります。

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

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

さて、クリックすると IAM、以下のような画面になります−

選択した場合 Roles、画面に次のボタンが表示されます-

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

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

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

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

クリック Create policy上の画面に表示されているボタン。画面に表示される詳細は次のとおりです。

を選択してください Serviceポリシーを作成する対象。後で、アクションのデータが表示されます。resources そして Request conditions。

ここで、サービスを選択する必要があります。選択しましょうAWS Dynamodb 検索から。 Actions 以下の詳細があります-

今、入力します Access levelDynamoDBに提供したい。次に、resources 以下の詳細が表示されます-

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

テーブルの許可については、次のことを行う必要があります Add ARN。ARNは、AWSDynamoDBで作成されたテーブルに固有の詳細です。テーブルがdynamodbで作成されると、詳細が表示されます。

クリックすると Add ARN 以下の詳細が表示されます-

さて、あなたが入ると ARN そしてその Region, Account そして Table名前が入力されます。クリックする必要がありますAddポリシーを追加するボタン。同様に、他のサービスのポリシーを作成できます。

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

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

ステップ1

クリック Create roleボタンをクリックして役割を作成します。作成されたすべての役割が次のように表示されます-

ステップ2

作成した役割に変更が必要な場合に備えて、必要な役割を選択できることに注意してください。選択した場合Author from scratch option、入力する必要があります Name, Runtime and Role。

ステップ3

次の詳細は、で確認できます。 Runtime ドロップダウン-

ステップ4

選択したランタイムを選択して、示されているように続行できます。

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

• Choose an existing role − これにより、IAMロールで作成されたすべてのロールが表示されます。

• Create new role from template(s) −これにより、役割を作成でき、その役割に対して選択する権限が表示されます。理解を深めるためにスクリーンショットを観察してください。

• Create a custom role − これにより、ユーザーは前に説明したようにポリシーを作成できます。

ステップ5

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

AWSLambda関数の一部

AWSLambda関数には2つの部分があります。Configuration そして Monitoring。それぞれについて詳しく説明しましょう。

構成

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

Add Triggers

AWSLambda関数に追加するために必要なトリガーは次のように表示されます-

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

例

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

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

ここでは、を選択する必要があります bucket name, event type Lambdaをトリガーする場所、プレフィックス、フィルターパターン（存在する場合）および Add 引き金。

Lambdaにコードを追加する

ここで、作成するLambdaコードに焦点を当てる必要があります。aws lambdaにコードを追加するには、3つのオプションがあります-

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

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

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

Using the inline editor

コードを記述できるインラインコードエディタは次のとおりです。

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

理解を深めるために、次のスクリーンショットをご覧ください-

コードはで書かれている必要があります index.js.Handler。詳細は実行時間によって異なります。にとってnodejs、それは filename.export function これは今です index.lambda handler。

Upload a .ZIP file

最初にコードを記述し、zipして、zipファイルをアップロードすることができます。 Upload a .ZIP file。

Upload a file from Amazon S3

S3バケットにファイルをアップロードして、オプションを選択できます Upload a file from Amazon S3。

のために注意してください .ZIP そして S3 ランタイムを変更することはできません。

環境変数

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

タグ

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

実行の役割

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

基本設定

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

通信網

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

デバッグとエラー処理

デバッグとエラー処理については、AWSサービスを選択して詳細を送信できます。利用可能なオプションは次のとおりですNone, SNS そして SQS。

並行性

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

監査とコンプライアンス

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

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

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

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

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

のコード 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関数は、呼び出されるとコードを実行します。この章では、AWSLambda関数のライフサイクルに関連するこれらすべてのステップについて詳しく説明します。

ラムダ関数を構築するための手順

ラムダ関数のライフサイクルには、4つの必要なステップが含まれています-

• Authoring
• Deploying
• Monitoring
• Troubleshooting

Lambdaコードのオーサリング

AWSLambda関数コードは次の言語で記述できます-

• NodeJS
• Java,
• Python
• C#
• Go.

AWSコンソール、AWS CLI、Eclipse IDE、Visual Studio IDE、サーバーレスフレームワークなどを使用してAWSLambdaのコードを記述できます。

次の表は、Lambda関数の記述に使用できる言語とさまざまなツールおよびIDEのリストを示しています。

言語	LambdaコードをオーサリングするためのIDE
NodeJS	AWSLambdaコンソール Visual Studio IDE
Java	Eclipse IDE
Python	AWSLambdaコンソール
C＃	Visual Studio IDE .NETコア
行く	AWSLambdaコンソール

Lambdaコードのデプロイ

Lambda関数を作成する言語を決定したら、コードをデプロイする2つの方法があります-

• AWSコンソールでコードを直接記述します
• すべてのファイルと依存関係を含むファイルをZipまたはjarします

ただし、zipファイルに適切な許可を与える必要があることに注意してください。

Lambdaコードのテスト

Lambdaコードは、AWSLambdaコンソール内のイベントについてテストできます。AWSCLIおよびサーバーレスCLIからLambda関数をテストすることもできます。AWSコンソールには、AWSLambda関数のテスト中にサンプルイベントとして使用できるイベントデータもあります。

ラムダ関数の監視

Lambda関数のモニタリングは、AWSCloudWatchを使用して実行できます。選択した言語で必要なログメッセージを追加し、AWSCloudWatchで同じものを表示できます。

Lambda関数の記述を開始するには、従うべきパターンがあります。以下は、Lambda関数を作成するために従うべき主なコアコンセプトです。

ハンドラ

ハンドラーは、実行が開始されるAWSラムダ関数の名前です。以下に示すように、AWSコンソールに表示されます-

ここで、デフォルトのハンドラーを別の名前に変更し、ハンドラーで同じ名前を更新したことに注意してください-

ハンドラーの呼び出し方法は、ランタイムとして選択された言語とは異なることに注意してください。

ハンドラーに渡されるパラメーター

ハンドラー関数を観察すると、渡されるパラメーターは次のとおりです。 event, context そして call back function 以下に示すように-

Event パラメータには、使用されるトリガーのすべての詳細が含まれます。

Contextパラメータは基本的に、Lambda関数が実行する実行時の詳細を処理します。を使用してLambda関数と対話できますcontextparam。AWS Lambdaが関数を終了するまでの残り時間、つまりLambda関数の作成中に指定されたタイムアウト、Lambda関数の名前、クラウドウォッチグループ名、arnの詳細などの詳細が含まれます。

例

例を使用して、AWSLambdaコンテキストオブジェクトから取得した詳細を理解しましょう-

exports.lambdahandler = (event, context, callback) => {
   // TODO implement
   console.log("context object details");
   console.log(JSON.stringify(context));
   callback(null, 'Lambda test');
};

上記のLambda関数を実行すると、次の出力が表示されます-

出力

ザ・ context 詳細は以下のとおりです。

{
   "callbackWaitsForEmptyEventLoop":true,"logGroupName":"/aws/lambda/myfirstlambdafunction",
   "logStreamName":"2018/05/20/[$LATEST]04f17ee4ff7048d5bb1fedffaa807c71","functionName":
   "myfirstlambdafunction","memoryLimitInMB":"128","functionVersion":"$LATEST","invokeid":
   "c931e21c-5bf3-11e8-acfe-47fdbb39eee9","awsRequestId":"c931e21c-5bf3-11e8-acfe-47fdbb39eee9",
   "invokedFunctionArn":"arn:aws:lambda:us-east-1:625297745038:function:myfirstlambdafunction"
}

functionName、memorylimit、requestIdなどの詳細があることを確認してください。

ロギング

Lambda関数内に追加されたログは、AWS関数の実行時にAWSCloudWatchに表示されます。ログの構文は、選択した言語によって異なります。例nodejs、それはconsole.logです。

これは、AWSCloudWatchで確認できる出力です-

エラー処理

AWS Lambda関数は、エラーまたは成功が発生したことをLambda関数に通知するために使用されるコールバック関数を提供します。ここでは、ランタイムとしてnodejsを使用していることに注意してください。エラー処理は、選択した言語によって異なります。

理解を深めるために、ここに示す例を参照してください。

exports.lambdahandler = (event, context, callback) => {
   // TODO implement
   var error = new Error("There is error in code");
   callback(error);
};

出力

Lambdaコードをテストすると、次のような出力が見つかります-

ログの詳細は次のとおりです-

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

NodeJSのハンドラー

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

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

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

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

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

イベントパラメータ

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

コンテキストパラメータ

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

コールバック機能

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

callback(error, result);

コールバック関数のパラメータを以下に説明します-

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

Result −これにより、ラムダ関数の正常な実行の詳細がわかります。エラーが発生した場合、結果パラメータは無視されます。

Note −AWSLambdaでコールバック関数を使用することは必須ではありません。コールバック関数がない場合、ハンドラーはそれを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が実行されるたびに、エラーや成功などのコールバックの詳細が、コンソールメッセージ（存在する場合）とともにAWSCloudWatchに記録されます。

Nodejs8.10でのAWSLambdaの操作

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

同期方法で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 ハンドラー関数では、ラムダ関数からの正確な出力を取得します。

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

次の例は、Lambda関数を非同期で呼び出す方法についてのアイデアを示しています-

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関数呼び出しの横で、関数内のpromiseが解決されるまで実行が一時停止します。ご了承くださいawait のみ有効です async 関数。

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

NodeJSのContextDetails

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

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

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

シニア番号	メソッド名と説明
1	getRemainingTimeInMillis() このメソッドは、Lambda関数が関数を終了するまでの残り時間をミリ秒単位で示します

コンテキストオブジェクトで使用可能な属性

シニア番号	属性名と説明
1	functionName これにより、AWSLambda関数名が与えられます
2	functionVersion これにより、実行中のAWSLambda関数のバージョンが提供されます
3	nvokedFunctionArn これにより、ARNの詳細がわかります。
4	memoryLimitInMB これは、Lambda関数の作成中に追加されたメモリ制限を示しています
5	awsRequestId これにより、AWSリクエストIDが提供されます。
6	logGroupName これにより、cloudwatchグループ名が付けられます
7	logStreamName これにより、ログが書き込まれるクラウドウォッチログストリームの名前がわかります。
8	identity これにより、aws mobileSDKで使用した場合のAmazonCognitoIDプロバイダーの詳細がわかります。 詳細は以下の通りです− identity.cognito_identity_id identity.cognito_identity_pool_id
9	clientContext これにより、aws mobilesdkで使用した場合のクライアントアプリケーションの詳細がわかります。詳細は以下のとおりです。 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-モバイルクライアントアプリからのカスタム値のdictがあります client_context.env-AWS MobileSDKからの環境の詳細があります

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

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にログインする

NodeJSへのログインにconsole.logを使用できます。ログの詳細は、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)"  ]
}

この章では、Javaで単純なAWSLambda関数を作成する方法を詳しく理解しましょう。

EclipseでのJARファイルの作成

AWSでラムダ関数を作成する前に、Eclipse用のAWSツールキットのサポートが必要です。同じもののインストールに関するガイダンスについては、を参照することができますEnvironment Setup このチュートリアルの章。

インストールが完了したら、ここに記載されている手順に従います-

ステップ1

Eclipse IDEを開き、で新しいプロジェクトを作成します。 AWS Lambda Java Project。理解を深めるために、以下のスクリーンショットをご覧ください-

ステップ2

選択したら Next、以下に示す画面にリダイレクトされます-

ステップ3

これで、入力タイプのデフォルトコードが作成されます Custom。クリックしたらFinish 以下に示すように、プロジェクトが作成されるボタン-

ステップ4

次に、プロジェクトを右クリックしてエクスポートします。選択するJava / JAR からのファイル Export ウィザードをクリックしてクリックします Next。

ステップ5

さて、クリックすると Next、[次へ]をクリックすると表示される宛先フォルダにファイルを保存するように求められます。

ファイルが保存されたら、AWSコンソールに戻り、Java用のAWSLambda関数を作成します。

ステップ6

今、アップロードします .jar を使用して作成したファイル Upload 以下のスクリーンショットに示すボタン-

Javaのハンドラーの詳細

Handler です package name そして class name。次の例を見て、ハンドラーを詳細に理解してください。

例

package com.amazonaws.lambda.demo;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class LambdaFunctionHandler implements RequestHandler
      
        { @Override public String handleRequest(Object input, Context context) { context.getLogger().log("Input: " + input); // TODO: implement your handler return "Hello from Lambda!"; } } 
      

上記のコードから、ハンドラーは次のようになります。 com.amazonaws.lambda.demo.LambdaFunctionHandler

それでは、変更をテストして出力を確認しましょう-

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

AWS Lambda実行との相互作用は、コンテキストを使用して行われます。Java内で使用される以下のメソッドを提供します-

シニア番号	コンテキストメソッドと説明
1	getMemoryLimitInMB() これにより、ラムダ関数の作成時に指定したメモリ制限が与えられます。
2	getFunctionName() これにより、ラムダ関数の名前が付けられます。
3	getFunctionVersion() これにより、実行中のラムダ関数のバージョンが得られます。
4	getInvokedFunctionArn() これにより、関数の呼び出しに使用されるARNが提供されます。
5	getAwsRequestId() これにより、awsリクエストIDが提供されます。このIDはラムダ関数用に作成され、一意です。問題が発生した場合に備えて、IDをawsサポートで使用できます。
6	getLogGroupName() これにより、作成されたawslambda関数にリンクされたawscloudwatchグループ名が与えられます。iamユーザーがcloudwatchloggingのパーミッションを持っていない場合はnullになります。
7	getClientContext() これにより、aws mobilesdkで使用した場合のアプリとデバイスに関する詳細が表示されます。バージョン名とコード、クライアントID、タイトル、アプリパッケージ名などの詳細が表示されます。nullにすることができます。
8	getIdentity() これにより、aws mobilesdkで使用した場合のAmazonCognitoIDに関する詳細が表示されます。nullにすることができます。
9	getRemainingTimeInMillis() これにより、指定されたタイムアウト後に関数が終了したときの残りの実行時間がミリ秒単位で示されます。
10	getLogger() これにより、コンテキストオブジェクトにリンクされたラムダロガーが提供されます。

ここで、上記のコードを更新して、上記のいくつかのメソッドの出力を観察してみましょう。理解を深めるために、以下のサンプルコードを確認してください。

package com.amazonaws.lambda.demo;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class LambdaFunctionHandler implements RequestHandler<Object, String> {
   @Override
   public String handleRequest(Object input, Context context) {
      context.getLogger().log("Input: " + input);
      System.out.println("AWS Lambda function name: " + context.getFunctionName());
      System.out.println("Memory Allocated: " + context.getMemoryLimitInMB());
      System.out.println("Time remaining in milliseconds: " + context.getRemainingTimeInMillis());
      System.out.println("Cloudwatch group name " + context.getLogGroupName());
      System.out.println("AWS Lambda Request Id " + context.getAwsRequestId());
      
      // TODO: implement your handler
      return "Hello from Lambda!";
   }
}

上記のコードを実行すると、以下のような出力が見つかります-

コンテキストのログ

ログ出力を表示しているときに、次の出力を確認できます-

Lambda関数に割り当てられたメモリは512MBです。割り当てられる時間は25秒です。上に表示されている残り時間は24961で、ミリ秒単位です。したがって、Lambda関数の実行には39ミリ秒に等しい25000-24961が使用されます。Cloudwatchグループ名とリクエストIDも上記のように表示されることに注意してください。

次のコマンドを使用して、Javaでログを出力したことに注意してください。

System.out.println (“log message”)

CloudWatchでも同じことが利用できます。これを行うには、AWSサービスに移動し、CloudWatchservices をクリックします Logs。

ここで、Lambda関数を選択すると、以下に示すようにログが日付ごとに表示されます-

Javaへのログイン

JavaでLambdaloggerを使用してデータをログに記録することもできます。同じことを示す次の例を観察してください-

例

package com.amazonaws.lambda.demo;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
public class LambdaFunctionHandler implements RequestHandler<Object, String> {
   @Override
   public String handleRequest(Object input, Context context) {
      LambdaLogger logger = context.getLogger();
      logger.log("Input: " + input);
      logger.log("AWS Lambda function name: " + context.getFunctionName()+"\n");
      logger.log("Memory Allocated: " + context.getMemoryLimitInMB()+"\n");
      logger.log("Time remaining in milliseconds: " + context.getRemainingTimeInMillis()+"\n");
      logger.log("Cloudwatch group name " + context.getLogGroupName()+"\n");
      logger.log("AWS Lambda Request Id " + context.getAwsRequestId()+"\n");
      
      // TODO: implement your handler
      return "Hello from Lambda!";
   }
}

上記のコードは、次の出力を提供します-

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

Lambda関数のJavaでのエラー処理

このセクションでは、Java forLambda関数でエラーを処理する方法について説明します。同じことを示す次のコードを観察してください-

package com.amazonaws.lambda.errorhandling;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class LambdaFunctionHandler implements RequestHandler<Object, String> {
   @Override
   public String handleRequest(Object input, Context context) {
      throw new RuntimeException("Error from aws lambda");
   } 
}

エラーの詳細はに表示されることに注意してください json errorMessageでフォーマット Error from AWS Lambda。また、ErrorType そして stackTrace エラーの詳細を示します。

上記のコードの出力と対応するログ出力は、以下のスクリーンショットに示すようになります-

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

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

ステップ1

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

ステップ2

次に、をクリックします Create functionボタンをクリックして、PythonでシンプルなAWSLambdaを作成するための詳細を入力します。このコードはメッセージを返しますHello from Lambda using Python ここに示すように見えます-

ステップ3

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

ステップ4

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

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

ステップ5

ここで、 Upload a .ZIP file 以下に示すオプション-

Pythonのハンドラーの詳細

ハンドラーは、ファイルの名前の後に関数の名前を続ける必要があることに注意してください。上記の場合、ファイル名はhellopython.py 関数の名前は my_handler; したがって、ハンドラーは hellopython.my_handler。

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

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

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

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

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

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

コンテキストオブジェクトで使用可能なメソッドと属性を以下の表に示します-

シニア番号	メソッド名と説明
1	get_remaining_time_in_millis() このメソッドは、ラムダ関数が関数を終了するまでの残り時間をミリ秒単位で示します

シニア番号	属性と説明
1	function_name これはawsラムダ関数名を与えます
2	function_version これにより、実行中のawslambda関数のバージョンが得られます
3	invoked_function_arn これにより、ARNの詳細がわかります。
4	memory_limit_in_mb これは、ラムダ関数の作成中に追加されたメモリ制限を示しています
5	aws_request_id これにより、awsリクエストIDが提供されます。
6	og_group_name これにより、cloudwatchグループ名が付けられます
7	log_stream_name これにより、ログが書き込まれるクラウドウォッチログストリームの名前がわかります。
8	identity これにより、aws mobileSDKで使用した場合のAmazonCognitoIDプロバイダーの詳細がわかります。詳細は以下の通りです− identity.cognito_identity_id identity.cognito_identity_pool_id
9	client_context これにより、aws mobilesdkで使用した場合のクライアントアプリケーションの詳細がわかります。詳細は以下のとおりです。 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-モバイルクライアントアプリからのカスタム値のdictがあります client_context.env-AWS MobileSDKからの環境の詳細の辞書があります

コンテキストの詳細を出力する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を使用して情報をログに記録するには、利用可能な印刷またはロガー機能を使用できます。上記のコンテキストの例を使用し、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でのこのコードの出力は次のとおりです-

次の例を観察して、ロガーを使用してログを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"

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

Lambda関数のPythonでのエラー処理

このセクションでは、Pythonでエラーを処理する方法を示す実用的な例を見てみましょう。ここに示されているコードを観察してください-

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

ログ表示はこちらの画像のようになります−

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

Goのインストール

開始するには、Go言語のサポートが必要です。このセクションでは、以下の詳細を実行して、GoでAWSLambdaの使用を開始します。これはGoダウンロードの公式サイトです：https://golang.org/dl/

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

Windowsへのインストール

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

で利用可能な環境変数を追加します ControlPanel ---> System ---> Advanced system settings.

次に、をクリックします Environment Variables ボタンを押して、ここに示すようにディレクトリパスを追加します-

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

これらの手順が完了すると、Goでの作業を開始できるようになります。コマンドプロンプトを開き、Goコマンドでバージョンを確認します。同じために次のスクリーンショットを観察してください。

LinuxおよびMacOSのインストール

LinuxおよびMacOSにパッケージをインストールするには、以下の手順に従ってください。

パッケージを開梱し、その場所に保管します /usr/local/go。今、追加します/usr/local/go/binPATH環境変数に。それはを使用して行うことができます/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を使用したAWSLambda関数

ビルド時に実行可能ファイルが提供されたときにGoで返されるプログラム。以下は、AWSLambdaをサポートするGoの簡単なプログラムです。インポートする必要がありますgithub.com/aws/aws-lambda-go/lambda、これには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プログラムは、メインのラムダから始まります。startは、ハンドラー関数で呼び出されます。以下に示すコードを確認してください-

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

ここで、Goコマンドを使用して上記のファイルを実行し、実行可能ファイルを圧縮してみましょう。

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

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

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

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

次に、AWSコンソールにログインし、を使用してLambda関数を作成します 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のAWSLambdaは、コンテキスト用に次のグローバル変数とプロパティを提供します。

• MemoryLimitInMB − awslambdaで設定されているメモリ制限（MB単位）。

• FunctionName −awsラムダ関数の名前。

• FunctionVersion −実行中のawsラムダ関数のバージョン。

• LogStreamName −cloudwatchログストリーム名。

• LogGroupName −cloudwatchグループ名。

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

AwsRequestID

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

ClientContext

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

InvokedFunctionArn

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

身元

AWSモバイルSDKと併用した場合のAmazonCognitoIDプロバイダーに関する詳細を提供します。

に追加された変更 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)
}

インポートする必要があります log そして lambda contextGoで使用します。コンテキストの詳細は次のとおりです-

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左側にあります。次に、リストでLambda関数を検索して、ログを確認します-

機能エラー

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

// 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)
}

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

この章では、C＃でAWSLambda関数を操作する方法について詳しく説明します。ここでは、Visual Studioを使用してコードを記述し、AWSLambdaにデプロイします。VisualStudioのインストールとAWSツールキットのVisualStudioへの追加に関する情報とヘルプについては、Introductionこのチュートリアルの章。Visual Studioのインストールが完了したら、以下の手順に従ってください。理解を深めるために、それぞれのスクリーンショットを参照してください-

ステップ1

Visual Studioを開き、手順に従って新しいプロジェクトを作成します。クリックFile -> New -> Project。

ステップ2

これで、次の画面が表示されます。 AWS Lambda for Visual C#。選択するAWS Lambda Project (.NET Core)。

必要に応じて名前を変更できます。ここではデフォルトの名前が保持されます。クリックOK 続ける。

次のステップでは、を選択するように求められます Blueprint。

選択する Empty function この例では、をクリックします Finish。以下に示すように、新しいプロジェクト構造が作成されます。

ここで、 Function.cs これは、AWSLambda用にイベントとコンテキストを持つハンドラーが作成されるメインファイルです。

Functions.csファイルの表示は次のとおりです。

以下のコマンドを使用して、入力パラメーターと出力パラメーターをAWSLambda関数にシリアル化できます。

[assembly: 
LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]

C＃のハンドラーの詳細

ハンドラーは次のように表示されます-

public string FunctionHandler(string input, ILambdaContext context) {
   return input?.ToUpper();
}

上記のコードのさまざまなコンポーネントを以下に説明します-

FunctionHandler −これがC＃AWSLambda関数の開始点です。

String input − ハンドラーへのパラメーター string input S3オブジェクト、APIゲートウェイの詳細などのすべてのイベントデータがあります。

ILambdaContext context −ILamdaContextは、コンテキストの詳細を持つインターフェイスです。ラムダ関数名、メモリの詳細、タイムアウトの詳細などの詳細があります。

Lambdaハンドラーは、同期および非同期の方法で呼び出すことができます。上記のように同期して呼び出された場合は、戻り値の型を指定できます。戻り値の型よりも非同期の場合は無効にする必要があります。

それでは、AWS Lambda C＃をデプロイして、同じものをテストしてみましょう。プロジェクトを右クリックして、Publish to AWS Lambda 以下に示すように-

を埋める Function Name をクリックします Next。表示される次の画面はAdvanced Function Details 示されているように-

入力します Role Name, Memory そして Timeout。詳細ここでは、作成され使用された既存のロールを128MBとして選択し、タイムアウトを10秒として選択したことに注意してください。完了したらクリックUpload AWSLambdaコンソールに公開します。

AWS Lambda関数がアップロードされると、次の画面が表示されます。クリックInvoke作成されたAWSLambda関数を実行します。現在、記述されたコードに従って何らかの入力が必要なため、エラーが表示されます。

ここで、いくつかのサンプル入力を入力してみましょう。 Invokeもう一度。ここでは、入力ボックスにいくつかのテキストを入力し、クリックしても同じであることに注意してくださいinvoke応答セクションに大文字で表示されます。ログ出力は以下に表示されます-

ここで、AWSコンソールをチェックして、VisualStudioから関数をデプロイしたときに関数が作成されているかどうかを確認しましょう。

上で作成されたLambda関数は aws lambda using csharp 以下のスクリーンショットに示すように、同じものがAWSコンソールに表示されます-

ハンドラー署名

ハンドラーは、AWSが実行するための開始点です。ハンドラーの名前は次のように定義する必要があります-

ASSEMBLY::TYPE::METHOD

署名の詳細は以下のとおりです。

ASSEMBLY−これは、作成されたアプリケーションの.NETアセンブリの名前です。これは基本的に、プロジェクトが作成されたフォルダーの名前です。

TYPE−これはハンドラーの名前です。基本的にはnamespace.classnameです。

METHOD −これは関数ハンドラーの名前です。

ハンドラー署名のコードは次のとおりです-

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Amazon.Lambda.Core;

// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]

namespace AWSLambda3 {
   public class Function {

      /// <summary>
      /// A simple function that takes a string and does a ToUpper
      /// </summary>
      /// <param name="input"></param>
      /// <param name="context"></param>
      /// <returns></returns>
      public string FunctionHandler(string input, ILambdaContext context) {
         return input?.ToUpper();
      }
   }
}

ここでアセンブリが AWSLamda3、タイプはnamespace.classnameであり、 AWSLambda3.Function 方法は FunctionHandler。したがって、ハンドラーの署名はAWSLamda3::AWSLambda3.Function::FunctionHandler

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

コンテキストオブジェクトは、AWS環境のランタイムに関する有用な情報を提供します。コンテキストオブジェクトで使用できるプロパティは、次の表に示すとおりです。

シニア番号	プロパティと説明
1	MemoryLimitInMB これにより、AWSLambda関数用に構成されたメモリの詳細が表示されます
2	FunctionName AWSLambda関数の名前
3	FunctionVersion AWSLambda関数のバージョン
4	InvokedFunctionArn この関数を呼び出すために使用されるARN。
5	AwsRequestId 作成されたAWS関数のAWSリクエストID
6	LogStreamName Cloudwatchログストリーム名
7	LogGroupName Cloudwatchグループ名
8	ClientContext AWS mobileSDKで使用する場合のクライアントアプリケーションとデバイスに関する情報
9	Identity AWS mobileSDKで使用した場合のamazoncogbnitoIDに関する情報
10	RemainingTime 関数が終了するまでの残りの実行時間
11	Logger コンテキストに関連付けられたロガー

例

このセクションでは、C＃のAWSLambdaで上記のプロパティのいくつかをテストしましょう。以下のサンプルコードを確認してください-

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Amazon.Lambda.Core;
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]

namespace AWSLambda6 {
   public class Function {

      /// <summary>
      /// </summary>
      /// <param name="input"></param>
      /// <param name="context"></param>
      /// <returns></returns>
      public void FunctionHandler(ILambdaContext context) {
         LambdaLogger.Log("Function name: " + context.FunctionName+"\n");
         context.Logger.Log("RemainingTime: " + context.RemainingTime+"\n");
         LambdaLogger.Log("LogGroupName: " + context.LogGroupName+"\n");            
      }
   }
}

上記のコードを呼び出したときに観察できる関連出力 C# 以下のようになります−

上記のコードを呼び出したときに観察できる関連出力 AWS Console 以下のようになります−

C＃を使用したロギング

ロギングには、2つの機能を使用できます-

• context.Logger.Log

• LambdaLogger.Log

ここに示されている次の例を観察してください-

public void FunctionHandler(ILambdaContext context) {
   LambdaLogger.Log("Function name: " + context.FunctionName+"\n");
   context.Logger.Log("RemainingTime: " + context.RemainingTime+"\n");
   LambdaLogger.Log("LogGroupName: " + context.LogGroupName+"\n");            
}

上記のコードに対応する出力を次に示します-

以下に示すように、CloudWatchからログを取得できます-

Lambda関数のC＃でのエラー処理

このセクションでは、C＃でのエラー処理について説明します。エラー処理については、Exception 以下に示す例に示すように、クラスを拡張する必要があります-

例

namespace example {            
   public class AccountAlreadyExistsException : Exception {
      public AccountAlreadyExistsException(String message) :
         base(message) {
      }
   }
} 
namespace example {
   public class Handler {
     public static void CreateAccount() {
       throw new AccountAlreadyExistsException("Error in AWS Lambda!");
     }
   }
}

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

{
   "errorType": "LambdaException",
   "errorMessage": "Error in AWS Lambda!"
}

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

この章では、AWSLambdaの以下の構成プロパティについて詳しく理解しましょう。

メモリ割り当て

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

デフォルトでは、割り当てられるメモリは 128MB。メモリを増やしたい場合は、スライダーをクリックできます。

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

使用することもできます aws cliコマンドプロンプトからメモリ制限を増やします。あなたは64MBの増分でメモリを与える必要があります。

それでは、AWSLambdaのメモリ制限を次の名前で増やしましょう。myfirstlambdafunction。

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

を使用してメモリを変更するために使用されるコマンド 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

AWSLambda関数の対応する出力 myfirstlambdafunctionAWSコンソールでここに表示されます。メモリが128MBから256MBに変更されていることを確認します。

最大実行時間

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

IAMの役割

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

ハンドラー名

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

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関数の出力は次のようになります-

Lambda関数を作成し、AWSコンソールで同じものをテストできます。この章では、これについて詳しく説明します。この目的のために、ここに示されている手順に従い、与えられているそれぞれのスクリーンショットを観察する必要があります-

ステップ1

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

ステップ2

今、をクリックします Lambda上で強調したサービス。これにより、以下に示すように関数を作成するようにリダイレクトされます-

ステップ3

次に、をクリックします Create function関数の詳細を入力します。次に、以下のような画面が表示されます-

ステップ4

選択した言語を選択して、コードを記述できます。選択したオプションがインライン編集コードの場合、コードはエディターで記述する必要があります。利用可能な他のオプションは次のとおりです-

ステップ5

完了したら、以下に示すように、右上隅にボタンが表示されている変更を保存する必要があります-

ステップ6

次に、をクリックします Testボタン。これにより、以下に示すように、Lambda関数の実行のすべての詳細が得られます-

ステップ7

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

exports.handler = (event, context, callback) => {
   // TODO implement
   callback(null, 'Lambda test');
};

これは Callback functionその結果、エラーまたは成功する可能性があります。成功すると、Lambda testメッセージ; エラーの場合、nullを渡します。

ステップ8

ザ・ Role Lambda関数の詳細は設定の一部であり、以下のように表示されます-

ステップ9

これで、必要に応じてロールを更新し、Lambda関数を保存できます。次に、ラムダ関数のメモリとタイムアウトの詳細が次のように表示されます-

ステップ10

次に、Lambda関数にトリガーを追加して、イベントが発生したときに実行されるようにする必要があります。トリガーの詳細は、以下に示すようにAWSLambda関数画面の開始時に表示されます-

これから、Lambda関数をトリガーするトリガーを選択できます。トリガーを選択するときは、トリガーの構成の詳細を追加する必要があります。

たとえば、S3のトリガーの場合、追加される構成の詳細は次のとおりです。

ステップ11

次に、トリガーをオンにするバケットを選択します。イベントタイプには次の詳細があります-

ステップ12

トリガーについては、プレフィックスタイプのファイルまたはファイルパターンについても言及できます。Lambdaがトリガーである必要があります。詳細は以下の通りです−

ステップ13

次に、トリガーに必要な詳細を入力して、をクリックします Add ボタン。トリガーを追加するためにLambda関数を保存します。関数を保存すると詳細がデプロイされ、これ以降、ファイルがS3バケットに追加されるたびに、Lambdaがトリガーされます。

AWSLambdaに追加されたS3トリガーを示す次のスクリーンショットを確認してください-

ステップ14

ここで、S3サンプルイベントを使用してLambda関数をテストしましょう。同じためのコードはここに示されています-

Amazon S3Putサンプルイベント

{
   "Records": [{
      "eventVersion": "2.0",
      "eventTime": "1970-01-01T00:00:00.000Z",
      "requestParameters": {
         "ExampleIPAddress": "127.0.0.1"
      },
      "s3": {
         "configurationId": "testConfigRule",
         "object": {
            "eTag": "0123456789abcdef0123456789abcdef",
            "sequencer": "0A1B2C3D4E5F678901",
            "key": "HappyFace.jpg",
            "size": 1024
         },
         "bucket": { 
            "arn": bucketarn,
            "name": "Examplebucket",
            "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 putイベントからアップロードされたファイルの詳細を取得するには、次のコマンドを使用する必要があります-

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 event name

ステップ15

それでは、AWS Lambdaコードを更新して、以下に示すようにS3の詳細を出力しましょう-

exports.lambdahandler = (event, context, callback) => {
   callback(null, "Bucket name: "+event.Records[0].s3.bucket.name+"  
   File name:"+event.Records[0].s3.object.key );
};

ステップ16

変更を保存します。クリックTest S3サンプルイベントを入力します-

ステップ17

今クリック Test そして、あなたは示されているように出力を見ることができます-

ステップ18

S3 AWSサービスを使用してS3でトリガーをテストするには、S3バケットにファイルをアップロードします。 test bucket trigger。Lambdaで使用されるロールを更新して、権限のS3およびSESポリシー（メールを送信する）を取得します。これにより、AWS Lambdaコードが更新され、トリガーが機能していることを確認するためにメールが送信されます-

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

var aws = require('aws-sdk');
var ses = new aws.SES({
   region: 'us-east-1'
});
exports.lambdahandler = function(event, context, callback) {
   var eParams = {
      Destination: {
         ToAddresses: ["[email protected]"]
      },
      Message: {
         Body: {
            Text: {
               Data: "Bucket name: "+event.Records[0].s3.bucket.name+"  File name:"+event.Records[0].s3.object.key
            }
         },
         Subject: {
            Data: "S3 and AWS Lambda"
         }
      },
      Example: "[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");
         }
   });
};

対応するスクリーンショットは次のとおりです-

ステップ19

次に、ファイルをアップロードして、AWSLambdaコードで提供されているメールIDを確認します-

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

AWSCLIのインストール

このセクションでは、さまざまなオペレーティングシステムへのAWSCLIのインストールについて説明します。与えられた手順に従い、添付されている場所で対応するスクリーンショットを観察します。

Windowsの場合

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

• Windows64ビットの場合-Windows用のAWSCLI MSIインストール（64ビット）

• Windows32ビットの場合-Windows用のAWSCLI MSIインストール（32）

対応するリンクを選択してクリックすると、次のようなウィンドウが表示されます-

次に、 Environment path in windows 以下のスクリーンショットに示すように-

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

aws --version

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

Linux / Macの場合

LinuxおよびMacにインストールするには、Python2.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左側からユーザーを選択します。求められた詳細をユーザーに追加します。

ユーザーを追加し、アクセスキーと秘密キーを取得します。新しいアクセスキーを表示するには、Show。資格情報は次のようになります-

Access key ID − AOSAIOSFOCDD7Example

Secret access key − aJuirCVtnROUN/K7MDENG/bPxRfiCYExampleKEY

AWSCLISのリファレンスコマンド

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

awscliコマンドの名前	コマンドリファレンス
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 <値>]
list-functions	list-functions [--master-region <value>] [--function-version <value>] [--max-items <value>] [--cli-input-json <value>] [--starting-トークン<値>] [-ページサイズ<値>] [-generate-cli-skeleton <値>]
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-サイズ<値>] [-vpc-config <値>] [-環境<値>] [-ランタイム<値>] [-dead-letter-config <値>] [-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-バージョン<値>] [-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で使用できるコマンドのリストを以下に示します-

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)−ここでは、ランタイム環境、つまり言語の選択を指定する必要があります。ランタイムの詳細は以下のとおりです-

利用可能なオプション	ランタイム
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
行く	go1.x

--role(string)−これはラムダポリシーの名前、つまり他のサービスにアクセスするためにラムダ関数に与えられるロールになります。指定された役割に従って権限が与えられます。

--handler (string) −これはラムダコードの実行を開始するハンドラーの名前です。

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

--code (structure) −AWSLambdaコード

--description (string) − AWSLambda関数の説明

--timeout (integer)−タイムアウトには、ラムダ関数が実行を終了する必要がある時間があります。デフォルトは3秒です。

--memory-size (integer)−これはawslambda関数に与えられたメモリです。AWSは、指定されたメモリに基づいてCPUとメモリの割り当て量を割り当てます。

--environment (structure) −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で提供された値をオーバーライドします。

ここで、ランタイムをnodejsとして使用して単純なAWS Lambda関数を作成し、出力するconsole.logをいくつか追加しましょう。

同じことを理解するためのサンプルコードを考えてみましょう-

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

次に、ファイルをzipして、次のように保存します。 awscli.zip。

ARNの取得

役割については、 arn私たちが作成した既存の役割から。ARNを取得するには、ここに示す手順に従う必要があります。添付されている場所でそれぞれのスクリーンショットを観察します-

ステップ1

IAMに移動し、必要な役割を選択します Roles。ロールのARNの詳細は、次のように表示されます。使用するRole ARN と create-function に aws cli。

ここで、ロールarnが：arn：aws：iam :: 625297745038：role / lambdaapipolicyであることに注意してください。

の値を持つコマンド create-function 次のとおりです-

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でコマンドを実行すると、次のような出力が表示されます。

AWSコンソールでは、Lambda関数は次​​のように表示されます-

機能の詳細は以下のとおりです。

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

図のように、関数をテストして出力を確認できます。

対応するログ出力をここに示します-

リスト関数

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

含まれているコマンド

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

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

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

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

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

--function-version(string)−オプション。これにより、関数バージョンが提供されます。

--max-items(integer)−オプション。これにより、指定された値に従ってアイテムが提供されます。

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

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

aws lambda list-functions --max-items 3

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

get-function

この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− AWSLambda関数の名前。関数のAmazonリソース名を指定することもできます。

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

get-functionの値を持つコマンドは次のとおりです。

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

これにより、AWSLambda関数の設定の詳細がわかります。

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

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

The following are the options used with

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

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

get-functionの値を持つコマンドは次のとおりです。

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

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

get-account-settings

この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

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

update-function-configuration

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

関係するコマンド

以下は、update-function-configurationapiに関連するコマンドです。

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

関係するオプション

以下は、update-function-configurationapiに関連するオプションです。

--function-name − awsラムダ関数の名前

--role (string) −オプション。役割のARNを更新する必要があります。

--handler (string) −オプション。awslambda関数のハンドラーの詳細。

--description(string) −オプション。関数の説明。

--timeout(integer) −オプション。awslambda関数を終了するために必要な時間。

--memory-size(integer) −オプション。これは、awslambda関数に与えられたメモリです。AWSは、指定されたメモリに基づいてCPUとメモリの割り当て量を割り当てます。

--environment (structure) −オプション。これは、awslambda関数で必要な環境の詳細を持つオブジェクトです。

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

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

ランタイムの詳細を以下の表に示します-

利用可能なオプション	ランタイム
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
行く	go1.x

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

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

それでは、以前に作成したAWSLambda関数のメモリとタイムアウトを変更してみましょう。以下の手順に従って、この目的のために添付された対応するスクリーンショットを確認してください-

ステップ1

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

ステップ2

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

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

ステップ3

次に、次の出力をディスプレイとして表示できます-

ステップ4

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

更新-関数-コード

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

関係するコマンド

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

関係するオプション

以下は、update-function-codeapiに関連するオプションです。

--function-name(string) − awsラムダ関数の名前

--zip-file (blob) −オプション。更新するコードが含まれているzipファイルのパス。

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

--s3-key(string) −オプション。アップロードする必要のあるAWSs3オブジェクトキー名。

--s3-object-version (string) −オプション。AWSs3オブジェクトのバージョン。

--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!'
};

あなたは以下を使うことができます command with values for this purpose −

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

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

AWSコンソールからの表示は次のようになります-

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

削除機能

ザ・ 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) −これはオプションです。ここでは、削除する必要があるawslambdaのバージョンを指定できます。

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

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

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

ここで、関数がAWSLambda関数リストに表示されないことに注意してください-

AWS Lambdaは、サーバーレスフレームワークを使用して作成およびデプロイできます。AWS Lambdaトリガーを作成し、必要なロールを作成して同じものをデプロイすることもできます。サーバーレスフレームワークを使用すると、大きなプロジェクトをより簡単に処理できます。必要なイベントとリソースは1つの場所に書き込まれ、いくつかのコマンドだけでAWSコンソールに全機能をデプロイできます。

この章では、AWSサーバーレスフレームワークの使用を開始する方法について詳しく学習します。

npminstallを使用してServerlessFrameworkをインストールします

まず、最初にインストールする必要があります nodejs。次のようにnodejsを確認できます-

npmパッケージを使用してサーバーレスをインストールするには、次のコマンドを使用する必要があります-

npm install -g serverless

npmが完了したら、AWSLambda関数の作成とデプロイに使用するコマンドのリストを表示するサーバーレスコマンドを実行します。以下のスクリーンショットをご覧ください-

サーバーレスの代わりにslsを使用することもできます。 sls サーバーレスの省略形コマンドです。

コマンドのヘルプが必要な場合 sls, 次のコマンドを使用できます-

sls create --help

サーバーレスフレームワークを作成するには、以下の手順に従う必要があります-

ステップ1

サーバーレスフレームワークの使用を開始するには、資格情報を追加する必要があります。これにより、ユーザーは最初にAWSコンソールで次のようにできます-

ステップ2

クリック Next:Permissions権限を追加するボタン。このユーザーには、既存のポリシーまたは管理者アクセスを添付する必要があります。

ステップ3

クリック Create Userユーザーを追加します。サーバーレスフレームワークを構成するために必要なアクセスキーと秘密キーが表示されます-

AWS ServerlessFrameworkを設定する

AWSサーバーレスフレームワークを設定する方法を見てみましょう。この目的のために次のコマンドを使用できます-

sls config credentials --provider aws --key accesskey --secret secretkey

入力された資格情報の詳細、つまり access key そして secret key に保存されます file /aws/credentials。

まず、プロジェクトファイルを保存するフォルダを作成します。

次に、作業を開始します aws-serverless フォルダ。

ServerlessFrameworkを使用してAWSLambdaを作成する

次に、以下の手順を使用して、サーバーレスフレームワークでLambda関数を作成しましょう。

ステップ1

サーバーレスの詳細は次のとおりです create コマンド-

ステップ2

ここで、次のようなテンプレートを割り当てる必要があります-

AWS-nodejs, aws-nodejs-typescript, aws-nodejs-ecma-script, aws-python, aws-python3, aws-groovy-gradle etc.

ステップ3

活用します aws-nodejsサーバーレスフレームワークを使用して最初のプロジェクトを作成するためのテンプレート。同じ目的のコマンドは次のとおりです-

sls create --template aws-nodejs

このコマンドは、テンプレートaws-nodejsのボイラープレートを作成することに注意してください。

ステップ4

次に、IDEで作成したフォルダを開きます。ここではVisualStudioコードを使用しており、フォルダー構造は次のとおりです。

ステップ5

作成されるファイルは2つあります。 handler.js そして Serverless.yml

AWSLambdaの基本的な機能の詳細を以下に示します。 handler.js 次のように-

'use strict';

module.exports.hello = (event, context, callback) => {
   const response = {
      statusCode: 200,
      body: JSON.stringify({
         message: 'Go Serverless v1.0! Your function executed successfully!',
         input: event,
      }),
   };
   callback(null, response);

   // Use this code if you don't use the http event with the LAMBDA-PROXY integration
   // callback(null, { message: 'Go Serverless v1.0! Your function executed successfully!', event });
};

このファイル Serverless.yml 以下に示すように、サーバーレスフレームワークの構成の詳細があります-

# Welcome to Serverless!
#
# This file is the main config file for your service.
# It's very minimal at this point and uses default values.
# You can always add more config options for more control.
# We've included some commented out config Examples here.
# Just uncomment any of them to get that config option.
#
# For full config options, check the docs:
#    docs.serverless.com
#
# Happy Coding!
service: aws-nodejs # NOTE: update this with your service name

# You can pin your service to only deploy with a specific Serverless version
# Check out our docs for more details
# frameworkVersion: "=X.X.X"

provider:
 name: aws
 runtime: nodejs6.10

# you can overwrite defaults here
#  stage: dev
#  region: us-east-1

# you can add statements to the Lambda function's IAM Role here
#  iamRoleStatements:
#    - Effect: "Allow"
#      Action:
#        - "s3:ListBucket"
#      Resource: { "Fn::Join" : ["", ["arn:aws:s3:::", { "Ref" : "ServerlessDeploymentBucket" } ] ]  }
#    - Effect: "Allow"
#      Action:
#        - "s3:PutObject"
#      Resource:
#        Fn::Join:
#          - ""
#          - - "arn:aws:s3:::"
#            - "Ref" : "ServerlessDeploymentBucket"
#            - "/*"

# you can define service wide environment variables here
#  environment:
#    variable1: value1

# you can add packaging information here
#package:
#  include:
#    - include-me.js
#    - include-me-dir/**
#  exclude:
#    - exclude-me.js
#    - exclude-me-dir/**

functions:
 hello:
   handler: handler.hello

#    The following are a few example events you can configure
#    NOTE: Please make sure to change your handler code to work with those events
#    Check the event documentation for details
#    events:
#      - http:
#          path: users/create
#          method: get
#      - s3: ${env:BUCKET}
#      - schedule: rate(10 minutes)
#      - sns: greeter-topic
#      - stream: arn:aws:dynamodb:region:XXXXXX:table/foo/stream/1970-01-01T00:00:00.000
#      - alexaSkill: amzn1.ask.skill.xx-xx-xx-xx
#      - alexaSmartHome: amzn1.ask.skill.xx-xx-xx-xx
#      - iot:
#          sql: "SELECT * FROM 'some_topic'"
#      - cloudwatchEvent:
#          event:
#            Example:
#              - "aws.ec2"
#            detail-type:
#              - "EC2 Instance State-change Notification"
#            detail:
#              state:
#                - pending
#      - cloudwatchLog: '/aws/lambda/hello'
#      - cognitoUserPool:
#          pool: MyUserPool
#          trigger: PreSignUp

#    Define function environment variables here
#    environment:
#      variable2: value2

# you can add CloudFormation resource templates here
#resources:
#  resources:
#    NewResource:
#      Type: AWS::S3::Bucket
#      Properties:
#        BucketName: my-new-bucket
#  Outputs:
#     NewOutput:
#       Description: "Description for the output"
#       Value: "Some output value"

次に、要件に従ってserverless.ymlファイルに変更を追加する必要があります。以下のコマンドを使用できます-

次のコマンドを使用できます Service −

service: aws-nodejs # NOTE: update this with your service name

ここでサービスを変更し、図のようにフォルダーに付けられた名前を追加します-

service: aws-serverless # NOTE: update this with your service name

プロバイダーの詳細は次のとおりです-

provider:
   name: aws
   runtime: nodejs6.10

プロバイダーは aws ランタイムは nodejs6.10。追加する必要がありますregion 私たちが働くことになる場所と stage、 あれは dev or prodプロジェクトの環境。したがって、provider：provider −の更新された詳細は次のとおりです。

name: aws
runtime: nodejs6.10
# you can overwrite defaults here
stage: prod
region: us-east-1

IAMの役割

ザ・ iam roleつまり、Lambdaを使用するための許可のコードはここに示されています .yml ファイル-

#  iamRoleStatements:
#    - Effect: "Allow"
#      Action:
#        - "s3:ListBucket"
#      Resource: { "Fn::Join" : ["", ["arn:aws:s3:::", { "Ref" : "ServerlessDeploymentBucket" } ] ]  }
#    - Effect: "Allow"
#      Action:
#        - "s3:PutObject"
#      Resource:
#        Fn::Join:
#          - ""
#          - - "arn:aws:s3:::"
#            - "Ref" : "ServerlessDeploymentBucket"
#            - "/*"

上記のセクションで、ロールの詳細、つまり他のAWSサービスで必要な権限を指定する必要があることに注意してください。

AWSLambdaハンドラーの詳細

のエクスポート機能の名前 handler.jsこんにちは。したがって、ハンドラーはファイルの名前の後にエクスポート名が続きます。

functions:
   hello:
      handler: handler.hello

以下に示すように追加されたs3サービスに関するリソースの詳細-

# you can add CloudFormation resource templates here
#resources:
#  resources:
#    NewResource:
#      Type: AWS::S3::Bucket
#      Properties:
#        BucketName: my-new-bucket
#  Outputs:
#     NewOutput:
#       Description: "Description for the output"
#       Value: "Some output value"

ServerlessFrameworkを使用してAWSLambdaをデプロイする

上記のラムダ関数をAWSコンソールにデプロイしましょう。この目的のために次のステップを使用できます-

ステップ1

まず、次のコマンドを使用する必要があります-

sls deploy

ステップ2

これで、次のようにAWSコンソールに関数が表示されます。サーバーレスAWSの詳細は、AWSクラウドフォーメーションに記録されます。この目的のために、AWSサービスに移動して選択しますCloudFormation。AWSLambdaの詳細は次のように表示されます-

指定された名前は、プロジェクト名の後に使用されるステージが続くことに注意してください。

ステップ3

AWS Lambdaのiamロールと、AWScloudwatchのロググループを作成します。コードの詳細と構成の詳細が保存されたS3バケットが作成されます。

これはコマンドによって作成されます sls deploy。iamロールを指定する必要はありません。代わりに、デフォルトでiamロールが作成されます。deploy ステージ。

ステップ4

イベントの詳細な流れは、以下のクラウド形成サービスに表示されます。

AWSLambdaコード

AWSLambdaコードとその実行設定を以下のスクリーンショットに示します-

Lambda関数をテストすると、次の出力が見つかります-

上記の関数のログ出力を次に示します-

以下に示すように、サーバーレスコマンドを使用してAWSLambda関数をテストすることもできます。

sls invoke --function hello

invokeコマンドの構文を次に示します-

sls invoke --function hello

このinvokeコマンドは、AWS Lambda関数をトリガーし、以下に示すようにコマンドプロンプトに出力を表示します-

次のコマンドを使用して、デプロイする前にLambda関数とそのコマンドをテストすることもできます。

sls invoke local --function hello

S3やDynanoDBなどのリソースはローカル環境でシミュレートできないため、ローカルでテストできるとは限らないことに注意してください。ローカルでテストできるのは、基本的な関数呼び出しのみです。

サーバーレスフレームワークでのAPIGatewayとAWSLambdaの使用

LambdaとAPIゲートウェイで動作する新しいプロジェクトを作成する方法を見てみましょう。この目的のために次のコマンドを使用できます-

sls create --template aws-nodejs

開催中 aws-apiVisualCodeでプロジェクトします。あなたはそれを見ることができますhandler.js そして serverless.yml作成されたファイル。apiゲートウェイを追加するために変更を加えましょう。

次の変更を行う必要があります serverless.yml −

これで、AWSLambdaを使用したAPIゲートウェイアクティベーション用にイベントの詳細が追加されました-

ここに追加された新しいものがあります events。イベントを次のように指定しましたhttp、そのパスとメソッドとともに。

パスは、APIゲートウェイパスが作成され、使用されるメソッドがGETであるときに使用するエンドポイントです。

ハンドラーが handler.hello、およびhelloはhandler.jsからのエクスポート名です。

サーバーレスフレームワークが実行するため、ここでapiゲートウェイをデプロイする必要はないことに注意してください。

今、私たちは実行します sls deploy トリガーを使用してAWSLambda関数を作成するコマンド api gateway。

sls deploy

デプロイの詳細が上にリストされていることを確認してください。それはGetパスの詳細としてエンドポイントを含むURL。ステージはprodそのため、同じことがURLで使用されます。関数の名前はaws-api-prod-hello。

URLを押して、出力を見てみましょう。api-gateway get url −から取得した応答は次のとおりです。

{"message":"Go Serverless v1.0! Your function executed 
successfully!","input":{"resource":"/first-api","path":"/first-api","httpMethod":
"GET","headers":{"Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,
image/webp,image/apng,*/*;q=0.8","Accept-Encoding":"gzip, deflate, br","Accept-Language":"en-US,en;q=0.9","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":"IN","Host":"nvbhfdojfg.execute-api.us-east-1.
amazonaws.com","upgrade-insecure-requests":"1","User-Agent":"Mozilla/5.0 
(Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)
 Chrome/66.0.3359.181 Safari/537.36","Via":"2.0 707912794802dbb4825c79b7d8626a5d.cloudfront.net (CloudFront)","X-Amz-Cf-Id":"j70MMqkWFp6kmvuauzp_nvTbI-WwKIQmm2Jl5hzSoN6gkdvX11hh-g==",
 "X-Amzn-Trace-Id":"Root=1-5b13f9ef-5b012e36b7f40b5013a326fc","X-Forwarded-For":"157.33.133.217, 54.182.242.73","X-Forwarded-Port":"443","X-Forwarded-Proto":"https"},
 "queryStringParameters":null,"pathParameters":null,"stageVariables":null,
 "requestContext":{"resourceId":"pes5sy","resourcePath":"/first-api","httpMethod":
 "GET","extendedRequestId":"H6P9fE-MoAMFdIg=","requestTime":"03/Jun/2018:14:23:
 43 +0000","path":"/prod/first-api","accountId":"625297745038","protocol":"HTTP/1.1",
 "stage":"prod","requestTimeEpoch":1528035823928,"requestId":"b865dbd6-6739-11e8-b135
 -a30269a8ec58","identity":{"cognitoIdentityPoolId":null,"accountId":null,
 "cognitoIdentityId":null,"caller":null,"SourceIp":"157.33.133.217","accessKey":null,
 "cognitoAuthenticationType":null,"cognitoAuthenticationProvider":null,"userArn":null,
 "userAgent":"Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like
 Gecko) Chrome/66.0.3359.181 Safari/537.36","user":null},"apiId":"nvbhfdojfg"},"body":null,
 "isBase64Encoded":false}}

URLを押すと、イベントの詳細も出力に表示されます。httpMethodはGETであり、クエリ文字列に何も渡されないため、queryStringParametersはnullです。イベントの詳細はに与えられますinput AWSLambdaハンドラーで指定したもの-

APIゲートウェイから取得する出力は body などの詳細 message そして input。応答は、APIゲートウェイとそれを出力として表示する方法によって完全に制御されます。

ここで、入力をクエリ文字列のGET URLに渡して、表示を確認しましょう-

次に、以下に示すようにクエリ文字列の出力を確認できます-

{"message":"Go Serverless v1.0! Your function executed 
successfully!","input":{"resource":"/first-api","path":"/first-api","httpMethod":
"GET","headers":{"Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,
image/webp,image/apng,*/*;q=0.8","Accept-Encoding":"gzip, deflate, 
br","Accept-Language":"en-US,en;q=0.9","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":"IN","Host":"nvbhfdojfg.execute-api.us-east-1.amazonaws.com",
"upgrade-insecure-requests":"1","User-Agent":"Mozilla/5.0 (Windows NT 6.3; Win64; x64)
 AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.181 Safari/537.36","Via":"2.0 
 8b1d3263c2fbd0a2c270b174d7aa3d61.cloudfront.net (CloudFront)","X-Amz-Cf-Id":"JIBZw3I-blKbnpHP8LYXPVolCgdW5KmEukZS4at9mi4vrWBMI-UKNw==",
 "X-Amzn-Trace-Id":"Root=1-5b13ff90-7d6e38d4c0e4a5d4e6184f30","X-Forwarded-For":
 "157.33.133.217, 54.182.242.127","X-Forwarded-Port":"443","X-Forwarded-Proto":"https"},"queryString
 Parameters":{"displaymessage":"Hello"},"pathParameters":null,"stageVariables":null,
 "requestContext":{"resourceId":"pes5sy","resourcePath":"/first-api","httpMethod":
 "GET","extendedRequestId":"H6TeiG34oAMFguA=","requestTime":"03/Jun/2018:14:47:44 +0000","path":"/prod/first-api","accountId":"625297745038","protocol":"HTTP/1.1",
"stage":"prod","requestTimeEpoch":1528037264252,"requestId":"12e5dca3-
673d-11e8-8966-69fcf43bd4db","identity":{"cognitoIdentityPoolId":null,"accountId":null,
"cognitoIdentityId":null,"caller":null,"exmpleIp":"157.33.133.217","accessKey":null,
"cognitoAuthenticationType":null,"cognitoAuthenticationProvider":null,"userArn":null,
"userAgent":"Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like
 Gecko) Chrome/66.0.3359.181 Safari/537.36","user":null},"apiId":"nvbhfdojfg"},"body":
 null,"isBase64Encoded":false}}

以下に示すように、AWSLambda関数を変更してクエリ文字列の詳細を表示するようにしましょう-

'use strict';
module.exports.hello = (event, context, callback) => {
   const response = {
      statusCode: 200,
      body: JSON.stringify({
         message:(event.queryStringParameters &&     event.queryStringParameters.displaymessage!="") ? event.queryStringParameters.displaymessage : 'Go Serverless v1.0! Your function executed successfully!'
      }),
   };
   callback(null, response);
   // Use this code if you don't use the http event with the LAMBDA-PROXY integration
   // callback(null, { message: 'Go Serverless v1.0! Your function executed successfully!', event });
};

クエリ文字列に基づいてメッセージを変更したことを確認します display message。これにより、関数が再度デプロイされ、出力が確認されます。以下に示すように、クエリ文字列変数表示メッセージに存在する詳細が表示されます。

ここで追加しましょう post 以下に示すように作成されたイベントへのメソッド-

ここで、行った変更をデプロイすると、deployコマンドから次の出力が表示されます-

ブラウザで投稿URLを直接テストしても、詳細はわかりません。で投稿URLをテストする必要がありますpostman。

郵便配達員を取得するには https://www.getpostman.com/apps。OSごとにアプリをダウンロードします。インストールすると、以下に示すように投稿のURLをテストできるようになります-

これにより、Lambda関数で追加したメッセージが表示されます。

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

AWSLambda実行モデル

AWSの実行は、AWSLambda関数に追加された設定の詳細によって異なります。関数が作成されると、memory そして time allotted、AWSLambda関数の実行に使用されます。

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

AWS Lambda関数が初めて呼び出されたとき、またはラムダ関数が更新された場合、実行コンテキストの設定のために追加されるレイテンシはほとんどありません。ただし、後続の呼び出しは最初の呼び出しと比較して高速です。Lambda関数の呼び出しにかかる時間が短い場合、AWSLambdaは実行コンテキストの再利用を再試行します。

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

• Lambdaの実行のためにデータベース接続が行われた場合、接続は再利用のために維持されます。したがって、Lambdaコードは、接続を最初にチェックする必要があるようなものである必要があります-存在する場合は、再利用します。そうでなければ、私たちは新たな新しいつながりを作らなければなりません。

• 実行コンテキストは、500MBのディスクスペースを維持します /tmpディレクトリ。必要なデータはこのディレクトリにキャッシュされます。コードを追加でチェックして、データが存在するかどうかを確認できます。

• Lambda関数が呼び出されたときにコールバックまたは一部のバックグラウンドプロセスが完了していない場合、ラムダ関数が再度呼び出されたときに実行が開始されます。そのようなことをする必要がない場合は、関数の実行が完了したときに、プロセスがすべて適切に終了していることを確認してください。

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

AWSLambda関数を呼び出す

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

AWSCLIを使用したAWSLambda関数の作成

次のコマンドを使用して、を使用してAWSLambda関数を作成できます。 aws cli −

Commands

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

Command with values

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>

Options

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

--invocation-type(string) − デフォルトでは、呼び出しタイプは requestresponse。invokation-typeで使用できる値は次のとおりです。RequestResponse, Event そして DryRun。

• イベントinvocation-typeは非同期応答に使用されます。

• DryRunは、Lambda関数を実行せずに検証する場合に使用します。

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

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

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

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

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

Command with values

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

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

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

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"

サンプルイベント

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

Amazon S3Putサンプルイベント

{
  "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"
   }]
}

取得するには details of the file from the s3 put event、次のコマンドを使用できます-

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

に get the bucket name、次のコマンドを使用できます-

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

に see the EventName、次のコマンドを使用できます-

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

AmazonS3サンプルイベントの削除

{
   "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

DynamoDBテーブルに変更が加えられると、AmazonDynamoDBはAWSLambdaのイベントになる可能性があります。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 Simple Notification Service

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

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

AmazonSNSサンプルイベント

AWSLambda関数で利用可能なすべての詳細を含むサンプルイベントを以下に示します。

{
  "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 MailServiceで呼び出すことができます。

AmazonSESメール受信サンプルイベント

AWSLambda内で使用した場合の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"
   }]
}

AmazonCloudwatchログ

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

AmazonCloudWatchログのサンプルイベント

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

Amazon API Gateway

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

APIゲートウェイプロキシリクエストイベント

{
   "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ゲートウェイプロキシ応答イベント

{
   "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関数を削除すると、AWSコンソールからAWSLambdaが削除されます。AWSLambda関数を削除する方法は2つあります。

• AWSコンソールを使用します。
• AWSCLIコマンドの使用

この章では、これら2つの方法について詳しく説明します。

AWSコンソールの使用

AWSコンソールを使用してLambda関数を削除するには、以下の手順に従います-

ステップ1

AWSコンソールにログインし、AWSLambdaサービスに移動します。これまでに作成されたAWSラムダ関数が以下に示すようにAWSコンソールに一覧表示されていることがわかります-

このリストは、これまでに23個のAWSLambda関数が作成されていることを示しています。上部にあるページネーションを使用してそれらを表示するか、検索ボックスを使用してAWSLambdaを検索できます。

ステップ2

AWSLambda関数のそれぞれにラジオボタンがあることに注意してください。削除したい機能を選択してください。以下に示すスクリーンショットを確認してください-

ステップ3

AWS Lambda関数を選択すると、 Action以前にグレー表示されていたドロップダウンが強調表示されます。ここで、コンボボックスを開くと、次のようなオプションが表示されます-

ステップ4

を選択 DeleteAWSLambda関数を削除するボタン。クリックしたらDelete、次のようにメッセージを表示します-

ステップ5

メッセージを注意深く読み、後でクリックします Delete AWSラムダ関数を完全に削除するボタン。

Note− aws lambdaを削除しても、リンクされているロールは削除されません。ロールを削除するには、IAMに移動してロールを削除する必要があります。

ステップ6

これまでに作成された役割のリストを以下に示します。あることに注意してくださいCreate role ボタンと Delete role ボタン。

削除する役割のチェックボックスをクリックします。一度に削除する複数の役割を選択することもできます。

ステップ7

[削除]ボタンをクリックすると、以下のような確認メッセージが表示されます-

今、注意深く言及された詳細を読み、後でクリックしてください Yes, delete ボタン。

AWSCLIコマンドの使用

まず、aws cliを使用してLambda関数を作成し、同じコマンドを使用して同じ関数を削除しましょう。この目的のために以下の手順に従ってください-

ステップ1

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

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

対応する出力をここに示します-

ステップ2

作成されたAWSLambda関数は lambdatestcli。既存のロールarnを使用してラムダ関数を作成しました。

次に、以下に示すように、AWSコンソールに表示されるこの関数を見つけることができます-

ステップ3

ここで、関数を呼び出して、次のコマンドを使用して出力をテストします。

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

このコマンドは、次のような出力を提供します-

ステップ4

ラムダ関数のcloudwatchからログを監視できます lambdatestcli

ステップ5

それでは、AWS関数を削除する実際の部分に移りましょう。 Delete aws cli api指定された機能を削除します。この目的で使用されるコマンドの詳細を以下に示します-

Command

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

Options

--function-name(string) −これは、Lambda関数名またはAWSLambda関数のarnを取ります。

--qualifier (string)−これはオプションです。ここで、削除する必要があるAWSLambdaのバージョンを指定できます。

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

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

Command with values

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

対応する出力を以下に示します-

ステップ6

ここで確認すると、以下のスクリーンショットに示すように、AWSLambda関数リストに関数が表示されないことがわかります。

Amazon APIGatewayの操作

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

この章では、AWSラムダとAPIゲートウェイでの作業に関連するさまざまなプロセスについて詳しく説明します。

関係するプロセス

以下は、AWSラムダとAPIゲートウェイの操作に関連するプロセスです-

• パーミッションのIAMロールを作成する
• AWSラムダ関数を作成する
• APIゲートウェイを作成する
• ラムダ関数をAPIゲートウェイにリンクする
• APIゲートウェイへのデータの受け渡し

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

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

パーミッションのIAMロールを作成する

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

IAMに移動し、 Roles 以下に示すように左側のセクションから-

クリック Create role ラムダ関数用。

Lambdaを選択し、 Permissions下部にあります。APIGatewayとLambdaに必要な権限を選択します。

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

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

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

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

ロールに関連付けられているポリシーが表示されます。クリックCreate role ロールの作成が完了し、ラムダ関数を続行できます。

AWSLambda関数を作成する

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

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

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

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

ここでは使用することに注意してください nodejsコードを書くためのランタイム。AWSコードとhelloworld メッセージは以下のとおりです−

AWSLambdaコードはに存在します index.jsファイル。ハンドラーと呼ばれる関数には、次のパラメーターがあります。events, context そして callback。

コールバック関数には基本的にエラーと成功メッセージがあります。ここにはエラー関連のコードがないため、nullが渡され、成功メッセージは次のようになります。HelloWorld from lambda.

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

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

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

[APIゲートウェイ]をクリックすると、新しいAPIゲートウェイを作成できる画面が表示されます。

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

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

クリック Actions ドロップダウンを使用して、APIの新しいリソースを作成します。

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

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

追加 GET/POST以下に示すように作成されたリソースへのメソッド。から方法を選択しますActions 落ちる。

クリック GET メソッドをAPIに追加するメソッド。

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

Lambda関数をAPIゲートウェイにリンクする

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

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

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

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

選択する Deploy API。展開状態を要求します。選択するNew Stage [展開ステージ]ドロップダウンから、ステージ名を次のように追加します Production。

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

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

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

それでは、APIGatewayからメッセージの詳細を取得しましょう。別のドメインからHTTPS呼び出しを呼び出す必要がある場合、たとえばAPIへのAJAX呼び出しの場合、作成されたAPIゲートウェイに対してCORSを有効にする必要があります。

API用に作成されたリソースを選択し、をクリックします Actions ドロップダウン-

さて、 Enable CORS 次の画面が開きます-

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

APIで使用するドメイン名を指定することもできます。クリックEnable CORS and replace existing CORS headers ボタンを押すと、以下のような確認メッセージが表示されます-

クリック Yes, replace existing valuesそれを有効にするボタン。ザ・Enable CORS 画面は以下のようになります−

APIゲートウェイへのデータの受け渡し

APIGatewayで作成したAPIを開きます displayhelloworld 以下に示すように-

クリック Integration Request 以下に示すようにデータを送信するには−

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

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

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

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

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

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

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

AmazonS3でのLambda関数の使用

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

AmazonS3でAWSLambda関数を使用するための手順

AmazonS3でAWSLambdaの使用を開始するには、次のものが必要です。

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

例

AmazonS3とAWSLambdaの間の基本的な相互作用を示す例を使用して、これらの手順を見てみましょう。

• ユーザーはAmazonS3バケットにファイルをアップロードします

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

• ファイルがアップロードされると、ユーザーはCloudwatchログにメッセージを表示できるようになります。

例の流れを説明するブロック図をここに示します-

S3バケットの作成

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

ステップ1

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

ステップ2

S3ストレージをクリックして Create bucket アップロードされたファイルを保存します。

ステップ3

クリックしたら Create bucket ボタンをクリックすると、次のような画面が表示されます-

ステップ4

詳細を入力してください Bucket name, Select the Region をクリックします Create左下のボタン。したがって、次の名前のバケットを作成しました。workingwithlambdaands3。

ステップ5

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

これで、S3でのバケットの作成は完了です。

S3とLambdaで機能するロールを作成する

S3およびLambdaで機能するロールを作成するには、以下の手順に従ってください。

ステップ1

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

ステップ2

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

ステップ3

次に、をクリックします Create roleこの役割を使用するサービスを選択します。Lambdaを選択し、Permission ボタン。

ステップ4

下から権限を追加して、 Review。

ステップ5

次の権限を選択したことに注意してください-

選択したポリシーが次のとおりであることを確認してください AmazonS3FullAccess, AWSLambdaFullAccess そして CloudWatchFullAccess。

ステップ6

次に、役割名、役割の説明を入力して、 Create Role 下部のボタン。

したがって、私たちの役割は lambdawiths3service 創造された。

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

このセクションでは、Lambda関数を作成してS3トリガーを追加する方法を見てみましょう。この目的のために、以下に示す手順に従う必要があります-

ステップ1

AWS Servicesに移動し、以下に示すようにLambdaを選択します-

ステップ2

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

ステップ3

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

ステップ4

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

ステップ5

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

選択する Object Created (All)、ファイルのアップロード、削除など時にAWSLambdaトリガーが必要なため。

ステップ6

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

ステップ7

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

awslambda関数の詳細を追加しましょう。ここでは、オンラインエディターを使用してコードを追加し、ランタイム環境として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でラムダ関数をテストしましょう。以下は、AWSLambdaで追加されたコードの詳細です-

ステップ10

それでは、役割、メモリ、タイムアウトを追加しましょう。

ステップ11

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

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

ステップ12

クリック Upload 図のようにファイルを追加するボタン-

ステップ13

クリック Add filesファイルを追加します。ファイルをドラッグアンドドロップすることもできます。次に、をクリックしますUpload ボタン。

したがって、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で確認できる出力は次のとおりです-

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

AmazonDynamoDBでのLambda関数の使用

DynamoDBは、データがテーブルに追加、更新、または削除されたときにAWSLambdaをトリガーできます。この章では、DynamoDBテーブルにアイテムを追加する簡単な例と、データを読み取り、データが追加されたメールを送信するAWSLambdaについて説明します。

必要条件

AmazonDBとAWSLambdaを使用するには、以下に示す手順に従う必要があります-

• 主キーを使用してDynamoDBにテーブルを作成します

• DynamoDBおよびAWSLambdaを操作する権限を持つロールを作成します。

• AWSLambdaで関数を作成する

• メールを送信するためのAWSLambdaトリガー

• DynamoDBにデータを追加する

この各ステップについて詳しく説明します。

例

DynamoDBとAWSLambdaの間の基本的な相互作用を示す次の例を実行します。この例は、次の操作を理解するのに役立ちます-

• Dynamodbテーブルにcustomerというテーブルを作成し、そのテーブルにデータを入力する方法。

• データが入力されるとAWSLambda関数をトリガーし、AmazonSESサービスを使用してメールを送信します。

例の流れを説明する基本的なブロック図は次のとおりです。

主キーを使用してDynamoDBにテーブルを作成する

AWSコンソールにログインします。以下に示すように、AWS Servicesに移動し、DynamoDBを選択します。DynamoDBを選択します。

DynamoDBは以下のようなオプションを表示します-

次に、をクリックします Create table図のようにテーブルを作成します。テーブルに名前を付けましたcustomer そのテーブルの主キーを cust_id。クリックCreate テーブルをdynamodbに追加するボタン。

作成されるテーブルは次のとおりです-

次のように作成されたテーブルにアイテムを追加できます-

クリック Items をクリックします Create item 示されているボタン-

DynamoDBおよびAWSLambdaを操作するためのアクセス許可を持つロールの作成

ロールを作成するには、AWSサービスに移動して[IAM]をクリックします。

以前に作成したDynamoDBテーブルにのみ使用するポリシーを作成しましょう-

今、選択します Service。選択したサービスがDynamoDB。にとってActions 私たちはすべてを取りました Dynamodbアクション、つまりリストへのアクセス、読み取り、書き込み。にとってresources、テーブルリソースタイプのアクションを選択します。クリックすると次のような画面が表示されます−

ここで、 table そして Add ARN示されているようにそれに。私たちは得るだろうARN からの詳細 customer table 以下のように作成-

入る arn 詳細はこちら−

クリック Addボタンをクリックして変更を保存します。完了したらClick on Review policy。以下に示すように、ポリシーの名前、説明などを入力します-

クリック create policyそれを保存します。作成するロールにポリシーを追加します。選択するRole 左側から詳細を入力します。

追加されたポリシーが次のとおりであることを確認します newpolicyfordynamdb, awslambdafullaccess, cloudwatchfullaccess そして amazonsesfullaccess。ロールを追加し、AWSLambda関数の作成時に使用します。

AWSLambdaで関数を作成する

したがって、次のように呼ばれるLambda関数を作成しました newlambdafordynamodb 示されているように。

次に、作成したAWSLambdaにDynamodDBトリガーを追加しましょう。使用するランタイムはNode.jsです。

AWSLambda用に設定されるDynamodbトリガーで次の詳細を見つけることができます-

今、単にクリックします Add AWSLambdaにトリガーを追加します。

メールを送信するAWSLambdaトリガー

AWS Lambdaは、データがAWSLambdaに挿入されるとトリガーされます。イベントパラメーターには、dynamodbデータが挿入されます。これにより、イベントからデータが読み取られ、メールが送信されます。

メールを送信する

メールを送信するには、以下の手順に従う必要があります-

ステップ1

AWSサービスに移動し、SES（シンプルメールサービス）を選択します。図のように、電子メールの送信先となる電子メールを検証します-

ステップ2

ボタンをクリックします Verify a New Email Address メールアドレスを追加します。

ステップ3

メールアドレスを入力して確認してください。メールアドレスは、クリックする必要があるアマゾンからのアクティベーションメールを受信します。アクティベーションが完了すると、メールIDが確認され、AWSサービスで使用できるようになります。

ステップ4

イベントからデータを読み取り、メールを送信するAWSLambdaコードを以下に示します-

var aws = require('aws-sdk');
var ses = new aws.SES({
   region: 'us-east-1'
});
exports.handler = function(event, context, callback) {
   console.log(event);
   let tabledetails = JSON.parse(JSON.stringify(event.Records[0].dynamodb));
   console.log(tabledetails.NewImage.address.S);
   let customerid = tabledetails.NewImage.cust_id.S;
   let name = tabledetails.NewImage.name.S;
   let address = tabledetails.NewImage.address.S;
	
   var eParams = {
      Destination: {
         ToAddresses: ["[email protected]"]
      },
      Message: {
         Body: {
            Text: {
               Data: "The data added is as follows:\n CustomerId:"+customerid+"\n Name:"+name+"\nAddress:"+address
            }
         },
         Subject: {
            Data: "Data Inserted in Dynamodb table customer"
         }
      },
      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");
      }
   });
}

次に、Lambda関数とデータをDynamoDBテーブルに保存します。

DynamoDBにデータを追加する

次のシーケンスを使用して、DynamoDBにデータを追加します。

ステップ1

テーブルに行く customer Dynamodbで作成されました。

ステップ2

クリック Create item。

ステップ3

クリック Save ボタンをクリックし、AWS Lambdaで提供されているメールIDをチェックして、メールがAWSLambdaによって送信されたかどうかを確認します。

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

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

必要条件

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

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

例

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

同じものの基本的なブロック図を以下に示します-

AWSSESを使用してEメールIDを確認する

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

次に、をクリックします Simple Email 示されているサービス-

クリック Email Addresses 図のように左側に-

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

入る Email Address確認したい。クリックVerify This Email Addressボタン。AWSから、そのメールIDにメールの件名が記載されたメールが届きます：Amazon Web Services –米国東部（バージニア北部）の地域でのメールアドレス確認リクエスト

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

AWS SES、Cloudwatch、AWSLambdaを使用するためのロールを作成する

また、サービスの使用を許可するロールを作成することもできます。これを行うには、IAMに移動して[役割]を選択します。必要なポリシーを追加し、役割を作成します。ここで作成された役割は次のとおりです。events with lambda。

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

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

次に、図のようにLambdaにトリガーを追加します-

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

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

メールを送信するためのLambdaコードを以下に示します-

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");
      }
   });
};

ここで、AWSSESサービスが必要です。次のようなコードを使用してこれを追加できます-

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

からメールを送信するには nodejs、作成しました eParams 次のような詳細を持つオブジェクト example mail, to mail id そして the body with message 次のように-

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]"
};

メールを送信するLambdaコードは次のとおりです-

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分ごとにAWSLambdaから送信されることを示しています。

AmazonSNSでLambda関数を使用する

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

• SNSサービスでトピックを作成し、AWSLambdaを使用してCloudWatchにトピックを追加します

• 指定された電話番号でSNSテキストメッセージを送信します。

必要条件

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

• SNSでトピックを作成する
• IAMで権限のロールを作成する
• AWSLambda関数を作成する
• トピックに公開してトリガーをアクティブ化する
• CloudWatchサービスでメッセージの詳細を確認してください。

指定された電話番号でSNSテキストメッセージを送信するには、次の手順を実行する必要があります。

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

例

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

これは同じことを説明する基本的なブロック図です-

SNSでトピックを作成する

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

ステップ1

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

ステップ2

クリック Simple Notification サービスと Create topic 初期化。

ステップ3

次に、クリックする必要があります Create new topic 示されているボタン-

ステップ4

入力します Topic name そして Display name をクリックします Create topic。次のように、ディスプレイにトピック名が表示されます。

IAMで権限のロールを作成する

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

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

AWSLambda関数を作成する

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

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

SNSトリガーを追加する

SNSトリガーを追加するには、次のようにSNS設定の詳細を入力します-

次に、 SNS topic そして Add 示されているように、AWSLambda関数へのトリガー-

次に、以下に示す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ですでにトピックを作成したことを思い出してください。トピックで公開し、AWSLambdaによってトリガーされるCloudWatchで詳細を確認します-

トピックに公開

まず、公開するトピックの名前を選択します。クリックPublish to topic ボタン−

入力します Subject そして Message 以下に示す詳細-

選択することもできます JSON 送信するメッセージ形式 JSONスタイル。クリックPublish the message 画面の最後にあるボタン。

CloudWatchServiceでメッセージの詳細を確認する

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

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

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

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

メッセージの送信に使用するAWSSDKと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);
   }	
});

今すぐトピックを入力して、cloudwatchのメッセージと上記の電話番号を確認してください。

クリック Publish messageメッセージを公開します。次のような電話番号のメッセージが表示されます-

CloudTrailでのLambda関数の使用

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

必要条件

AWS CloudTrail、S3、およびAWS Lambdaの使用を開始する前に、以下を実行する必要があります-

• CloudTrailログを保存するS3バケットを作成します
• SNSサービスを作成する
• CloudTrailでトレイルを作成し、S3バケットとSNSサービスを割り当てます
• 権限を使用してIAMロールを作成します。
• awsラムダ関数を作成する
• AWSLambda構成

例

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

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

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

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

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

SNSサービスを作成する

AWSコンソールに移動し、 Simple notification Service。左側からトピックを選択し、[新しいトピックの作成]ボタンをクリックします。

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

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

AWSコンソールに移動し、 CloudTrail 図のように管理ツールからのサービス-

クリック Trails 下図のように左側から−

クリック Create Trailボタン。入力しますTrail name, Apply trail to all regions と選択します Yes。次に、ログはすべてのリージョンに適用されます。

にとって Read/Write events、選択 All。追加しますS3 bucket そして SNS topic詳細は以下のとおりです。ここで新しいものを作成することも、既存のものを追加することもできます。

利用可能なオプションがあることに注意してください encrypt log files, enable log file validation, send sns notification for every log file deliveryなど。ここではデフォルト値を使用しました。ファイルの暗号化を許可すると、暗号化キーが要求されます。詳細が追加されたら、[トレイルの作成]ボタンをクリックします。

権限のあるIAMロールを作成する

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

AWSLambda関数を作成する

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

AWSLambda構成

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

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

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ラムダがトリガーされ、コードに記載されているメールIDにメールが送信されます。

AWSLambdaで必要に応じてログを処理できることに注意してください。

AmazonKinesisでのLambda関数の使用

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

必要条件

KinesisとAWSLambdaを使い始めるための基本的な要件は次のとおりです-

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

例

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

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

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

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

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

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

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

クリック Create data stream。以下のKinesisストリーム名に名前を入力します。

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

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

名前を入力して、 Create Kinesis stream 下部のボタン。

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

AWSLambda関数を作成する

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

クリック Create function画面の最後にあるボタン。キネシスをトリガーとしてAWSLambdaに追加します。

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

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

AWSLambdaへのコードの追加

この目的のために、ランタイムとして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データストリームにデータを追加する

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

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

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

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

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

• AWSコンソールの使用
• AWSCLIの使用

AWSコンソールの使用

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

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

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

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

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

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

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

AWSCLIの使用

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 Lambdaで他のAWSサービスをテストする場合は、AWSコンソールとAWSCLIのテストイベントを使用してテストできます。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);};

AWSCLIを使用して同じものを呼び出しましょう。イベントをファイルに保存し、次のコマンドを使用してペイロードに使用します-

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

CloudFrontでAWSLambda @Edgeを使用する

Lambda @ Edgeは、cloudfrontが配信するコンテンツをカスタマイズするために使用されるAWSLambdaコンピューティングサービスへの追加です。

AWSのクラウドフロントでのAWSLambdaの動作を示すブロック図を以下に示します-

AWSLambdaを使用する方法は4つあります-

• Viewer Request − エンドユーザーがViewerRequestというリクエストをCloudFrontに送信します

• Origin Request − CloudFrontはリクエストをオリジンに転送します

• Origin Response − CloudFrontはオリジンからレスポンスを受信します

• Viewer Response − CloudFront send the response to the viewer

We can use Lambda@Edge for the following purposes −

• To change the headers at the request and response time.

• Add cookies details to the headers. Carry out AB testing based on the request and response.

• Redirect the URL to another site, based on the header details.

• We can fetch the user-agent from the headers and find out the details of the browser, OS, etc.

Requisites

To start with working on CloudFront and Lambda@Edge, we need the following −

• Create S3 storage bucket with file details

• Create role which will allow permission to work with CloudFront and Lambda@Edge

• Create CloudFront distribution

• Create lambda function

• Add lambda function details to cloudfront

• Check the cloudfront url in browser

We will work on an example with CloudFront and Lambda@Egde, wherein we will host the page and change the response when detected as desktop and devices.

Create S3 Storage Bucket with File Details

Login to AWS console and create a bucket in S3 and add the . html file which you want to display.

Click on S3 and Create bucket as shown below −

Now, click Create bucket button and add the details of the bucket as shown below −

Click on Create button and upload the .html in it.

Create Role

Go to AWS console and click IAM.

Now, click Roles -> Create role button as shown −

Choose the permission for S3, Lambda and Cloudfront. It is a good practice to create the policy giving permission to only the required function, storage by using the ARN details.

In the example discussed below, we are showing the Full Access permission. Policies for the role name role for cloudfront is added as shown above. Click on Create role.

All the policy required for lambda@edge and cloudfront are as shown above. There is a additional step to be done here since incase of cloudfront the url will be available across region and it needs a trust relationship between the services we are using.

Now, for the role created, click on Trust relationships tab as shown −

Click on Edit Trust Relationship as shown below −

It displays a policy document. We need to add the other services in the Principal -> Service which we are planning to use. The final trust relationship policy document is as shown below −

Click Update Trust Policy button to save the changes.

Create CloudFront Distribution

Go to CloudFront service as shown below −

Click on CloudFront service and click on Create Distribution −

Origin Settings, Behaviour Settings and Distribution settings

Let us look into these settings one by one −

Origin Settings

Various parameters of Origin settings are explained as below −

Origin Domain Name − This is the name of the S3 bucket where we have stored the html files. We can also store images, if any, in the S3 bucket by creating folders of our choice.

Origin Path − Here you need to enter the name of the folder where the files are stored. At present, we do not have this folder, so we will keep it blank for now.

Origin ID − It gets populated when the origin domain name is selected. You can change the id as per your choice.

Restrict Bucket Access − In this, we will choose the option yes. Here we need security for the S3 bucket so that no one has the access to the S3 bucket. For this option there are some more options populated like Origin Access Identity, Comment and Grant Read Permission on Bucket.

Origin Access Identity − We have used create a new identity option. You can also choose the existing identity. This creates a new identity which is used by CloudFront to read the details from S3 bucket.

Grand Read Permission on Bucket − For this, choose the option Yes.

Origin Custom Headers − We will keep the headers blank here, as we do not need the details right now.

Next, let us discuss and fill up the Behaviour Settings for Cloudront distribution −

Now, select the protocol – https or http, and the caching option. Note that the default caching is 86400 or 24 hrs. You can change this value as per the requirement.

Click Object Caching (customize option) to change the caching. You can use smooth streaming in case if there any videos on your page. Here, we are keeping the default option available. Once the lambda function is created, its details will be added.

The details for distribution settings are shown below −

Various parameters of distribution settings are explained below −

Price class − It has details like the origin of users traffic. Note that here we have selected the default one - Use All Edge Locations.

AWS WAF Web ACL − This is for web application firewall selection. Here, it has option as None. First, we need to create the firewall in AWS. It provides security to the site.

Alternate Domain Names − Here you can specify the domain name if you have.

SSL Certificate − This has all the details to be selected for SSL certificate. We will keep the default ones.

Default Root Object − Here we will specify the filename which we have uploaded in S3. For this, we need the content from the .html to be displayed by default.

For the rest, we will keep the default setting.

Click Create Distribution button to add the distribution.

Note that the distribution will take some time to show the status as deployed.

Create AWS Lambda Function

Go to AWS console and create Lambda function.

In AWS Lambda code, we will take the request headers and check the user-agent. If the user-agent is from desktop, we will change the response to display message as “DESKTOP : Welcome to AWS Lambda with Cloudfront!” and if device the message will be“MOBILE DEVICES : Hello from Lambda@Edge!”

The corresponding AWS Lambda code is as shown below −

let content = `
<\!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="utf-8">
      <title>Simple Lambda@Edge Static Content Response</title>
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
   </head>
   
   <body>
      <h1>MOBILE DEVICES : Hello from Lambda@Edge!</h1>
   </body>
</html>
`;
let content1 = `
<\!DOCTYPE html>
<html lang="en">
   <head>
      <meta charset="utf-8">
      <title>Simple Lambda@Edge Static Content Response</title>
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
   </head>
   
   <body>
      <h1>DESKTOP : Welcome to AWS Lambda with Cloudfront!</h1>
   </body>
</html>
`;
exports.handler = (event, context, callback) => {
   let request = event.Records[0].cf.request;
   let finalrequest = JSON.stringify(request);
   let headers = request.headers;
   let useragent = JSON.stringify(headers["user-agent"][0].value);
   let str = "";
   if(/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini|Mobile|mobile|CriOS/i.test(useragent)) {
      str = content;
   } else {
      str = content1;
   }
   const response = {
      status: '200',
      statusDescription: 'OK',        
      body: str+useragent,
   };
   callback(null, response);
};

Now, save the Lambda function. Note that we need to publish the Lambda function so that it can be used with all regions. To publish, we need to do the following −

From Actions dropdown, select Publish new version as shown below −

If you, click Publish new version, it displays the following screen −

Now, enter the Version description and click Publish. The ARN will display the version of the AWS Lambda function created as shown below −

Add CloudFront trigger to the new version created as shown below −

Now, add the configuration details for CloudFront. The CloudFront event has option for Viewer request, Origin request, Origin response, and Viewer response.

Next, choose the CloudFront distribution created earlier. From events, we will select Viewer request. Based on the viewer request, the desktop/device from user-agent will be decided and the response will be changed. Next, add the trigger details.

Once the trigger is added, we need to wait for the distribution from CloudFront to be deployed.

Once the status is changed to Deployed, we can test the CloudFront url and check the domain name in browser.

The display in desktop browser is as shown below. Here we have printed the user-agent from the viewer-request event.

This is the display in mobile device.

Thus, in the above example, we have used Lambda@Edge to change response on desktop and mobile device.

Monitoring and TroubleShooting using Cloudwatch

Functions created in AWS Lambda are monitored by Amazon CloudWatch. It helps in logging all the requests made to the Lambda function when it is triggered.

Consider that the following code is uploaded in AWS Lambda with function name as lambda and cloudwatch.

exports.handler = (event, context, callback) => {
   // TODO implement
   console.log("Lambda monitoring using amazon cloudwatch");    
   callback(null, 'Hello from Lambda');
};

When the function is tested or triggered, you should see an entry in Cloudwatch. For this purpose, go to AWS services and click CloudWatch.

Select logs from left side.

When you click Logs, it has the Log Groups of AWS Lambda function created in your account. Select anyAWS Lambda function and check the details. Here, we are referring to Lambda function with name:lambdaandcloudwatch. The logs added to the Lambda function are displayed here as shown below −

Now, let us add S3 trigger to the Lambda function and see the logs details in CloudWatch as shown below −

Let us update AWS Lambda code to display the file uploaded and bucket name as shown in the code given below −

exports.handler = (event, context, callback) => {
   // TODO implement
   console.log("Lambda monitoring using amazon cloudwatch");
   const bucket = event.Records[0].s3.bucket.name;
   const filename = event.Records[0].s3.object.key;
   const message = `File is uploaded in - ${bucket} -> ${filename}`;
   console.log(message);
   callback(null, 'Hello from Lambda');
};

Now, add file in s3storetestlambdaEventbucket as shown −

When the file is uploaded, AWS Lambda functions will get triggered and the console log messages from Lambda code are displayed in CloudWatch as shown below −

If there is any error, CloudWatch gives the error details as shown below −

Note that we have referred to the bucket name wrongly in AWS Lambda code as shown −

exports.handler = (event, context, callback) => {
   // TODO implement
   console.log("Lambda monitoring using amazon cloudwatch");
   const bucket = event.Records[0].bucket.name;
   const filename = event.Records[0].s3.object.key;
   const message = `File is uploaded in - ${bucket} -> ${filename}`;
   console.log(message);
   callback(null, 'Hello from Lambda');
};

The bucket name reference from the event is wrong. Thus, we should see an error displayed in CloudWatch as shown below −

CloudWatch Metrics

The details of the Lambda function execution can be seen in the metrics. Click Metrics displayed in the left side.

The graph details for the lambda function lambdaandcloudwatch are as shown below −

It gives details such as the duration for which the Lambda function is executed, number of times it is invoked and the errors from the Lambda function.

AWS Lambda – Additional Example

Till now, we have seen working of AWS Lambda with AWS services. Based on that knowledge, let us create a simple user registration form and post the data using API gateway to AWS Lambda. AWS Lambda will get the data from the event or theAPI gateway trigger and will add those details to DynamoDB table.

Example

Let us consider an example and perform the following functionalities on it −

• Create DynamoDB Table

• Create Form for User Registration

• Create AWS Lambda and API gateway to send message to Phone using AWS SNS service

• Create AWS Lambda and API gateway to POST form data and insert in DynamoDb table

• Create AWS Lambda and API gateway to read data from Dynamodb table

• Final Working of the User Registration Form

Create DynamoDB Table

The data entered will be stored in DynamodDB table. We will use API gateway to share data entered with AWS Lambda and later AWS Lambda will add the details in DynamoDB.

You can use the following details to create DynamodDB table in AWS console. First, go to AWS Service and click DynamoDB. Click Table to create the table as shown below −

You can use the ARN to create policy for the DynamoDB to be used with AWS Lambda.

Go to IAM and select Policies. Click Create policy, choose service as DynamodDB as shown below −

Click All DynamoDB actions as shown above. Choose resource and enter the ARN for table as shown below −

Now, click Add as shown below.

If you click Review policy button at the end of the screen, you can see the following window −

Enter name of the policy and click Create policy button at the end of the page. Now, we need to create role to be used with Lambda. We need permissionsforDynamoDB, APIGateway and Lambda.

Go to AWS services and select IAM. Select Roles from left side and add the required roles.

Enter the role name and click Create role. The role created is roleforlambdaexample.

Create Form for User Registration

Here is the display of the user registration form to enter and to read the data from the dynamodb table.

Create AWS Lambda and API Gateway to Send OTP Message to Phone using SNS service

If you see the user registration form, there is a button validate phone. User is suppose to enter phone number and click on validate phone button to validate the phone number.

For this purpose −

When a user clicks this button, the API gateway post method which contains the phone details is called and internally AWS Lambda is triggered.

Then, AWS Lambda sendsOTP to the phone number entered using AWS SNS service.

The user receives the OTP and has to enter thisOTP number.

The textbox to enter OTP will appear when the phone number is entered and validate phone button is clicked.

The OTP received from AWS Lambda and the OTP entered by the user has to match, to allow the user to submit the user registration form.

A simple block diagram that explains the working of phone validation is shown here −

The AWS Lambda function created is as shown here −

The corresponding AWS Lambda code is as given below −

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

Note that we are using SNS service to send the OTP code. This code is used to validate the mobile number entered by the user in the user registration form. The API gateway created for above phone validation is as follows −

The Lambda function given is phonevalidationexample. We are taking the mobile phone details here to be used inside AWS Lambda. Then, AWS Lambda will send the OTP code to the given mobile number.

Create AWS Lambda and API Gateway to POST Form Data and Insert in DynamoDB Table

For user registration form, all the fields are mandatory. There is anAJAX call made wherein the data entered in the form is posted to the API Gateway URL.

A simple block diagram which explains the working of the submit button is shown here −

Once the form is filled, the submit button will call the API gateway which will trigger AWS Lambda. AWS Lambda will get the details of the form from event or theAPI Gateway and the data will be inserted in the DynamodDB table.

Let us understand the creation of API Gateway and AWS Lambda.

First, go to AWS services and click Lambda. The Lambda function created is as shown here −

Now, to create an API gateway, go to AWS service and select API Gateway. Click on Create API button shown below.

Enter the API name and click on Create API button to add the API.

Now, an API is created called as registeruser. Select the API and click Actions dropdown to create Resource.

Click Create Resource. Now, let us add the POST method. For this, click on resources created on left side and from Actions dropdown select create method. This will display dropdown as shown below −

Select the POST method and add the Lambda function that we created above.

Click Save button to add the method. To send the form details to Lambda function lambdaexample we need to add the Integration Request as shown below −

To post the form details, you will have to click Integration Request. It will display below details.

Click Body Mapping Templates to add the form fields to be posted.

Next, click Add mapping template and enter the content type. Here, we have added application/json as the content type. Click it and here you need to enter the field in json format as shown below −

Now, click the Save button and deploy the API as shown below −

Here is the API created for POST which will use inside our .html file. Please note we need to Enable CORS for the resource created. Will use the api gateway url to make ajax call so the CORS has to enabled.

Select the Methods on which you want to enable the CORS. Click on Enable CORS and replace existing CORS headers.

It displays the confirmation screen as follows −

Click Yes, replace existing values to enable CORS.

The AWS Lambda code forPOST API Gateway is as shown here −

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

The event parameter in AWS Lambda handler will have all the details which are added earlier in POST integration request. The details from event are added to the DynamodDB table as shown in the code.

Now, we need to get the service details from AWS-SDK as shown below −

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

Create AWS Lambda and API Gateway to Read Data from DynamodDB Table

Now, we will create AWS Lambda function to read data from DynamoDB table. We will trigger APIGateway to the AWS Lambda function which will send data to the html form.

The AWS Lambda function created is as shown below −

The corresponding AWS Lambda code is as follows −

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

Here the data is read from the DynamoDB table and given to the callback. Now, we will create APIGateway and add AWS Lambda function as the trigger.

We will add get method to the API created earlier.

Lambda function added is lambdareaddataexample. Click Save to save the method and deploy the api.

Final Working of the User Registration Form

The final display of the form is as shown below −

Now, enter the details as shown above. Note that the submit button is disabled. It will be enabled only when all the details are entered as shown −

Now, enter the mobile number and click validate phone button. It will display the alert message saying “OTP is send to the mobile, please enter the OTP to continue”. OTP sent to the mobile number is as follows −

Enter the OTP and remaining details and submit the form.

The data in DynamoDB registeruser table after submit is as shown here −

The code details are as given below −

Example1.html

<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").html('');
         $("#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();
});

Till now, we have done AJAX call to the API created and posted the data as shown above.

The AJAX call to add the data to the table is as follows −

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();
            }
         });
      }
   });
});

Note that to read the data, a function is called, whose code is given below −

function getdata() {
   var a = 0;
   $.ajax({ type:'GET', url:posturl, success: function(data) { $("#displaydetails").html('');
         $("#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);
      }
   });
}

When you click mobile number validate button, the following code is called and sends the mobile number −

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