AWS Lambda 快速指南

AWS Lambda – 概述

AWS Lambda 是一種提供無伺服器計算的服務，這意味著無需管理伺服器即可進行計算。程式碼根據AWS服務的事件響應執行，例如在S3儲存桶中新增/刪除檔案、更新Amazon DynamoDB表、來自Amazon API Gateway的HTTP請求等。

要使用AWS Lambda，我們只需將程式碼推送到AWS Lambda服務即可。AWS負責所有其他任務和資源，例如基礎設施、作業系統、伺服器維護、程式碼監控、日誌和安全。

AWS Lambda 支援Java、NodeJS、Python、C#、Go、Ruby和Powershell等語言。請注意，AWS Lambda僅適用於AWS服務。

什麼是AWS Lambda？

AWS Lambda的官方文件定義如下：

AWS Lambda 是一種計算服務，允許您執行程式碼而無需配置或管理伺服器。AWS Lambda 僅在需要時執行您的程式碼，並自動擴充套件，從每天幾個請求到每秒數千個請求。您只需為消耗的計算時間付費——程式碼未執行時不收取任何費用。

AWS Lambda 如何工作？

下圖顯示了透過五個簡單步驟解釋AWS Lambda工作原理的框圖：

步驟1 - 使用AWS Lambda支援的任何語言（例如NodeJS、Java、Python、C#和Go）上傳AWS Lambda程式碼。

步驟2 - 以下是AWS Lambda可以觸發的一些AWS服務。

步驟3 - AWS Lambda包含已上傳的程式碼和觸發事件的詳細資訊。例如，來自Amazon S3、Amazon API Gateway、DynamoDB、Amazon SNS、Amazon Kinesis、CloudFront、Amazon SES、CloudTrail、移動應用程式等的事件。

步驟4 - 只有在以下情況下由AWS服務觸發時，才會執行AWS Lambda程式碼：

使用者將檔案上傳到S3儲存桶
訪問/釋出端點URL
在DynamoDB表中新增/更新/刪除資料
推送通知
資料流收集
網站託管
傳送電子郵件
移動應用程式等。

步驟5 - 請記住，AWS僅在AWS Lambda程式碼執行時才收費，否則不收費。

使用AWS Lambda的優勢

使用AWS Lambda可以獲得多種好處。本節將詳細討論這些好處：

易於使用程式碼

AWS Lambda為您提供上傳程式碼的基礎設施。它負責維護程式碼，並在發生所需事件時觸發程式碼。它允許您選擇程式碼所需的記憶體和超時時間。

AWS Lambda還可以根據事件觸發器執行並行請求。

日誌記錄

AWS Lambda 提供程式碼執行次數、執行時間、記憶體消耗等詳細資訊。AWS CloudWatch 收集所有日誌，這有助於理解執行流程和除錯程式碼。

按使用量計費

AWS Lambda 的計費基於記憶體使用、請求次數和執行時間，以至少 100 毫秒為增量計費。因此，對於 500 毫秒的執行，每 100 毫秒計費一次。如果您指定 AWS Lambda 程式碼在 500 毫秒內執行，而實際執行時間僅為 200 毫秒，AWS 只會為您使用的執行時間（即 200 毫秒）計費，而不是 500 毫秒。AWS 始終僅對使用的執行時間收費。如果函式未執行，則無需付費。

多語言支援

AWS Lambda 支援流行的語言，例如 Node.js、Python、Java、C# 和 Go。這些語言被廣泛使用，任何開發人員都可以輕鬆編寫 AWS Lambda 程式碼。

輕鬆編寫和部署程式碼

Lambda 提供多種編寫和部署程式碼的選項。您可以使用 AWS 線上編輯器、Visual Studio IDE 或 Eclipse IDE 編寫程式碼。它還支援無伺服器框架，這使得編寫和部署 AWS Lambda 程式碼變得更容易。除了 AWS 控制檯外，我們還可以使用 AWS CLI 建立和部署程式碼。

其他功能

您可以透過登入 AWS 免費套餐免費使用 AWS Lambda。它為您提供一年的免費服務。請檢視 AWS 免費套餐提供的免費服務。

使用AWS Lambda的缺點

儘管 AWS Lambda 具有許多優點，但它也存在以下缺點：

它不適合小型專案。
您需要仔細分析程式碼並確定記憶體和超時時間。如果您的函式需要比分配時間更長的時間，它將根據其上指定的超時時間終止，並且程式碼將不會完全執行。
由於 AWS Lambda 完全依賴 AWS 的基礎設施，因此如果您的程式碼需要，您無法安裝任何附加軟體。

觸發AWS Lambda的事件

可以觸發 AWS Lambda 的事件如下：

S3 物件的條目
在 DynamoDB 表中插入、更新和刪除資料
來自 SNS 的推送通知
對 API Gateway 的 GET/POST 呼叫
在 CloudFront 中修改檢視器或源請求/響應的標頭
AWS Kinesis 資料流中的日誌條目
CloudTrail 中的日誌歷史記錄

AWS Lambda 的用例

AWS Lambda 是一種計算服務，主要用於執行後臺程序。它可以與其他 AWS 服務一起使用時觸發。下面列出了我們可以使用 AWS Lambda 的 AWS 服務：

S3 物件和 AWS Lambda

當 S3 中有任何檔案上傳時，Amazon S3 會將事件詳細資訊傳遞給 AWS Lambda。檔案上傳、刪除或移動的詳細資訊將傳遞給 AWS Lambda。AWS Lambda 中的程式碼可以在收到事件詳細資訊時採取必要的步驟。例如，建立插入到 S3 中的影像的縮圖。

DynamoDB 和 AWS Lambda

當表中新增、更新和刪除資料時，DynamoDB 可以觸發 AWS Lambda。AWS Lambda 事件包含有關插入/更新或刪除的 AWS DynamoDB 表的所有詳細資訊。

API Gateway 和 AWS Lambda

API Gateway 可以在 GET/POST 方法上觸發 AWS Lambda。我們可以建立一個表單並將詳細資訊與 API Gateway 端點共享，並將其與 AWS Lambda 一起使用以進行進一步處理，例如在 DynamoDB 表中建立資料的條目。

SNS 和 AWS Lambda

SNS 用於推送通知、傳送簡訊等。當 SNS 中發生任何推送通知時，我們可以觸發 AWS Lambda。當 AWS Lambda 收到觸發器時，我們還可以向電話號碼傳送簡訊。

定時事件和 AWS Lambda

定時事件可用於 cron 作業。它可以觸發 AWS Lambda 以按定期時間模式執行任務。

CloudTrail 和 AWS Lambda

CloudTrail 可用於監控帳戶上的日誌。我們可以使用 AWS Lambda 來進一步處理 CloudTrail 日誌。

Kinesis 和 AWS Lambda

Kinesis 用於捕獲/儲存來自網站點選、日誌、社交媒體 feed 的即時跟蹤資料，AWS Lambda 的觸發器可以對這些日誌進行額外的處理。

CloudFront 和 Lambda@Edge

CloudFront 是一個內容交付網路，您可以在其中託管您的網站，Lambda@Edge 可用於處理來自檢視器請求、源請求、源響應和檢視器響應的標頭。標頭修改包括修改 cookie 資料、重寫 URL、用於 AB 測試以更改傳送回用戶的響應、出於安全目的新增額外的標頭資訊等任務。

AWS Lambda – 環境設定

在開始使用 AWS Lambda 之前，您需要擁有 Amazon 控制檯的登入帳戶。AWS Lambda 支援兩種 IDE：Visual Studio 和 Eclipse。本章將詳細逐步討論 AWS Lambda 的安裝。

在AWS控制檯中建立登入

您可以使用 Amazon 免費套餐免費在 AWS 控制檯中建立登入帳戶。您可以按照以下步驟建立 Amazon 登入帳戶以使用 Amazon 服務：

步驟1

訪問https://aws.amazon.com/free/ 並點選建立免費帳戶。您可以看到如下所示的螢幕截圖：

步驟2

點選建立免費帳戶按鈕，您將被重定向到如下所示的螢幕：

現在，在此表單中填寫您選擇的電子郵件地址、密碼和 AWS 帳戶名稱的詳細資訊，然後點選繼續。

步驟3

現在，您可以看到如下所示的螢幕：

在此表單中輸入所有必需的詳細資訊。

請注意，根據所選國家/地區，需要支付最低費用。一旦輸入的詳細資訊得到驗證，這筆費用就會退還。您需要信用卡或簽帳金融卡詳細資訊才能建立免費帳戶。對於印度使用者，將扣除2盧比，對於美國使用者，將收取1美元。一旦驗證使用者，這筆費用將退還給相應的卡使用者。

請注意，該帳戶是免費的，並且對服務的用量有限制。如果使用量超過限制，使用者將為此付費。

輸入上述表單中的詳細資訊後，點選建立帳戶並繼續。

您將被重定向到如下所示的下一個螢幕。

步驟4

您需要輸入付款詳細資訊，即信用卡或簽帳金融卡，以及其有效期和持卡人姓名，如下所示：

步驟5

輸入所有詳細資訊後，點選安全提交，它將使用銀行驗證卡，並將向您傳送與卡關聯的手機上的OTP。您可以看到如下所示的視窗：

現在，輸入OTP詳細資訊並點選付款。您將根據所選國家/地區收費。

步驟6

付款完成後，下一步是電話驗證。您需要輸入您的手機號碼，如下所示：

填寫完詳細資訊後，點選立即呼叫。AWS 將立即使用自動化系統呼叫您。通話時，請使用手機按鍵將顯示在您的 AWS 站點上的 4 位數字輸入到您的手機中。這將驗證您的號碼，您將在建立登入時指定的郵箱中收到郵件啟用郵件。

步驟 7

點選郵件連結，輸入帳戶名或郵箱 ID 和密碼，登入到 AWS 服務，如下所示：

帳戶名顯示在右上角，如上所示。您現在可以開始使用 AWS Lambda 服務。AWS Lambda 服務支援的語言包括 NodeJS、Python、Java、C# 和 Go。

Visual Studio 2017 的安裝

有兩個 IDE 與 AWS 相容：Visual Studio 和 Eclipse。在本節中，我們將討論在 Windows、Linux 和 Mac 上安裝 Visual Studio 2017。訪問 Visual Studio 官方網站：https://www.visualstudio.com/downloads/。您將看到如下所示的歡迎螢幕：

下載社群版，即Visual Studio Community 2017，因為它現在對練習是免費的。安裝完成後，它將引導您完成安裝步驟，您需要在其中選擇稍後要使用的軟體包。您可以選擇nodejs、python、c#軟體包以供我們以後使用。

Visual Studio 2017 的 AWS 工具包支援

安裝 Visual Studio 2017 後，您需要按照以下步驟安裝 Visual Studio 2017 的 AWS 工具包支援：

步驟1

訪問https://aws.amazon.com/visualstudio/並下載 Visual Studio 的 AWS 工具包。顯示如下所示：

請注意，為 Visual Studio 2017 下載的軟體包是vsix軟體包。如果您的 Visual Studio 版本介於 2013-2015 之間，它將安裝msi安裝程式。點選如下所示的下載按鈕。

步驟2

現在，雙擊下載的 vsix 軟體包，它將引導您完成安裝步驟，如下所示：

成功安裝 Visual Studio 後，您將看到如下所示的視窗：

步驟3

現在，開啟 Visual Studio 2017，您應該會看到 AWS 的歡迎頁面，如下所示：

請注意，您需要新增訪問金鑰、金鑰和帳戶編號才能開始並使用 Visual Studio 中的 AWS 服務。

NodeJS 的 AWS Lambda 模板

您可以使用Visual Studio Code，如下所示。

步驟1

您可以從官方網站免費下載Visual Studio Code：https://www.visualstudio.com/downloads/. Visual Studio 下載的主頁如下所示：

步驟2

現在，開啟 Visual Studio Code，如下所示：

步驟3

要安裝 AWS 支援，nodejs 支援選項可在擴充套件程式中找到。您可以搜尋 AWS，它將顯示如下選項：

步驟4

現在，安裝 AWS Lambda 的nodejs模板，如下所示：

步驟5

點選儲存庫並在 Visual Studio 中克隆它以開始在 Visual Studio 中編寫 Lambda 函式。它將您重定向到此儲存庫，我們可以在 Visual Studio 中克隆它：https://github.com/loganarnett/vscode-lambda-snippets。現在，從 Visual Studio 中的檢視選項開啟命令面板。

步驟6

點選它並選擇 git clone，如下所示：

步驟 7

輸入儲存庫 URL 並根據您的選擇在本地儲存它。建立index.js檔案，如下所示，以使用 lambda 函式：

Eclipse IDE 的安裝

現在，您需要安裝最新的 Eclipse Java EE IDE。您可以從 Eclipse 官方網站下載它：https://www.eclipse.org/downloads/

Eclipse IDE 的 AWS 工具包支援

安裝 Eclipse 後，執行以下步驟：

步驟1

從選單中轉到幫助，然後點選安裝新軟體。

步驟2

在對話方塊頂部標記為使用的文字框中輸入https://aws.amazon.com/eclipse。

步驟3

現在，從如下所示的列表中選擇所需的AWS 核心管理工具和其他可選專案。

步驟4

現在，點選下一步。Eclipse 將引導您完成以下步驟中給出的其餘安裝步驟。

步驟5

AWS 核心模組顯示在下面的網格中，如下圖所示：

步驟6

安裝完成後，AWS 工具將在 Eclipse 中可用，如下所示：

步驟 7

點選 Amazon 服務時，您將看到以下螢幕。

現在，點選 AWS 資源管理器以檢視可用的服務。我們將在後續章節中討論如何使用已安裝的 IDE。

AWS Lambda – 簡介

AWS Lambda 是一種服務，它負責計算您的程式碼而無需任何伺服器。它被稱為無伺服器計算。程式碼根據 AWS 服務中的事件響應執行，例如在 S3 儲存桶中新增/刪除檔案、更新 Amazon DynamoDB 表、來自 Amazon API Gateway 的 HTTP 請求等。

AWS Lambda 程式碼可以用 NodeJS、Java、C#、Python 和 Go 編寫。本章將詳細討論在 AWS 控制檯中建立 AWS Lambda 函式。

AWS 控制檯

登入到 AWS 控制檯連結https://aws.amazon.com/console。登入後，它將引導您到顯示 AWS 服務的螢幕。

示例：建立函式

讓我們透過一個示例瞭解 AWS 控制檯的功能。點選 Lambda（如上所示），它將重定向到建立函式，如下所示：

點選建立函式按鈕，螢幕將顯示以下詳細資訊：

請注意，預設情況下，選項是從頭開始創作。此選項允許您從頭開始編寫 Lambda 程式碼。它將只有一個帶有hello world訊息的簡單函式。

第二個選項藍圖具有以下詳細資訊。

它提供了為 AWS Lambda 提供的可用語言中的一些 aws 服務編寫的程式碼的詳細資訊。如果您需要為任何服務編寫 AWS Lambda 程式碼，您可以在藍圖中檢視並開始。

第三個選項無伺服器應用程式儲存庫具有無伺服器應用程式的設定，這將有助於部署 AWS Lambda 程式碼。

在接下來的討論中，我們將使用從頭開始創作選項來建立 AWS lambda 函式。

在建立 Lambda 函式之前，我們需要一個角色，即使用 AWS 服務和 aws lambda 的許可權。稍後，該角色必須分配給 aws lambda 函式。

在 AWS 控制檯中建立角色

要在 AWS 控制檯中建立角色，請轉到 AWS 控制檯服務並點選 IAM，如下所示：

現在，如果您點選IAM，您將看到如下所示的螢幕：

如果您選擇角色，您可以在螢幕上看到以下按鈕：

現在，點選建立角色。它會要求您選擇需要使用建立的角色的服務。

由於我們需要將此角色與 AWS Lambda 一起使用，因此選擇Lambda並點選下一步：許可權按鈕，如上所示。下一個螢幕顯示根據 AWS 服務可用的策略名稱。您可以從此處選擇策略：

例如，如果您希望 AWS Lambda 能夠使用 S3 和 DynamoDB，則需要選擇策略。在搜尋框中，輸入 AWS 服務並點選複選框。您可以選擇多個策略，然後點選下一步：稽核。

也可以建立您自己的策略。例如，存在 dynamodb 表，並且您只需要向該表授予許可權，在這種情況下，您可以建立策略。

點選如上螢幕所示的建立策略按鈕。螢幕上顯示以下詳細資訊。

選擇您正在為其建立策略的服務。稍後，它將顯示操作、資源和請求條件的資料。

