---

AWS Lambda – 快速指南

AWS Lambda – 概述

AWS Lambda 是一种执行无服务器计算的服务，即无需任何服务器即可进行计算。代码根据 AWS 服务中事件的响应执行，例如在 S3 存储桶中添加/删除文件、更新 Amazon dynamo dB 表、来自 Amazon API 网关的 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 支持的任何语言上传 AWS lambda 代码，即 NodeJS、Java、Python、C# 和 Go。

步骤 2 − 这些是可以触发 AWS lambda 的少数 AWS 服务。

步骤 3 − AWS Lambda 包含上传代码和触发事件的详细信息。例如，来自 Amazon S3、Amazon API Gateway、Dynamo dB、Amazon SNS、Amazon Kinesis、CloudFront、Amazon SES、CloudTrail、移动应用程序等的事件。

步骤 4 − 仅在以下场景下由 AWS 服务触发时执行 AWS Lambda 代码，例如 −

• 用户在 S3 存储桶中上传文件
• http get/post 端点 URL 被命中
• 在 dynamo dB 表中添加/更新/删除数据
• 推送通知
• 数据流收集
• 网站托管
• 发送电子邮件
• 移动应用程序等。

步骤 5 − 请记住，AWS 仅在 AWS lambda 代码执行时收费，而不是否则。

使用 AWS Lambda 的优势

当您使用 AWS Lambda 时，它提供了多种好处。本节将详细讨论这些好处 −

轻松使用代码

AWS Lambda 为您提供了上传代码的基础设施。它负责维护代码并在发生所需事件时触发代码。它允许您选择代码所需的内存和超时。

AWS Lambda 还可以根据事件触发器执行并行请求。

日志配置

AWS Lambda 提供代码执行次数、执行时间、内存消耗等详细信息。AWS CloudWatch 收集所有日志，有助于了解执行流程和代码调试。

根据使用情况计费

AWS Lambda 计费基于内存使用情况、发出的请求和执行，以最低 100ms 的增量计费。因此，对于 500ms 的执行，计费将每 100ms 一次。如果您指定 AWS lambda 代码在 500ms 内执行，并且执行时间仅为 200ms，则 AWS 将仅向您收取所花费的时间，即 200ms 的执行时间，而不是 500ms。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。它为您提供 1 年的免费服务。查看 AWS 免费套餐提供的免费服务。

使用 AWS Lambda 的缺点

尽管 AWS Lambda 具有许多优点，但它仍存在以下缺点 −

• 它不适合小型项目。

• 您需要仔细分析您的代码并确定内存和超时。如果您的函数需要的时间超过分配的时间，它将根据其上指定的超时终止，并且代码将无法完全执行。

• 由于 AWS Lambda 完全依赖 AWS 的基础设施，因此如果您的代码需要，您无法安装任何其他软件。

触发 AWS Lambda 的事件

可以触发 AWS Lambda 的事件如下 −

• 进入 S3 对象
• 在 Dynamo DB 表中插入、更新和删除数据
• 从 SNS 推送通知
• 对 API 网关的 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 网关和 AWS Lambda

API 网关可以在 GET/POST 方法上触发 AWS Lambda。我们可以创建一个表单并与 API 网关端点共享详细信息，并将其与 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 用于捕获/存储来自网站点击、日志、社交媒体源的实时跟踪数据，并且 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 位数字输入到您的手机中。这将验证您的号码，您将在创建登录时指定的邮件 ID 中收到邮件激活。

第 7 步

单击邮件链接并输入帐户名称或电子邮件 ID 和密码，然后登录 AWS 服务，如下所示 −

账户名称显示在右上角，如上所示。您现在可以开始使用 AWS Lambda 服务。对于 AWS Lambda 服务，支持的语言包括 NodeJS、Python、Java、C# 和 Go。

安装 Visual Studio 2017

有 2 个与 AWS 兼容的 IDE:Visual Studio 和 Eclipse。在本节中，我们将讨论在 Windows、Linux Mac 上安装 Visual Studio 2017。转到 Visual Studio 的官方网站:https://www.visualstudio.com/downloads/。您可以看到如图所示的欢迎屏幕 −

下载社区版本，即 Visual Studio Community 2017，因为它现在免费供练习使用。安装后，它将引导您完成安装步骤，您需要在其中选择稍后要使用的软件包。您可以选择nodejs、python、c#包以便我们稍后使用。

AWS Toolkit 对 Visual Studio 2017 的支持

安装 Visual Studio 2017 后，您必须按照给定的步骤安装 AWS Toolkit 对 Visual Studio 2017 的支持 −

步骤 1

转到 https://aws.amazon.com/visualstudio/ 并下载 AWS Toolkit for Visual Studio。显示如下图所示 −

请注意，为 Visual Studio 2017 下载的包是 vsix 包。如果您的 Visual Studio 版本在 2013-2015 之间，它将安装 msi 安装程序。单击下载按钮，如下所示。

步骤 2

现在，双击下载的 vsix 包，它将引导您完成安装步骤，如下所示 −

成功安装 Visual Studio 后，您将看到一个窗口，如下所示 −

步骤 3

现在，打开 Visual Studio 2017，您应该会看到来自 AWS 的欢迎页面，如下所示−

请注意，您需要添加访问密钥、密钥和帐号才能开始使用 Visual Studio 中的 AWS 服务。

适用于 NodeJS 的 AWS Lambda BoilerPlate

您可以将其与 visual studio code 一起使用，如下所示。

步骤 1

您可以从官方网站免费下载 Visual studio code:https://www.visualstudio.com/downloads/。 Visual Studio 下载的主页如下所示 −

步骤 2

现在，打开 Visual Studio 代码，如下所示 −

步骤 3

要安装对 AWS 的支持，扩展中提供了 对 nodejs 的支持 选项。您可以搜索 AWS，它将显示以下选项 −

步骤 4

现在，在 nodejs 中安装 AWS Lambda 的样板，如图所示 −

步骤 5

单击存储库并在 Visual Studio 中克隆它，以开始在 Visual Studio 中编写 Lambda 函数。它会将您重定向到我们可以在 Visual Studio 中克隆的此存储库:https://github.com/loganarnett/vscode-lambda-snippets。现在，从 Visual Studio 中的 View 选项打开命令面板。

第 6 步

单击它并选择 git clone，如下所示 −

第 7 步

输入存储库 URL 并根据您的选择在本地保存。按照如下所示创建 index.js 文件以使用 lambda 函数 −

Eclipse IDE 的安装

现在，您必须安装最新的 eclipse Java EE IDE。您可以从 Eclipse 官方网站下载:https://www.eclipse.org/downloads/

AWS Toolkit 对 Eclipse IDE 的支持

安装 Eclipse 后，执行以下步骤 −

步骤 1

从菜单中转到帮助，然后单击安装新软件。

步骤 2

输入 https://aws.amazon.com/eclipse，在对话框顶部标有 Work with 的文本框中输入。

步骤 3

现在，从下面显示的列表中选择所需的 AWS Core Management Tools 和其他可选项目。

步骤 4

现在，单击 Next。 Eclipse 将引导您完成下面给出的后续步骤中给出的剩余安装步骤。

步骤 5

AWS 核心模块显示在下面的网格中，如下面的屏幕截图所示 −

步骤 6

安装后，AWS 工具将在 Eclipse 中可用，如下所示 −

步骤 7

单击 Amazon服务。

现在，单击 AWS Explorer 查看可用的服务。我们将在接下来的章节中讨论如何使用已安装的 IDE。

AWS Lambda – 简介

AWS Lambda 是一种无需任何服务器即可计算代码的服务。它被称为无服务器计算。代码是根据 AWS 服务中事件的响应执行的，例如在 S3 存储桶中添加/删除文件、更新 Amazon DynamoDBtables、来自 Amazon Api 网关的 HTTP 请求等。

AWS Lambda 代码可以用 NodeJS、Java、C#、Python 和 Go 编写。本章将详细介绍如何在 AWS 控制台中创建 AWS Lambda 函数。

AWS 控制台

通过链接 https://aws.amazon.com/console 登录 AWS 控制台。登录后，它会将您重定向到显示 AWS 服务的屏幕。

示例:创建函数

让我们借助示例了解 AWS 控制台的功能。单击 Lambda(上面标记)，它将重定向到创建函数，如下所示 −

单击 创建函数 按钮，屏幕显示以下详细信息 −

请注意，默认情况下，选项为 从头开始创作。此选项允许您从头开始编写 Lambda 代码。它将只具有一个带有 hello world 消息的简单函数。

第二个选项 Blue prints 具有以下详细信息。

它提供了已使用 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。Actions 具有以下详细信息 −

现在，输入您想要授予 DynamoDB 的 访问级别。然后，资源 将显示以下详细信息 −

现在，选择表资源类型。您可以看到以下输出 −

对于表的权限，您需要添加 ARN。ARN 是 AWS DynamoDB 中创建的表所独有的详细信息。在 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，它是 filename.export 函数，现在是 index.lambda 处理程序。

上传 .ZIP 文件

