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

步骤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.ac.cn/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: ["[email protected]"]
      },
      Message: {
         Body: {
            Text: {
               Data: "Bucket name: "+event.Records[0].s3.bucket.name+"  File name:"+event.Records[0].s3.object.key
            }
         },
         Subject: {
            Data: "S3 and AWS Lambda"
         }
      },
      Example: "[email protected]"
   };
   console.log('===SENDING EMAIL===');
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
         else {
            console.log("===EMAIL SENT===");
            console.log("EMAIL CODE END");
            console.log('EMAIL: ', email);
            context.succeed(event);
            callback(null, "email is send");
         }
   });
};

相应的屏幕截图如下所示：

步骤19

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

Amazon Cloudwatch 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: ["[email protected]"]
      },
      Message: {
         Body: {
            Text: {
               Data: "The data added is as follows:\n CustomerId:"+customerid+"\n Name:"+name+"\nAddress:"+address
            }
         },
         Subject: {
            Data: "Data Inserted in Dynamodb table customer"
         }
      },
      Source: "[email protected]"
   };
   console.log('===SENDING EMAIL===');
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
      else {
         console.log("===EMAIL SENT===");
         console.log("EMAIL CODE END");
         console.log('EMAIL: ', email);
         context.succeed(event);
         callback(null, "email is send");
      }
   });
}

现在，保存 Lambda 函数和 DynamoDB 表中的数据。

在 DynamoDB 中添加数据

使用以下步骤在 DynamoDB 中添加数据。

步骤1

转到在 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

现在，单击**简单电子邮件**服务，如图所示：

单击左侧的**电子邮件地址**，如图所示：

它显示一个**验证新的电子邮件地址**按钮。点击它。

输入您要验证的**电子邮件地址**。单击**验证此电子邮件地址**按钮。您将在该电子邮件 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: ["[email protected]"]
      },
      Message: {
         Body: {
            Text: {
               Data: "this mail comes from aws lambda event scheduling"
            }
         },
         Subject: {
            Data: "Event scheduling from aws lambda"
         }
      },
      Source: "[email protected]"
   };
   console.log('===SENDING EMAIL===');
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
      else {
         console.log("===EMAIL SENT===");
         console.log("EMAIL CODE END");
         console.log('EMAIL: ', email);
         context.succeed(event);
         callback(null, "email is send");
      }
   });
};

现在，我们需要 AWS SES 服务。您可以使用如下所示的代码添加它：

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

为了从**nodejs**发送邮件，我们创建了一个**eParams**对象，其中包含例如**示例邮件、收件人邮件 ID**和**带有消息的主体**等详细信息，如下所示：

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

发送电子邮件的 Lambda 代码如下：

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

现在，让我们保存此 Lambda 函数并检查电子邮件 ID 的邮件。下图显示了每 5 分钟从 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

步骤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 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: ["[email protected]"]
      },
      Message: {
         Body: {
            Text: {
               Data:s3message
            }
         },
         Subject: {
            Data: "cloudtrail logs"
         }
      },
      Source: "[email protected]"
   };
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
      else {
         console.log("===EMAIL SENT===");
         console.log("EMAIL CODE END");
         console.log('EMAIL: ', email);
         context.succeed(event);
         callback(null, "email is send");
      }
   });
};

请注意，我们正在从事件中获取S3存储桶和日志详细信息，并使用SES服务发送邮件，如上所示。

每当在AWS控制台中发生任何活动时，日志都会发送到S3存储桶，同时AWS Lambda函数也会被触发，并将邮件发送到代码中提到的电子邮件ID。

请注意，您可以在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: ["[email protected]"]
      },
      Message: {
         Body: {
            Text: {
               Data:payload
            }
         },
         Subject: {
            Data: "Kinesis data stream"
         }
      },
      Source: "[email protected]"
   };    
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
      else {
         console.log("===EMAIL SENT===");
         console.log("EMAIL CODE END");
         console.log('EMAIL: ', email);
         context.succeed(event);
         callback(null, "email is send");
      }
   });
};

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

打印页面