現在，我們應該選擇服務。讓我們從搜尋中選擇AWS Dynamodb。操作具有以下詳細資訊：

現在，輸入您想賦予 DynamoDB 的訪問級別。然後，資源將顯示以下詳細資訊：

現在，選擇表資源型別。您可以看到以下輸出：

要授予表許可權，您需要新增 ARN。ARN 是在 AWS DynamoDB 中建立的表的唯一詳細資訊。建立表時，您將獲得這些詳細資訊。

如果您點選新增 ARN，它將顯示以下詳細資訊：

現在，如果您輸入ARN，則區域、帳戶和表名稱將被填充。您應該點選新增按鈕以新增策略。類似地，您可以為其他服務建立策略。

在這裡，我們選擇了兩個策略AmazonS3FullAccess和AmazonDynamoDBFullACcess。我們已在此角色中授予 S3 和 DynamoDB 完全訪問許可權。但是，建議您僅為必要的儲存桶和表授予許可權。

您可以按照前面討論的步驟使用ARN建立策略。

步驟1

點選建立角色按鈕以建立角色。所有建立的角色都顯示如下：

步驟2

請注意，如果您需要修改已建立的角色，可以選擇所需的角色。如果我們選擇從頭開始創作選項，則必須輸入名稱、執行時和角色。

步驟3

您可以在執行時下拉選單中觀察以下詳細資訊：

步驟4

您可以選擇您選擇的執行時並繼續操作，如下所示。

角色下拉選單具有以下選項：

選擇現有角色 - 這將顯示在 IAM 角色中建立的所有角色。
從模板建立新角色 - 這將允許您建立角色，並顯示為此角色選擇的許可權。觀察螢幕截圖以更好地理解。
建立自定義角色 - 這允許使用者建立策略，正如我們前面所討論的。

步驟5

選擇執行時、角色並新增函式。點選建立函式按鈕以建立 lambda 函式。顯示的下一個螢幕如下所示：

AWS Lambda 函式的組成部分

AWS Lambda 函式有兩個部分：配置和監控。讓我們詳細討論每個部分。

配置

配置中包含以下功能。

新增觸發器

需要新增到 AWS Lambda 函式的觸發器顯示如下：

請注意，當我們選擇觸發器時，我們需要為該觸發器新增配置詳細資訊。例如，對於 S3 觸發器，我們需要選擇儲存桶名稱；對於 Dynamodb 觸發器，我們需要選擇表名稱。

示例

讓我們來看一個 S3 觸發器的配置詳細資訊示例：

現在，新增已新增的 S3 觸發器的配置詳細資訊：

此處您需要選擇要觸發 Lambda 的儲存桶名稱、事件型別，以及任何字首和過濾器模式，然後新增觸發器。

在 Lambda 中新增程式碼

現在，我們應該關注要編寫的 Lambda 程式碼。在 aws lambda 中新增程式碼有三個選項：

使用內聯編輯器
使用 .zip 檔案
從 Amazon S3 上傳檔案

如下面的螢幕截圖所示：

讓我們詳細討論每一個。

使用內聯編輯器

您可以編寫程式碼的內聯程式碼編輯器如下所示：

您可以選擇您選擇的語言來編寫程式碼。您可以在此處再次選擇執行時。

請觀察以下螢幕截圖以更好地理解：

程式碼必須編寫在index.js.Handler中。詳細資訊將根據執行時而有所不同。對於nodejs，它是檔名.匯出函式，現在是index.lambda handler。

上傳 .ZIP 檔案

您可以先編寫程式碼，將其壓縮，然後透過選擇上傳 .ZIP 檔案來上傳 zip 檔案。

從 Amazon S3 上傳檔案

您可以將檔案上傳到 S3 儲存桶，並選擇從 Amazon S3 上傳檔案選項。

請注意，對於.ZIP和S3，將無法更改執行時。

環境變數

它們接收鍵值對並將它們與 AWS Lambda 程式碼共享。我們可以在 AWS Lambda 中使用環境變數來儲存資料庫連線詳細資訊、輸出儲存的檔案詳細資訊、日誌檔案詳細資訊等。

執行角色

如果在建立 Lambda 函式開始時未正確執行，您可以在此處再次更改角色。您可以在此處更新或建立新角色。它提供了在建立 Lambda 函式開始時顯示的相同選項。

基本設定

您需要在此處輸入 Lambda 函式正在執行的操作的簡短說明。選擇 Lambda 函式所需的記憶體和超時。

網路

這允許您選擇 VPC，這將允許您從 VPC 訪問 Lambda 函式。預設情況下，不會選擇任何 VPC。

除錯和錯誤處理

對於除錯和錯誤處理，您可以選擇 AWS 服務來發送詳細資訊。可用的選項為無、SNS和SQS。

併發

這允許您為該函式分配允許的併發執行的特定限制。

稽核和合規性

這包含使用 AWS CloudTrail 管理的日誌。

完成後，您需要使用此處所示的“儲存”按鈕儲存更改：

現在，如果您單擊測試按鈕，它將請求測試事件。您可以傳遞示例測試事件，如下所示：

建立的測試事件如下所示：

現在，儲存測試事件並單擊測試按鈕以檢視 AWS Lambda 函式的執行：

index.js的程式碼如下：

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

請注意，當發生錯誤或成功時會呼叫回撥函式。如果成功，您將看到顯示Lambda 測試。

監控

選擇監控選項卡以檢視 Lambda 函式的執行詳細資訊。圖表顯示執行時間、發生的錯誤等的詳細資訊。

您也可以在 CloudWatch 中檢視日誌。為此，請轉到 AWS 服務並選擇 CloudWatch，如下所示：

現在，從左側選擇日誌，並在過濾器中輸入您的函式名稱：

構建 Lambda 函式

AWS Lambda 函式在被呼叫時執行程式碼。本章將詳細討論 AWS Lambda 函式生命週期中涉及的所有這些步驟。

構建 Lambda 函式的步驟

Lambda 函式的生命週期包括四個必要的步驟：

創作
部署
監控
故障排除

創作 Lambda 程式碼

AWS Lambda 函式程式碼可以用以下語言編寫：

NodeJS
Java
Python
C#
Go。

我們可以使用 AWS 控制檯、AWS CLI、Eclipse IDE、Visual Studio IDE、無伺服器框架等編寫 AWS Lambda 程式碼。

下表顯示了語言以及可用於編寫 Lambda 函式的不同工具和 IDE 的列表：

語言	用於創作 Lambda 程式碼的 IDE
NodeJS	AWS Lambda 控制檯 Visual Studio IDE
Java	Eclipse IDE
Python	AWS Lambda 控制檯
C#	Visual Studio IDE .NET core
Go	AWS Lambda 控制檯

部署 Lambda 程式碼

一旦您確定要編寫 Lambda 函式的語言，就有兩種方法可以部署程式碼：

直接在 AWS 控制檯中編寫程式碼
使用所有檔案和依賴項壓縮或打包檔案

但是，請記住，必須為 zip 檔案授予適當的許可權。

測試 Lambda 程式碼

可以在 AWS Lambda 控制檯中測試 Lambda 程式碼的事件。也可以從 AWS cli 和無伺服器 cli 測試 Lambda 函式。AWS 控制檯還具有可作為樣本事件在測試 AWS Lambda 函式時使用的事件資料。

監控 Lambda 函式

可以使用 AWS CloudWatch 監控 Lambda 函式。我們可以在我們選擇的語言中新增必要的日誌訊息，並在 AWS CloudWatch 中檢視相同的日誌訊息。

要開始編寫 Lambda 函式，需要遵循一定的模式。以下是編寫 Lambda 函式時需要遵循的主要核心概念：

處理程式

處理程式是 AWS lambda 函式的名稱，從這裡開始執行。它在 AWS 控制檯中顯示如下：

請注意，這裡我們將預設處理程式更改為另一個名稱，並在處理程式中更新了該名稱：

請注意，處理程式的呼叫方式因選擇的執行時語言而異。

傳遞給處理程式的引數

如果您觀察處理程式函式，則傳遞的引數為事件、上下文和回撥函式，如下所示：

事件引數包含用於觸發器的所有詳細資訊。

上下文引數基本上負責 Lambda 函式執行的執行時詳細資訊。我們可以使用上下文引數與 Lambda 函式進行互動。它包含諸如 AWS Lambda 終止函式之前剩餘的時間（即建立 Lambda 函式時指定的超時）、Lambda 函式的名稱、CloudWatch 組名稱、ARN 詳細資訊等詳細資訊。

示例

讓我們藉助示例瞭解從 AWS Lambda 上下文物件獲得的詳細資訊：

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

執行上述 Lambda 函式時，您可以看到以下輸出：

輸出

上下文詳細資訊如下所示：