您可以先编写代码，将其压缩，然后选择 上传 .ZIP 文件 上传 zip 文件。

从 Amazon S3 上传文件

您可以在 S3 存储桶中上传文件，然后选择选项 从 Amazon S3 上传文件。

请注意，对于 .ZIP 和 S3，无法更改运行时。

环境变量

它们采用键值对并与 AWS Lambda 代码共享它们。我们可以在 AWS Lambda 中使用环境变量来存储数据库连接详细信息、用于存储输出的文件详细信息、日志文件详细信息等。

标签

它们是添加到 AWS Lambda 的键值对，以便在跨不同区域使用时更好地组织函数。对于简单的用例，它不是必需的。当创建大量 Lambda 函数时，标记有助于过滤和管理 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 代码

一旦您决定要编写 Lambda 函数的语言，就有两种方法可以部署代码 −

• 直接在 AWS 控制台中编写代码
• 将文件与所有文件和依赖项一起压缩或打包

但是，请记住，必须授予 zip 文件适当的权限。

测试 Lambda 代码

可以在 AWS Lambda 控制台内测试 Lambda 代码的事件。还可以从 AWS cli 和无服务器 cli 测试 Lambda 函数。AWS 控制台还具有事件数据，可在测试 AWS Lambda 函数时用作示例事件。

监控 Lambda 函数

可以使用 AWS CloudWatch 监控 Lambda 函数。我们可以用我们选择的语言添加必要的日志消息，并在 AWS CloudWatch 中看到相同的消息。

要开始编写 Lambda 函数，需要遵循一些模式。以下是编写 Lambda 函数时要遵循的主要核心概念 −

Handler

Handler 是执行开始的 AWS lambda 函数的名称。它出现在 AWS 控制台中，如下所示 −

请注意，我们在此处将默认处理程序更改为其他名称，并在处理程序中更新了相同的名称 −

请注意，调用处理程序的方式与选择为运行时的语言不同。

传递给处理程序的参数

如果您观察处理程序函数，传递的参数是 event、context 和 call back function，如下所示 −

Event参数包含所用触发器的所有详细信息。

Context 参数主要负责 Lambda 函数执行的运行时详细信息。我们可以使用 context 参数与 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 函数时，您可以看到以下输出 −

输出

context 详细信息如下 −

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

请注意，它具有诸如 functionName、memorylimit、requestId 等详细信息。

日志记录

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

Handler 的参数

Handler 是构建 Lambda 函数的主要核心。处理程序需要三个参数:event、context 和 callback。

事件参数

它包含触发事件的所有详细信息。例如，如果我们使用 Lambda 函数在 S3 上触发，事件将包含 S3 对象的详细信息。

上下文参数

它包含上下文的详细信息，例如 Lambda 函数的属性和配置详细信息。

回调函数

它有助于将详细信息返回给调用者。回调的结构如下所示 −

callback(error, result);

回调函数的参数解释如下 −

错误 − 如果在执行 Lambda 函数期间发生任何错误，它将包含详细信息。如果 Lambda 函数成功执行，则可以将 null 作为回调函数的第一个参数传递。

结果 − 这将提供 lambda 函数成功执行的详细信息。如果发生错误，则忽略结果参数。

注意 − 在 AWS Lambda 中，不强制使用回调函数。如果没有回调函数，处理程序将返回 null。

有效的回调签名如下 −

callback(); 		// 它将返回成功，但不向调用者提供任何指示
callback(null); 	// 它将返回成功，但不向调用者提供任何指示
callback(null, "success"); // 它将向调用者返回成功指示
callback(error); 	// 它将向调用者返回错误指示

每当 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 控制台中测试此代码后，您可以观察到以下输出 −

请注意，上述代码的输出是一个承诺对象。它不提供计数，因为计数在 setTimeout 内递增，并且函数调用不会等待 setTimeout 内的执行并返回承诺对象。

如果我们在处理程序函数上使用 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 组名称、超时详细信息等。

下表显示了 context 对象可用的方法和属性列表 −

context 对象可用的方法

上下文对象可用的属性

查看以下示例以更好地了解上下文对象 −

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

在 AWS 控制台中测试此代码后，您可以观察到以下输出 −

在 AWS 控制台中测试此代码后，您可以观察到以下日志输出 −

在 NodeJS 中登录