{
   "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 等詳細資訊。

日誌記錄

當 AWS 函式執行時，AWS Lambda 函式中新增的日誌將顯示在 AWS CloudWatch 中。日誌語法將根據所選語言而有所不同。例如，在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 程式碼時，您可以找到如下所示的輸出：

日誌詳細資訊如下：

AWS Lambda – NODEJS 中的函式

Nodejs 是 AWS Lambda 函式支援的語言之一。nodejs 支援的版本為 v6.10 和 v8.10。在本節中，我們將詳細瞭解 NODEJS 中 AWS Lambda 函式的各種功能。

NodeJS 中的處理程式

要在 nodejs 中編寫 AWS Lambda 函式，我們應該首先宣告一個處理程式。nodejs 中的處理程式是檔名稱和匯出函式的名稱。例如，檔名為index.js，匯出函式名為lambda handler，因此其對應的處理程式為index.lambdahandler

觀察此處顯示的樣本處理程式：

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

處理程式引數

處理程式是構建 Lambda 函式的核心。處理程式採用三個引數：事件、上下文和回撥。

事件引數

它包含觸發事件的所有詳細資訊。例如，如果我們使用 Lambda 函式觸發 S3，則事件將包含 S3 物件的詳細資訊。

上下文引數

它包含上下文詳細資訊，例如 Lambda 函式的屬性和配置詳細資訊。

回撥函式

它有助於將詳細資訊返回給呼叫者。回撥的結構如下所示：

callback(error, result);

下面解釋回撥函式的引數：

錯誤 –如果在 Lambda 函式執行期間發生任何錯誤，則將包含詳細資訊。如果 Lambda 函式成功，則可以將null作為回撥函式的第一個引數傳遞。

結果 –這將提供 Lambda 函式成功執行的詳細資訊。如果發生錯誤，則忽略結果引數。

注意 –在 AWS Lambda 中不必使用回撥函式。如果沒有回撥函式，處理程式將將其返回為 null。

有效的回撥簽名如下所示：

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

每當 AWS Lambda 執行時，回撥詳細資訊（例如錯誤或成功）都會與任何控制檯訊息一起記錄在 AWS CloudWatch 中。

在 Nodejs8.10 中使用 AWS Lambda

讓我們瞭解如何在 nodejs8.10 中使用 AWS Lambda 並以同步和非同步方式呼叫函式。

以同步方式呼叫 Lambda 函式

以下示例讓您瞭解以同步方式呼叫 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 函式的準確輸出。

以非同步方式呼叫處理程式

以下示例讓您瞭解以非同步方式呼叫 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

Context 物件提供詳細資訊，例如 Lambda 函式的名稱、剩餘時間（以毫秒為單位）、請求 ID、CloudWatch 組名稱、超時詳細資訊等。

下表列出了上下文物件可用的方法和屬性：

上下文物件可用的方法

序號	方法名稱及描述
1	getRemainingTimeInMillis() 此方法以毫秒為單位返回 Lambda 函式終止執行前剩餘的時間。

上下文物件可用的屬性

序號	屬性名稱及描述
1	functionName 返回 AWS Lambda 函式名稱。
2	functionVersion 返回正在執行的 AWS Lambda 函式的版本。
3	invokedFunctionArn 返回 ARN 詳細資訊。
4	memoryLimitInMB 顯示建立 Lambda 函式時設定的記憶體限制。
5	awsRequestId 返回 AWS 請求 ID。
6	logGroupName 返回 CloudWatch 日誌組名稱。
7	logStreamName 返回寫入日誌的 CloudWatch 日誌流名稱。
8	identity 當與 AWS Mobile SDK 一起使用時，返回有關 Amazon Cognito 身份提供商的詳細資訊。返回的詳細資訊如下： identity.cognito_identity_id identity.cognito_identity_pool_id
9	clientContext 當與 AWS Mobile SDK 一起使用時，返回客戶端應用程式的詳細資訊。返回的詳細資訊如下： client_context.client.installation_id client_context.client.app_title client_context.client.app_version_name client_context.client.app_version_code client_context.client.app_package_name client_context.custom - 包含來自移動客戶端應用程式的自定義值的字典。 client_context.env - 包含來自 AWS Mobile SDK 的環境詳細資訊。

請檢視以下示例，以便更好地瞭解上下文物件：

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

在 AWS 控制檯中測試此程式碼後，您可以觀察以下輸出：

在 AWS 控制檯中測試此程式碼後，您可以觀察到以下日誌輸出：

NodeJS 中的日誌記錄

我們可以在 NodeJS 中使用 console.log 進行日誌記錄。日誌詳細資訊可以從 CloudWatch 服務中針對 Lambda 函式獲取。

請檢視以下示例以便更好地理解：

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

在 AWS 控制檯中測試此程式碼後，您可以觀察以下輸出：

您可以從 CloudWatch 中觀察到以下截圖：

NodeJS 中的錯誤處理

讓我們瞭解 NodeJS 中的錯誤通知是如何完成的。請檢視以下程式碼：

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

您可以在日誌輸出中觀察到以下內容：

錯誤詳細資訊在回撥中提供，如下所示：

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

AWS Lambda – Java 函式

在本章中，讓我們詳細瞭解如何在 Java 中建立一個簡單的 AWS Lambda 函式。

在 Eclipse 中建立 JAR 檔案

在開始在 AWS 中建立 Lambda 函式之前，我們需要 Eclipse 的 AWS 工具包支援。有關安裝的任何指導，您可以參考本教程中的 **環境設定** 章節。

安裝完成後，請按照此處提供的步驟操作：

步驟1

開啟 Eclipse IDE 並使用 **AWS Lambda Java Project** 建立一個新專案。請檢視下面的截圖以便更好地理解：

步驟2

選擇 **下一步** 後，它會將您重定向到如下所示的螢幕：

步驟3

現在，為輸入型別 **自定義** 建立了預設程式碼。單擊 **完成** 按鈕後，專案將建立如下所示：

步驟4

現在，右鍵單擊您的專案並匯出它。從 **匯出** 嚮導中選擇 **Java/JAR** 檔案，然後單擊 **下一步**。

步驟5

現在，如果您單擊 **下一步**，系統將提示您儲存檔案到目標資料夾，該資料夾會在您單擊下一步時詢問。

儲存檔案後，返回 AWS 控制檯併為 Java 建立 AWS Lambda 函式。

步驟6

現在，使用 **上傳** 按鈕上傳我們建立的 **.jar** 檔案，如下圖所示：

Java 的 Handler 詳細資訊

**Handler** 是 **包名** 和 **類名**。請檢視以下示例以詳細瞭解 handler：

示例

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

請注意，從上面的程式碼中，handler 將是 **com.amazonaws.lambda.demo.LambdaFunctionHandler**

現在，讓我們測試更改並檢視輸出：

Java 中的上下文物件

使用上下文物件與 AWS Lambda 執行進行互動。它提供以下在 Java 內部使用的方法：

序號	上下文方法及描述
1	getMemoryLimitInMB() 返回建立 Lambda 函式時指定的記憶體限制。
2	getFunctionName() 返回 Lambda 函式的名稱。
3	getFunctionVersion() 返回正在執行的 Lambda 函式的版本。
4	getInvokedFunctionArn() 返回用於呼叫函式的 ARN。
5	getAwsRequestId() 返回 AWS 請求 ID。此 ID 為 Lambda 函式建立，並且是唯一的。如果您遇到任何問題，此 ID 可與 AWS 支援一起使用。
6	getLogGroupName() 返回與建立的 AWS Lambda 函式關聯的 AWS CloudWatch 日誌組名稱。如果 IAM 使用者沒有 CloudWatch 日誌記錄許可權，則為 null。
7	getClientContext() 當與 AWS Mobile SDK 一起使用時，返回有關應用程式和裝置的詳細資訊。它將提供版本名稱和程式碼、客戶端 ID、標題、應用程式包名稱等詳細資訊。它可以為 null。
8	getIdentity() 當與 AWS Mobile SDK 一起使用時，返回有關 Amazon Cognito 身份的詳細資訊。它可以為 null。
9	getRemainingTimeInMillis() 返回函式在指定超時後終止執行前剩餘的執行時間（毫秒）。
10	getLogger() 返回與上下文物件關聯的 Lambda 日誌記錄器。

現在，讓我們更新上面給出的程式碼，並觀察上面列出的一些方法的輸出。請檢視以下示例程式碼以便更好地理解：

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 毫秒。因此 25000 - 24961 等於 39 毫秒用於 Lambda 函式的執行。請注意，CloudWatch 日誌組名稱和請求 ID 也如上所示。

請注意，我們使用了以下命令在 Java 中列印日誌：

System.out.println (“log message”)

這在 CloudWatch 中也是可用的。為此，請轉到 AWS 服務，選擇 **CloudWatch 服務** 並單擊 **日誌**。

現在，如果您選擇 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 中處理 Lambda 函式的錯誤。請檢視以下顯示相同內容的程式碼：

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 為 **來自 AWS Lambda 的錯誤**。此外，**ErrorType** 和 **stackTrace** 提供有關錯誤的更多詳細資訊。

上面給出的程式碼的輸出和相應的日誌輸出將如下面的截圖所示：

AWS Lambda – Python 函式

在本章中，我們將建立一個簡單的 AWS Lambda 函式（Python），並詳細瞭解其工作原理。

在開始在 AWS 中建立 Lambda 函式之前，我們需要 Python 的 AWS 工具包支援。為此，請按照以下步驟操作，並檢視相應的附加螢幕截圖：

步驟1

登入 AWS 控制檯並建立 Lambda 函式，然後選擇 Python 作為語言。

步驟2

現在，單擊 **建立函式** 按鈕並輸入建立簡單的 AWS Lambda（Python）的詳細資訊。此程式碼返回訊息 **來自使用 Python 的 Lambda 的問候**，如下所示：

步驟3

現在，儲存更改並測試程式碼以檢視輸出。當您使用 UI 中的測試按鈕在 AWS 控制檯中對其進行測試時，您應該會看到以下輸出和日誌。

步驟4

現在，您可以使用任何 Python 編輯器或 IDE 編寫程式碼。在這裡，我們使用 Visual Studio Code 編寫程式碼。您應該稍後壓縮檔案並將其上傳到 AWS 控制檯。

在這裡，我們已壓縮程式碼並將其用於 AWS 控制檯。

步驟5

現在，選擇 **上傳 .ZIP 檔案** 選項，如下所示：

Python 的 Handler 詳細資訊

請注意，handler 必須是檔名後跟函式名。在上述情況下，我們的檔名是 **hellopython.py**，函式名是 **my_handler**；因此 handler 將是 **hellopython.my_handler**。

上傳完成後並儲存更改後，它實際上會在 AWS Lambda 控制檯的線上編輯器中顯示 zip 檔案的詳細資訊。現在，讓我們測試程式碼以檢視輸出和日誌。

現在，讓我們使用以下示例程式碼瞭解 Lambda 函式的詳細資訊：

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

在上面的程式碼中，函式名 my_handler 有 2 個引數，event 和 context。

Python 中的上下文物件

上下文物件提供詳細資訊，例如 Lambda 函式的名稱、剩餘時間（毫秒）、請求 ID、CloudWatch 日誌組名稱、超時詳細資訊等。

下表列出了上下文物件可用的方法和屬性：

序號	方法名稱及描述
1	get_remaining_time_in_millis() 此方法以毫秒為單位返回 Lambda 函式終止執行前剩餘的時間。

序號	屬性及描述
1	function_name 返回 AWS Lambda 函式名稱。
2	function_version 返回正在執行的 AWS Lambda 函式的版本。
3	invoked_function_arn 返回 ARN 詳細資訊。
4	memory_limit_in_mb 顯示建立 Lambda 函式時設定的記憶體限制。
5	aws_request_id 返回 AWS 請求 ID。
6	log_group_name 返回 CloudWatch 日誌組名稱。
7	log_stream_name 返回寫入日誌的 CloudWatch 日誌流名稱。
8	identity 當與 AWS Mobile SDK 一起使用時，返回有關 Amazon Cognito 身份提供商的詳細資訊。返回的詳細資訊如下： identity.cognito_identity_id identity.cognito_identity_pool_id
9	client_context 當與 AWS Mobile SDK 一起使用時，返回客戶端應用程式的詳細資訊。返回的詳細資訊如下： client_context.client.installation_id client_context.client.app_title client_context.client.app_version_name client_context.client.app_version_code client_context.client.app_package_name client_context.custom - 包含來自移動客戶端應用程式的自定義值的字典。 client_context.env - 包含來自 AWS Mobile SDK 的環境詳細資訊的字典。

讓我們在 Python 中檢視一個有效的示例，它輸出上下文詳細資訊。請檢視以下程式碼：

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

上面顯示的程式碼的相應輸出如下：

使用 Python 進行日誌記錄

要使用 Python 記錄資訊，我們可以使用可用的 print 或 logger 函式。讓我們使用上述上下文示例，並在 CloudWatch 中檢查是否列印了日誌。請檢視以下程式碼：

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 中的輸出如下所示：

請檢視以下示例，以瞭解有關使用 logger 將日誌列印到 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!')

日誌顯示如下面的圖片所示：

AWS Lambda – Go 函式

Go 語言支援是 AWS 最近新增的功能。要使用 Go，您需要在建立 AWS Lambda 函式時從 AWS 控制檯中選擇該語言。在本章中，讓我們詳細瞭解 AWS Lambda 函式（Go 語言）。

安裝 Go

要開始，我們需要 Go 語言支援。在本節中，我們將介紹以下詳細資訊，以便開始使用 AWS Lambda（Go）。這是 Go 下載的官方網站：https://golang.com.tw/dl/

現在，根據您的作業系統下載軟體包。請按照此處提供的步驟在相應作業系統上安裝 Go。

在 Windows 上安裝

請注意，對於 Windows，有 32 位和 64 位下載版本可用。下載 zip 檔案，解壓縮內容並將其儲存在您選擇的目錄中。

新增環境變數，位置在 **控制面板 ---> 系統 ---> 高階系統設定**。

現在，單擊**環境變數**按鈕並新增如下所示的目錄路徑：

您也可以編輯系統變數，如下所示：

完成這些步驟後，您應該能夠開始使用 Go。開啟命令提示符並檢查 Go 命令的版本。請檢視以下螢幕截圖。

在 Linux 和 Mac OS 上安裝

要在 Linux 和 Mac OS 上安裝軟體包，請按照以下說明操作：

解壓縮軟體包並將其儲存在 ** /usr/local/go** 位置。現在，將 ** /usr/local/go/bin** 新增到 PATH 環境變數中。可以使用 ** /etc/profile** 或 ** $HOME/.profile** 來完成此操作。

為此，您可以使用以下命令：

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

要在 Windows、Linux 和 Mac 上新增 AWS 支援，請在您的 git 命令列中使用以下命令：

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

要編譯 Windows/Linux/Mac 程式碼，請使用以下命令：

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

使用 GO 的 AWS Lambda 函式

Go 構建時返回的程式會生成一個可執行檔案。以下是一個簡單的 Go 程式，具有 AWS Lambda 支援。我們需要匯入 **github.com/aws/aws-lambda-go/lambda**，因為它具有 Lambda 程式設計功能。AWS Lambda 的另一個重要需求是處理程式。

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 程式的執行從 main 函式開始，其中 lambda.start 函式與處理程式函式一起呼叫。請檢視以下程式碼：

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

現在，讓我們使用 Go 命令執行上述檔案，然後壓縮可執行檔案。

我們一直在使用的檔案結構如下所示：

使用 **go build**，它會建立一個名為 main.exe 的可執行檔案。要壓縮檔案並將其上傳到 AWS Lambda，您可以使用以下步驟：

要編譯 Windows/Linux/Mac 程式碼，請使用以下命令：

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

然後，登入到 AWS 控制檯並使用 **Go** 作為執行時建立 Lambda 函式：

建立函式後，上傳上面建立的可執行 zip 檔案。

使用 Go 的 Lambda 函式處理程式

處理程式是 Go 程式執行的起點。從 main 函式呼叫 **lambda.start**，執行將與處理程式函式一起呼叫。請注意，要新增的處理程式將是 **main**。

請檢視此處程式碼以瞭解：

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

請按照以下螢幕截圖操作：

現在，儲存函式並進行測試。您可以看到如下所示的執行結果。

相應的日誌輸出將如下所示：

使用 Go 的 Context 物件

AWS Lambda 在 Go 中為 context 提供以下全域性變數和屬性。

**MemoryLimitInMB** - 在 aws lambda 中配置的記憶體限制（以 MB 為單位）。
**FunctionName** - aws lambda 函式的名稱。
**FunctionVersion** - 正在執行的 aws lambda 函式的版本。
**LogStreamName** - CloudWatch 日誌流名稱。
**LogGroupName** - CloudWatch 組名稱。

context 上可用的屬性如下：

AwsRequestID

這是在呼叫 AWS Lambda 函式時獲得的 AWS 請求 ID。

ClientContext

透過 AWS Mobile SDK 呼叫時，它包含有關客戶端應用程式和裝置的詳細資訊。它可以為空。客戶端上下文提供詳細資訊，例如客戶端 ID、應用程式標題、版本名稱、版本程式碼和應用程式包名稱。

InvokedFunctionArn

呼叫的函式的 ARN。未限定的 ARN 將執行 $LATEST 版本，別名將執行其指向的函式版本。

Identity

它提供有關與 AWS Mobile SDK 一起使用時的 Amazon Cognito 身份提供程式的詳細資訊。

新增到 **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 context** 以與 Go 一起使用。上下文詳細資訊如下：

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，然後單擊左側的**日誌**。現在，在列表中搜索 Lambda 函式以檢視日誌：

函式錯誤

您可以使用 errors 模組在 AWS Lambda 中建立自定義錯誤處理，如下面的程式碼所示：

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

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

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

上面程式碼的輸出如下所示：

AWS Lambda – C# 中的函式

本章將詳細解釋如何在 C# 中使用 AWS Lambda 函式。在這裡，我們將使用 Visual Studio 將程式碼編寫並部署到 AWS Lambda。有關安裝 Visual Studio 和向 Visual Studio 新增 AWS 工具包的任何資訊和幫助，請參閱本教程中的**簡介**章節。完成 Visual Studio 的安裝後，請按照以下步驟操作。請參考相應的螢幕截圖以更好地理解：

步驟1

開啟 Visual Studio 並按照步驟建立新專案。單擊 **檔案 -> 新建 -> 專案**。

步驟2

現在，將顯示以下螢幕，您可以在其中選擇 **用於 Visual C# 的 AWS Lambda**。選擇 **AWS Lambda 專案 (.NET Core)**。

如果需要，您可以更改名稱，這裡將保留預設名稱。單擊 **確定** 以繼續。

下一步將要求您選擇一個 **藍圖**。

在此示例中選擇 **空函式** 並單擊 **完成**。它將建立一個新的專案結構，如下所示：

現在，選擇 **Function.cs**，這是建立 AWS Lambda 處理程式（包含事件和上下文）的主要檔案。

Functions.cs 檔案顯示如下：

您可以使用以下命令將輸入和輸出引數序列化到 AWS Lambda 函式：

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

C# 的處理程式詳細資訊

處理程式顯示如下：

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

以下解釋了上述程式碼的各個組成部分：

**FunctionHandler** - 這是 C# AWS Lambda 函式的起點。

**String input** - 處理程式 **string input** 的引數包含所有事件資料，例如 S3 物件、API 閘道器詳細資訊等。

**ILambdaContext context** - ILamdaContext 是一個介面，包含上下文詳細資訊。它包含諸如 lambda 函式名稱、記憶體詳細資訊、超時詳細資訊等。

Lambda 處理程式可以同步和非同步方式呼叫。如果像上面那樣以同步方式呼叫，則可以具有返回型別。如果是非同步的，則返回型別必須是 void。

現在，讓我們部署 AWS Lambda C# 並進行測試。右鍵單擊專案，然後單擊 **釋出到 AWS Lambda**，如下所示：

填寫 **函式名稱** 並單擊 **下一步**。下一個螢幕顯示的是 **高階函式詳細資訊**，如下所示：

輸入 **角色名稱、記憶體** 和 **超時** 詳細資訊。請注意，這裡我們選擇了已建立的現有角色，並使用 128MB 記憶體和 10 秒超時。完成後，單擊 **上傳** 以釋出到 AWS Lambda 控制檯。

上傳 AWS Lambda 函式後，您可以看到以下螢幕。單擊 **呼叫** 以執行建立的 AWS Lambda 函式。目前，它顯示錯誤，因為它需要一些程式碼中規定的輸入。

現在，讓我們輸入一些示例輸入並再次 **呼叫** 它。請注意，這裡我們在輸入框中輸入了一些文字，並且在單擊 **呼叫** 後，響應部分會將其顯示為大寫。日誌輸出顯示如下：

現在，讓我們還檢查 AWS 控制檯，看看是否建立了函式，因為我們已從 Visual Studio 部署了該函式。

上面建立的 Lambda 函式是 **使用 csharp 的 aws lambda**，它在 AWS 控制檯中顯示如下面的螢幕截圖所示：

處理程式簽名

處理程式是 AWS 執行的起點。處理程式的名稱應定義為：

ASSEMBLY::TYPE::METHOD

簽名的詳細資訊如下所述：

**ASSEMBLY** - 這是為建立的應用程式生成的 .NET 程式集的名稱。它基本上是從建立專案的資料夾的名稱。

**TYPE** - 這是處理程式的名稱。它基本上是名稱空間.類名。

**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**，型別是名稱空間.類名，即 **AWSLambda3.Function**，方法是 **FunctionHandler**。因此，處理程式簽名是 **AWSLamda3::AWSLambda3.Function::FunctionHandler**

C# 中的 Context 物件

Context 物件提供有關 AWS 環境中執行時的有用資訊。上下文物件中可用的屬性如下表所示：

序號	屬性和描述
1	MemoryLimitInMB 這將提供為 AWS Lambda 函式配置的記憶體的詳細資訊
2	FunctionName AWS Lambda 函式的名稱
3	FunctionVersion AWS Lambda 函式的版本
4	InvokedFunctionArn 用於呼叫此函式的 ARN。
5	AwsRequestId 為建立的 AWS 函式生成的 AWS 請求 ID
6	LogStreamName CloudWatch 日誌流名稱
7	LogGroupName CloudWatch 組名稱
8	ClientContext 與 AWS Mobile SDK 一起使用時有關客戶端應用程式和裝置的資訊
9	Identity 與 AWS Mobile SDK 一起使用時有關 Amazon Cognito 身份的資訊
10	RemainingTime 函式終止之前的剩餘執行時間
11	Logger 與上下文關聯的記錄器

示例

在本節中，讓我們測試 C# 中 AWS Lambda 中的一些上述屬性。請檢視以下示例程式碼：

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 控制檯** 中呼叫上述程式碼時，您可以看到的相關輸出如下所示：

使用 C# 進行日誌記錄

對於日誌記錄，您可以使用兩個函式：

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 Lambda – 配置 Lambda 函式

在前面的章節中，我們學習瞭如何在 AWS 控制檯中建立 AWS Lambda 函式。但是，建立 Lambda 函式還有其他引數。這些包括記憶體分配、超時等。

在本章中，讓我們詳細瞭解 AWS Lambda 的以下配置屬性。

記憶體分配

登入到 AWS 控制檯並建立或選擇現有的 lambda 函式。單擊**配置**選項卡以獲取已分配記憶體的詳細資訊。檢視以下螢幕截圖：

請注意，預設情況下分配的記憶體為 **128MB**。如果要增加記憶體，您可以單擊滑塊。

移動滑塊時，記憶體將遞增到64MB。請注意，最大可用記憶體為3008MB。請檢視下面的螢幕截圖：

您也可以使用命令提示符中的aws cli來增加記憶體限制。您需要以64MB的增量指定記憶體。

現在，讓我們增加名為myfirstlambdafunction的AWS Lambda函式的記憶體限制。

該函式的記憶體詳細資訊如下面的螢幕截圖所示：

使用aws cli更改記憶體的命令如下：

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

AWS Lambda函式myfirstlambdafunction在AWS控制檯中的相應輸出顯示在此處。請注意，記憶體已從128MB更改為256MB。

最大執行時間

超時是指如果發生超時，分配給AWS Lambda函式終止的時間。AWS Lambda函式將在分配的時間內執行，或者如果超過給定的超時時間，則終止。您需要評估函式執行所需的時間，並相應地在AWS控制檯的配置選項卡中選擇時間，如下所示：

IAM角色

建立AWS Lambda函式時，需要分配角色或許可權。如果您需要AWS Lambda用於S3或dynamoDB，則需要分配與lambda服務相關的許可權。根據分配的角色，AWS Lambda將決定要採取的步驟。例如，如果您授予dynamodb的完全訪問許可權，則可以新增、更新和刪除dynamodb表中的行。

處理程式名稱

這是AWS Lambda函式執行的開始。處理程式函式包含觸發事件的詳細資訊、上下文物件以及必須在AWS Lambda成功或失敗時傳送回的回撥。

nodejs中處理程式函式的格式如下所示：

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

使用環境變數的Lambda函式

在本節中，我們將建立一個使用在配置部分中新增的環境變數的簡單Lambda函式。為此，請按照以下步驟操作，並參考相應的螢幕截圖：

步驟1

轉到AWS控制檯並在Lambda中建立一個函式，如圖所示。

步驟2

現在，新增環境變數，如圖所示：

步驟3

現在，讓我們在Lambda程式碼中獲取相同的變數，如下所示：

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

步驟4

要從環境變數中獲取詳細資訊，我們需要使用process.env，如圖所示。請注意，此語法適用於NodeJS執行時。

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

步驟5

Lambda函式執行的輸出將如下所示：

使用AWS控制檯建立和部署

我們可以在AWS控制檯中建立Lambda函式並對其進行測試。本章將詳細討論這一點。為此，您需要按照此處提供的步驟操作，並觀察給出的相應螢幕截圖：

步驟1

登入AWS控制檯https://aws.amazon.com/console/。現在，您將被重定向到顯示AWS服務的螢幕。

步驟2

現在，單擊上面突出顯示的Lambda服務。這將重定向到建立函式，如下所示：

步驟3

現在，單擊建立函式並輸入函式的詳細資訊。然後，您可以看到如下所示的螢幕：

步驟4

您可以透過選擇您選擇的語言來編寫程式碼。如果選擇的選項是內聯編輯程式碼，則必須在編輯器中編寫程式碼。其他可用選項如下：

步驟5

完成後，您需要儲存更改，右上角有一個按鈕，如下所示：

步驟6

現在，單擊測試按鈕。這將提供Lambda函式執行的所有詳細資訊，如下所示：

步驟 7

index.js的程式碼如下：

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

這將呼叫回撥函式，結果可能是錯誤或成功。成功時，您將看到Lambda測試訊息；如果失敗，它將傳遞null。

步驟8

Lambda函式的角色詳細資訊是配置的一部分，如下所示：

步驟9

現在，您可以根據需要更新角色並儲存Lambda函式。然後，將顯示lambda函式的記憶體和超時詳細資訊，如下所示：

步驟10

現在，我們需要向Lambda函式新增觸發器，以便在事件發生時執行它。觸發器詳細資訊顯示在AWS Lambda函式螢幕的開頭，如下所示：

由此，您可以選擇希望Lambda函式觸發的觸發器。當您選擇觸發器時，必須新增觸發器的配置詳細資訊。

例如，對於S3上的觸發器，要新增的配置詳細資訊如下：

步驟11

現在，選擇您希望在其上觸發觸發器的儲存桶。事件型別具有以下詳細資訊：

步驟12

對於觸發器，您還可以提及字首型別檔案或檔案模式，Lambda必須觸發。詳細資訊如下所示：

步驟13

現在，填寫觸發器所需的詳細資訊並單擊新增按鈕。儲存Lambda函式以新增觸發器。儲存函式會部署詳細資訊，從現在開始，只要將檔案新增到S3儲存桶，Lambda就會被觸發。

請觀察以下螢幕截圖，其中顯示了新增到AWS Lambda的S3觸發器：

步驟14

現在，讓我們使用S3示例事件來測試Lambda函式。相應的程式碼如下所示：

Amazon S3 Put示例事件

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

儲存更改。單擊測試並輸入S3示例事件：

步驟17

現在單擊測試，您可以看到輸出如下：

步驟18

要使用S3 AWS服務測試S3上的觸發器，請在S3儲存桶中上傳檔案：test bucket trigger。更新與Lambda一起使用的角色，以獲取S3和SES策略（用於傳送郵件）的許可權。這將更新AWS Lambda程式碼以傳送郵件以檢視觸發器是否正常工作：

更新後的AWS Lambda程式碼如下所示：

var aws = require('aws-sdk');
var ses = new aws.SES({
   region: 'us-east-1'
});
exports.lambdahandler = function(event, context, callback) {
   var eParams = {
      Destination: {
         ToAddresses: ["coxxxxxxx@gmail.com"]
      },
      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: "coxxxxxx@gmail.com"
   };
   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

現在，上傳檔案並檢查AWS Lambda程式碼中提供的郵件ID：

使用AWS CLI建立和部署

AWS CLI是一個命令列工具，有助於使用AWS服務。我們可以用它來建立、更新、刪除和呼叫aws lambda函式。本章將詳細討論AWS CLI的安裝和使用方法。

AWS CLI的安裝

本節將指導您完成在各種作業系統上安裝AWS CLI的過程。請按照給定的步驟操作，並在附有螢幕截圖的地方觀察相應的螢幕截圖。

對於Windows

檢查您的Windows配置，並選擇以下連結之一來安裝AWS CLI MSI：

對於Windows 64位：適用於Windows的AWS CLI MSI安裝程式（64位）
對於Windows 32位：適用於Windows的AWS CLI MSI安裝程式（32位）

選擇相應的連結並單擊它後，您會在此處找到一個視窗：

接下來，設定Windows中的環境路徑，如下面的螢幕截圖所示：

完成後，您可以在命令提示符中使用以下命令來檢視是否已安裝aws cli：

aws --version

它將顯示aws-cli版本的詳細資訊，如下面的螢幕截圖所示：

對於Linux/Mac

要在Linux和Mac上安裝，您需要Python 2.6.3或更高版本。然後，使用以下命令進行進一步的安裝過程：

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

現在，我們需要配置AWS設定。您可以為此使用以下命令：

aws configure

為此，它需要以下詳細資訊：

AWS訪問金鑰ID
AWS秘密訪問金鑰
預設區域名稱
預設輸出格式

您可以從您的aws控制檯中獲取這些詳細資訊。轉到右上角的帳戶名稱，如圖所示：

現在，單擊我的安全憑證並從左側選擇使用者。新增具有所需詳細資訊的使用者。

新增使用者並獲取訪問金鑰和秘密金鑰。要檢視新的訪問金鑰，請選擇顯示。您的憑證將如下所示：

訪問金鑰ID - AOSAIOSFOCDD7Example

秘密訪問金鑰 - aJuirCVtnROUN/K7MDENG/bPxRfiCYExampleKEY

AWS CLIS參考命令

下表將提供可用於與aws cli一起使用的命令參考。

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

現在，讓我們逐一詳細討論這些命令。

create-function

此api將建立一個新的lambda函式。程式碼需要以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 (字串) - 這將採用函式的名稱。名稱可以是64位字元。

--runtime(字串) - 在這裡，您需要指定執行時環境，即語言選擇。執行時的詳細資訊如下所示：

可用選項	執行時
Python v3.6	python3.6
Python v2.7	python2.7
NodeJS v6.10	nodejs6.10
NodeJS v8.10	nodejs8.10
Java	java8
C# 1	dotnetcore1.0
C# 2	dotnetcore2.0
Go	go1.x

--role(字串) - 這將是lambda策略的名稱，即授予lambda函式以訪問其他服務的許可權。它將具有根據指定角色的許可權。

--handler (字串) - 這是lambda程式碼執行將開始的處理程式的名稱。

對於nodejs，處理程式名稱是我們匯出的模組名稱。
對於 Java，它是 package.classname :: handler 或 package.classname
對於 Python，handler 是 nameofthefile。

--code (結構) −AWS Lambda 程式碼

--description (字串) − AWS Lambda 函式的描述

--timeout (整數) − 超時時間，表示 Lambda 函式必須終止執行的時間。預設為 3 秒。

--memory-size (整數) − 為 AWS Lambda 函式分配的記憶體大小。AWS 將根據提供的記憶體大小分配相應的 CPU 和記憶體。

--environment (結構) − 一個包含 AWS Lambda 函式所需環境詳細資訊的物件。

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

--kms-key-arn (字串) − 用於加密環境變數的 Amazon 資源名稱 (ARN)。如果未提供，將使用預設設定進行加密。

--zip-file (blob) − 包含程式碼詳細資訊的 zip 檔案的路徑。

--cli-input-json (字串)：根據提供的 JSON 字串執行服務操作。JSON 字串遵循 --generate-cli-skeleton 提供的格式。如果命令列中提供了其他引數，則 CLI 值將覆蓋 JSON 提供的值。

現在，讓我們使用 Node.js 作為執行時建立一個簡單的 AWS Lambda 函式，並新增一些 console.log 用於列印。

考慮一個示例程式碼以便理解：

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

現在，將檔案壓縮並將其儲存為 awscli.zip。

獲取 ARN

對於角色，讓我們使用我們已建立的現有角色的 arn。要獲取 ARN，您必須按照此處所示的步驟操作。請觀察附帶的相應螢幕截圖：

步驟1

轉到 IAM 並從角色中選擇所需的角色。角色的 ARN 詳細資訊如下所示。在 aws cli 中使用 create-function 命令時，請使用 角色 ARN。

此處觀察到的角色 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 函式顯示如下：

函式的詳細資訊如下所示：

配置的詳細資訊如下：

您可以測試該函式並檢查輸出，如下所示：

相應的日誌輸出顯示在此處：

list-functions

此 API 提供迄今為止在 AWS Lambda 中建立的函式列表。

包含的命令

以下是與該 API 相關的命令：

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

list-functions 下的選項

以下是您可以在此 list-functions API 下使用的各種選項：

--master-region (字串) − 可選。需要顯示函式的區域。

--function-version (字串) − 可選。這將提供函式版本。

--max-items (整數) − 可選。這將根據指定的值提供專案。

--cli-input-json (字串) − 可選。將根據提供的 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 − AWS Lambda 函式的名稱。您也可以指定函式的 Amazon 資源名稱。

--qualifier (字串) − 可選。函式版本可用於獲取函式的詳細資訊。

帶有 get-function 值的命令為：

aws lambda get-function --function-name awslambdausingcli

命令顯示的詳細資訊如下：

它提供了上傳的 zip 程式碼的 URL。在上述情況下，URL 為：

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

get-function-configuration

這將提供 AWS Lambda 函式的配置詳細資訊。

以下是與該 API 一起使用的命令：

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

以下是使用的選項

--function-name (字串) − aws lambda 函式的名稱。您也可以指定函式的 Amazon 資源名稱。

--qualifier (字串) − 可選。函式版本可用於獲取函式的詳細資訊。

帶有 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 (字串) − 根據提供的 JSON 字串執行服務。

--generate-cli-skeleton (字串) − 它列印 JSON 輸出，而不傳送 API 請求。

您可以使用以下命令獲取 get-account-settings：

aws lambda get-account-settings

執行上述命令時，您可以看到以下輸出：

update-function-configuration

此 API 有助於更新已建立的 AWS Lambda 函式的配置詳細資訊。您可以更改記憶體、超時、處理程式、角色、執行時、描述等。

涉及的命令

以下是 update-function-configuration API 中涉及的命令：

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

涉及的選項

以下是 update-function-configuration API 中涉及的選項：

--function-name − aws lambda 函式的名稱

--role (字串) − 可選。需要更新角色的 ARN。

--handler (字串) − 可選。aws lambda 函式的處理程式詳細資訊。

--description (字串) − 可選。函式的描述。

--timeout (整數) − 可選。aws lambda 函式可以終止所需的時間。

--memory-size (整數) − 可選。為 aws lambda 函式分配的記憶體大小。AWS 將根據提供的記憶體大小分配相應的 CPU 和記憶體。

--environment (結構) − 可選。這是一個包含 AWS Lambda 函式所需環境詳細資訊的物件。

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

--runtime (字串) − 在此處，您需要指定執行時環境，即語言選擇。

執行時的詳細資訊如下表所示：

可用選項	執行時
Python v3.6	python3.6
Python v2.7	python2.7
NodeJS v6.10	nodejs6.10
NodeJS v8.10	nodejs8.10
Java	java8
C# 1	dotnetcore1.0
C# 2	dotnetcore2.0
Go	go1.x

--cli-input-json (字串) − 可選。這將根據提供的 JSON 字串在 API 上執行操作。

--generate-cli-skeleton (字串) − 可選。這將輸出所有詳細資訊的 JSON 骨架，而無需執行 API。輸出可以用作 --cli-input-json 的輸入。

現在，讓我們更改之前建立的 AWS Lambda 函式的記憶體和超時。請按照以下步驟操作，並觀察為此目的附加的相應螢幕截圖：

步驟1

更改發生之前的記憶體和超時如下：

步驟2

現在，使用 update-function-configuration，讓我們將記憶體更改為 320MB，超時更改為 10 秒。為此，請使用以下帶有值的命令：

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

步驟3

然後，您可以看到以下顯示輸出：

步驟4

使用 update-function-configuration 後，AWS 控制檯中的顯示如下：

Update-function-code

此 API 將更新現有 AWS Lambda 函式的程式碼。

涉及的命令

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

涉及的選項

以下是 update-function-code API 中涉及的選項：

--function-name (字串) − aws lambda 函式的名稱

--zip-file (blob) − 可選。包含要更新的程式碼的 zip 檔案的路徑。

--s3-bucket (字串) − 可選。包含已上傳程式碼的 zip 檔案的 S3 儲存桶名稱。

--s3-key (字串) − 可選。要上傳的 AWS s3 物件鍵名稱。

--s3-object-version (字串) − 可選。AWS s3 物件版本。

--cli-input-json (字串) − 可選。這將根據提供的 JSON 字串在 API 上執行操作。

--generate-cli-skeleton (字串) − 可選。這將輸出所有詳細資訊的 JSON 骨架，而無需執行 API。輸出可以用作 --cli-input-json 的輸入。

更新後的程式碼如下所示：

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

您可以為此目的使用以下 帶有值的命令：

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

相應的輸出如下所示：

AWS 控制檯的顯示如下所示：

相應的日誌輸出如下所示：

delete-function

delete aws cli API 將刪除給定的函式。

包含的命令

相同的命令詳細資訊在此處給出：

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

包含的選項

此 API 中包含的選項如下：

--function-name (字串) − 這將採用 lambda 函式名稱或 aws lambda 函式的 arn。

--qualifier (字串) − 這是可選的。在這裡，您可以指定需要刪除的 aws lambda 版本。

--cli-input-json (字串) − 根據提供的 JSON 字串執行服務操作。JSON 字串遵循 --generate-cli-skeleton 提供的格式。如果命令列中提供了其他引數，則 CLI 值將覆蓋 JSON 提供的值。

--generate-cli-skeleton (字串) − 它列印 JSON 骨架到標準輸出，而不傳送 API 請求。

您可以為此目的使用以下帶有值的命令：

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

現在，請注意，在 AWS Lambda 函式列表中將看不到該函式：

使用 Serverless Framework 建立和部署

可以使用 Serverless Framework 建立和部署 AWS Lambda。它允許您建立 AWS Lambda 觸發器，並透過建立所需的角色來部署這些觸發器。Serverless Framework 允許以更簡單的方式處理大型專案。所需事件和資源寫在同一個地方，只需幾個命令即可在 AWS 控制檯中部署完整功能。

在本節中，您將詳細瞭解如何開始使用 AWS Serverless Framework。

使用 npm install 安裝 Serverless Framework

首先，您需要安裝 nodejs。您可以如下檢查 nodejs：

您必須使用以下命令使用 npm 包安裝 serverless：

npm install -g serverless

npm 完成後，執行 serverless 命令，該命令顯示用於建立和部署 AWS Lambda 函式的命令列表。請觀察以下螢幕截圖：

您也可以使用 sls 代替 serverless。sls 是 serverless 的簡寫命令。

如果您需要有關命令 sls 的幫助，可以使用以下命令：

sls create --help

要建立一個 Serverless Framework，您必須按照以下步驟操作：

步驟1

要開始使用 Serverless Framework，我們需要新增憑據。這樣，您就可以在 AWS 控制檯中首先看到使用者，如下所示：

步驟2

單擊 下一步：許可權 按鈕以新增許可權。您必須將現有策略或管理員訪問許可權附加到此使用者。

步驟3

單擊 建立使用者 以新增使用者。它將顯示我們需要配置 Serverless Framework 的訪問金鑰和金鑰：

配置 AWS Serverless Framework

讓我們看看如何配置 AWS Serverless Framework。您可以為此目的使用以下命令：

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

請注意，輸入的憑據詳細資訊，即 訪問金鑰 和金鑰儲存在 檔案 /aws/credentials 中。

首先，建立一個要儲存專案檔案的資料夾。

接下來，我們將開始在 aws-serverless 資料夾中工作。

使用 Serverless Framework 建立 AWS Lambda

現在，讓我們使用以下步驟，利用 Serverless 框架建立一個 Lambda 函式。

步驟1

以下是 serverless **create** 命令的詳細資訊：

步驟2

現在，我們需要指定模板，如下所示：

AWS-nodejs、aws-nodejs-typescript、aws-nodejs-ecma-script、aws-python、aws-python3、aws-groovy-gradle 等。

步驟3

我們將使用 **aws-nodejs** 模板來使用 Serverless 框架建立我們的第一個專案。該命令如下所示：

sls create --template aws-nodejs

請注意，此命令會為 aws-nodejs 模板建立一個樣板。

步驟4

現在，在 IDE 中開啟建立的資料夾。這裡我們使用 Visual Studio Code，資料夾結構如下所示：

步驟5

建立了 2 個檔案：**handler.js** 和 **Serverless.yml**

AWS Lambda 基本函式詳細資訊如下所示在 **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** 包含 Serverless 框架的配置詳細資訊，如下所示：

# 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（開發）或 prod（生產）** 環境。因此，以下是提供程式的更新詳細資訊：

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

IAM角色

**iam 角色**，即與 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 服務所需的許可權。

AWS Lambda 處理程式詳細資訊

**handler.js** 中匯出的函式名稱為 hello。因此，處理程式是檔名後跟匯出名稱。

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"

使用 Serverless 框架部署 AWS Lambda

讓我們將上述 Lambda 函式部署到 AWS 控制檯。您可以為此使用以下步驟：

步驟1

首先，您必須使用以下命令：

 sls deploy

步驟2

現在，您應該在 AWS 控制檯中看到該函式，如下所示。Serverless AWS 的詳細資訊記錄在 AWS CloudFormation 中。為此，請轉到 AWS 服務並選擇 **CloudFormation**。AWS Lambda 的詳細資訊將顯示如下：

請注意，給定的名稱是專案名稱後跟使用的階段。

步驟3

它建立用於 AWS Lambda 的 iam 角色和用於 AWS CloudWatch 的日誌組。建立儲存程式碼詳細資訊和配置詳細資訊的 S3 儲存桶。

這是由命令 **sls deploy** 建立的。您無需指定 iam 角色，而是在 **deploy** 階段預設建立。

步驟4

事件的詳細流程如下所示在 CloudFormation 服務中。

AWS Lambda 程式碼

AWS Lambda 程式碼及其執行設定如下面的螢幕截圖所示：

測試 Lambda 函式時，您可以找到以下輸出：

上述函式的日誌輸出在此處顯示：

我們還可以使用以下所示的 serverless 命令測試 AWS Lambda 函式：

sls invoke --function hello

invoke 命令的語法在此處顯示：

sls invoke --function hello

此 invoke 命令會觸發 AWS Lambda 函式並在命令提示符中顯示輸出，如下所示：

您還可以測試部署前的 Lambda 函式，並使用以下命令：

sls invoke local --function hello

請注意，並非總是可以在本地進行測試，因為 S3 和 DynamoDB 等資源無法在本地環境中模擬。只有基本的函式呼叫可以在本地進行測試。

使用 API Gateway 和 Serverless 框架結合 AWS Lambda

讓我們看看如何建立新專案來使用 Lambda 和 API Gateway。您可以為此使用以下命令：

sls create --template aws-nodejs

現在，在 Visual Studio Code 中開啟 **aws-api** 專案。您可以看到已建立 **handler.js** 和 **serverless.yml** 檔案。讓我們對其進行更改以新增 API Gateway。

您必須在 **serverless.yml** 中進行以下更改：

現在，為使用 AWS Lambda 啟用 API Gateway 添加了事件詳細資訊：

這裡添加了一個新內容，稱為 **events**。我們將事件指定為 **http**，以及其路徑和方法。

路徑是我們建立 API Gateway 路徑時將使用的端點，而使用的方法是 GET。

請注意，處理程式是 **handler.hello**，而 hello 是 handler.js 中的匯出名稱。

請注意，您無需在此處部署 API Gateway，因為 Serverless 框架將執行此操作。

現在，我們將執行 **sls deploy** 命令來建立觸發器為 **API Gateway** 的 AWS Lambda 函式。

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，因為查詢字串中沒有任何內容。事件詳細資訊提供給我們在 AWS Lambda 處理程式中指定的 **input**。

我們從 API Gateway 獲取的輸出僅是 **body** 詳細資訊，例如 **message** 和 **input**。響應完全由 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 
 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}}

讓我們更改 AWS Lambda 函式以僅顯示查詢字串詳細資訊，如下所示：

'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** 更改了訊息。這將再次部署函式並檢查輸出。它顯示查詢字串變數 display message 中存在的詳細資訊，如下所示。

現在，讓我們向建立的事件新增 **post** 方法，如下所示：

現在，部署所做的更改，您可以看到部署命令的以下輸出：

請注意，直接在瀏覽器中測試 post URL 將不會提供詳細資訊。您應該在 **Postman** 中測試 post URL。

要獲取 Postman，請訪問 https://www.getpostman.com/apps。根據您的作業系統下載應用程式。安裝後，您應該能夠測試您的 post URL，如下所示：

這將顯示我們在 Lambda 函式中新增的訊息。

執行和呼叫 Lambda 函式

本章將詳細解釋執行和呼叫 Lambda 函式的過程以及所涉及的步驟。

AWS Lambda 執行模型

AWS 執行取決於為 AWS Lambda 函式新增的配置詳細資訊。建立函式時，會分配 **記憶體** 和 **時間**，用於執行 AWS Lambda 函式。

藉助配置詳細資訊，AWS Lambda 會建立一個執行上下文。執行上下文是一個臨時的執行時環境，如果存在任何外部依賴項（例如資料庫連線、http 端點、第三方庫等），則會準備好這些依賴項。