我们可以使用 console.log 在 NodeJS 中登录。可以从 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) {
   // 此源代码仅抛出错误。
   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 函数之前，我们需要 AWS 工具包对 Eclipse 的支持。有关安装的任何指导，您可以参考本教程中的环境设置章节。

完成安装后，请按照此处给出的步骤 −

步骤 1

打开 Eclipse IDE 并使用 AWS Lambda Java 项目 创建一个新项目。观察下面给出的屏幕截图以便更好地理解 −

步骤 2

选择 下一步 后，它会将您重定向到下面显示的屏幕 −

步骤 3

现在，为输入类型 自定义 创建了一个默认代码。单击完成按钮后，项目将创建，如下所示 −

步骤 4

现在，右键单击您的项目并将其导出。从导出向导中选择Java / JAR文件，然后单击下一步。

步骤 5

现在，如果您单击下一步，系统将提示您将文件保存在目标文件夹中，单击下一步时会询问该文件夹。

保存文件后，返回 AWS 控制台并为 Java 创建 AWS Lambda 函数。

步骤 6

现在，使用上传按钮上传我们创建的.jar文件，如给出的屏幕截图所示以下 −

Java 的处理程序详细信息

处理程序 是 包名称 和 类名称。查看以下示例以详细了解处理程序 −

示例

package com.amazonaws.lambda.demo;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class LambdaFunctionHandler implements RequestHandler {
   @Override
   public String handleRequest(Object input, Context context) {
      context.getLogger().log("Input: " + input);

      // TODO: implement your handler
      return "Hello from Lambda!";
   }
}

从上面的代码可以看出，处理程序将是 com.amazonaws.lambda.demo.LambdaFunctionHandler

现在，让我们测试更改并查看输出 −

Java 中的上下文对象

使用上下文与 AWS Lambda 执行进行交互。它提供了以下在 Java 内部使用的方法 −

现在，让我们更新上面给出的代码，并观察上面列出的某些方法的输出。观察下面给出的示例代码以获得更好的理解 −

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("日志消息")

CloudWatch 中也有同样的功能。为此，转到 AWS 服务，选择 CloudWatchservices 并单击 日志。

现在，如果您选择 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()+"
");
      logger.log("Memory Allocated: " + context.getMemoryLimitInMB()+"
");
      logger.log("Time remaining in milliseconds: " + context.getRemainingTimeInMillis()+"
");
      logger.log("Cloudwatch group name " + context.getLogGroupName()+"
");
      logger.log("AWS Lambda Request Id " + context.getAwsRequestId()+"
");
      
      // TODO: implement your handler
      return "Hello from Lambda!";
   }
}

上述代码将为您提供以下输出 −

CloudWatch 中的输出将如下所示 −

Java 中 Lambda 函数的错误处理

本节将解释如何在 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 为 Error from AWS Lambda。此外，ErrorType 和 stackTrace 提供了有关错误的更多详细信息。

上述代码的输出和相应的日志输出将如以下屏幕截图所示 −

AWS Lambda – Python 中的函数

在本章中，我们将在 Python 中创建一个简单的 AWS Lambda 函数，并详细了解其工作概念。

在继续在 AWS 中创建 Lambda 函数之前，我们需要 AWS 工具包对 Python 的支持。为此，请按照下面给出的步骤操作并观察附加的相应屏幕截图 −

步骤 1

登录 AWS 控制台并创建 Lambda 函数，并选择 Python 为语言。

步骤 2

现在，单击创建函数按钮并输入在 Python 中创建简单 AWS Lambda 的详细信息。此代码返回消息 Hello from Lambda using Python，如下所示 −

步骤 3

现在，保存更改并测试代码以查看输出。当您使用 UI 中的测试按钮在 AWS 控制台中测试它时，您应该会看到以下输出和日志。

步骤 4

现在，您可以在任何编辑器或 Python IDE 中编写代码。在这里，我们使用 Visual Studio Code 来编写代码。您稍后应该压缩文件并在 AWS 控制台中上传。

在这里，我们压缩了代码并使用它 AWS 控制台。

步骤 5

现在，选择上传 .ZIP 文件选项，如下所示 −

Python 的处理程序详细信息

请注意，处理程序必须是文件的名称，后跟函数的名称。在上述情况下，我们的文件名是 hellopython.py，函数名称是 my_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 中的 Context 对象

Context 对象提供详细信息，例如 Lambda 函数的名称、剩余时间(以毫秒为单位)、请求 ID、云监视组名称、超时详细信息等。

下表显示了 context 对象上可用的方法和属性 −

让我们看一个输出上下文详细信息的 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"

此操作的输出将如下面的屏幕截图所示 −

Python 中 Lambda 函数的错误处理

在本节中，让我们看一个实际示例，该示例展示了如何在 Python 中处理错误。观察此处给出的代码片段 −

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

日志显示如下图所示 −

AWS Lambda – Go 语言函数

Go 语言支持是 AWS 的最新功能。要使用 Go，您需要在创建 AWS Lambda 函数时从 AWS 控制台中选择语言。在本章中，让我们详细了解 Go 语言中的 AWS Lambda 函数。

安装 Go

首先，我们需要 Go 语言支持。在本节中，我们将介绍以下详细信息，以开始使用 Go 中的 AWS Lambda。这是 Go 下载的官方网站:https://golang.org/dl/

现在，根据操作系统下载软件包。按照此处给出的步骤在相应的操作系统上安装 Go。

在 Windows 上安装

请注意，对于 Windows，有 32 位和 64 位下载可供下载。下载 zip 文件并解压内容并将其存储在您选择的目录中。

添加 ControlPanel ---> System ---> 中可用的环境变量高级系统设置。

现在，单击环境变量按钮并添加目录路径，如下所示 −

您还可以编辑系统变量，如下所示 −

完成这些步骤后，您应该可以开始使用 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 中，build 给出可执行文件时返回的程序。以下是支持 AWS Lambda 的 Go 简单程序。我们需要导入 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() {
    // 使处理程序可用于 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 程序开始执行的地方。从主调用到 lambda.start，使用处理程序函数调用执行。请注意，要添加的处理程序将是 main。

观察此处的代码以了解 −

func main() {
    // 使处理程序可用于 AWS Lambda 的远程过程调用
    lambda.Start(hello)
}

按照下面给出的屏幕截图进行操作 −

现在，保存该函数并进行测试。您可以看到此处显示的执行结果。

相应的日志输出将如下所示 −

Go 中的 Context 对象

Go 中的 AWS Lambda 为上下文提供了以下全局变量和属性。

• MemoryLimitInMB − aws lambda 中配置的内存限制(以 MB 为单位)。

• FunctionName − aws lambda 函数的名称。

• FunctionVersion − 执行的 aws lambda 函数的版本。

• LogStreamName − cloudwatch 日志流名称。

• LogGroupName − cloudwatch 组名称。

上下文中可用的属性如下所示 −

AwsRequestID

这是调用 AWS Lambda 函数时获得的 AWS 请求 ID。

ClientContext

这包含通过 AWS Mobile SDK 调用时有关客户端应用程序和设备的详细信息。它可以为空。客户端上下文提供客户端 ID、应用程序标题、版本名称、版本代码和应用程​​序包名称等详细信息。

InvokedFunctionArn

调用的函数的 ARN。不合格的 ARN 执行 $LATEST 版本，别名执行它指向的函数版本。

身份

它提供有关与 AWS 移动 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() {
   // 使处理程序可用于 AWS Lambda 的远程过程调用
   lambda.Start(hello)
}

我们需要导入 log 和 lambda 上下文 才能在 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() {
   // 使处理程序可用于 AWS Lambda 的远程过程调用
   lambda.Start(hello)
}

相同的输出如下所示 −

检查 CloudWatch 中的日志

您还可以在 CloudWatch 中查看日志。为此，请转到 AWS 服务并选择 cloudwatch，然后单击左侧的 Logs。现在，在列表中搜索 Lambda 函数以查看日志 −

函数错误

您可以使用错误模块在 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() {
   // 使处理程序可用于 AWS Lambda 的远程过程调用
   lambda.Start(hello)
}

上面显示的代码的输出如下所示 −

AWS Lambda – C# 中的函数

本章将详细介绍如何在 C# 中使用 AWS Lambda 函数。在这里，我们将使用 Visual Studio 编写代码并将其部署到 AWS Lambda。有关安装 Visual Studio 和将 AWS 工具包添加到 Visual Studio 的任何信息和帮助，请参阅本教程中的简介一章。完成 Visual Studio 的安装后，请按照以下步骤操作。请参阅相应的屏幕截图以更好地理解 −

步骤 1

打开 Visual Studio 并按照步骤创建新项目。单击文件 -> 新建 ->项目。

步骤 2

现在，将显示以下屏幕，您可以在其中选择 AWS Lambda for Visual C#。选择 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 函数的起点。

字符串输入 −处理程序 字符串输入 的参数包含所有事件数据，例如 S3 对象、API 网关详细信息等。

ILambdaContext 上下文 − ILamdaContext 是一个具有上下文详细信息的接口。它包含 lambda 函数名称、内存详细信息、超时详细信息等详细信息。

Lambda 处理程序可以同步和异步方式调用。如果以同步方式调用(如上所示)，则可以获得返回类型。如果是异步，则返回类型必须为 void。

现在，让我们部署 AWS Lambda C# 并进行测试。右键单击项目，然后单击发布到 AWS Lambda，如下所示 −

填写函数名称，然后单击下一步。显示的下一个屏幕是高级函数详细信息，如下所示 −

输入角色名称、内存和超时。详细信息请注意，我们在这里选择了现有角色，并使用了 128MB 的内存和 10 秒的超时时间。完成后，单击 Upload 以发布到 AWS Lambda 控制台。

上传 AWS Lambda 函数后，您可以看到以下屏幕。单击 Invoke 以执行创建的 AWS Lambda 函数。目前，它显示错误，因为它需要根据编写的代码进行一些输入。

现在，让我们输入一些示例输入并再次 Invoke。请注意，我们在这里已在输入框中输入了一些文本，单击 invoke 时，相同的文本将以大写显示在响应部分中。日志输出显示在下方 −

现在，让我们检查 AWS 控制台以查看是否已创建该函数，因为我们已经从 Visual Studio 部署了该函数。

上面创建的 Lambda 函数是 使用 csharp 的 aws lambda，并且它在 AWS 控制台中显示如下屏幕截图所示 −

处理程序签名

处理程序是 AWS 执行的起点。处理程序的名称应定义为 −

ASSEMBLY::TYPE::METHOD

签名的详细信息解释如下 −

ASSEMBLY − 这是为创建的应用程序创建的 .NET 程序集的名称。它基本上是创建项目的文件夹的名称。

TYPE − 这是处理程序的名称。它基本上是命名空间.classname。

METHOD −这是函数处理程序的名称。

处理程序签名的代码如下所示。 −

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

// Assembly 属性使 Lambda 函数的 JSON 输入能够转换为 .NET 类。
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]

namespace AWSLambda3 {
   public class Function {

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

请注意，此处的程序集为 AWSLamda3，类型为 namespace.classname，即 AWSLambda3.Function，方法为 FunctionHandler。因此，处理程序签名为 AWSLamda3::AWSLambda3.Function::FunctionHandler

C# 中的 Context 对象

Context 对象提供有关 AWS 环境中运行时的有用信息。上下文对象中可用的属性如下表所示 −

示例

在本节中，让我们使用 C# 测试 AWS Lambda 中的一些上述属性。观察下面给出的示例代码 −

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Amazon.Lambda.Core;
// Assembly 属性使 Lambda 函数的 JSON 输入能够转换为 .NET 类。
[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+"");
         context.Logger.Log("RemainingTime: " + context.RemainingTime+"");
         LambdaLogger.Log("LogGroupName: " + context.LogGroupName+"");            
      }
   }
}

在 C# 中调用上述代码时，您可以观察到的相关输出如下所示 −

在 AWS Console 中调用上述代码时，您可以观察到的相关输出如下所示 −

使用 C# 进行日志记录

对于日志记录，您可以使用两个函数 −

• context.Logger.Log

• LambdaLogger.Log

观察以下示例显示在这里 −

public void FunctionHandler(ILambdaContext context) {
LambdaLogger.Log("函数名称:" + context.FunctionName+"");
context.Logger.Log("剩余时间:" + context.RemainingTime+"");
LambdaLogger.Log("LogGroupName:" + context.LogGroupName+"");
}

上面给出的代码的相应输出显示在此处 −

您可以从 CloudWatch 获取日志，如下所示 −

C# 中 Lambda 函数的错误处理

本节讨论 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 您的函数名称 --
region 您的函数所在的区域 --memory-size 内存量 --
profile admin 用户

此处显示 AWS Lambda 函数 myfirstlambdafunction 在 AWS 控制台中的相应输出。观察内存从 128MB 更改为 256MB。

最大执行时间

超时是分配给 AWS Lambda 函数在发生超时时终止的时间。AWS Lambda 函数将在分配的时间内运行，如果超过给定的超时，则终止。您需要评估函数执行所需的时间，并在 AWS 控制台的 配置 选项卡中选择相应的时间，如下所示 −

IAM 角色

创建 AWS Lambda 函数时，需要分配角色或权限。如果您需要 AWS Lambda for 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

现在，单击 Test 按钮。这将提供 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 都会被触发。

观察以下屏幕截图，其中显示 S3 触发器已添加到 AWS Lambda −

步骤 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 //将显示文件的名称

您必须使用以下命令获取存储桶名称 −

event.Records[0].s3.bucket.name //将提供存储桶的名称。

您必须使用以下命令来获取 EventName −

event.Records[0].eventName // 将显示事件名称

步骤 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 存储桶中上传文件:测试存储桶触发器。更新 Lambda 使用的角色以获取 S3 和 SES 策略(发送邮件)的权限。这将更新 AWS Lambda 代码以发送邮件，以查看触发器是否正常工作 −

更新后的 AWS Lambda 代码如下所示 −

var aws = require('aws-sdk');
var ses = new aws.SES({
   region: 'us-east-1'
});
exports.lambdahandler = function(event, context, callback) {
   var eParams = {
      Destination: {
         ToAddresses: ["coxxxxxxx@gmail.com"]
      },
      Message: {
         Body: {
            Text: {
               Data: "Bucket name: "+event.Records[0].s3.bucket.name+"  File name:"+event.Records[0].s3.object.key
            }
         },
         Subject: {
            Data: "S3 and AWS Lambda"
         }
      },
      Example: "coxxxxxx@gmail.com"
   };
   console.log('===SENDING EMAIL===');
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
         else {
            console.log("===EMAIL SENT===");
            console.log("EMAIL CODE END");
            console.log('EMAIL: ', email);
            context.succeed(event);
            callback(null, "email is send");
         }
   });
};