當第一次呼叫 AWS Lambda 函式或更新 Lambda 函式時，由於執行上下文的設定，會增加一點延遲。但是，後續呼叫與第一次呼叫相比速度更快。如果呼叫 Lambda 函式的時間較短，AWS Lambda 會嘗試再次重用執行上下文。

執行上下文的重用具有以下含義：

如果為 Lambda 的執行完成任何資料庫連線，則會保持連線以供重用。因此，Lambda 程式碼必須首先檢查連線是否存在並重用；否則，我們將必須建立新的連線。
執行上下文在 ** /tmp** 目錄中維護 500MB 的磁碟空間。所需資料快取在此目錄中。您可以在程式碼中新增額外的檢查以檢視資料是否存在。
如果在呼叫 Lambda 函式時回撥或某些後臺程序未完成，則當再次呼叫 Lambda 函式時，執行將開始。如果您不需要發生這種情況，請確保在函式執行完成後所有程序都已正確結束。

您應該使用執行上下文和儲存在 tmp 目錄中的資料。您必須在程式碼中新增必要的檢查以檢視所需的資料是否存在，然後再建立新的資料。這將節省執行時間並使其速度更快。

呼叫 AWS Lambda 函式

我們可以使用 **aws cli** 手動呼叫 AWS。我們已經看到如何使用 **cli** 建立和部署 AWS Lambda。在這裡，我們將首先使用 **aws cli** 建立一個函式並呼叫它。

使用 AWS CLI 建立 AWS Lambda 函式

您可以使用以下命令使用 **aws cli** 建立 AWS Lambda 函式：

命令

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

帶值的命令

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

輸出如下所示：

在 AWS 控制檯中建立的函式如下所示：

現在，您可以使用命令：**invoke** 呼叫該函式

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

選項

**--function-name -** 指定要呼叫的函式的名稱。

**--invocation-type(string) -** 預設情況下，invokation-type 為 **requestresponse**。可用於 invokation-type 的值為 **RequestResponse、Event** 和 **DryRun**。

Event invocation-type 用於非同步響應。
DryRun 用於在無需執行 Lambda 函式的情況下驗證它。

**--log-type -** 如果 invocation type 為 RequestResponse，則它將為 **Tail**。它提供最後 4KB 的 base64 編碼日誌資料。可能的值為 **Tail** 和 **None**。

**--client-context -** 您可以將特定於客戶端的詳細資訊傳遞給 Lambda 函式。clientcontext 必須採用 json 格式並進行 base64 編碼。最大檔案大小為 3583 位元組。

**--payload -** json 格式的輸入到您的 lambda 函式。

--qualifier − 可以指定 Lambda 函式版本或別名。如果傳遞函式版本，則 API 將使用限定的函式 ARN 來呼叫 Lambda 函式。如果指定別名，則 API 使用別名 ARN 來呼叫 Lambda 函式。

outfile − 這是儲存內容的檔名。

帶值的命令

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

您可以使用 payload 選項以 JSON 格式傳送虛擬事件到 Lambda 函式，如下所示。

相關的 AWS Lambda 程式碼如下：

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

請注意，在程式碼中，我們有控制檯輸出 event.name 和 event.addr。現在，讓我們在 aws cli 中使用 payload 選項傳送帶有名稱和地址的事件，如下所示：

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

然後 payload 接受一個包含 JSON 輸入的檔案路徑作為輸入，如下所示：

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

相應的輸出如下所示：

輸出儲存在檔案 C:\clioutput\outputfile.txt 中，如下所示：

"Hello Roy Singh and address is Mumbai"

示例事件

您可以透過傳遞示例事件來測試 AWS Lambda 函式。本節提供了一些 AWS 服務的示例事件。您可以使用 invoke 命令測試使用任何服務觸發時的輸出。請觀察下面給出的對應示例事件程式碼：

Amazon S3 Put示例事件

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

要獲取來自 s3 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 eventname

Amazon S3 刪除示例事件

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

Amazon DynamoDB

當 DynamoDB 表發生更改時，Amazon DynamoDB 可以成為 AWS Lambda 上的一個事件。我們可以執行諸如新增條目、更新和刪除 DynamodDB 表中的記錄等操作。

這裡顯示了 DynamoDB 新增、插入和刪除事件的示例事件：

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

Amazon Simple Notification Service

AWS Lambda 可以幫助處理在簡單通知服務 (SNS) 中建立的通知。每當在 SNS 中釋出訊息時，都可以使用 SNS 事件觸發 Lambda 函式，該事件包含訊息的詳細資訊。這些訊息可以在 Lambda 函式內部處理，並根據需要進一步傳送到其他服務。

輸入訊息後，SNS 將觸發 Lambda 函式。如果任何錯誤嘗試呼叫 Lambda 函式，SNS 將最多重試三次。

Amazon SNS 示例事件

下面顯示了一個示例事件，其中包含 AWS Lambda 函式中可用的所有詳細資訊，以執行進一步的處理：

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

Amazon Simple Mail Service

Amazon Simple Mail Service 可用於傳送訊息和接收訊息。當收到訊息時，可以呼叫 AWS Lambda 函式。

Amazon SES 電子郵件接收示例事件

下面顯示了在 AWS Lambda 中使用時 SES 事件的詳細資訊：

{
  "Records": [{
      "eventVersion": "1.0",
      "ses": {
         "mail": {
            "commonHeaders": {
               "from": [
                  "Jane Doe <janedoe@example.com>"
               ],
            "to": [
               "johndoe@Source.com"
            ],
            "returnPath": "janedoe@example.com",
            "messageId": "<0123456789Source.com>",
            "date": "Wed, 7 Oct 2015 12:34:56 -0700",
            "subject": "Test Subject"
         },
         "example": "janedoe@example.com",
         "timestamp": "1970-01-01T00:00:00.000Z",
         "destination": [
            "johndoe@example.com"
         ],
         "headers": [{
            "name": "Return-Path",
            "value": "<janedoe@example.com>"
         },
         {
            "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 johndoe@example.com; 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 <janedoe@example.com>"
         },
         {
            "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": "johndoe@example.com"
         },
         {
            "name": "Content-Type",
            "value": "text/plain; charset=UTF-8"
         }],
         "headersTruncated": false,
         "messageId": "o3vrnil0e2ic28tr"
      },
      "receipt": {
         "recipients": [
            "johndoe@example.com"
         ],
         "timestamp": "1970-01-01T00:00:00.000Z",
         "spamVerdict": {
            "status": "PASS"
         },
         "dkimVerdict": {
            "status": "PASS"
         },
         "processingTimeMillis": 574,
         "action": {
            "type": "Lambda",
            "invocationType": "Event",
            "functionArn": "arn:aws:lambda:us-west-2:012345678912:function:example"
         },
         "spfVerdict": {
            "status": "PASS"
         },
         "virusVerdict": {
            "status": "PASS"
         }
      }
   },
   "eventexample": "aws:ses"
   }]
}

Amazon Cloudwatch Logs

可以使用CloudWatch Logs 訂閱從 Amazon CloudWatch Logs 觸發 AWS Lambda。CloudWatch Logs 訂閱具有有關日誌的即時資料的即時資料，這些資料可以在 AWS Lambda 內進行處理和分析，或者可以用於載入到其他系統。

Amazon CloudWatch Logs 示例事件

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

Amazon API Gateway

AWS Lambda 函式可以在https URL 上呼叫。它可以在GET、POST、PUT 上執行。當呼叫 https URL 時，AWS Lambda 函式也會被觸發，並且使用 get/post 傳遞到 https 的資料可以在 AWS Lambda 內部使用，用於插入到 DynamoDB 或傳送郵件等。

API Gateway 代理請求事件

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

API Gateway 代理響應事件

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

刪除Lambda函式

刪除 AWS Lambda 函式將從 AWS 控制檯中刪除 AWS Lambda。刪除 AWS Lambda 函式有兩種方法。

使用 AWS 控制檯。
使用 AWS CLI 命令

本章詳細討論這兩種方法。

使用 AWS 控制檯

要使用 AWS 控制檯刪除 Lambda 函式，請按照以下步驟操作：

步驟1

登入到 AWS 控制檯並轉到 AWS Lambda 服務。您可以發現到目前為止建立的 AWS lambda 函式列在 AWS 控制檯中，如下所示：

該列表顯示到目前為止已建立了 23 個 AWS Lambda 函式。您可以使用頂部提供的分頁檢視它們，或者使用搜索框搜尋 AWS Lambda。

步驟2

請注意，每個 AWS Lambda 函式都有一個單選按鈕。選擇要刪除的函式。請觀察下面的螢幕截圖：

步驟3

選擇 AWS Lambda 函式後，之前灰顯的操作下拉選單現在高亮顯示。現在，開啟組合框，它將顯示如下選項：

步驟4

選擇刪除按鈕以刪除 AWS Lambda 函式。單擊刪除後，它會顯示如下訊息：

步驟5

仔細閱讀訊息，然後單擊刪除按鈕永久刪除 aws lambda 函式。

注意：刪除 aws lambda 不會刪除關聯的角色。要刪除角色，您需要轉到 IAM 並刪除角色。

步驟6

到目前為止建立的角色列表如下所示。請注意，有一個建立角色按鈕和刪除角色按鈕。

單擊要刪除的角色旁邊的複選框。您也可以一次選擇多個角色進行刪除。

步驟 7

單擊“刪除”按鈕後，您將看到如下所示的確認訊息：

現在，仔細閱讀提到的詳細資訊，然後單擊是，刪除按鈕。

使用 AWS CLI 命令

讓我們首先使用 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

建立的 AWS Lambda 函式是lambdatestcli。我們使用現有的角色 arn 來建立 lambda 函式。

然後您可以在 AWS 控制檯中看到此函式，如下所示：

步驟3

現在，讓我們使用顯示的命令呼叫該函式以測試輸出：

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

此命令將為您提供如下所示的輸出：

步驟4

您可以從 CloudWatch 檢視 lambda 函式lambdatestcli的日誌。

步驟5

現在，讓我們來看一下刪除 AWS 函式的實際部分。刪除 aws cli api 將刪除給定的函式。為此使用的命令詳細資訊如下所示：

命令

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

選項

--function-name(string) − 這將接受 AWS Lambda 函式的 Lambda 函式名稱或 arn。

--qualifier (string) − 這是可選的。在這裡，您可以指定需要刪除的 AWS Lambda 版本。