对应的截图如下 −

第 19 步

现在，上传文件并检查 AWS Lambda 代码中提供的邮件 ID −

使用 AWS CLI 创建和部署

AWS CLI 是一个命令行工具，可帮助您使用 AWS 服务。我们可以使用它来创建、更新、删除和调用 AWS Lambda 函数。在本章中，您将详细讨论 AWS CLI 的安装和使用。

AWS CLI 的安装

本节将指导您在各种操作系统上安装 AWS CLI。按照给出的步骤操作，并观察所附的相应屏幕截图。

对于 Windows

检查您的 Windows 配置并选择以下链接之一安装 AWS CLI MSI −

• 对于 Windows 64 位 − 适用于 Windows (64 位) 的 AWS CLI MSI 安装

• 适用于 Windows 32 位 − 适用于 Windows (32) 的 AWS CLI MSI 安装

选择相应的链接并单击它后，您可以找到一个窗口，如下所示 −

接下来，设置 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 的命令参考。

现在，让我们逐一详细讨论这些命令。

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 (string) − 这将获取函数的名称。名称可以是 64 位字符。

--runtime(string) − 在这里您需要指定运行时环境，即语言选择。运行时的详细信息如下所示 −

--role(字符串) − 这将是 lambda 策略的名称，即赋予 lambda 函数访问其他服务的角色。它将具有根据指定角色的权限。

--handler(字符串) − 这是 lambda 代码执行将从其开始的处理程序的名称。

• 对于 nodejs，处理程序名称是我们导出的模块名称。
• 对于 java，它是 package.classname :: handler 或 package.classname
• 对于 python，处理程序是文件的名称。

--code(结构) −AWS Lambda 代码

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

--timeout(整数) − timeout 将具有 lambda 函数必须终止执行的时间。默认值为 3 秒。

--memory-size(整数) − 这是分配给 aws lambda 函数的内存。AWS 将根据给定的内存分配 CPU 和内存分配量。

--environment(结构) − 它是一个包含 aws lambda 函数中所需的环境详细信息的对象。

例如:变量 = {Name1 = 字符串，Name2 = 字符串}

--kms-key-arn(字符串) − 这是用于加密环境变量的亚马逊资源名称 (ARN)。如果未提供，则将采用默认设置进行加密。

--zip-file (blob) − 包含代码详细信息的 zip 文件的路径。

--cli-input-json (string):根据提供的 JSON 字符串执行服务操作。JSON 字符串遵循 --generate-cli-skeleton 提供的格式。如果在命令行上提供了其他参数，CLI 值将覆盖 JSON 提供的值。

现在，让我们使用运行时作为 nodejs 创建一个简单的 AWS Lambda 函数并添加一些要打印的 console.log。

考虑一个示例代码来理解相同的内容 −

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

现在，压缩文件并将其存储为 awscli.zip。

获取 ARN

对于角色，让我们使用我们创建的现有角色中的 arn。要获取 ARN，您必须按照此处显示的步骤操作。观察附加的相应屏幕截图 −

步骤 1

转到 IAM 并从 角色 中选择所需的角色。角色的 ARN 详细信息显示如下。在 aws cli 中将 Role ARN 与 create-function 结合使用。

请注意，此处的角色 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(string) − 可选。需要显示函数的区域。

--function-version(string) − 可选。这将提供函数版本。

--max-items(integer) − 可选。这将根据指定的值提供项目。

--cli-input-json(string) − 可选。将根据提供的 json 文件执行操作。

带有值 list-functions 的命令如下 −

aws lambda list-functions --max-items 3

该命令显示详细信息如下 −

get-function

此 api 将提供函数的详细信息以及使用 create-function 上传的 zip 文件的 url 链接。带有 zip 详细信息的 url 仅在 10 分钟内有效。

包含的命令

以下是与此 api 相关的命令 −

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

包含的选项

--function-name − AWS Lambda 函数的名称。您还可以指定函数的 Amazon 资源名称。

--qualifier(string) − 可选。函数版本可用于获取函数的详细信息。

带有 get-function 值的命令是 −

aws lambda get-function --function-name awslambdausingcli

命令显示详细信息如下 −

它提供已上传邮政编码的 url。在上述情况下，url 为−

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

get-function-configuration

这将提供 AWS Lambda 函数的配置详细信息。

以下是与此 api 一起使用的命令 −

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

以下是与

一起使用的选项

--function-name (string) − aws lambda 函数的名称。您还可以指定函数的 Amazon 资源名称。

--qualifier(string) − 可选。函数版本可用于获取函数的详细信息。

带有 get-function 值的命令是 −

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

该命令显示详细信息如下 −

get-account-settings

此 api 提供账户设置。

涉及的命令

您可以与此 api 一起使用的命令是 −

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

涉及的选项

您可以将以下选项与此 api 一起使用 −

--cli-input-json(string) − 根据提供的 json 字符串执行服务。

--generate-cli-skeleton(string) − 它打印 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 (string) − 可选。需要更新角色的 ARN。

--handler (string) − 可选。aws lambda 函数的处理程序详细信息。

--description(string) − 可选。函数的描述。

--timeout(integer) − 可选。aws lambda 函数终止所需的时间。

--memory-size(integer) − 可选。这是分配给 aws lambda 函数的内存。AWS 将根据给定的内存分配 CPU 和内存分配量。

--environment(结构)− 可选。它是一个包含 aws lambda 函数中所需的环境详细信息的对象。

例如:变量 Variables = {Name1 = string，Name2 = string}

--runtime(string)− 在这里您需要指定运行时环境，即语言选择。

运行时的详细信息显示在下表中 −

--cli-input-json (string) − 可选。这将按照提供的 json 字符串中指定的方式对 api 执行操作。

--generate-cli-skeleton (string) − 可选。这将输出所有详细信息的 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(string) − aws lambda 函数的名称

--zip-file (blob) − 可选。包含要更新的代码的 zip 文件的路径。

--s3-bucket(string) − 可选。包含已上传代码的 zip 文件的 S3 bucket 名称。

--s3-key(string) − 可选。必须上传的 AWS s3 对象密钥名称。

--s3-object-version (string) − 可选。 AWS s3 对象版本。

--cli-input-json (string) − 可选。这将按照提供的 json 字符串中指定的操作对 api 执行操作。

--generate-cli-skeleton (string) − 可选。这将输出所有详细信息的 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(string) − 这将采用 lambda 函数名称或 aws lambda 函数的 arn。

--qualifier (string) − 这是可选的。您可以在此处指定需要删除的 aws lambda 版本。

-- cli-input-json(string) − 根据提供的 JSON 字符串执行服务操作。JSON 字符串遵循 --generate-cli-skeleton 提供的格式。如果在命令行上提供了其他参数，CLI 值将覆盖 JSON 提供的值。

--generate-cli-skeleton(string) − 它会将 json 骨架打印到标准输出，而无需发送 API 请求。

您可以将以下命令与值一起使用以实现此目的 −

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

现在，请注意，该函数不会出现在 AWS Lambda 函数列表中 −

使用无服务器框架创建和部署

可以使用无服务器框架创建和部署 AWS Lambda。它允许您创建 AWS Lambda 触发器，并通过创建所需的角色来部署触发器。无服务器框架允许以更简单的方式处理大型项目。所需的事件和资源都写在一个地方，只需几个命令即可在 AWS 控制台上部署完整功能。

在本章中，您将详细了解如何开始使用 AWS 无服务器框架。

使用 npm install 安装无服务器框架

首先，您需要先安装 nodejs。您可以按如下方式检查 nodejs −

您必须使用以下命令使用 npm 包安装 serverless −

npm install -g serverless

npm 完成后，执行 serverless 命令，该命令显示用于创建和部署 AWS Lambda 函数的命令列表。观察下面给出的屏幕截图 −

您也可以使用 sls 代替 serverless。 sls 是 serverless 的简写命令。

如果您需要有关命令 sls 的帮助，您可以使用以下命令 −

sls create --help

要创建 serverless 框架，您必须遵循以下步骤 −

步骤 1