--cli-input-json(string) − 根據提供的 JSON 字串執行服務操作。JSON 字串遵循--generate-cli-skeleton提供的格式。如果在命令列上提供其他引數，則 CLI 值將覆蓋 JSON 提供的值。

--generate-cli-skeleton(string) − 它在不傳送 API 請求的情況下將 json 骨架列印到標準輸出。

帶值的命令

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

相應的輸出如下所示：

步驟6

如果您現在檢查，您可以觀察到該函式將不會在 AWS Lambda 函式列表中顯示，如下面的螢幕截圖所示：

使用Amazon API Gateway

AWS Lambda 函式可以在HTTPS URL 上呼叫。它可以在 GET、POST、PUT 上執行。當呼叫 HTTPS URL 時，AWS Lambda 函式也會被觸發，並且使用get/post傳遞到 HTTPS 的資料可以在 AWS Lambda 內部使用，用於插入到 DynamoDB 或傳送郵件等。

本章詳細討論了使用 AWS lambda 和 API Gateway 涉及的各種流程。

涉及的流程

以下是使用 AWS lambda 和 API Gateway 涉及的流程：

建立用於許可權的 IAM 角色
建立 AWS lambda 函式
建立 API Gateway
將 lambda 函式連結到 api gateway
將資料傳遞到 api gateway

這裡給出了一個解釋 API Gateway 和 AWS Lambda 工作原理的基本圖：

本章將進一步詳細解釋這些過程以及相關的螢幕截圖。

建立用於許可權的 IAM 角色

從下面的 Amazon 服務中，選擇 IAM 以建立 Lambda 函式將使用的角色。

轉到 IAM 並從左側部分選擇角色，如下所示：

單擊建立角色以建立 Lambda 函式。

選擇 Lambda 並單擊底部的許可權。選擇 API Gateway 和 Lambda所需的許可權。

在搜尋中搜索 API gateway，它將列出所有相關的許可權。在這裡，我們選擇了對 API gateway 的完全訪問許可權，如下所示：

現在，搜尋 API gateway，它將列出所有相關的許可權。在這裡，我們選擇了對 API gateway 的完全訪問許可權，如下所示：

您必須對策略也重複相同的過程。

選擇必要的策略後，單擊檢視以進行下一步。根據您的選擇輸入角色的名稱，如下所示：

它顯示附加到角色的策略。單擊建立角色，我們就完成了角色建立，可以繼續進行 lambda 函式。

建立 AWS Lambda 函式

轉到 AWS 服務，然後單擊 lambda 服務以建立一個函式，將其與 api gateway 連線。

Lambda 函式的 UI 螢幕如下所示。單擊建立函式按鈕以繼續建立 Lambda 函式。

輸入函式的名稱並選擇我們上面建立的現有角色。

它會顯示一條訊息，表明名為lambdawithapigateway的函式已成功建立。

請注意，這裡我們將使用nodejs執行時來編寫程式碼。帶有helloworld訊息的 AWS 程式碼如下所示：

AWS Lambda 程式碼位於index.js檔案中。名為 handler 的函式具有名為events、context和callback的引數。

回撥函式基本上包含錯誤和成功訊息。請注意，這裡我們沒有任何與錯誤相關的程式碼，因此傳遞 null，成功訊息為HelloWorld from lambda。

最後，儲存新增的更改，讓我們繼續將 Lambda 函式新增到 API gateway。

建立 API Gateway

登入到您的 AWS 帳戶並開啟 API Gateway，如下所示：

單擊 API Gateway，它將引導您進入可以建立新的 API Gateway 的螢幕。

單擊建立 API並新增如下所示的詳細資訊：

單擊螢幕右側的建立 API按鈕。這將在螢幕左側顯示新建立的 API。

單擊操作下拉選單以為此 API 建立一個新的資源。

現在，建立一個新的資源，如下所示：

輸入如下所示的資源名稱。您將在最後建立的 url 中看到輸入的資源名稱。單擊建立資源，您將在螢幕上看到它，如下所示：

向建立的資源新增GET/POST方法，如下所示。從操作下拉選單中選擇方法。

單擊GET方法將該方法新增到 API。

下一步是整合，它將與 Lambda 函式整合。現在將 Lambda 函式新增到其中，如下所示：

將 Lambda 函式連結到 API Gateway

選擇之前建立的 lambda 函式。

儲存更改，您將看到一個對話方塊，要求您授予許可權，如下所示：

單擊確定以授予許可權。這是 API Gateway HTTP 請求和 Lambda 函式之間的執行詳細資訊：

現在，讓我們部署 API Gateway 更改。為此，我們需要從操作下拉選單中選擇部署 API，如下所示：

選擇 **部署API**。系統會詢問部署狀態。從部署階段下拉選單中選擇 **新階段**，並將階段名稱新增為 **生產**。

單擊 **部署** 按鈕，它將重定向您到如下所示的 URL：

從左側選擇 **GET** 方法以獲取 URL。在新標籤頁中開啟 URL 以檢視 Lambda 函式的訊息。

這是一個使用 AWS Lambda 和 AWS API Gateway 的基本示例。在上面的示例中，我們在 Lambda 函式中硬編碼了訊息。

現在，讓我們從 API Gateway 獲取訊息詳細資訊。如果 HTTPS 呼叫需要從不同的域呼叫，例如對 API 的 AJAX 呼叫，我們需要為建立的 API Gateway 啟用 CORS。

選擇為 API 建立的資源，然後單擊 **操作** 下拉選單：

現在，**啟用 CORS** 將開啟以下螢幕：

您可以使用幾種方法啟用 CORS。**Access-Control-Allow-Origin** 被標記為 *，這意味著它允許從任何域獲取 API Gateway 的內容。

您還可以指定要與 API 協同工作的域名。單擊 **啟用 CORS 並替換現有 CORS 頭** 按鈕，它將顯示如下所示的確認訊息：

單擊 **是，替換現有值** 按鈕以啟用它。**啟用 CORS** 螢幕如下所示：

向 API Gateway 傳遞資料

開啟在 API Gateway 中建立的 API **displayhelloworld**，如下所示：

單擊 **整合請求** 以傳送資料，如下所示：

選擇 **正文對映模板** 併為此示例新增 **Content-Type** 為 **application/json**。單擊新增的內容型別，新增如下詳細資訊：

現在，新增如下所示的 JSON 格式模板：

請注意，我們已將訊息作為引數來獲取來自 API Gateway 的資料並將其與 AWS Lambda 共享。獲取詳細資訊的語法如上所示。

現在，部署 API 以使更改在 API Gateway URL 上可用。為此，我們需要更改 Lambda 函式以根據 API Gateway URL 顯示資料。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

請注意，這裡我們將訊息作為查詢字串傳遞給 GET URL。然後您可以觀察如下所示的輸出：

它讀取從 URL 傳送到訊息的詳細資訊，並在瀏覽器中顯示相同的詳細資訊。

將 Lambda 函式與 Amazon S3 一起使用

Amazon S3 服務用於檔案儲存，您可以在其中上傳或刪除檔案。當 S3 儲存桶中存在任何檔案上傳時，我們可以觸發 S3 上的 AWS Lambda。AWS Lambda 具有一個處理程式函式，該函式充當 AWS Lambda 函式的起點。處理程式包含事件的詳細資訊。在本節中，讓我們看看如何在上傳 S3 儲存桶中的檔案時使用 AWS S3 觸發 AWS Lambda 函式。

將 AWS Lambda 函式與 Amazon S3 一起使用的步驟

要開始將 AWS Lambda 與 Amazon S3 一起使用，我們需要以下內容：

建立 S3 儲存桶
建立具有使用 s3 和 lambda 許可權的角色
建立 lambda 函式並將 s3 新增為觸發器。

示例

讓我們透過一個示例來了解這些步驟，該示例顯示了 Amazon S3 和 AWS Lambda 之間的基本互動。

使用者將檔案上傳到 Amazon S3 儲存桶
上傳檔案後，它將在後臺觸發 AWS Lambda 函式，該函式將以控制檯訊息的形式顯示檔案已上傳的輸出。
上傳檔案後，使用者將能夠在 CloudWatch 日誌中看到該訊息。

解釋示例流程的框圖如下所示：

建立 S3 儲存桶

讓我們首先按照以下步驟在 AWS 控制檯中建立一個 s3 儲存桶：

步驟1

轉到 Amazon 服務，然後單擊儲存部分中的 **S3**，如下面的圖片中突出顯示的那樣：

步驟2

單擊 S3 儲存並單擊 **建立儲存桶**，該儲存桶將儲存上傳的檔案。

步驟3

單擊 **建立儲存桶** 按鈕後，您將看到如下螢幕：

步驟4

輸入詳細資訊 **儲存桶名稱、選擇區域** 並單擊左下角的 **建立** 按鈕。因此，我們建立了名為 **workingwithlambdaands3** 的儲存桶。

步驟5

現在，單擊儲存桶名稱，它會要求您上傳檔案，如下所示：

因此，我們完成了在 S3 中建立儲存桶的工作。

建立與 S3 和 Lambda 協同工作的角色

要建立與 S3 和 Lambda 協同工作的角色，請按照以下步驟操作：

步驟1

轉到 AWS 服務並選擇 IAM，如下所示：

步驟2

現在，單擊 **IAM -> 角色**，如下所示：

步驟3

現在，單擊 **建立角色** 並選擇將使用此角色的服務。選擇 Lambda 並單擊 **許可權** 按鈕。

步驟4

從下面新增許可權並單擊 **檢視**。

步驟5

請注意，我們選擇了以下許可權：

請注意，我們選擇的策略是 **AmazonS3FullAccess、AWSLambdaFullAccess** 和 **CloudWatchFullAccess**。

步驟6

現在，輸入角色名稱、角色描述並單擊底部的 **建立角色** 按鈕。

因此，我們建立了名為 **lambdawiths3service** 的角色。

建立 Lambda 函式並新增 S3 觸發器

在本節中，讓我們看看如何建立一個 Lambda 函式並向其新增 S3 觸發器。為此，您必須按照以下步驟操作：

步驟1

轉到 AWS 服務並選擇 Lambda，如下所示：

步驟2

單擊 **Lambda** 並按照新增 **名稱** 的過程進行操作。選擇 **執行時、角色** 等並建立函式。我們在下面的螢幕截圖中顯示了我們建立的 Lambda 函式：

步驟3

現在讓我們新增 S3 觸發器。

步驟4

從上面選擇觸發器並新增如下所示的詳細資訊：

步驟5

從儲存桶下拉選單中選擇建立的儲存桶。事件型別具有以下詳細資訊：

選擇 **物件建立（全部）**，因為我們需要在上傳、刪除等檔案時觸發 AWS Lambda。

步驟6

您可以新增用於過濾新增的檔案的字首和檔案模式。例如，僅對 .jpg 圖片觸發 lambda。現在讓我們將其保留為空白，因為我們需要為上傳的所有檔案觸發 Lambda。單擊 **新增** 按鈕以新增觸發器。

步驟 7

您可以找到 Lambda 函式的觸發器顯示，如下所示：

讓我們新增 aws lambda 函式的詳細資訊。在這裡，我們將使用線上編輯器新增我們的程式碼並使用 nodejs 作為執行時環境。

步驟8

要使用 AWS Lambda 觸發 S3，我們必須在程式碼中使用 S3 事件，如下所示：

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

請注意，event 引數包含 S3event 的詳細資訊。我們已經記錄了儲存桶名稱和檔名，這些名稱將在您將影像上傳到 S3bucket 時記錄。

步驟9

現在，讓我們儲存更改並使用 S3upload 測試 lambda 函式。以下是在 AWS Lambda 中新增的程式碼詳細資訊：

步驟10

現在，讓我們新增角色、記憶體和超時。

步驟11

現在，儲存 Lambda 函式。從 Amazon 服務開啟 S3 並開啟我們之前建立的名為 **workingwithlambdaands3** 的儲存桶。

將影像上傳到其中，如下所示：

步驟12

單擊 **上傳** 按鈕以新增檔案，如下所示：

步驟13

單擊 **新增檔案** 以新增檔案。您也可以拖放檔案。現在，單擊 **上傳** 按鈕。

因此，我們在 S3 儲存桶中上傳了一張影像。

步驟14

要檢視觸發器詳細資訊，請轉到 AWS 服務並選擇 **CloudWatch**。開啟 Lambda 函式的日誌並使用以下程式碼：

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

您可以在 CloudWatch 中觀察到的輸出如下所示：

當檔案上傳到 S3 儲存桶時，AWS Lambda 函式將被觸發，詳細資訊將記錄在 CloudWatch 中，如下所示：

將 Lambda 函式與 Amazon DynamoDB 一起使用

當資料新增到表中、更新或刪除時，DynamoDB 可以觸發 AWS Lambda。在本節中，我們將處理一個簡單的示例，該示例將專案新增到 DynamoDB 表和 AWS Lambda，後者將讀取資料並使用新增的資料傳送郵件。

先決條件

要使用 Amazon DB 和 AWS Lambda，我們需要按照如下所示的步驟操作：

在 DynamoDB 中建立一個帶有主鍵的表
建立一個具有使用 DynamoDB 和 AWS Lambda 許可權的角色。
在 AWS Lambda 中建立函式
傳送郵件的 AWS Lambda 觸發器
在 DynamoDB 中新增資料

讓我們詳細討論每個步驟。

示例

我們將處理以下示例，該示例顯示了 DynamoDB 和 AWS Lambda 之間的基本互動。此示例將幫助您瞭解以下操作：

在 Dynamodb 表中建立一個名為 customer 的表，以及如何在該表中輸入資料。
輸入資料後觸發 AWS Lambda 函式，並使用 Amazon SES 服務傳送郵件。

解釋示例流程的基本框圖如下所示：

在 DynamoDB 中建立帶有主鍵的表

登入到 AWS 控制檯。轉到 AWS 服務並選擇 DynamoDB，如下所示。選擇 DynamoDB。

DynamoDB 顯示如下所示的選項：

現在，單擊 **建立表** 以建立表，如下所示。我們將表命名為 **customer**，該表的表主鍵為 **cust_id**。單擊 **建立** 按鈕將表新增到 dynamodb。

建立的表如下所示：

我們可以如下所示向建立的表中新增專案：

單擊 **專案** 並單擊 **建立專案** 按鈕，如下所示：

建立具有使用 DynamoDB 和 AWS Lambda 許可權的角色

要建立角色，請轉到 AWS 服務並單擊 IAM。

讓我們建立一個策略，僅用於之前建立的 DynamoDB 表。

現在，選擇一個**服務**。請注意，我們選擇的服務是**DynamoDB**。對於**操作**，我們選擇了所有**DynamoDB**操作，即訪問列表、讀取和寫入。對於**資源**，我們將選擇表資源型別操作。單擊它後，您將看到如下螢幕：

現在，選擇**表**並向其**新增 ARN**，如圖所示。我們將從如下所示建立的**客戶表**中獲取**ARN**詳細資訊：

在此處輸入**arn**詳細資訊：

單擊**新增**按鈕儲存更改。完成後，**單擊檢視策略**。輸入策略名稱、描述等，如下所示：

單擊**建立策略**以儲存它。將策略新增到要建立的角色中。從左側選擇**角色**並輸入詳細資訊。

請注意，新增的策略是**newpolicyfordynamdb、awslambdafullaccess、cloudwatchfullaccess**和**amazonsesfullaccess**。新增角色，並在建立 AWS Lambda 函式時使用它。

在 AWS Lambda 中建立函式

因此，我們建立了一個名為**newlambdafordynamodb**的 Lambda 函式，如圖所示。

現在，讓我們將 DynamoDB 觸發器新增到建立的 AWS Lambda 中。我們將使用的執行時是 Node.js。

您可以在 DynamoDB 觸發器中找到以下需要為 AWS Lambda 配置的詳細資訊：

現在，只需單擊**新增**即可將觸發器新增到 AWS Lambda。

傳送郵件的 AWS Lambda 觸發器

當資料插入 AWS Lambda 時，AWS Lambda 將被觸發。事件引數將包含插入的 DynamoDB 資料。這將從事件中讀取資料併發送電子郵件。

傳送電子郵件

要傳送電子郵件，您需要按照以下步驟操作：

步驟1

轉到 AWS 服務並選擇 SES（簡單電子郵件服務）。驗證我們需要向其傳送電子郵件的電子郵件，如圖所示：

步驟2

單擊**驗證新的電子郵件地址**按鈕以新增電子郵件地址。

步驟3

輸入要驗證的電子郵件地址。該電子郵件地址將收到來自 Amazon 的啟用郵件，需要點選該郵件。啟用完成後，電子郵件 ID 將被驗證，並可與 AWS 服務一起使用。

步驟4

下面提供了讀取事件資料併發送電子郵件的 AWS Lambda 程式碼：

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: ["xxxxx@gmail.com"]
      },
      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: "xxxxx@gmail.com"
   };
   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

轉到在 DynamoDB 中建立的**customer**表。

步驟2

單擊**建立專案**。

步驟3

單擊**儲存**按鈕並檢查 AWS Lambda 中提供的電子郵件 ID，檢視 AWS Lambda 是否已傳送郵件。

將 Lambda 函式與計劃事件一起使用

計劃事件應該根據規則集定期發生。計劃事件用於在 CloudWatch 服務中定義的間隔後執行 Lambda 函式。它們最適合與 AWS Lambda 一起處理 cron 作業。本章將透過簡單的示例解釋如何使用計劃事件和 AWS Lambda 每 5 分鐘傳送一次郵件。

先決條件

將 Lambda 函式與計劃事件一起使用的要求如下：

使用 AWS SES 驗證電子郵件 ID
建立角色以使用 AWS SES、CloudWatch 和 AWS Lambda
建立 Lambda 函式以傳送電子郵件
從 AWS CloudWatch 新增計劃事件規則

示例

我們將要考慮的示例將向 AWS Lambda 函式新增 CloudWatch 事件。CloudWatch 將根據附加到它的時間模式觸發 AWS Lambda。例如，在下面的示例中，我們使用了 5 分鐘作為觸發器。這意味著每 5 分鐘，AWS Lambda 將被觸發，並且 AWS Lambda 將在每次觸發時傳送郵件。

相同的基本框圖如下所示：

使用 AWS SES 驗證電子郵件 ID

登入 AWS 並轉到 AWS SES 服務，如下所示：

現在，單擊**簡單電子郵件**服務，如圖所示：

單擊左側的**電子郵件地址**，如圖所示：

它顯示一個**驗證新的電子郵件地址**按鈕。點選它。

輸入您要驗證的**電子郵件地址**。單擊**驗證此電子郵件地址**按鈕。您將在該電子郵件 ID 上收到來自 AWS 的郵件，電子郵件主題為：Amazon Web Services – 美國東部（弗吉尼亞北部）地區的電子郵件地址驗證請求

單擊郵件中提供的連結以驗證電子郵件地址。驗證後，它將顯示電子郵件 ID，如下所示：

建立角色以使用 AWS SES、CloudWatch 和 AWS Lambda

您還可以建立一個角色，該角色允許使用這些服務。為此，請轉到 IAM 並選擇角色。新增所需的策略並建立角色。請注意，此處建立的角色是**帶有 lambda 的事件**。

建立 Lambda 函式以傳送電子郵件

您必須按照步驟使用 nodejs 作為執行時建立 Lambda 函式。

現在，新增觸發器到 Lambda，如圖所示：

新增**CloudWatch Events 觸發器**的詳細資訊，如下所示：

請注意，事件將根據建立的規則觸發器每 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: ["xxxxxxxt12@gmail.com"]
      },
      Message: {
         Body: {
            Text: {
               Data: "this mail comes from aws lambda event scheduling"
            }
         },
         Subject: {
            Data: "Event scheduling from aws lambda"
         }
      },
      Source: "coxxxxxx@gmail.com"
   };
   console.log('===SENDING EMAIL===');
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
      else {
         console.log("===EMAIL SENT===");
         console.log("EMAIL CODE END");
         console.log('EMAIL: ', email);
         context.succeed(event);
         callback(null, "email is send");
      }
   });
};

現在，我們需要 AWS SES 服務。您可以使用如下所示的程式碼新增它：

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

為了從**nodejs**傳送郵件，我們建立了一個**eParams**物件，其中包含例如**示例郵件、收件人郵件 ID**和**帶有訊息的主體**等詳細資訊，如下所示：

var eParams = {
   Destination: {
      ToAddresses: ["xxxxxxxx12@gmail.com"]
   },
   Message: {
      Body: {
         Text: {
            Data: "this mail comes from aws lambda event scheduling"
         }
      },
      Subject: {
         Data: "Event scheduling from aws lambda"
      }
   },
   Source: "coxxxxxx@gmail.com"
};

傳送電子郵件的 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 分鐘從 AWS Lambda 傳送郵件。

將 Lambda 函式與 Amazon SNS 一起使用

Amazon SNS 是一種用於推送通知的服務。在本章中，我們將透過一個示例解釋 AWS Lambda 和 Amazon SNS 的工作原理，在這個示例中，我們將執行以下操作：

在 SNS 服務中建立主題並使用 AWS Lambda 將主題新增到 CloudWatch
向提供的電話號碼傳送 SNS 文字訊息。

先決條件

要建立 SNS 服務中的主題並使用 AWS Lambda 將主題新增到 CloudWatch，我們無需按照以下步驟操作：

在 SNS 中建立主題
在 IAM 中建立角色以進行許可權設定
建立 AWS Lambda 函式
釋出到主題以啟用觸發器
檢查 CloudWatch 服務中的訊息詳細資訊。

要向提供的電話號碼傳送 SNS 文字訊息，我們需要執行以下操作：

在 AWS Lambda 中新增程式碼以向您的手機發送訊息。

示例

在此示例中，我們將在 SNS 中建立一個主題。當在要釋出的主題中輸入詳細資訊時，AWS Lambda 將被觸發。主題詳細資訊記錄在 CloudWatch 中，AWS Lambda 將向手機發送訊息。

這是一個解釋相同內容的基本框圖：

在 SNS 中建立主題

您必須按照以下步驟在 SNS 中建立主題：

步驟1

登入 AWS 控制檯並轉到 Amazon 中的 SNS 服務，如下所示：

步驟2

單擊**簡單通知**服務並單擊其中的**建立主題**。

步驟3

然後，您必須單擊**建立新主題**按鈕，如圖所示：

步驟4

輸入**主題名稱**和**顯示名稱**，然後單擊**建立主題**。您應該在顯示屏中看到主題名稱，如下所示：

在 IAM 中建立角色以進行許可權設定

要建立用於與 AWS Lambda 和 SNS 服務一起工作的角色，我們需要登入到 AWS 控制檯。然後，從 Amazon 服務中選擇 IAM，然後從左側單擊角色，如下所示。

請注意，我們已添加了 SNS、Lambda 和 CloudWatch 的策略。新增角色名稱並單擊“建立角色”按鈕以完成角色建立過程。

建立 AWS Lambda 函式

在本節中，讓我們瞭解如何使用 nodejs 作為執行時建立 AWS Lambda 函式。

為此，請登入 AWS 控制檯，並從 AWS 服務中選擇 AWS Lambda。新增函式名稱、角色詳細資訊等，並建立 AWS Lambda 函式，如圖所示。

新增 SNS 觸發器

要新增 SNS 觸發器，請輸入 SNS 配置詳細資訊，如圖所示：

然後，選擇**SNS 主題**並向 AWS Lambda 函式**新增**觸發器，如圖所示：

然後，新增下面給出的 AWS lambda 程式碼：

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 中建立了主題。我們現在將在主題中釋出，並在 CloudWatch 中檢視將由 AWS Lambda 觸發的詳細資訊：

釋出到主題

首先選擇您要釋出的主題的名稱。單擊**釋出到主題**按鈕：

輸入**主題**和**訊息**詳細資訊，如下所示：

您還可以選擇**JSON**訊息格式以**JSON**樣式傳送。單擊螢幕末尾的**釋出訊息**按鈕。

在 CloudWatch 服務中檢查訊息詳細資訊

登入 AWS 控制檯並開啟 CloudWatch 服務。單擊左側的日誌，然後選擇建立的 AWS Lambda 函式的日誌。您可以找到如下所示的日誌顯示，其中包含上面建立的訊息：

在 AWS Lambda 中新增程式碼以向您的手機發送訊息

我們將使用 SNS 文字訊息透過 AWS Lambda 向手機發送訊息。您可以使用以下程式碼更新 AWS Lambda 程式碼，如下所示：

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

我們添加了 AWS SDK 和 SNS 服務以用於傳送訊息。來自 SNS 的事件訊息將作為文字訊息傳送到提供的電話號碼。

例如，請注意以下程式碼：

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

現在輸入主題以檢視 CloudWatch 中的訊息和上面提供的電話號碼。

單擊**釋出訊息**以釋出訊息。您將在提供的電話號碼上看到一條訊息，如下所示：

將 Lambda 函式與 CloudTrail 一起使用

AWS CloudTrail是亞馬遜提供的一項服務，用於記錄AWS控制檯中所有活動。它記錄所有API呼叫並存儲歷史記錄，這些記錄可用於後續的除錯目的。請注意，我們無法從CloudTrail觸發Lambda函式。CloudTrail將所有歷史記錄以日誌的形式儲存在S3儲存桶中，我們可以從S3觸發AWS Lambda函式。每當向S3儲存桶新增任何日誌時，只要需要處理任何日誌，AWS Lambda函式就會被觸發。

先決條件

在開始使用AWS CloudTrail、S3和AWS Lambda之前，您需要執行以下操作：

建立S3儲存桶以儲存CloudTrail日誌
建立SNS服務
在CloudTrail中建立一個跟蹤，並分配S3儲存桶和SNS服務
建立具有許可權的IAM角色。
建立AWS Lambda函式
AWS Lambda配置

示例

讓我們來看一個示例，該示例演示了AWS CloudTrail、S3和AWS Lambda的工作原理。在這裡，我們將建立一個S3儲存桶，用於儲存在AWS控制檯中進行的任何互動的所有日誌。讓我們建立一個SNS主題併發布它。對於此操作，日誌將作為檔案輸入到S3中。AWS Lambda函式將被觸發，並使用Amazon SES服務傳送郵件。

解釋此過程的框圖如下所示：

建立S3儲存桶以儲存CloudTrail日誌

轉到AWS控制檯並單擊S3服務。單擊建立儲存桶並輸入要儲存CloudTrail日誌的儲存桶名稱，如下所示：

注意，這裡我們建立了一個名為cloudtraillogsaws的S3儲存桶來儲存日誌。

建立SNS服務

轉到AWS控制檯並單擊簡單通知服務。從左側選擇主題，然後單擊“建立新主題”按鈕。

我們建立了一個名為displaytrail的主題來發布主題。其詳細資訊將儲存在上面建立的S3儲存桶中。

在Cloudtrail中建立一個跟蹤，並分配S3儲存桶和SNS服務

轉到AWS控制檯，從管理工具中單擊CloudTrail服務，如下所示：

從左側單擊跟蹤，如下所示：

單擊建立跟蹤按鈕。輸入跟蹤名稱，將跟蹤應用於所有區域選擇為是。然後日誌將應用於所有區域。

對於讀/寫事件，選擇全部。新增S3儲存桶和SNS主題詳細資訊，如下所示。您可以在此處建立一個新的，也可以新增一個現有的。

請注意，可以選擇加密日誌檔案、啟用日誌檔案驗證、為每個日誌檔案交付傳送SNS通知等。這裡我使用了預設值。您可以允許檔案加密，系統會要求您提供加密金鑰。新增詳細資訊後，單擊“建立跟蹤”按鈕。

建立具有許可權的IAM角色

轉到AWS控制檯並選擇IAM。建立一個具有S3、Lambda、CloudTrail和SES（用於傳送電子郵件）許可權的角色。建立的角色如下所示：

建立 AWS Lambda 函式

轉到AWS服務並單擊Lambda服務。新增函式名稱，選擇執行時為nodejs，並選擇為Lambda函式建立的角色。以下是建立的Lambda函式。

AWS Lambda配置

接下來，我們需要將S3新增為建立的AWS Lambda函式的觸發器。

新增S3儲存桶詳細資訊以新增觸發器，並新增以下AWS Lambda程式碼：

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

請注意，我們正在從事件中獲取S3儲存桶和日誌詳細資訊，並使用SES服務傳送郵件，如上所示。

每當在AWS控制檯中發生任何活動時，日誌都會發送到S3儲存桶，同時AWS Lambda函式也會被觸發，並將郵件傳送到程式碼中提到的電子郵件ID。

請注意，您可以在AWS Lambda中根據您的需求處理日誌。

將Lambda函式與Amazon Kinesis一起使用

AWS Kinesis服務用於捕獲/儲存來自網站點選、日誌、社交媒體Feed的即時跟蹤資料。我們可以觸發AWS Lambda函式來對這些日誌執行其他處理。

先決條件

開始使用Kinesis和AWS Lambda的基本要求如下所示：

建立具有所需許可權的角色
在Kinesis中建立資料流
建立AWS Lambda函式。
將程式碼新增到AWS Lambda
將資料新增到Kinesis資料流

示例

讓我們做一個示例，在這個示例中，我們將觸發AWS Lambda函式來處理來自Kinesis的資料流，並使用接收到的資料傳送郵件。

解釋此過程的簡單框圖如下所示：

建立具有所需許可權的角色

轉到AWS控制檯並建立一個角色。

在Kinesis中建立資料流

轉到AWS控制檯並在Kinesis中建立資料流。

共有4個選項，如下所示。在本例中，我們將使用“建立資料流”。

單擊建立資料流。在下面給出的Kinesis流名稱中輸入名稱。

輸入資料流的分片數。

分片的詳細資訊如下所示：

輸入名稱並單擊底部的建立Kinesis流按鈕。

請注意，流需要一些時間才能變為活動狀態。

建立 AWS Lambda 函式

轉到AWS控制檯並單擊Lambda。建立AWS Lambda函式，如下所示：

單擊螢幕末尾的建立函式按鈕。將Kinesis新增為AWS Lambda函式的觸發器。

將配置詳細資訊新增到Kinesis觸發器：

新增觸發器，然後向AWS Lambda新增程式碼。

向AWS Lambda新增程式碼

為此，我們將使用nodejs作為執行時。Kinesis資料流觸發AWS Lambda函式後，我們將傳送郵件。

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: ["xxxxxxx@gmail.com"]
      },
      Message: {
         Body: {
            Text: {
               Data:payload
            }
         },
         Subject: {
            Data: "Kinesis data stream"
         }
      },
      Source: "cxxxxxxxxx@gmail.com"
   };    
   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");
      }
   });
};

event引數包含在Kinesis資料流中輸入的資料。一旦在Kinesis資料流中輸入資料，上述AWS Lambda程式碼就會被啟用。

將資料新增到Kinesis資料流

在這裡，我們將使用AWS CLI向Kinesis資料流新增資料，如下所示。為此，我們可以使用以下命令：

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

然後，AWS Lambda函式被啟用，併發送郵件。

將Lambda函式與自定義使用者應用程式一起使用

我們可以使用AWS Lambda函式透過以下兩種方式處理使用者應用程式生成的事件：

使用 AWS 控制檯
使用AWS CLI

使用 AWS 控制檯

在AWS控制檯中，我們將使用事件和AWS Lambda。為此，請轉到AWS控制檯並建立一個Lambda函式。

接下來，讓我們新增AWS Lambda函式的程式碼：

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

請注意，在上面的程式碼中，我們使用event列印名稱和地址。

事件的詳細資訊將使用如下建立的測試事件提供：

現在，儲存事件並進行測試。

相應的日誌輸出如下所示：

使用AWS CLI

我們可以使用AWS CLI如下呼叫上述函式：

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

事件詳細資訊提供給payload，輸出儲存在C:\clioutput\outputfile.txt中，如下所示：

input.txt

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

使用AWS CLI呼叫Lambda函式時，您可以看到輸出如下所示：

同樣，如果您想測試任何其他AWS服務的AWS Lambda函式，您可以使用AWS控制檯和AWS CLI中的測試事件來進行測試。SNS服務的示例事件如下所示：

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

讓我們新增上面顯示的示例事件並對其進行測試，如下所示：

在AWS Lambda中，程式碼將列印SNS訊息，如下例所示：

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

讓我們使用AWS CLI呼叫相同的函式。讓我們將事件儲存在檔案中，並使用顯示的命令將其用於payload：

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

將AWS Lambda@Edge與CloudFront一起使用

Lambda@Edge是AWS Lambda計算服務的補充，用於自定義CloudFront交付的內容。

顯示AWS Lambda與AWS CloudFront一起工作的框圖如下所示：

AWS Lambda函式可以有四種使用方式：

檢視者請求-終端使用者向CloudFront發出請求，稱為檢視者請求
源請求-CloudFront將請求轉發到源
源響應-CloudFront從源接收響應
檢視者響應-CloudFront將響應傳送給檢視者