要开始使用 serverless 框架，我们需要添加凭证。通过此操作，您可以在 AWS 控制台中首先按如下方式添加用户 −

步骤 2

单击下一步:权限按钮添加权限。您必须将现有策略或管理员访问权限附加到此用户。

步骤 3

单击创建用户以添加用户。它将显示我们配置无服务器框架所需的访问密钥和密钥 −

配置 AWS 无服务器框架

让我们看看如何配置 AWS 无服务器框架。您可以使用以下命令实现此目的 −

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

请注意，输入的凭据的详细信息，即访问密钥和密钥存储在文件 /aws/credentials中。

首先，创建一个文件夹，用于存储项目文件。

接下来，我们将在aws-serverless文件夹中开始工作。

使用无服务器创建 AWS Lambda框架

现在，让我们使用下面给出的步骤创建一个带有无服务器框架的 Lambda 函数 −

步骤 1

以下是无服务器 create 命令的详细信息 −

步骤 2

现在，我们需要分配模板，如下所示 −

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

步骤 3

我们将使用 aws-nodejs 模板来创建我们的第一个使用无服务器框架的项目。相同目的的命令如下所示 −

sls create --template aws-nodejs

请注意，此命令为模板 aws-nodejs 创建了一个样板。

步骤 4

现在，打开在 IDE 中创建的文件夹。这里我们使用 Visual Studio 代码，文件夹结构如下 −

步骤 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);

   // 如果您不使用 LAMBDA-PROXY 集成的 http 事件，请使用此代码
   // callback(null, { message: 'Go Serverless v1.0! Your function executed successfully!', event });
};

此文件 Serverless.yml 具有无服务器框架的配置详细信息，如下所示−

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

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

provider:
 name: aws
 runtime: nodejs6.10

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

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

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

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

functions:
 hello:
   handler: handler.hello

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

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

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

现在，我们需要根据我们的要求在 serverless.yml 文件中添加更改。您可以使用下面给出的命令 −

您可以对 Service 使用以下命令 −

service: aws-nodejs # 注意:使用您的服务名称更新此项

现在，在此处更改服务并添加我们文件夹的名称，如下所示 −

service: aws-serverless # 注意:使用您的服务名称更新此项

提供商详细信息如下所示 −

provider:
   name: aws
   runtime: nodejs6.10

提供商是 aws，运行时是 nodejs6.10。我们需要添加我们将在其中工作的 region 和 stage，即项目的 dev 或 prod 环境。因此，以下是更新后的 provider:provider 详细信息 −

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"

使用无服务器框架部署 AWS Lambda

让我们将上述 lambda 函数部署到 AWS 控制台。您可以使用以下步骤实现此目的 −

步骤 1

首先，您必须使用以下命令 −

 sls deploy

步骤 2

现在，您应该在 AWS 控制台中看到该函数，如图所示。无服务器 AWS 的详细信息记录在 AWS 云形成中。为此，请转到 AWS 服务并选择 CloudFormation。AWS Lambda 的详细信息显示如下 −

请注意，给出的名称是项目名称，后跟使用的阶段。

步骤 3

它为 AWS Lambda 创建 iam 角色，为 AWS cloudwatch 创建日志组。创建了 S3 存储桶，其中存储了代码详细信息和配置详细信息。

这是由命令 sls deploy 创建的。您无需指定 iam 角色，而是在 部署 阶段默认创建该角色。

第 4 步

云形成服务中显示了事件的详细流程。

AWS Lambda 代码

AWS Lambda 代码及其执行设置显示在下面的屏幕截图中 −

测试 Lambda 函数时，您可以找到以下输出 −

上述函数的日志输出显示在此处 −

我们还可以使用无服务器命令测试 AWS Lambda 函数，如下所示 −

sls invoke --function hello

此处显示调用命令的语法 −

slsinvoke --function hello

此调用命令触发 AWS Lambda 函数并在命令提示符中显示输出，如下所示 −

您还可以在部署之前测试 Lambda 函数，并使用以下命令测试相同的命令 −

slsinvoke local --function hello

请注意，由于无法在本地环境中模拟 S3 和 DynanoDB 等资源，因此并不总是可以在本地进行测试。只能在本地测试基本函数调用。

将 API 网关和 AWS Lambda 与无服务器框架结合使用

让我们看看如何创建新项目以使用 Lambda 和 api 网关。您可以使用以下命令实现此目的 −

sls create --template aws-nodejs

现在，在可视化代码中打开 aws-api 项目。您可以看到已创建 handler.js 和 serverless.yml 文件。让我们在其中进行更改以添加 api 网关。

您必须在 serverless.yml 中进行以下更改 −

现在，添加了使用 AWS Lambda 激活 api 网关的事件详细信息 −

这里添加了一个名为 events 的新内容。我们已将事件指定为 http，以及其路径和方法。

路径是创建 api 网关路径时将使用的端点，使用的方法是 GET。

请注意，处理程序是 handler.hello，hello 是来自 handler.js 的导出名称。

请注意，您不必在此处部署 api 网关，因为无服务器框架将执行它。

现在，我们将运行 sls deploy 命令来创建以触发器为 api 网关 的 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 为空，因为查询字符串中没有传递任何内容。事件详细信息提供给我们在 AWS Lambda 处理程序中指定的 input −

我们从 api 网关获得的输出只有 body 详细信息，例如 message 和 input。响应完全由 api 网关控制，以及如何将其显示为输出。

现在，让我们将输入传递给查询字符串中的 GET url 并查看显示 −

然后您可以看到查询字符串的输出，如下所示 −

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

让我们将 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);
   // 如果您不使用 LAMBDA-PROXY 集成的 http 事件，请使用此代码
   // callback(null, { message: 'Go Serverless v1.0! Your function executed successfully!', event });
};

请注意，我们已根据查询字符串 display message 更改了消息。这将再次部署该函数并检查输出。它显示查询字符串变量显示消息中的详细信息，如下所示。

现在让我们将 post 方法添加到创建的事件中，如下所示 −

现在，部署所做的更改，您可以看到部署命令的以下输出 −

请注意，直接在浏览器中测试帖子网址不会提供详细信息。您应该在 postman 中测试帖子网址。

要获取 postman，请转到 https://www.getpostman.com/apps。根据您的操作系统下载应用程序。安装后，您应该能够测试您的帖子网址，如下所示 −

这将显示我们在 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:
odeproject\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 用于异步响应。

• 当您想要验证 Lambda 函数而无需执行它时，请使用 DryRun。

--log-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:
odeproject\outputfile.txt

您可以使用 payload 选项以 json 格式向 lambda 函数发送虚拟事件，如下所示。

相关的 AWS Lambda 代码如下 −

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

观察代码，我们有控制台event.name和event.addr。现在，让我们使用 aws cli 中的 payload 选项发送带有名称和地址的事件，如下所示 −

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

然后，payload 将输入作为具有 json 输入的文件路径，如下所示 −

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

相应的输出如下所示 −

输出存储在文件 C:\clioutput\outputfile.txt 中，如下所示−

"Hello Roy Singh and address is Mumbai"

示例事件

您可以通过传递示例事件来测试 AWS Lambda 函数。本节提供了一些 AWS 服务的示例事件。您可以使用 invoke 命令来测试使用任何服务触发时的输出。请观察下面给出的相应示例事件的代码 −

Amazon S3 Put Sample Event

{
  "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 //将显示文件的名称

要获取存储桶名称，您可以使用以下命令 −

event.Records[0].s3.bucket.name //将提供存储桶的名称。

要查看 EventName，您可以使用以下命令 −

event.Records[0].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 有助于处理在 Simple Notification Service (SNS) 中创建的通知。每当在 SNS 中发布消息时，Lambda 函数都可以通过 SNS 事件触发，该事件包含消息的详细信息。这些消息可以在 Lambda 函数内部处理，并可以根据要求进一步发送到其他服务。

输入消息后，SNS 将触发 Lambda 函数。如果任何错误尝试调用 Lambda 函数，SNS 将重试调用 lambda 函数最多三次。

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 可用于发送消息，也可用于接收消息。收到消息时，可在 Simple Mail Service 上调用 AWS Lambda 函数。

Amazon SES 电子邮件接收示例事件

在 AWS Lambda 中使用时 SES 事件的详细信息如下所示 −

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

Amazon Cloudwatch Logs

可以使用 CloudWatch Logs 订阅 从 Amazon CloudWatch Logs 触发 AWS Lambda。CloudWatch Logs 订阅包含有关日志的实时数据，这些数据可以在 AWS Lambda 内部进行处理和分析，也可以用于加载到其他系统。

Amazon CloudWatch Logs 示例事件

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

Amazon API Gateway

可以在 https url 上调用 AWS Lambda 函数。可以在 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 网关代理响应事件

{
   "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 函数后，之前呈灰色的 Action 下拉菜单现在会突出显示。现在，打开组合框，它将显示如下所示的选项 −

步骤 4

选择 Delete 按钮以删除 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 lambdainvoke --function-name "lambdatestcli" --log-type Tail
C:\demotest\outputfile.txt

此命令将为您提供如下所示的输出 −

步骤 4

您可以从 cloudwatch 中观察日志lambda 函数 lambdatestcli

步骤 5

现在，让我们进入删除 AWS 函数的实际部分。Delete aws cli api 将删除给定的函数。用于此目的的命令的详细信息如下 −

Command

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

选项

--function-name(string) − 这将采用 Lambda 函数名称或 AWS Lambda 函数的 arn。

--qualifier (string) − 这是可选的。您可以在此处指定需要删除的 AWS Lambda 版本。

-- cli-input-json(string) − 根据提供的 JSON 字符串执行服务操作。JSON 字符串遵循 --generate-cli-skeleton 提供的格式。如果在命令行上提供了其他参数，CLI 值将覆盖 JSON 提供的值。

--generate-cli-skeleton(string) −它会将 JSON 框架打印到标准输出，而无需发送 API 请求。

带值的命令

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

相应的输出如下所示 −

第 6 步

如果您现在检查，您会发现该函数不会出现在 AWS Lambda 函数列表中，如下面的屏幕截图所示 −

使用 Amazon API Gateway

可以在 HTTPS URL 上调用 AWS Lambda 函数。可以在 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 网关
• 将数据传递到 api 网关

此处提供了一个解释 API 网关和 AWS Lambda 工作原理的基本图表 −

本章将通过相关屏幕截图进一步详细解释这些流程。

创建 IAM 角色以获取权限

从 Amazon 服务(如下所示)中选择 IAM 以创建 Lambda 函数要使用的角色。

转到 IAM 并从左侧部分选择角色(如下所示)−

单击创建为 Lambda 函数添​​加角色。

选择 Lambda 并单击底部的权限。选择 API 网关和 Lambda 所需的权限。

在搜索中搜索 API 网关，它将列出所有相关权限。这里我们选择了对 API 网关的完全访问权限，如下所示 −

现在，搜索 API 网关，它将列出所有相关权限。这里我们选择了对 API 网关的完全访问权限，如下所示 −

您还必须对策略重复相同的过程。

选择完必要的策略后，单击 Review 进行下一步。根据您的选择输入角色名称，如下所示 −

它显示附加到角色的策略。单击创建角色，我们就完成了角色创建，可以继续执行 lambda 函数了。

创建 AWS Lambda 函数

转到 AWS 服务并单击 lambda 服务以创建一个函数，用于将其与 api 网关连接起来。

Lambda 函数的 UI 屏幕如下所示。单击创建函数按钮继续创建 Lambda 函数。

输入函数名称并选择我们上面创建的现有角色。

它会闪烁一条消息，表示名为 lambdawithapigateway 的函数已成功创建。

请注意，这里我们将使用 nodejs 运行时来编写代码。带有helloworld消息的AWS代码如下所示−

AWS Lambda 代码存在于 index.js 文件中。名为 handler 的函数具有参数，即 events、context 和 callback。

回调函数基本上包含错误和成功消息。请注意，这里我们没有任何与错误相关的代码，因此传递了 null，成功消息是 HelloWorld from lambda.

最后，保存添加的更改，让我们继续将 Lambda 函数添​​加到 API 网关。

创建 API 网关

登录您的 AWS 帐户并打开 API 网关，如下所示 −

单击 API 网关，它将带您进入可以创建新 API 网关的屏幕。

单击 创建 API 并添加详细信息，如下所示 −

单击屏幕右侧的创建 API按钮。这将在屏幕左侧显示新创建的 API。

单击 操作 下拉菜单为 API 创建新资源。

现在，创建一个新资源，如下所示 −

输入 资源名称，如下所示。您将在最后创建的 URL 中看到输入的资源名称。单击创建资源，您将在屏幕上看到如下内容 −

向创建的资源添加 GET/POST 方法，如下所示。从操作下拉菜单中选择方法。

单击GET方法将方法添加到 API。

下一步是将其与 Lambda 函数集成的集成。现在将 Lambda 函数添​​加到其中，如下所示 −

将 Lambda 函数链接到 API 网关

选择之前创建的 lambda 函数。

保存更改，您将看到一个对话框，要求授予权限，如下所示 −

单击确定以获取权限。这是 API 网关 HTTP 请求和 Lambda 函数之间的执行详细信息 −

现在，让我们部署 API 网关更改。为此，我们需要从操作下拉列表中选择部署 API，如下所示 −

选择部署 API。它将询问部署状态。从部署阶段下拉菜单中选择新阶段，并将阶段名称添加为生产。

单击部署按钮，它将重定向到如下所示的 URL −

从左侧选择GET方法以获取 URL。在新选项卡中打开 URL 以查看来自 Lambda 函数的消息。

这是使用 AWS Lambda 和 AWS API 网关的基本示例。在上面的例子中，我们在 Lambda 函数中对消息进行了硬编码。

现在，让我们从 API 网关获取消息详细信息。如果必须从不同的域调用 HTTPS 调用，例如对 API 的 AJAX 调用，我们需要为创建的 API 网关启用 CORS。

选择为 API 创建的源，然后单击 Actions 下拉菜单 −

现在，启用 CORS 将打开以下屏幕 −

您可以使用几种方法来启用 CORS。 Access-Control-Allow-Origin 标记为 *，表示允许从任何域获取 API 网关的内容。

您还可以指定要与 API 配合使用的域名。单击 启用 CORS 并替换现有 CORS 标头 按钮，它将显示确认消息，如下所示 −

单击 是，替换现有值 按钮以启用它。 启用 CORS 屏幕如下所示 −

将数据传递到 API 网关

打开在 API 网关中创建的 API displayhelloworld 如下所示 −

单击 集成请求 发送数据，如下所示 −

选择 Body Mapping Templates 并添加 Content-Type此示例为 application/json。单击添加的内容类型，添加以下详细信息 −

现在，添加 JSON 格式的模板，如下所示 −

请注意，我们已将消息作为参数，以从 API 网关获取数据并将其与 AWS Lambda 共享。获取详细信息的语法如上所示。

现在，部署 API 以使更改在 API 网关 URL 上可用。为此，我们需要更改 Lambda 函数以根据 API 网关 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 并单击 Permission 按钮。

步骤 4

从下面添加权限并单击 Review。

步骤 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);
};

请注意，事件参数包含 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 显示如下所示的选项 −

现在，单击 Create table 以创建如下所示的表。我们将表命名为 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 函数，如下所示。

现在，让我们将 DynamodDB 触发器添加到创建的 AWS Lambda。我们将使用的运行时是 Node.js。

您可以在 Dynamodb 触发器中找到要为 AWS Lambda 配置的以下详细信息 −

现在，只需单击 Add 即可将触发器添加到 AWS Lambda。

AWS Lambda 触发器发送邮件

当数据插入 AWS Lambda 时，AWS Lambda 将被触发。事件参数将插入 dynamodb 数据。这将从事件中读取数据并发送电子邮件。

发送电子邮件

要发送电子邮件，您需要按照以下步骤操作 −

步骤 1

转到 AWS 服务并选择 SES(简单电子邮件服务)。验证我们需要发送电子邮件的电子邮件，如下所示 −

步骤 2

单击按钮 验证新电子邮件地址 以添加电子邮件地址。

步骤 3

输入电子邮件地址进行验证。电子邮件地址将收到来自亚马逊的激活邮件，需要点击激活邮件。激活完成后，电子邮件 ID 已验证，可用于 AWS 服务。

步骤 4

从事件中读取数据并发送电子邮件的 AWS Lambda 代码如下所示 −

var aws = require('aws-sdk');
var ses = new aws.SES({
   region: 'us-east-1'
});
exports.handler = function(event, context, callback) {
   console.log(event);
   let tabledetails = JSON.parse(JSON.stringify(event.Records[0].dynamodb));
   console.log(tabledetails.NewImage.address.S);
   let customerid = tabledetails.NewImage.cust_id.S;
   let name = tabledetails.NewImage.name.S;
   let address = tabledetails.NewImage.address.S;
	
   var eParams = {
      Destination: {
         ToAddresses: ["xxxxx@gmail.com"]
      },
      Message: {
         Body: {
            Text: {
               Data: "The data added is as follows:
 CustomerId:"+customerid+"
 Name:"+name+"
Address:"+address
            }
         },
         Subject: {
            Data: "Data Inserted in Dynamodb table customer"
         }
      },
      Source: "xxxxx@gmail.com"
   };
   console.log('===SENDING EMAIL===');
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
      else {
         console.log("===EMAIL SENT===");
         console.log("EMAIL CODE END");
         console.log('EMAIL: ', email);
         context.succeed(event);
         callback(null, "email is send");
      }
   });
}

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

在 DynamoDB 中添加数据

按照以下顺序在 DynamoDB 中添加数据。

步骤 1

转到 Dynamodb 中创建的表 customer。

步骤 2

单击 Create item。

步骤 3

单击 Save 按钮并检查 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 添加计划事件规则

示例

我们将要考虑的示例将 CloudWatch 事件添加到 AWS Lambda 函数。Cloudwatch 将根据附加到它的时间模式触发 AWS Lambda。例如，在下面的例子中，我们使用 5 分钟作为触发器。这意味着每 5 分钟，AWS Lambda 将被触发一次，并且 AWS Lambda 将在触发时发送邮件。