我們可以將Lambda@Edge用於以下目的：

更改請求和響應時間的標頭。
將cookie詳細資訊新增到標頭。根據請求和響應進行AB測試。
根據標頭詳細資訊將URL重定向到另一個站點。
我們可以從標頭中獲取使用者代理，並找出瀏覽器、作業系統等的詳細資訊。

先決條件

要開始使用CloudFront和Lambda@Edge，我們需要以下內容：

建立包含檔案詳細資訊的S3儲存桶
建立允許使用CloudFront和Lambda@Edge的角色
建立CloudFront分發
建立Lambda函式
將Lambda函式詳細資訊新增到CloudFront
在瀏覽器中檢查CloudFront URL

我們將使用CloudFront和Lambda@Egde做一個示例，在這個示例中，我們將託管頁面並在檢測到桌上型電腦和裝置時更改響應。

建立包含檔案詳細資訊的S3儲存桶

登入到AWS控制檯，在S3中建立一個儲存桶，並新增要顯示的.html檔案。

單擊S3和建立儲存桶，如下所示：

現在，單擊建立儲存桶按鈕並新增儲存桶的詳細資訊，如下所示：

單擊建立按鈕並將.html檔案上傳到其中。

建立角色

轉到AWS控制檯並單擊IAM。

現在，單擊角色->建立角色按鈕，如下所示：

選擇S3、Lambda和Cloudfront的許可權。最好透過使用ARN詳細資訊來建立策略，該策略只允許對所需函式和儲存進行操作。

在下面討論的示例中，我們顯示了完全訪問許可權。為角色名稱role for cloudfront新增的策略如上所示。單擊“建立角色”。

Lambda@edge和CloudFront所需的所有策略如上所示。這裡還有一個額外的步驟需要完成，因為在CloudFront的情況下，URL將在區域之間可用，並且它需要我們在使用的服務之間的信任關係。

現在，對於建立的角色，單擊信任關係選項卡，如下所示：

單擊編輯信任關係，如下所示：

它顯示一個策略文件。我們需要在主體->服務中新增我們計劃使用的其他服務。最終的信任關係策略文件如下所示：

單擊更新信任策略按鈕以儲存更改。

建立CloudFront分發

轉到CloudFront服務，如下所示：

單擊CloudFront服務，然後單擊建立分發：

源設定、行為設定和分發設定

讓我們逐一瞭解這些設定：

源設定

源設定的各種引數解釋如下：

源域名-這是我們儲存html檔案的S3儲存桶的名稱。我們還可以透過建立我們選擇的資料夾，在S3儲存桶中儲存影像（如果有）。

源路徑-您需要在此處輸入儲存檔案的資料夾名稱。目前，我們沒有這個資料夾，因此我們將暫時將其保留為空。

源ID-選擇源域名後，它將被填充。您可以根據您的選擇更改ID。

限制儲存桶訪問許可權 − 在此步驟中，我們將選擇是。我們需要保護 S3 儲存桶的安全，防止任何人訪問它。此選項下還有一些其他選項，例如源訪問標識、註釋和授予儲存桶讀取許可權。

源訪問標識 − 我們使用了建立新的標識選項。您也可以選擇現有標識。這將建立一個新的標識，CloudFront 使用它來從 S3 儲存桶讀取詳細資訊。

授予儲存桶讀取許可權 − 為此，請選擇是。

源自定義標頭 − 我們將在此處保留標頭為空白，因為我們目前不需要這些詳細資訊。

接下來，讓我們討論並填寫 CloudFront 分發的行為設定 −

現在，選擇協議 – https 或 http，以及快取選項。請注意，預設快取時間為 86400 或 24 小時。您可以根據需要更改此值。

單擊物件快取（自定義選項）以更改快取。如果您的頁面上有任何影片，您可以使用平滑流。在這裡，我們保留預設選項。建立 Lambda 函式後，將新增其詳細資訊。

分發設定的詳細資訊如下所示 −

下面解釋了分發設定的各種引數 −

價格等級 − 它包含使用者流量來源的詳細資訊。請注意，我們在此處選擇了預設選項 - 使用所有邊緣位置。

AWS WAF Web ACL − 用於 Web 應用防火牆選擇。此處，選項為無。首先，我們需要在 AWS 中建立防火牆。它為站點提供安全保護。

備用域名 − 如果您有域名，可以在此處指定。

SSL 證書 − 此處包含所有需要為 SSL 證書選擇的詳細資訊。我們將保留預設值。

預設根物件 − 在此處，我們將指定已上傳到 S3 的檔名。為此，我們需要預設顯示 .html 內容。

對於其餘部分，我們將保留預設設定。

單擊建立分發按鈕以新增分發。

請注意，分發需要一些時間才能顯示已部署狀態。

建立 AWS Lambda 函式

轉到 AWS 控制檯並建立 Lambda 函式。

在 AWS Lambda 程式碼中，我們將獲取請求標頭並檢查使用者代理。如果使用者代理來自桌面，我們將更改響應以顯示訊息為“DESKTOP：歡迎使用 AWS Lambda 和 Cloudfront！”，如果來自移動裝置，訊息將為“移動裝置：來自 Lambda@Edge 的問候！”

相應的 AWS Lambda 程式碼如下所示 −

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

現在，儲存 Lambda 函式。請注意，我們需要釋出 Lambda 函式才能將其與所有區域一起使用。要釋出，我們需要執行以下操作 −

從“操作”下拉選單中，選擇釋出新版本，如下所示 −

如果單擊釋出新版本，將顯示以下螢幕 −

現在，輸入版本說明並單擊釋出。ARN 將顯示建立的 AWS Lambda 函式的版本，如下所示 −

將 CloudFront 觸發器新增到建立的新版本，如下所示 −

現在，新增 CloudFront 的配置詳細資訊。CloudFront 事件具有檢視器請求、源請求、源響應和檢視器響應選項。

接下來，選擇之前建立的 CloudFront 分發。從事件中，我們將選擇檢視器請求。根據檢視器請求，將確定來自使用者代理的桌面/裝置，並更改響應。接下來，新增觸發器詳細資訊。

新增觸發器後，我們需要等待 CloudFront 的分發部署。

狀態更改為已部署後，我們可以測試 CloudFront url 並檢查瀏覽器中的域名。

桌面瀏覽器中的顯示如下所示。在這裡，我們列印了來自檢視器請求事件的使用者代理。

這是在移動裝置上的顯示。

因此，在上面的示例中，我們使用了 Lambda@Edge 來更改桌面和移動裝置上的響應。

使用Cloudwatch監控和故障排除

在 AWS Lambda 中建立的函式由 Amazon CloudWatch 監控。它有助於記錄觸發 Lambda 函式時對其發出的所有請求。

假設以下程式碼已上傳到 AWS Lambda，函式名稱為lambda and cloudwatch。

exports.handler = (event, context, callback) => {
   // TODO implement
   console.log("Lambda monitoring using amazon cloudwatch");    
   callback(null, 'Hello from Lambda');
};

測試或觸發函式時，您應該在 CloudWatch 中看到一個條目。為此，請轉到 AWS 服務並單擊 CloudWatch。

從左側選擇日誌。

單擊日誌後，它包含您帳戶中建立的 AWS Lambda 函式的日誌組。選擇任何 AWS Lambda 函式並檢查詳細資訊。在這裡，我們指的是名為：lambdaandcloudwatch 的 Lambda 函式。此處顯示新增到 Lambda 函式的日誌，如下所示 −

現在，讓我們將 S3 觸發器新增到 Lambda 函式，並檢視 CloudWatch 中的日誌詳細資訊，如下所示 −

讓我們更新 AWS Lambda 程式碼以顯示上傳的檔案和儲存桶名稱，如下面的程式碼所示 −

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

現在，在s3storetestlambdaEventbucket中新增檔案，如下所示 −

上傳檔案時，AWS Lambda 函式將被觸發，並且 Lambda 程式碼中的控制檯日誌訊息將顯示在 CloudWatch 中，如下所示 −

如果出現任何錯誤，CloudWatch 會顯示錯誤詳細資訊，如下所示 −

請注意，我們在 AWS Lambda 程式碼中錯誤地引用了儲存桶名稱，如下所示 −

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

事件中的儲存桶名稱引用是錯誤的。因此，我們應該看到 CloudWatch 中顯示的錯誤，如下所示 −

CloudWatch 指標

可以在指標中檢視 Lambda 函式執行的詳細資訊。單擊左側顯示的指標。

Lambda 函式lambdaandcloudwatch 的圖形詳細資訊如下所示 −

它提供了諸如 Lambda 函式執行的持續時間、呼叫次數以及 Lambda 函式的錯誤等詳細資訊。

AWS Lambda – 附加示例

到目前為止，我們已經瞭解了 AWS Lambda 與 AWS 服務一起工作的過程。基於這些知識，讓我們建立一個簡單的使用者登錄檔單，並使用 API 閘道器將資料釋出到 AWS Lambda。AWS Lambda 將從事件或 API 閘道器觸發器獲取資料，並將這些詳細資訊新增到 DynamoDB 表中。

示例

讓我們考慮一個示例，並對其執行以下功能 −

建立 DynamoDB 表
建立使用者登錄檔單
建立 AWS Lambda 和 API 閘道器以使用 AWS SNS 服務向手機發送訊息
建立 AWS Lambda 和 API 閘道器以釋出表單資料並將其插入 DynamoDB 表中
建立 AWS Lambda 和 API 閘道器以從 DynamoDB 表中讀取資料
使用者登錄檔單的最終工作原理

建立 DynamoDB 表

輸入的資料將儲存在 DynamoDB 表中。我們將使用 API 閘道器與 AWS Lambda 共享輸入的資料，之後 AWS Lambda 將在 DynamoDB 中新增詳細資訊。

您可以使用以下詳細資訊在 AWS 控制檯中建立 DynamoDB 表。首先，轉到 AWS 服務並單擊DynamoDB。單擊表以建立表，如下所示 −

您可以使用 ARN 為要與 AWS Lambda 一起使用的 DynamoDB 建立策略。

轉到 IAM 並選擇策略。單擊建立策略，選擇服務為 DynamoDB，如下所示 −

單擊所有 DynamoDB 操作，如上所示。選擇資源並輸入表的 ARN，如下所示 −

現在，單擊新增，如下所示。

如果您單擊螢幕末尾的檢視策略按鈕，則會看到以下視窗 −

輸入策略名稱並單擊頁面末尾的建立策略按鈕。現在，我們需要建立要與 Lambda 一起使用的角色。我們需要 DynamoDB、APIGateway 和 Lambda 的許可權。

轉到 AWS 服務並選擇 IAM。從左側選擇角色並新增所需的角色。

輸入角色名稱並單擊建立角色。建立的角色為roleforlambdaexample。

建立使用者登錄檔單

這是使用者登錄檔單的顯示，用於輸入和從 dynamodb 表中讀取資料。

建立 AWS Lambda 和 API 閘道器以使用 SNS 服務向手機發送 OTP 訊息

如果您看到使用者登錄檔單，則有一個驗證手機按鈕。使用者應該輸入電話號碼並單擊驗證手機按鈕來驗證電話號碼。

為此 −

當用戶單擊此按鈕時，將呼叫包含電話詳細資訊的 API 閘道器 POST 方法，並在內部觸發 AWS Lambda。

然後，AWS Lambda 使用 AWS SNS 服務向輸入的電話號碼傳送 OTP。

使用者收到 OTP 並必須輸入此 OTP 號碼。

輸入 OTP 的文字框將在輸入電話號碼並單擊驗證手機按鈕後出現。

從 AWS Lambda 收到的 OTP 和使用者輸入的 OTP 必須匹配，才能允許使用者提交使用者登錄檔單。

這裡顯示了一個簡單的框圖，解釋了電話驗證的工作原理 −

建立的 AWS Lambda 函式如下所示 −

相應的 AWS Lambda 程式碼如下所示 −

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

請注意，我們正在使用 SNS 服務傳送 OTP 程式碼。此程式碼用於驗證使用者在使用者登錄檔單中輸入的手機號碼。為上述電話驗證建立的 API 閘道器如下所示 −

給定的 Lambda 函式為phonevalidationexample。我們在此處獲取手機詳細資訊以在 AWS Lambda 內部使用。然後，AWS Lambda 將 OTP 程式碼傳送到指定的手機號碼。

建立 AWS Lambda 和 API 閘道器以釋出表單資料並將其插入 DynamoDB 表中

對於使用者登錄檔單，所有欄位都是必填項。進行了一個 AJAX 呼叫，其中表單中輸入的資料被髮布到 API 閘道器 URL。

這裡顯示了一個簡單的框圖，解釋了提交按鈕的工作原理 −

填寫表單後，提交按鈕將呼叫API閘道器，觸發AWS Lambda。AWS Lambda將從事件或API閘道器獲取表單詳情，並將資料插入DynamoDB表。

讓我們瞭解API閘道器和AWS Lambda的建立。

首先，進入AWS服務並點選Lambda。建立的Lambda函式如下所示：

現在，要建立API閘道器，請轉到AWS服務並選擇**API閘道器**。點選下面顯示的**建立API**按鈕。

輸入**API名稱**，然後點選**建立API**按鈕新增API。

現在，建立了一個名為**registeruser**的API。選擇API並點選**操作**下拉選單以建立**資源**。

點選**建立資源**。現在，讓我們新增**POST**方法。為此，點選左側建立的資源，然後從**操作**下拉選單中選擇**建立方法**。這將顯示如下所示的下拉選單：

選擇POST方法並新增我們上面建立的Lambda函式。

點選**儲存**按鈕新增方法。要將表單詳情傳送到Lambda函式**lambdaexample**，我們需要新增**整合請求**，如下所示：

要釋出表單詳情，您需要點選**整合請求**。它將顯示以下詳情。

點選**正文對映模板**將要釋出的表單欄位新增到其中。

接下來，點選**新增對映模板**並輸入內容型別。這裡，我們添加了**application/json**作為內容型別。點選它，您需要在此處以JSON格式輸入欄位，如下所示：

現在，點選**儲存**按鈕並部署API，如下所示：

這是為POST建立的API，將在我們的.html檔案中使用。請注意，我們需要為建立的資源啟用CORS。我們將使用API閘道器URL進行AJAX呼叫，因此必須啟用CORS。

選擇要啟用CORS的方法。點選**啟用CORS並替換現有CORS標頭**。

它將顯示如下確認螢幕：

點選**是，替換現有值**以啟用CORS。

POST API閘道器的AWS Lambda程式碼如下所示：

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

AWS Lambda處理程式中的event引數將包含之前在POST整合請求中新增的所有詳細資訊。來自event的詳細資訊將新增到DynamoDB表中，如程式碼所示。

現在，我們需要從AWS-SDK獲取服務詳情，如下所示：

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

建立AWS Lambda和API閘道器以從DynamoDB表讀取資料

現在，我們將建立一個AWS Lambda函式來從DynamoDB表讀取資料。我們將觸發APIGateway到AWS Lambda函式，該函式將資料傳送到html表單。

建立的AWS Lambda函式如下所示：

相應的AWS Lambda程式碼如下：

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

這裡從DynamoDB表讀取資料並提供給回撥函式。現在，我們將建立APIGateway並將AWS Lambda函式新增為觸發器。

我們將GET方法新增到之前建立的API。

新增的Lambda函式為**lambdareaddataexample**。點選**儲存**儲存方法並部署api。

使用者登錄檔單的最終工作原理

表單的最終顯示如下所示：

現在，輸入上面顯示的詳細資訊。請注意，提交按鈕被停用。只有當所有詳細資訊都輸入完畢後，它才會啟用，如下所示：

現在，輸入手機號碼並點選**驗證手機**按鈕。它將顯示一條警報訊息，提示**“OTP已傳送到手機，請輸入OTP繼續”**。傳送到手機號碼的OTP如下：

輸入OTP和其餘詳細資訊並提交表單。

提交後，DynamoDB **registeruser** 表中的資料如下所示：

程式碼詳情如下：

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();
});

到目前為止，我們已經對建立的API進行了AJAX呼叫，併發布瞭如上所示的資料。

向表中新增資料的AJAX呼叫如下：

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

請注意，要讀取資料，會呼叫一個函式，其程式碼如下：

function getdata() {
   var a = 0;
   $.ajax({
      type:'GET',
      url:posturl,				
      success: function(data) {
         $("#displaydetails").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);
      }
   });
}

當您點選手機號碼驗證按鈕時，將呼叫以下程式碼併發送手機號碼：

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

列印頁面