其基本框图如下所示 −

使用 AWS SES 验证电子邮件 ID

登录 AWS 并转到 AWS SES 服务，如下所示 −

现在，单击简单电子邮件服务，如下所示 −

单击电子邮件地址在左侧显示为 −

它会显示一个按钮验证新电子邮件地址。单击它。

输入您要验证的电子邮件地址。单击验证此电子邮件地址按钮。您将在该电子邮件 ID 上收到来自 AWS 的邮件，邮件主题为:Amazon Web Services – 美国东部(弗吉尼亚北部)地区的电子邮件地址验证请求

单击邮件中提供的链接以验证电子邮件地址。验证后，将显示电子邮件 ID，如下所示 −

创建角色以使用 AWS SES、Cloudwatch 和 AWS Lambda

您还可以创建一个授予使用服务权限的角色。为此，请转到 IAM 并选择角色。添加所需的策略并创建角色。请注意，此处创建的角色是 events with lambda。

创建 Lambda 函数以发送电子邮件

您必须按照以下步骤使用运行时作为 nodejs 创建 Lambda 函数。

现在，将触发器添加到 Lambda，如下所示 −

将详细信息添加到 CloudWatch Events Trigger，如下所示 −

请注意，根据创建的规则触发器，该事件将每 5 分钟触发一次。

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

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

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

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

要从 nodejs 发送邮件，我们创建了 eParams 对象，其中包含诸如 示例邮件、邮件 ID 和 包含消息的正文 之类的详细信息，如下所示 −

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

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

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

现在，让我们保存此 Lambda 函数并检查邮件的电子邮件 ID。下面的屏幕截图显示，每 5 分钟从 AWS Lambda 发送一次邮件。

将 Lambda 函数与 Amazon SNS 结合使用

Amazon SNS 是一种用于推送通知的服务。在本章中，我们将借助一个示例解释 AWS Lambda 和 Amazon SNS 的工作原理，该示例将执行以下操作 −

• 在 SNS 服务中创建主题并使用 AWS Lambda 将主题添加到 CloudWatch

• 向给定的电话号码发送 SNS 短信。

前提条件

要在 SNS 服务中创建主题并使用 AWS Lambda 将主题添加到 CloudWatch，我们无需遵循下面给出的步骤 −

• 在 SNS 中创建主题
• 在 IAM 中创建权限角色
• 创建 AWS Lambda 函数
• 发布到主题以激活触发器
• 检查 CloudWatch 服务中的消息详细信息。

发送 SNS 短信根据给定的电话号码，我们需要执行以下操作 −

• 在 AWS Lambda 中添加代码以将消息发送到您的手机。

示例

在此示例中，我们将在 SNS 中创建一个主题。当在要发布的主题中输入详细信息时，将触发 AWS Lambda。主题详细信息记录在 CloudWatch 中，AWS Lambda 会通过手机发送一条消息。

以下是解释相同内容的基本框图 −

在 SNS 中创建主题

您必须按照以下步骤在 SNS 中创建主题 −

步骤 1

登录 AWS 控制台并转到 Amazon 中的 SNS 服务，如下所示 −

步骤 2

单击 Simple Notification Service 并Create topic它。

步骤 3

然后，您必须单击创建新主题按钮，如下所示 −

步骤 4

输入主题名称和显示名称，然后单击创建主题。您应该在显示中看到主题名称，如下所示 −

在 IAM 中创建权限角色

要创建角色以使用 AWS Lambda 和 SNS 服务，我们需要登录 AWS 控制台。然后，从 Amazon 服务中选择 IAM，然后单击左侧的角色，如下所示。

请注意，我们已经为 SNS、Lambda 和 CloudWatch 添加了策略。添加角色名称并单击创建角色按钮以完成角色创建过程。

创建 AWS Lambda 函数

在本节中，让我们了解如何使用 nodejs 作为运行时创建 AWS Lambda 函数。

为此，登录 AWS 控制台并从 AWS 服务中选择 AWS Lambda。添加函数名称、角色详细信息等，并创建 AWS Lambda 函数，如下所示。

添加 SNS 触发器

要添加 SNS 触发器，请输入 SNS 配置详细信息，如下所示 −

然后，选择 SNS 主题 并 添加 将触发器添加到 AWS Lambda 函数，如下所示 −

然后，添加下面给出的 AWS lambda 代码 −

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

在上面的代码中，event.Records[0].Sns.Message 提供了添加的消息详细信息。我们已添加控制台日志以在 CloudWatch 中查看它们。现在，保存 Lambda 函数以及所需的内存和时间分配。

发布到主题以激活触发器

回想一下，我们已经在步骤 1 中在 SNS 中创建了主题。我们现在将在主题中发布并在 CloudWatch 中查看详细信息，这将由 AWS Lambda − 触发

发布到主题

首先选择要发布的主题的名称。单击发布到主题按钮 −

输入主题和消息详细信息，如下所示 −

您还可以选择JSON消息格式以JSON样式发送。单击屏幕末尾的发布消息按钮。

在 CloudWatch 服务中检查消息详细信息

登录 AWS 控制台并打开 CloudWatch 服务。单击左侧的日志并选择创建的 AWS Lambda 函数的日志。您可以找到以下显示，其中包含如上所示的创建消息的日志 −

在 AWS Lambda 中添加代码以将消息发送到您的手机

这里将使用 SNS 短信通过 AWS Lambda 在手机上发送消息。您可以使用以下代码更新 AWS Lambda 代码，如下所示 −

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

我们添加了 AWS SDK 和 SNS 服务以用于发送消息。来自 SNS 的事件的消息将以短信形式发送到给定的电话号码。

例如，请观察以下代码 −

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

现在输入主题，即可在 cloudwatch 中看到消息和上面给出的电话号码。

单击发布消息以发布消息。您会在给出的电话号码上看到一条消息，如下所示 −

将 Lambda 函数与 CloudTrail 结合使用

AWS CloudTrail 是 Amazon 提供的一项服务，可帮助记录在 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 Bucket 以存储 CloudTrail 日志

转到 AWS 控制台并单击 S3 服务。单击创建存储桶并输入要存储 cloudtrail 日志的存储桶的名称，如图所示 −

请注意，我们在这里创建了一个 S3 存储桶 cloudtraillogsaws 用于存储日志。

创建 SNS 服务

转到 AWS 控制台并单击简单通知服务。从左侧选择主题，然后单击创建新主题按钮。

我们创建了名为 displaytrail 的主题来发布主题。其详细信息将存储在上面创建的 S3bucket 中。

在 Cloudtrail 中创建 Trail 并分配 S3 bucket 和 SNS 服务

转到 AWS 控制台并从管理工具中单击 CloudTrail 服务，如下所示 −

从左侧单击 Trails，如下所示 −

单击Create Trail按钮。输入Trail name(跟踪名称)、Apply trail to allregion(将跟踪应用于所有区域)并选择Yes。这样，日志将应用于所有区域。

对于Read/Write events(读/写事件)，选择All。添加S3 bucket(S3 存储桶)和SNS topic(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+"
Log details:"+event.Records[0].s3.object.key;
   console.log(s3message);
   var eParams = {
      Destination: {
         ToAddresses: ["xxxxxxxxx12@gmail.com"]
      },
      Message: {
         Body: {
            Text: {
               Data:s3message
            }
         },
         Subject: {
            Data: "cloudtrail logs"
         }
      },
      Source: "coxxxxxx@gmail.com"
   };
   var email = ses.sendEmail(eParams, function(err, data) {
      if (err) console.log(err);
      else {
         console.log("===EMAIL SENT===");
         console.log("EMAIL CODE END");
         console.log('EMAIL: ', email);
         context.succeed(event);
         callback(null, "email is send");
      }
   });
};

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

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

请注意，您可以根据需要在 AWS Lambda 中处理日志。

将 Lambda 函数与 Amazon Kinesis 结合使用

AWS Kinesis 服务用于捕获/存储来自网站点击、日志、社交媒体源的实时跟踪数据。我们可以触发 AWS Lambda 对这些日志执行额外的处理。

必备条件

开始使用 Kinesis 和 AWS Lambda 的基本要求如下所示 −

• 创建具有所需权限的角色
• 在 Kinesis 中创建数据流
• 创建 AWS Lambda 函数。
• 向 AWS Lambda 添加代码
• 向 Kinesis 数据流添加数据

示例

让我们来研究一个示例，其中我们将触发 AWS Lambda 来处理来自 Kinesis 的数据流并使用收到的数据发送邮件。

下面显示了一个用于解释该过程的简单框图 −

创建具有所需权限的角色

转到 AWS 控制台并创建角色。

在 Kinesis 中创建数据流

转到 AWS 控制台并在 kinesis 中创建数据流。

如图所示，有 4 个选项。我们将在此示例中创建数据流。

单击创建数据流。在下面给出的 Kinesis 流名称中输入名称。

输入数据流的分片数量。

分片的详细信息如下所示 −

输入名称并单击底部的创建 Kinesis 流按钮。

请注意，流需要一定的时间才能完成处于活动状态。

创建 AWS Lambda 函数

转到 AWS 控制台并单击 Lambda。创建 AWS Lambda 函数，如下所示 −

单击屏幕末尾的创建函数按钮。将 Kinesis 作为触发器添加到 AWS Lambda。

将配置详细信息添加到 Kinesis 触发器 −

添加触发器，现在将代码添加到 AWS Lambda。

将代码添加到 AWS Lambda

为此，我们将使用 nodejs 作为运行时。一旦使用 kinesis 数据流触发 AWS Lambda，我们就会发送邮件。

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

事件参数包含 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);
};

请注意，在上面的代码中，我们使用事件打印名称和地址。

事件的详细信息将使用创建的测试事件给出，如下所示 −

现在，保存事件并进行测试。

相应的日志输出如下所示 −

使用 AWS CLI

我们可以使用 AWS CLI 调用上述函数，如下所示 −

aws lambda 调用--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 调用相同的操作。让我们将事件保存在文件中，并使用显示的命令将其用作有效负载 −

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 文件，您将看到您想要显示的 .html 文件。

单击 S3 和 Create bucket，如下所示 −

现在，单击 Create bucket 按钮并添加存储桶的详细信息，如下所示 −

单击 Create 按钮并在其中上传 .html。

创建角色

转到 AWS 控制台并单击 IAM。

现在，单击 角色 -> 创建角色 按钮，如图所示 −

选择 S3、Lambda 和 Cloudfront 的权限。使用 ARN 详细信息创建仅向所需功能存储授予权限的策略是一种很好的做法。

在下面讨论的示例中，我们显示了 完全访问 权限。如上所示，添加了角色名称 role for cloudfront 的策略。单击创建角色。

lambda@edge 和 cloudfront 所需的所有策略如上所示。这里还有一个额外的步骤需要完成，因为如果是 CloudFront，URL 将跨区域可用，并且需要我们正在使用的服务之间存在信任关系。

现在，对于创建的角色，单击 信任关系 选项卡，如下所示 −

单击 编辑信任关系，如下所示 −

它显示一个策略文档。我们需要在 主体 -> 服务 中添加我们计划使用的其他服务。最终的信任关系策略文档如下所示 −

单击更新信任策略按钮保存更改。

创建 CloudFront 分发

转到 CloudFront 服务，如下所示 −

单击 CloudFront 服务，然后单击创建分发 −

源设置、行为设置和分发设置

让我们先看看这些设置一个 −

Origin Settings

Origin 设置的各种参数解释如下 −

Origin Domain Name − 这是我们存储 html 文件的 S3 bucket 的名称。我们还可以通过创建我们选择的文件夹将图像(如果有)存储在 S3 bucket 中。

Origin Path − 在这里您需要输入存储文件的文件夹的名称。目前，我们没有这个文件夹，所以我们暂时将其保留为空白。

Origin ID − 当选择源域名时，它会被填充。您可以根据自己的选择更改 ID。

限制存储桶访问 − 在此，我们将选择选项 是。在这里，我们需要 S3 存储桶的安全性，以便没有人可以访问 S3 存储桶。对于此选项，还有一些选项，如 源访问身份、注释和授予存储桶的读取权限。

源访问身份 − 我们使用创建新身份选项。您也可以选择现有身份。这将创建一个新身份，CloudFront 会使用该身份从 S3 存储桶中读取详细信息。

存储桶的全面读取权限 − 为此，请选择选项 是。

源自定义标头 − 我们将在此处保留标头为空白，因为我们现在不需要详细信息。

接下来，让我们讨论并填写 Cloudront 分发的 行为设置 −

现在，选择协议 - https 或 http，以及缓存选项。请注意，默认缓存为 86400 或 24 小时。您可以根据需要更改此值。

单击对象缓存(自定义选项)以更改缓存。如果您的页面上有任何视频，您可以使用流畅流式传输。在这里，我们保留默认选项。创建 lambda 函数后，将添加其详细信息。

分发设置的详细信息如下所示 −

下面解释了分发设置的各种参数 −

价格类别 − 它包含用户流量来源等详细信息。请注意，我们在这里选择了默认值 - 使用所有边缘位置

AWS WAF Web ACL − 这是用于 Web 应用程序防火墙选择。在这里，它有 无 选项。首先，我们需要在 AWS 中创建防火墙。它为网站提供安全性。

备用域名 − 您可以在此处指定域名(如果有)。

SSL 证书 − 这包含为 SSL 证书选择的所有详细信息。我们将保留默认值。

默认根对象 − 在这里我们将指定已在 S3 中上传的文件名。为此，我们需要默认显示 .html 中的内容。

其余部分，我们将保留默认设置。

单击 创建分发 按钮添加分发。

请注意，分发需要一些时间才能显示已部署的状态。

创建 AWS Lambda 函数

转到 AWS 控制台并创建 Lambda 函数。

在 AWS Lambda 代码中，我们将获取请求标头并检查用户代理。如果用户代理来自桌面，我们将更改响应以显示消息为"桌面:欢迎使用 Cloudfront 的 AWS Lambda!"，如果是设备，则消息为"移动设备:来自 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 的分发部署。

状态更改为 Deployed 后，我们可以测试 CloudFront url 并在浏览器中检查域名。

桌面浏览器中的显示如下所示。这里我们从查看器请求事件中打印了用户代理。

这是移动设备中的显示。

因此，在上面的例子中，我们使用 Lambda@Edge 来更改桌面和移动设备上的响应。

使用 Cloudwatch 进行监控和故障排除

在 AWS Lambda 中创建的函数由 Amazon CloudWatch 监控。它有助于在触发 Lambda 函数时记录对该函数发出的所有请求。

请考虑以下代码已上传到 AWS Lambda，函数名称为 lambda 和 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 函数执行的详细信息。单击左侧显示的 Metrics。

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 网关以 POST 表单数据并插入 DynamoDb 表中

• 创建 AWS Lambda 和 API 网关以从 Dynamodb 表中读取数据

• 用户注册表单的最终工作

创建 DynamoDB 表

输入的数据将存储在 DynamodDB 中表。我们将使用 API 网关共享使用 AWS Lambda 输入的数据，稍后 AWS Lambda 将在 DynamoDB 中添加详细信息。

您可以使用以下详细信息在 AWS 控制台中创建 DynamodDB 表。首先，转到 AWS 服务并单击 DynamoDB。单击 表 创建表，如下所示 −

您可以使用 ARN 为要与 AWS Lambda 一起使用的 DynamoDB 创建策略。

转到 IAM 并选择 策略。单击创建策略，选择服务为 DynamodDB，如下所示 −

单击所有 DynamoDB操作，如上所示。选择资源并输入表的 ARN，如下所示 −

现在，单击添加，如下所示。

如果您单击屏幕末尾的审核策略按钮，您将看到以下窗口 −

输入策略的名称，然后单击页面末尾的创建策略按钮。现在，我们需要创建要与 Lambda 一起使用的角色。我们需要 DynamoDB、APIGateway 和 Lambda 的权限。

转到 AWS 服务并选择 IAM。从左侧选择角色并添加所需的角色。

输入角色名称并单击创建角色。创建的角色是 roleforlambdaexample。

创建用户注册表单

以下是用户注册表单的显示，用于输入和读取 dynamodb 表中的数据。

创建 AWS Lambda 和 API 网关以使用 SNS 服务向手机发送 OTP 消息

如果您看到用户注册表单，则有一个按钮验证电话。用户需要输入电话号码并点击验证电话按钮来验证电话号码。

为此目的 −

当用户点击此按钮时，将调用包含电话详细信息的 API 网关发布方法，并在内部触发 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 网关获取表单的详细信息，并将数据插入 DynamodDB 表中。

让我们了解 API 网关和 AWS Lambda 的创建。

首先，转到 AWS 服务并单击 Lambda。创建的 Lambda 函数如下所示 −

现在，要创建 API 网关，请转到 AWS 服务并选择 API 网关。单击下面显示的 创建 API 按钮。

输入 API 名称，然后单击 创建 API 按钮添加 API。

现在，创建一个名为 registeruser 的 API。选择 API 并单击 Actions 下拉菜单以创建 Resource。

单击 Create Resource。现在，让我们添加 POST 方法。为此，单击左侧创建的资源，然后从 Actions 下拉菜单中选择 create method。这将显示如下所示的下拉列表 −

选择 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 处理程序中的事件参数将包含之前在 POST 集成请求中添加的所有详细信息。事件的详细信息将添加到 DynamodDB 表中，如代码所示。

现在，我们需要从 AWS-SDK 获取服务详细信息，如下所示 −

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

创建 AWS Lambda 和 API Gateway 以从 DynamodDB 表中读取数据

现在，我们将创建 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 函数作为触发器。

我们将向之前创建的 API 添加 get 方法。

添加的 Lambda 函数是 lambdareaddataexample。单击 Save 以保存方法并部署 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;
   }
}

---