CloudFormation-学习指南-全-

CloudFormation 学习指南（全）

原文：annas-archive.org/md5/912446fec9e40bcf8a3a73116fe3a795

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

随着亚马逊 Web 服务（AWS）基础设施逐步向云端迁移，高效管理与云相关的任务仍然是系统管理员面临的一大挑战。CloudFormation 是一种为高效管理 AWS 上的基础设施相关服务而开发的语言，其特点有助于确保 AWS 资源部署过程的安全性。学习 CloudFormation 作为一本基础指南，将开启你与 CloudFormation 的学习之旅。我们将向你介绍基础设施即代码（IaC）和实现自动化与基础设施管理所需的 AWS 服务的基本概念。接着，我们将深入探讨 CloudFormation 映射、条件、限制、输出和 EC2 等概念。在最后几章中，你将使用 CloudFormation 模板管理整个 AWS 基础设施。

本书结束时，你将能够使用 CloudFormation 实现基础设施即代码（IaC）。

本书适用对象

学习 CloudFormation 适用于云工程师、系统管理员、云架构师或任何从事云开发或云管理领域的利益相关者。需要具备 AWS 的基础知识。

本书内容

第一章，介绍 AWS CloudFormation，将介绍 AWS CloudFormation，并解释如何开始使用 AWS CloudFormation。

第二章，构建你的第一个 AWS CloudFormation 项目，将解释如何开始构建第一个 AWS CloudFormation 项目。该项目将通过一步步的实践方法来实施。

第三章，开发 AWS CloudFormation 模板，将探讨如何开发 AWS CloudFormation 模板。读者将学习如何使用 JSON 和 YAML 创建 AWS CloudFormation 模板。还将介绍如何使用 AWS CloudFormation Designer 在 GUI 模式下开发 AWS CloudFormation 模板。

第四章，AWS CloudFormation StackSets，将探讨 AWS CloudFormation StackSets 的基础知识。在本章结束时，读者将了解如何构建和管理 AWS CloudFormation StackSets。

第五章，使用 AWS CloudFormation 构建 Lambda 函数，将带领读者了解如何使用 AWS CloudFormation 部署 Lambda 函数的过程。

第六章，AWS CloudFormation 安全性，将讨论如何保护使用 AWS CloudFormation 部署的资源。

第七章，AWS CloudFormation 的生产基础设施管理与测试，将解释如何使用 AWS CloudFormation 管理和部署测试及生产基础设施。本章不在书中，但可以通过以下链接下载：www.packtpub.com/sites/default/files/downloads/Managing_and_Testing_Production_Infrastructure_for_AWS_CloudFormation.pdf。

最大化本书的使用效果

由于实际示例涉及使用 AWS，因此需要拥有一个 AWS 账户。

下载示例代码文件

你可以从你在 www.packtpub.com 的账户下载本书的示例代码文件。如果你在其他地方购买了本书，你可以访问 www.packtpub.com/support 并注册，将文件直接发送到你的邮箱。

你可以通过以下步骤下载代码文件：

登录或注册 www.packtpub.com。
选择 SUPPORT 标签。
点击代码下载与勘误。
在搜索框中输入书名，并按照屏幕上的指示操作。

文件下载后，请确保使用最新版本的工具解压或提取文件夹：

Windows 的 WinRAR/7-Zip
Mac 的 Zipeg/iZip/UnRarX
Linux 的 7-Zip/PeaZip

本书的代码包也托管在 GitHub 上，网址为 github.com/PacktPublishing/Learn-CloudFormation。如果代码有更新，它将在现有的 GitHub 仓库中进行更新。

我们还有其他来自我们丰富的书籍和视频目录中的代码包可供下载，网址为 github.com/PacktPublishing/。快去看看吧！

下载彩色图像

我们还提供了一份 PDF 文件，包含了本书中使用的截图/图表的彩色图像。你可以在这里下载：www.packtpub.com/sites/default/files/downloads/LearnCloudFormation_ColorImages.pdf。

使用的约定

本书中使用了若干文本约定。

CodeInText：表示文本中的代码词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 用户名。例如：“我们可以使用 CloudFormation 模板中的 Parameters 属性。”

代码块的设置方式如下：

exports.handler = (event, context, callback) => {
    var data = event['msg'];
    callback(null, 'Received: ' + data);
};

当我们希望引起你注意代码块的特定部分时，相关行或项目会以粗体显示：

{
 "Type" : "AWS::S3::Bucket",
 "Properties" : {
 "AccessControl" : String,
 "AccelerateConfiguration" : AccelerateConfiguration,
 "AnalyticsConfigurations" : [ AnalyticsConfiguration, ... ],
 "BucketEncryption" : BucketEncryption,
 "BucketName" : String,
}

任何命令行输入或输出均按如下方式书写：

$ aws cloudformation create-stack --stack-name my-simple-stack 
 --template-body file://home/user/templates/simple-s3.json 
 --parameters YourBucketName=my-simple-s3

粗体：表示一个新术语、一个重要的词或你在屏幕上看到的词。例如，菜单或对话框中的词汇将在文本中这样呈现。以下是一个示例：“在管理控制台中，点击左侧菜单中的 Roles。”

警告或重要提示会像这样出现。

小贴士和技巧会像这样出现。

联系我们

我们总是欢迎读者的反馈。

一般反馈：请通过电子邮件feedback@packtpub.com联系我们，并在邮件主题中注明书名。如果你对本书的任何方面有疑问，请通过questions@packtpub.com与我们联系。

勘误：虽然我们已经尽最大努力确保内容的准确性，但错误仍然可能发生。如果你在本书中发现了错误，我们将非常感激你报告给我们。请访问www.packtpub.com/submit-errata，选择你的书籍，点击勘误提交表单链接，并输入详细信息。

盗版：如果你在互联网上遇到任何形式的我们作品的非法复制，我们将非常感激你提供该位置地址或网站名称。请通过copyright@packtpub.com与我们联系，并提供相关材料的链接。

如果你有兴趣成为作者：如果你在某个领域有专业知识，并且有兴趣撰写或参与书籍的编写，请访问authors.packtpub.com。

评价

请留下评价。当你阅读并使用了这本书后，为什么不在你购买书籍的网站上留下评价呢？潜在的读者可以通过你的公正意见做出购买决定，我们 Packt 团队也能了解你对我们产品的看法，而我们的作者也能看到你对他们书籍的反馈。谢谢！

有关 Packt 的更多信息，请访问packtpub.com。

第一章：介绍 AWS CloudFormation

云技术使 IT 人员能够轻松构建虚拟数据中心，从而能够根据特定配置设置虚拟机。现在，基础设施即代码（IaC）通过脚本化方式构建虚拟数据中心。在本章中，我们将简要介绍 IaC 和 AWS CloudFormation 中的一些术语。

本章将覆盖以下主题：

介绍 IaC
AWS CloudFormation
CloudFormation 模板
CloudFormation 堆栈
CloudFormation StackSets
探索 AWS CloudFormation 控制台

介绍 IaC

云技术使你能够虚拟化管理服务器。我们可以在虚拟模型中设置内存、CPU 和存储。为了基于云平台构建数据中心，你设置你的资源，如虚拟机、虚拟网络和应用程序。有时，你需要重新配置数据中心设计或在其他位置重建它。你可能会执行相同的操作来构建你的数据中心。这些任务可能会让你感到不满。

IaC 可以被描述为一种可编程的基础设施，使你能够使用脚本管理资源配置，并自动化基础设施的提供以及部署。

IaC（基础设施即代码）的设计旨在减少手动配置中导致效率低下的复杂性。你可以将基础设施代码部署到开发、测试、预生产和生产环境。下图展示了 IaC 中的流程：

图 1.1：IaC 中的流程

假设你在几台机器上部署了一些资源，然后由于停电等灾难，一些机器发生故障。从技术上讲，你应该手动部署所有资源。IaC 的设计旨在帮助你自动部署基础设施。IaC 可以在部署现代基础设施时最小化你的风险。

我们可以使用单个 IaC 脚本模板在多个环境中部署基础设施。这种方法使我们能够最小化部署中的问题。我们不需要担心重新部署基础设施，因为我们已经拥有基础设施脚本。

AWS CloudFormation

亚马逊 AWS 是一个基于云的服务平台，提供各种云服务。由于有大量云服务，我们可以部署任何服务器和任何程序用于通用或特定目的。AWS CloudFormation 旨在实现 IaC。你可以编写脚本来构建自定义基础设施。一旦完成，你可以部署一个表示基础设施即代码的模板，用于开发、测试、预生产和生产环境。

AWS CloudFormation 是一个动态基础设施的解决方案。你可以编写自己的基础设施，而无需担心重新配置和重新部署。AWS CloudFormation 允许你在文本文件中建模整个基础设施。这种方法可以标准化你组织中的基础设施资源，并加速故障排除过程。

AWS CloudFormation 帮助构建和重建基础设施和应用程序，无需执行手动操作或编写自定义脚本。

若要了解更多关于 AWS CloudFormation 的信息，可以访问其官方网站 aws.amazon.com/cloudformation/。

您将找到大量信息，例如特性、定价和文档，如以下截图所示：

图 1.2：官方 AWS CloudFormation 网站

目前，AWS CloudFormation 是免费的，但通常在 IaC 脚本中使用的资源不是。您可以在 aws.amazon.com/cloudformation/pricing/ 上查看定价详情。

它是如何工作的？

AWS CloudFormation 提供了从脚本构建基础设施的解决方案。您可以为基础设施设计设置多个资源。一般情况下，请参阅以下流程图了解如何构建 IaC：

图 1.3：构建 AWS CloudFormation 的流程

首先，编写脚本以使用 AWS CloudFormation 构建基础设施；您应该使用 JSON、YAML 或文本编写 IaC 脚本。完成脚本后，您可以将该脚本文件上传到 AWS CloudFormation。您也可以首先将其放在 AWS S3 上，以便 AWS CloudFormation 直接下载。

AWS CloudFormation 为堆栈提供配置，并根据您的脚本创建 AWS 资源。您还可以为您的 CloudFormation 堆栈设置目标区域。

您可以使用单个 CloudFormation 模板在多个区域部署和复制 AWS 资源。如果想要在单个 CloudFormation 模板中处理不同区域的 AWS 资源，我们可以构建 AWS StackSets。

控制 IaC 源脚本

由于我们使用 JSON、YAML 和文本格式编写 IaC，所以可以保存这些脚本文件，并将其存储到源代码控制服务器上。您可以根据需要管理编辑的脚本版本。

您可以使用 Git 管理 IaC 脚本。一旦脚本发布，您可以将它们推送到 AWS CloudFormation 以配置您的 AWS 资源。以下图表显示了使用源代码控制进行 IaC 脚本编写：

图 1.4：使用源代码控制的 IaC 脚本

上述图表描述了如何将源代码控制与 AWS CloudFormation 结合使用。我们在本地计算机上编写 IaC 脚本。完成后，将脚本检入源代码控制服务器。如果您有一个测试团队，团队可以使用 AWS CloudFormation 测试脚本。

CloudFormation 模板

我们可以在 AWS CloudFormation 中轻松开发 IaC。AWS 已经提供了一系列模板供我们设计 IaC。您可以使用 JSON、YAML 和文本编写 AWS CloudFormation 脚本。

例如，我们在 AWS CloudFormation 上使用 AWS S3。我们可以如下使用 JSON 编写 AWS CloudFormation 脚本：

{
 "Resources" : {
   "HelloBucket" : {
    "Type" : "AWS::S3::Bucket",
    "Properties" : {
        "AccessControl" : "PublicRead" 
    }
   }
 }
}

我们还可以使用 YAML 编写这些 IaC 脚本：

Resources:
 HelloBucket:
    Type: AWS::S3::Bucket
    Properties:
      AccessControl: PublicRead

你可以使用 JSON 或 YAML 来编写 IaC 脚本，并且当我们使用这些资源时，你需要学习 AWS CloudFormation API 中包含的参数。

有时候，当我们对 JSON 或 YAML 了解不多时，我们更倾向于以可视化方式构建 AWS CloudFormation。幸运的是，AWS 提供了 AWS CloudFormation 模板设计器。我们可以通过点击和拖动任何资源到编辑器中。你可以在以下截图中看到这一点：

图 1.5：AWS CloudFormation 模板设计器

如果你想在终端模式下工作，AWS 提供了 AWS CLI，它使你能够使用终端构建 AWS CloudFormation 模板。

AWS 还提供了 AWS CloudFormation 模板，因此你无需额外花费精力开发 CloudFormation 模板。你可以在docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-sample-templates.html下载这些模板示例。

我们将在第三章《开发 AWS CloudFormation 模板》中了解更多有关 AWS CloudFormation 模板中 IaC 脚本的内容。我们将使用 JSON 和 YAML 脚本来开发 IaC。我们还将学习如何使用 AWS CloudFormation 模板设计器。

CloudFormation 堆栈

所有你希望在 AWS 环境中构建的资源都应该在 CloudFormation 模板中定义。然后，我们将这个模板放入 CloudFormation 堆栈中。堆栈是一组 AWS 资源，你可以将其作为一个整体进行管理。你可以通过创建、更新或删除堆栈来创建、更新或删除一组资源。

在开发 AWS CloudFormation 堆栈时，确保所有带有 CloudFormation 模板的资源符合 AWS 区域要求。并不是所有区域的资源都相同。如果不符合，你在配置资源时会遇到问题。

有时候，我们在基础设施设计中使用多种资源，比如数据库集群。在这种情况下，我们可以开发 CloudFormation 嵌套堆栈。这意味着我们的 CloudFormation 堆栈由多个堆栈组成。例如，我们绘制了如下图所示的设计。CloudFormation 堆栈由两个堆栈组成：B1 和 B2。在 B1 堆栈 内，我们使用了三个 CloudFormation 堆栈：C1、C2 和 C3。然后，我们在 C3 堆栈 内构建了两个堆栈，如下所示的 AWS CloudFormation 嵌套堆栈模型：

图 1.6：AWS CloudFormation 嵌套堆栈示例模型

为了理解 AWS CloudFormation 堆栈，我们将在第二章《构建你的第一个 AWS CloudFormation 项目》和第三章《开发 AWS CloudFormation 模板》中深入探讨这个话题。我们将回顾一些场景，向你展示如何使用 AWS CloudFormation 堆栈。

CloudFormation StackSets

如果您计划在多个区域部署 AWS 资源，可以使用 CloudFormation StackSet。从技术上讲，CloudFormation StackSet 旨在通过使用单个 AWS CloudFormation 模板，帮助您在多个区域的 AWS 账户中创建 CloudFormation 堆栈。

以下图示展示了 CloudFormation StackSet 的处理模型。在此场景中，如果要执行 StackSet，将生成一个 StackSet 实例。当 StackSet 被创建时，它会根据您的 CloudFormation 模板生成堆栈。由于这是一个 StackSet，AWS 将在其预定义区域内构建堆栈。下图展示了 StackSet 的处理模型：

图 1.7：StackSet 的处理模型

当我们编辑 StackSet 时，AWS CloudFormation 会更新所有堆栈。当我们执行删除 StackSet 的操作时，AWS CloudFormation 会删除与该 StackSet 相关的所有堆栈。

我们将在第四章中深入了解 AWS CloudFormation StackSets。本章将提供一些场景，向您展示 AWS CloudFormation StackSets 的工作原理。

探索 AWS CloudFormation 管理控制台

在本节中，我们将熟悉 AWS CloudFormation 管理控制台。要使用 AWS CloudFormation，您需要一个有效的 AWS 账户。您可以通过打开浏览器并访问 console.aws.amazon.com/cloudformation/ 来访问 AWS CloudFormation 管理控制台。

现在，您应该能看到 AWS CloudFormation 管理控制台，如下截图所示。您可以点击“创建新堆栈”按钮来创建堆栈。如果您想创建一个 StackSet，可以点击“创建新 StackSet”按钮：

图 1.8：AWS CloudFormation 管理控制台

如果您想构建 CloudFormation 脚本模板，可以点击“设计模板”按钮。AWS CloudFormation 将提供 CloudFormation 设计器编辑器，帮助您构建自己的基础设施。您可以在 图 1.5 中看到此界面。

您应该为 AWS CloudFormation 设置您的工作区域。在 CloudFormation StackSet 中，我们可以为不同的堆栈使用不同的区域。

在 AWS CloudFormation 管理控制台中，我们可以管理所有的堆栈和 StackSets，包括编辑和删除它们的资源。

使用 AWS CLI 管理 CloudFormation

如果您通常喜欢在终端模式下工作，AWS 提供了 AWS CLI 来管理 AWS CloudFormation。您可以从终端创建堆栈和 StackSet，还可以更新和删除您的 CloudFormation 项目。

一些命令已被定义，用于通过 AWS CLI 管理 CloudFormation。如果你想使用 CloudFormation，应该使用这些命令。有关 AWS CLI 命令的更多信息，请查看docs.aws.amazon.com/cli/latest/reference/cloudformation/index.html。

以下截图展示了如何通过 AWS CLI 创建 CloudFormation 堆栈。我们将在第二章《构建你的第一个 AWS CloudFormation 项目》中学习如何做到这一点：

图 1.9：使用 AWS CLI 管理 CloudFormation

本章结束了。我们回顾了一些 AWS CloudFormation 的术语。下一章我们将学习如何使用这个控制台。

总结

我们学习了一些 AWS CloudFormation 的术语，以更好地理解 AWS CloudFormation 是什么。接下来，我们将了解如何实现一个简单的 IaC 程序，并使用 AWS 进行部署。

问题

什么是 IaC？
IaC 的好处有哪些？
AWS CloudFormation 的主要目标是什么？
AWS CloudFormation 是如何工作的？
如何构建 AWS CloudFormation 模板？
什么是基础设施嵌套堆栈？
为什么要实现 AWS CloudFormation StackSets？

第二章：构建您的第一个 AWS CloudFormation 项目

我们可以使用 AWS CloudFormation 构建各种基础设施模型。我们可以在我们的基础设施设计中作为 IaC 添加、更新和删除 AWS 资源，然后将我们的 IaC 脚本部署到 AWS CloudFormation。在本节中，我们将构建一个简单的项目，展示如何使用 AWS CloudFormation 开发 IaC。

本章将涵盖以下主题：

准备项目
使用管理控制台实现 CloudFormation
使用 AWS CLI 实现 CloudFormation
管理 AWS CloudFormation 项目

CloudFormation 项目场景

在上一章中，我们了解了什么是 AWS CloudFormation。在本章中，我们将继续探索 AWS CloudFormation。我们将专注于如何使用 CloudFormation 构建一个简单的 IaC。

为了简化问题的复杂性，我们将使用一个简单的 AWS 资源，如 Amazon S3，并通过 CloudFormation 在 Amazon S3 中创建一个存储桶。为了构建 CloudFormation 项目，我们将按照以下图示的步骤进行：

图 2.1：部署 AWS CloudFormation 的项目步骤

上图展示了如何构建和部署 CloudFormation 项目。在此场景中，我们将使用 CloudFormation 堆栈来构建 IaC 设计。步骤如下：

在 CloudFormation 模板中构建 IaC 脚本，以定义用于构建基础设施的 AWS 资源
将模板文件上传到 CloudFormation 服务器
创建 CloudFormation 堆栈
配置 CloudFormation 堆栈的所有选项
在部署到 CloudFormation 服务器之前，检查所有设置
部署 CloudFormation 堆栈

我们将把这些步骤应用到我们的 CloudFormation 项目中。每个步骤将在下一节中执行。

准备工作

从技术上讲，我们不需要任何特殊的准备。你应该拥有一个有效的 AWS 账户才能构建 CloudFormation 项目，此外你还需要一个互联网连接，因为我们通过互联网网络构建和管理 AWS。

最后，你应该注意定价。目前，CloudFormation 是免费的，但在 CloudFormation 项目中使用的 AWS 资源可能会产生费用。某些 AWS 资源是免费的，但有一些限制。

使用管理控制台实现 CloudFormation 项目

在本节中，我们将通过 CloudFormation 管理控制台图形化构建我们的第一个 CloudFormation 项目。请按照以下步骤操作：

打开浏览器并访问console.aws.amazon.com/cloudformation。
使用你的有效 AWS 账户登录。登录成功后，你应该能够看到 AWS CloudFormation 管理控制台，如下图所示：

图 2.2：AWS CloudFormation 管理控制台

要开始创建一个简单的 CloudFormation 项目，首先创建一个堆栈。
点击图 2.2中显示的“创建新堆栈”按钮。
现在你应该能看到以下截图所示的页面：

图 2.3：选择 CloudFormation 的模板

在上面的截图所示界面中，上传一个 CloudFormation 模板文件。你可以上传模板文件，或者使用“设计模板”选项创建模板。如果你已经有一个上传到 Amazon S3 的 CloudFormation 模板文件，可以指定该文件的路径。
在此演示中，我们将一个 CloudFormation 模板文件从本地上传到 Amazon S3。模板文件有 JSON 和 YAML 两种格式。
现在，我们可以创建 JSON 和 YAML 格式的模板文件。你可以选择 JSON 格式的模板文件（hello-cloudformation.json）或 YAML 格式的模板文件（hello-cloudformation.yaml）。

以下是 hello-cloudformation.json 文件的内容：

{
 "Resources" : {
    "MySimpleBucket" : {
       "Type" : "AWS::S3::Bucket"
    }
 }
}

以下是 hello-cloudformation.yaml 文件的内容：

Resources:
 MySimpleBucket:
   Type: AWS::S3::Bucket
     Properties:
       AccessControl: PublicRead

在创建 JSON 或 YAML 格式的 CloudFormation 模板文件后，你可以将其上传到 CloudFormation 管理控制台。
选择图 2.3中显示的“上传模板到 Amazon S3”选项。
然后，点击“选择文件”选项，从本地计算机选择你的模板文件。
等待模板文件上传到 Amazon S3。
上传完成后，点击“下一步”按钮继续项目的步骤。
现在你应该能看到以下截图所示的界面：

图 2.4：添加堆栈名称

填写堆栈名称，这用于 CloudFormation 中堆栈的标识。
填写堆栈名称后，点击“下一步”按钮继续。
你将看到以下截图，用于配置堆栈选项，如标签和权限：

图 2.5：配置堆栈选项

在此演示中，我们不会配置 CloudFormation 堆栈中的任何选项，因此可以跳过这一步。点击“下一步”按钮继续。
现在你可以看到审查界面，如下图所示：

图 2.6：执行前的确认，并将资源部署到 Amazon AWS

审查你所设置的所有信息。
完成后，点击“创建”按钮执行你的模板，然后将所有资源从预定义模板部署到 Amazon AWS。你的浏览器应该会自动跳转到 CloudFormation 仪表盘。你现在应该能看到正在创建堆栈的状态，如下图所示：

图 2.7：在 CloudFormation 中创建堆栈

如果你想查看创建进度，可以点击右上角的圆形箭头。
处理完成后，你应该能在“状态”列中看到它，以下截图显示了这个状态：

图 2.8：堆栈已完全创建

如果你想查看已创建堆栈的详细信息，可以点击堆栈名称，如上图所示。
然后，你将看到选定 CloudFormation 堆栈的详细信息。以下截图显示了堆栈详细信息的示例：

图 2.9：从堆栈获取详细信息

AWS CloudFormation 会创建你在模板文件中定义的所有资源。
在我们的演示中，我们创建了 Amazon S3。你可以通过打开 Amazon S3 管理控制台在 console.aws-amazon.com/s3 来验证它。
在 Amazon S3 管理控制台中，你应该能看到一个名为你在 CloudFormation 堆栈中定义的名称的桶，如以下截图所示：

图 2.10：在 AWS CloudFormation 中创建了 S3 桶

这是通过 CloudFormation 管理控制台图形化构建 AWS CloudFormation 的部分内容结束。

接下来，我们将通过 AWS CLI 完成一个类似的操作场景。

使用 AWS CLI 实现 CloudFormation 项目

在本节中，我们将探讨如何在 CloudFormation 中使用 AWS CLI。在上一节中，我们通过 CloudFormation 管理控制台图形化地构建并部署了 CloudFormation。我们将进行类似的操作，通过 AWS CLI 构建并部署 CloudFormation。

让我们开始探索吧！

设置 AWS 命令行界面（CLI）

AWS CLI 是 Amazon 提供的一个工具，用于在终端模式下管理 Amazon AWS。我们通过这个终端管理所有的 AWS 资源。该工具支持 Windows、Linux 和 macOS。如果你使用 Windows 平台，可以从以下网站下载此工具，并选择你的 Windows 版本：

Windows 64 位: s3.amazonaws.com/aws-cli/AWSCLI64.msi
Windows 32 位: s3.amazonaws.com/aws-cli/AWSCLI32.msi

对于 Linux 和 Mac，你可以通过 Python 运行时使用 pip 安装 AWS CLI。请输入以下命令：

$ pip install awscli

如果你想通过 pip 升级 AWS CLI，请输入以下命令：

$ pip install awscli --upgrade --user

如果你已经安装或升级了 CLI，可以通过检查其版本来验证 AWS CLI。请输入以下命令：

$ aws --version

你应该能看到 AWS CLI 的版本。例如，你可以在以下截图中看到我的 AWS CLI 版本：

图 2.11：检查 AWS CLI 版本

要使用当前的 AWS 账户配置 AWS CLI，请输入以下命令：

$ aws configure

你应该准备好所有必要的访问密钥和秘密密钥。我建议阅读关于此内容的指南，网址是 docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html。

下一步是配置 AWS CLI 的安全访问，以便与 CloudFormation 一起使用。

配置 CloudFormation 的安全访问

要通过 AWS CLI 使用 CloudFormation，我们需要配置安全访问和权限。在本演示中，我们将使用 Amazon S3 来构建和部署 CloudFormation，因此我们需要在 AWS CLI 中配置 CloudFormation 和 Amazon S3 的安全设置。

以下是为 CloudFormation 和 Amazon S3 添加安全访问的步骤：

打开浏览器并访问 AWS IAM 管理控制台 console.aws.amazon.com/iam。
一旦进入 IAM 管理控制台，在左侧菜单中点击“Policies”选项。你应该看到如下截图：

图 2.12：为 CloudFormation 添加新策略

现在，创建一个用于 CloudFormation 的自定义策略。
点击“Create policy”，如图 2.12中的箭头所示。然后，你应该看到一个策略表单，如图 2.13所示。
我们将以 JSON 格式添加策略脚本，所以在创建表单中点击 JSON 标签页，如下截图所示：

图 2.13：添加访问 CloudFormation 资源的策略

在这种情况下，我们给予 CloudFormation 完全访问权限。你可以编写这些脚本并将其粘贴到 图 2.13中显示的 JSON 标签页：

{
  "Version": "2012-10-17",
  "Statement": [
                {
                  "Sid": "Stmt1449904348000",
                  "Effect": "Allow",
                  "Action": [
                      "cloudformation:*"
                  ],
                  "Resource": [
                      "*"
                  ]
               }
 ]
}

一旦粘贴了脚本，你可以点击“Review policy”按钮，应该看到如图 2.14所示的表单。
填写你的策略名称和描述。例如，以下截图中的审查策略名称为 AWSCloudFormationLRW：

图 2.14：填写策略名称和描述

完成后，点击“Create policy”开始创建策略。接下来，我们继续将该策略添加到我们的账户中。
在左侧菜单中点击“Users”部分，选择在 AWS CLI 中使用的用户账户。
在你的 IAM 用户摘要部分，你应该看到以下截图：

图 2.15：将策略添加到用户

要将你自己的策略添加到 IAM 账户中，点击权限标签页中的“Add permissions”；请参见图 2.15。然后，你应该看到如图 2.16所示的屏幕。
在授予权限部分选择“直接附加现有策略”选项，并输入你的策略名称，例如AWSCloudFormationLRW。
你应该能看到你自己的策略。点击它，如以下截图所示：

图 2.16：从你自己的策略中添加权限

选择完策略后，点击底部的 Next:Review。现在你应该看到如图 2.17所示的表单。
完成后，点击“Add permissions”将该策略添加到你的 IAM 账户：

图 2.17：确认添加权限

现在，你的 IAM 用户拥有完整访问权限的 CloudFormation 策略。
使用相同的方法，我们还需要将 AmazonS3FullAccess 策略添加到你的 IAM 账户中。
添加现有的 AmazonS3FullAccess 策略，如以下截图所示：

图 2.18：将 AmazonS3FullAccess 策略添加到用户

选择 AmazonS3FullAccess 策略，然后将其添加到你的 IAM 用户。
完成后，你的 IAM 应该拥有 CloudFormation 和 AmazonS3FullAccess 策略，如下截图所示：

图 2.19：CloudFormation 和 Amazon S3 策略已被添加

现在，你的 IAM 用户拥有 CloudFormation 和 AmazonS3FullAccess 权限。现在，你可以通过 AWS CLI 管理 CloudFormation。

下一步是构建 CloudFormation 并将其部署到 AWS CloudFormation。

构建和部署 CloudFormation

在这一部分，我们将使用 AWS CLI 部署 AWS CloudFormation。要在 AWS CLI 中使用 CloudFormation，我们需要了解一些 CloudFormation 命令。你可以在docs.aws.amazon.com/cli/latest/reference/cloudformation/index.html找到所有 CloudFormation 命令。

我们将使用与第一个示例相同的模板，hello-cloudformation.json。我们将把这个模板上传到 CloudFormation 并进行部署。

现在打开终端并导航到hello-cloudformation.json文件所在的目录。要创建堆栈，我们可以使用cloudformation create-stack命令。输入以下命令上传模板并创建堆栈：

$ aws cloudformation create-stack --stack-name mystackcli1 --template-body file://./hello-cloudformation.json --debug

上述命令的解释如下：

--stack-name mystackcli1：这定义了堆栈名称。在此情况下，堆栈名称为mystackcli1。
--template-body file://./hello-cloudformation.json：这是一个模板文件。你应当使用file://并指定完整的模板文件路径。在本示例中，终端已导航至包含./hello-cloudformation.json文件的目录。
--debug：这是一个启用详细信息的参数，帮助我们查看 CLI 的所有详细消息。

关于 CloudFormation create-stack命令的信息，我建议你阅读以下文档：docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html。

如果此操作成功执行，你应该在终端中看到 StackId。你可以看到我程序输出的以下截图：

图 2.20：使用 AWS CLI 创建 CloudFormation 解决方案

为了验证操作是否完成，你可以使用 CloudFormation CLI 中的list-stacks命令。有关list-stacks命令的更多信息，请访问docs.aws.amazon.com/cli/latest/reference/cloudformation/list-stacks.html。现在，输入以下命令：

$ aws cloudformation list-stacks

你应该能看到堆栈操作的状态，如下图所示。例如，堆栈状态可以在StackStatus选项中找到，该选项由矩形框标出：

图 2.21：从 CLI 显示所有 CloudFormation 堆栈

我们还可以通过传入堆栈名称，使用describe-stacks命令来查看堆栈的详细信息。有关describe-stacks命令的信息可以在docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-stacks.html找到。对于演示，我想查看名为mystackcli1的堆栈的详细信息：

$ aws cloudformation describe-stacks --stack-name mystackcli1

执行后，你应该可以在堆栈状态选项中看到堆栈状态，如下图所示：

图 2.22：通过 CLI 检查堆栈状态

如果堆栈的状态是 CREATE_COMPLETE，则表示堆栈创建成功。你可以在 CloudFormation 管理控制台中验证这一点。选择你在 AWS CLI 中使用的区域。以下截图显示了我的堆栈是通过 AWS CLI 创建的：

图 2.23：一个通过 AWS CLI 创建的 CloudFormation 堆栈

本节介绍了如何使用 AWS CLI 创建 CloudFormation 堆栈。接下来，我们将修改一个现有的 CloudFormation 堆栈。

编辑一个 CloudFormation 项目

在本节中，我们将更新我们的 CloudFormation 项目。对于一个简单的更新场景，我们将修改 Amazon S3 中的存储桶名称。我们将修改 CloudFormation 模板，然后将此模板应用于 CloudFormation 服务器。

我们将使用 CloudFormation 管理控制台和 AWS CLI 来执行项目更新。每种方法将在下一节中进行说明。

使用管理控制台编辑 CloudFormation

我们将修改一个现有的 CloudFormation 堆栈。对于一个简单的场景，我们将更改 Amazon S3 中的存储桶标题。我们将使用之前演示中修改过的模板文件hello-cloudformation-v2.json。

以下是使用 CloudFormation 管理控制台修改现有堆栈的步骤：

打开浏览器并导航到 AWS CloudFormation，网址是console.aws.amazon.com/cloudformation/。
在 AWS CloudFormation 仪表板中，选择要修改的堆栈。
然后，点击“操作”并从子菜单中选择“更新堆栈”选项。你可以在下图中看到这一点：

图 2.24：在 CloudFormation 管理控制台中编辑选定的堆栈

选择要编辑的堆栈后，选择“上传模板到 Amazon S3”选项。
点击“下一步”按钮以读取 CloudFormation 模板。你现在应该看到以下屏幕：

图 2.25：上传更新后的模板

上传更新后的模板，例如hello-cloudformation-v2.json。完成后，点击“下一步”按钮。
CloudFormation 会检查你的模板。如果模板文件的内容相似，CloudFormation 将不会执行下一步操作。
如果有更改，CloudFormation 将继续该过程。你应该能看到如图 2.26所示的屏幕。我们不能更改堆栈名称。现在，点击“Next”按钮：

图 2.26：显示待更新的堆栈

你现在应该能看到如图 2.27所示的屏幕。修改你的堆栈选项，然后点击“Next”按钮：

图 2.27：设置堆栈的选项

你现在应该能看到如图 2.28所示的审查屏幕。检查所有更改并点击“Update”以将更改部署到 CloudFormation：

图 2.28：在部署前审查所有更改

CloudFormation 将应用所有更改到你的堆栈。你可以在堆栈仪表板的状态列中查看进度。
完成后，你应该在状态列中看到 UPDATE_COMPLETE，如下图所示：

图 2.29：堆栈更新完成

这是关于使用管理控制台编辑 CloudFormation 堆栈的部分的结尾。接下来，我们将使用 AWS CLI 执行相同的过程。

使用 AWS CLI 编辑 CloudFormation

在本节中，我们将重点介绍如何使用 AWS CLI 编辑现有的 CloudFormation 堆栈。我们有修改过的模板文件hello-cloudformation-v2.json。我们将通过将其替换为hello-cloudformation-v2.json文件来更新现有的 CloudFormation 堆栈。

现在打开终端并导航到hello-cloudformation-v2.json文件所在的目录。要更新堆栈，我们可以使用cloudformation update-stack命令。输入以下命令以上传模板并创建堆栈：

$ aws cloudformation update-stack --stack-name mystackcli1 --template-body file://./hello-cloudformation-v2.json --debug

上述命令解释如下：

--stack-name mystackcli1：这是将要更新的堆栈。在本例中，堆栈名称为mystackcli1。
--template-body file://./hello-cloudformation-v2.json：这是已更改的模板文件。你应该使用file://与完整的模板文件路径。在本演示中，终端已经导航到包含./hello-cloudformation-v2.json文件的目录。
--debug：这是一个启用详细信息的参数，因此我们可以看到 CLI 的所有详细消息。

关于 CloudFormation update-stack命令的更多信息，建议阅读docs.aws.amazon.com/cli/latest/reference/cloudformation/update-stack.html文档。

如果此操作成功执行，你可以使用describe-stacks命令检查当前操作状态。输入以下命令：

$ aws cloudformation describe-stacks --stack-name mystackcli1

你应该能看到如以下截图所示的堆栈状态选项：

图 2.30：从 CLI 编辑 CloudFormation 堆栈

如果成功，你应该能够看到 CloudFormation 和你已修改的 AWS 资源上的更改。

在下一部分，我们将学习如何删除现有的 CloudFormation 项目。

删除 CloudFormation 项目

如果您不再使用 CloudFormation 堆栈，可以在 CloudFormation 中删除它。由于您可能会因使用的所有 AWS 资源而收费，建议删除与 CloudFormation 堆栈相关的所有资源。我们还可以因为基础架构代码设计错误而删除 CloudFormation 堆栈。删除 CloudFormation 堆栈将删除与该堆栈相关的所有资源。

在本节中，我们将学习如何使用管理控制台和 AWS CLI 删除 CloudFormation 堆栈。

使用管理控制台删除 CloudFormation

如果您想要删除 CloudFormation 堆栈，可以访问 CloudFormation 管理控制台，在那里您应该看到您的 CloudFormation 堆栈。

要删除 CloudFormation 堆栈，请选择要删除的堆栈。然后，点击 Actions，您应该看到如下截图所示的菜单。选择 Delete Stack 选项以删除所选的堆栈：

图 2.31：删除堆栈

从菜单中选择删除堆栈选项后，您应该看到一个确认对话框，如下截图所示。点击 Yes, Delete 继续删除堆栈：

图 2.32：删除堆栈的确认

完成后，您的 CloudFormation 堆栈将被删除，包括堆栈中使用的所有 AWS 资源。

接下来，我们将通过 AWS CLI 执行此操作。

使用 AWS CLI 删除 CloudFormation 堆栈

如果您希望通过 AWS CLI 删除 CloudFormation 堆栈，可以使用 CloudFormation 中的delete-stack。您可以在docs.aws.amazon.com/cli/latest/reference/cloudformation/delete-stack.html找到此命令。

要删除 CloudFormation 堆栈，可以使用delete-stack命令，并传入您的堆栈名称。例如，要删除名为mystackcli1的 CloudFormation 堆栈，请输入以下命令：

$ aws cloudformation delete-stack --stack-name mystackcli1

如果您想获取详细消息，可以在命令中添加--debug参数。我的程序输出可见下面的截图：

图 2.33：从 CLI 中删除堆栈

要验证已删除的堆栈，您可以使用describe-stacks命令，并传入您的堆栈名称。例如，对于堆栈名称mystackcli1，请输入以下命令：

$ aws cloudformation describe-stacks --stack-name mystackcli1

程序输出的示例可见下面的截图：

图 2.34：从 CLI 检查堆栈和删除过程状态

我们已经学习完本章内容，学会了如何在 Amazon AWS 上构建和部署一个 CloudFormation 项目。

总结

我们学习了如何利用 Amazon S3 构建一个简单的 CloudFormation 项目。我们使用 CloudFormation 管理控制台和 AWS CLI 构建了一个 CloudFormation 项目。演示操作包括创建、编辑和删除。

在下一章中，我们将学习如何构建 AWS CloudFormation 模板。

问题

什么是 CloudFormation 堆栈？
使用管理控制台构建 CloudFormation 有什么好处？
使用 AWS CLI 构建 CloudFormation 有什么优势？

第三章：开发 AWS CloudFormation 模板

构建 AWS CloudFormation 需要了解如何为 AWS 编写 IaC（基础设施即代码）。在本章中，我们将探索如何使用 JSON 和 YAML 开发 IaC 脚本。我们还将回顾如何通过 IaC 脚本访问 AWS 资源。

本章将涵盖以下主题：

审查 AWS CloudFormation 模板格式
审查 AWS CloudFormation 的 JSON 和 YAML
AWS CloudFormation 模板的编程模型
编写 JSON 和 YAML 来创建 AWS CloudFormation 模板
从 CloudFormation 模板中获取输入
AWS CloudFormation Designer 简介
给模板描述
从选项中选择输入
映射参数
使用内建函数

审查 AWS CloudFormation 模板格式

IaC 技术旨在使开发人员通过编写脚本来构建基础架构。AWS CloudFormation 使用 IaC 方法构建基于 AWS 的基础设施技术堆栈。每个 AWS 资源都可以以脚本形式声明。开发人员可以通过在 AWS CloudFormation 模板中声明 AWS 资源来构建自己的基础架构。

要开发 AWS CloudFormation，我们需要了解 AWS CloudFormation 模板是什么，以及如何构建该模板。AWS 资源是在 AWS 服务中定义的。例如，Amazon S3 可以在 AWS CloudFormation 模板中以 JSON 格式定义，如下所示：

{
 "Type" : "AWS::S3::Bucket",
 "Properties" : {
 "AccessControl" : String,
 "AccelerateConfiguration" : AccelerateConfiguration,
 "AnalyticsConfigurations" : [ AnalyticsConfiguration, ... ],
 "BucketEncryption" : BucketEncryption,
 "BucketName" : String,
 "CorsConfiguration" : CorsConfiguration,
 "InventoryConfigurations" : [ InventoryConfiguration, ... ],
 "LifecycleConfiguration" : LifecycleConfiguration,
 "LoggingConfiguration" : LoggingConfiguration,
 "MetricsConfigurations" : [ MetricsConfiguration, ... ]
 "NotificationConfiguration" : NotificationConfiguration,
 "ReplicationConfiguration" : ReplicationConfiguration,
 "Tags" : [ Resource Tag, ... ],
 "VersioningConfiguration" : VersioningConfiguration,
 "WebsiteConfiguration" : WebsiteConfiguration
 }
}

该模板也可以以 YAML 格式声明：

Type: "AWS::S3::Bucket"
Properties: 
 AccessControl: String
 AccelerateConfiguration:
 AccelerateConfiguration
 AnalyticsConfigurations:
 - AnalyticsConfiguration
 BucketEncryption: 
 BucketEncryption
 BucketName: String
 CorsConfiguration:
 CorsConfiguration
 InventoryConfigurations:
 - InventoryConfiguration 
 LifecycleConfiguration:
 LifecycleConfiguration
 LoggingConfiguration:
 LoggingConfiguration
 MetricsConfigurations: 
 - MetricsConfiguration
 NotificationConfiguration:
 NotificationConfiguration
 ReplicationConfiguration:
 ReplicationConfiguration
 Tags:
 - Resource Tag
 VersioningConfiguration:
 VersioningConfiguration
 WebsiteConfiguration:
 WebsiteConfiguration

我们可以看到，每个 AWS 资源都可以声明为资源类型。通常，AWS 资源类型可以定义如下：

AWS::aws-product-name::data-type-name

如果我们想要使用这些资源，就需要了解 AWS 资源类型。AWS 资源类型列表的示例如下表所示：

AWS 资源名称	AWS 资源类型
AWS EC2 实例	`AWS::EC2::Instance`
AWS EC2 VPC	`AWS::EC2::VPC`
AWS IAM 用户	`AWS::IAM::User`
AWS IoT 设备事物	`AWS::IoT::Thing`
AWS Lambda 函数	`AWS::Lambda::Function`
AWS RDS 数据库实例	`AWS::RDS::DBInstance`
AWS S3 桶	`AWS::S3::Bucket`

表 3.1：AWS 资源类型示例列表

有关各种 AWS 资源类型的更多信息，可以在docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html中找到。

AWS CloudFormation 模板由各种 AWS 资源类型组成，具体取决于您在基础架构中的需求。通常，AWS CloudFormation 模板格式可以通过以下图示描述。模板由各种属性组成，如AWSTemplateFormatVersion、Description、Metadata 和 Parameters：

图 3.1：AWS CloudFormation 模板格式

每个 AWS CloudFormation 模板都有以下一个或多个属性：

AWSTemplateFormatVersion: 这是 AWS CloudFormation 模板版本，不同于 API 或 WSDL 版本。这个属性是可选的。
描述: 这是定义描述模板的文本字符串。这个属性是可选的。
元数据: 这是定义提供关于模板附加信息的对象。这个属性是可选的。
参数: 这是定义在运行时传递给模板的值。你可以引用模板中资源和输出部分的参数。这个属性是可选的。
映射: 这是一个键和值的映射，你可以用它来指定条件参数的值。这个属性是可选的。
条件: 这是定义在堆栈创建或更新过程中，是否创建某些资源或是否为某些资源属性分配值的条件。这个属性是可选的。
变换: 这有助于简化模板编写，通过将 AWS 基础设施作为代码的表达方式进行压缩，并实现模板组件的重用。
资源: 这是指定堆栈资源及其属性的部分，例如 EC2 和 Amazon S3。这个属性是必需的。
输出: 这是描述每当查看堆栈属性时返回的值。这个属性是可选的。

由于 AWS CloudFormation 模板是用 JSON 和 YAML 编写的，我们将学习如何同时开发 JSON 和 YAML。在接下来的部分，我们将探讨这些编程方法。

回顾 JSON 和 YAML 编程

在这一部分，我们将学习一些关于 JSON 和 YAML 编程的内容。为了构建 AWS CloudFormation 模板，我们需要了解 JSON 和 YAML。从技术角度来看，JSON 和 YAML 是脚本语言的一部分。我们将在下一部分深入探讨每个主题。

JSON 编程

JSON 是一种数据交换格式。该格式基于 ECMA-404。更多信息，请参考 www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf。JSON 可以定义为键值模型。我们可以编写如下脚本：

{
 key: value
}

例如，我们可以为 Employee 数据定义一个 JSON 对象。我们可以编写如下脚本：

{
 "id": 1,
 "name": "michael",
 "country": "us"
}

你可以看到 Employee 对象有三个属性——id、name 和 country。从技术角度讲，我们可以声明数字类型和字符串类型的属性。我们还可以使用 [] 来定义 Employee 对象的集合。每个对象都在 {} 内定义。我们可以编写如下脚本：

[
 {
  "id": 1,
  "name": "michael",
  "country": "us"
 },
 {
  "id": 2,
  "name": "jason",
  "country": "uk"
 },
 {
  "id": 3,
  "name": "ryu",
  "country": "jp"
 }
]

JSON 支持无限制的父子属性。例如，每个 Employee 对象可能有两个或更多的地址。我们可以如下声明：

{
 "id": 1,
 "name": "michael",
 "address":[
      {
        "street": "abc street",
        "city": "new york"
      },
      {
        "street": "vue street",
        "city": "hoston"
      }
 ],
 "country": "us"
}

这是 JSON 编程部分的结束。接下来，我们将学习如何开发 YAML。

YAML 编程

YAML 是一种数据序列化语言，旨在让人类直接编写和读取。一个简单的 YAML 对象可以如下定义：

key:
 value

在 JSON 格式中，我们使用 {} 和 : 来表示键值对数据。在 YAML 中，我们只使用 :。

在上一节中，我们在 JSON 中声明了 Employee 对象。我们可以使用以下脚本将其转换为 YAML：

id:
 1
name:
 "michael"
country:
 "us"

如果我们想要定义一个 YAML 对象集合，可以使用-语法表示集合中的一个项。让我们将 Employee 集合从 JSON 转换为 YAML。我们可以编写如下脚本：

- id: 1
  name: "michael"
  country: "us"
- id: 2
  name: "jason"
  country: "uk"
- id: 3
  name: "ryu"
  country: "jp"

要声明 YAML 对象的父子关系，我们可以使用 : 来传递 YAML 对象。例如，我们可以从 Employee 对象中添加一个 address 对象。我们可以编写以下脚本来实现它：

id:
 1
name:
 "michael"
address:
    - street: "abc street"
      city: "new york"
    - street: "vue street"
      city: "hoston"
country: 
 "us"

这是编写 YAML 对象的一个简单实现。接下来，我们将使用 JSON 和 YAML 构建 AWS CloudFormation 模板。

AWS CloudFormation 模板的编程模型

开发 AWS CloudFormation 模板意味着我们为基于基础设施的 AWS 技术编写脚本。在此模型中，我们可以应用软件开发生命周期（SDLC）。通常，我们将 AWS CloudFormation 模板的开发模型表示为下图所示：

图 3.2：CloudFormation 模板开发周期

从前面的图示中，我们可以执行以下任务：

分析问题：我们识别问题并决定修复哪些问题。
构建基础设施设计：根据你的问题和解决方案，我们定义一个基础设施设计，包括一些 AWS 资源来实施。
开发 CloudFormation 模板：在你构建好基础设施设计后，你就可以编写 CloudFormation 模板。你需要在脚本中定义所有 AWS 资源。你可以使用 JSON 和 YAML 文件，或使用 CloudFormation Designer 来编写模板。
部署 AWS CloudFormation：在你完成 CloudFormation 模板后，你可以上传并配置这些脚本。
测试：你可以测试你的基础设施。如果在测试中发现问题，你可以修改脚本，然后重新进行测试。

从 SDLC 的角度来看，在开发 CloudFormation 模板时你可以使用敏捷方法。有很多敏捷方法模型，如 Scrum 和极限编程（XP）。你还可以使用源代码控制来管理 CloudFormation 模板文件。接下来，我们将为 CloudFormation 编写脚本。

编写 JSON 和 YAML 以创建 AWS CloudFormation 模板

我们已经学习了在图 3.1中描述的 CloudFormation 模板格式。CloudFormation 模板可以使用 JSON 和 YAML 实现。从图 3.1中，我们可以按照如下方式用 JSON 格式实现 CloudFormation 模板：

{
 "AWSTemplateFormatVersion" : "version date",
 "Description" : "JSON string",
 "Metadata" : {
   template metadata
 },
 "Parameters" : {
   set of parameters
 },
 "Mappings" : {
   set of mappings
 },
 "Conditions" : {
   set of conditions
 },
 "Transform" : {
   set of transforms
 },
 "Resources" : {
   set of resources
 },
 "Outputs" : {
   set of outputs
 }
}

CloudFormation 中的所有属性都不是必需的。只有Resources属性需要在你的 CloudFormation 模板中定义。你也可以使用 YAML 定义 CloudFormation 模板。我们可以按照如下方式用 YAML 声明来自图 3.1的 CloudFormation 模板：

AWSTemplateFormatVersion: "version date"
Description:
 String
Metadata:
 template metadata
Parameters:
 set of parameters
Mappings:
 set of mappings
Conditions:
 set of conditions
Transform:
 set of transforms
Resources:
 set of resources
Outputs:
 set of outputs

本书将通过各种用例和场景探讨一些来自 CloudFormation 模板的属性。在下一节中，我们将构建一个 CloudFormation 模板，以获取用户输入。

从 CloudFormation 模板获取输入。

在第二章中，构建你的第一个 AWS CloudFormation 项目，我们在应用 Amazon S3 资源的同时构建了 CloudFormation。由于我们没有指定 S3 存储桶名称，Amazon S3 会为我们的存储桶生成一个随机名称。在这一节中，我们将构建 CloudFormation，并通过用户输入来设置 Amazon S3 存储桶名称。

我们可以使用 CloudFormation 模板中的 Parameters 属性。Parameters 属性的值将传递给我们的 Amazon AWS 资源。要从资源中获取 Parameters，你可以使用 Ref 并传递参数名称。例如，我有一个参数 YourBucketName。该参数传递给我的资源 MySimpleBucket，用于 BucketName 属性，如下所示：

{ 
  "Parameters": { 
    "YourBucketName":{
      "Description": "Amazon S3 Bucket name",
      "Type": "String"
    }
 },
 "Resources" : {
    "MySimpleBucket" : {
      "Type" : "AWS::S3::Bucket",
      "Properties" : {
        "AccessControl" : "PublicRead",
        "BucketName" : {
           "Ref": "YourBucketName"
        }
      } 
    }
  }
}

为了演示，我们将创建一个自定义的 Amazon S3 存储桶名称，由用户填写。你可以执行以下步骤来实现该演示：

在本地计算机上准备 CloudFormation 模板。
创建一个 JSON 或 YAML 文件来构建 CloudFormation 模板。
提供一个 JSON 格式的模板文件 simple-s3.json 和一个 YAML 格式的 simple-s3.yaml 文件。你可以编写以下脚本。

simple-s3.json 文件的脚本如下：

{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "Amazon S3 with custom Bucket name",
    "Parameters": {      
      "YourBucketName":{
          "Description": "Amazon S3 Bucket name",
          "Type": "String"
      }
    },
    "Resources" : {
        "MySimpleBucket" : {
            "Type" : "AWS::S3::Bucket",
            "Properties" : {
                "AccessControl" : "PublicRead",
                "BucketName" : {
                    "Ref": "YourBucketName"
                  }
            }                
        }

    }
}

simple-s3.yaml 文件的脚本如下：

AWSTemplateFormatVersion:
 "2010-09-09"
Description:
 "Amazon S3 with custom Bucket name"
Parameters:
 YourBucketName:
   Description:
     "Amazon S3 Bucket name"
   Type:
     "String"
Resources:
 MySimpleBucket:
   Type:
     "AWS::S3::Bucket"
   Properties:
     AccessControl:
        "PublicRead"
   BucketName:
     Ref:
        "YourBucketName"

完成后，将这些脚本保存到一个文件中。
将模板文件上传到 AWS CloudFormation。
转到 console.aws.amazon.com/cloudformation 并点击“创建新堆栈”按钮。你应该看到一个屏幕，如下图所示。
选择“上传模板到 Amazon S3”选项。
点击“选择文件”按钮上传 CloudFormation 模板文件，然后点击“下一步”按钮：

图 3.3：选择 CloudFormation 模板。

你应该看到一个屏幕，如图 3.4所示。你应该使用我们定义的参数 YourBucketName。这是我们的 S3 存储桶名称。
填写堆栈名称和 YourBucketName 字段来设置存储桶名称：

图 3.4：显示 CloudFormation 模板的参数。

例如，我将堆栈名称填写为 my-simple-stack，将存储桶名称填写为 my-simple-s3。你可以在以下截图中看到我的输入。
完成后，你可以点击下一步按钮，如下图所示：

图 3.5：填写 CloudFormation 参数。

在你点击下一步按钮后，应该会要求你填写选项。在这种情况下，我们不填任何项目，只需点击下一步按钮：

图 3.6：设置 CloudFormation 选项。

在配置您的 CloudFormation 模板之前，您应该看到如下截图的确认信息。
如果完成，您可以点击“创建”按钮来部署 CloudFormation：

图 3.7：CloudFormation 确认

AWS CloudFormation 将创建模板中定义的所有资源。
您应该能够在仪表盘上看到资源配置状态，如下图所示：

图 3.8：部署 CloudFormation

您可以验证 Amazon S3 控制台，以确保您的资源已由 CloudFormation 创建。
请查看以下截图，这是我的 Amazon S3 存储桶，桶名为 my-simple-s3。这个桶名是从 图 3.5 中的输入填充的：

图 3.9：Amazon S3 由 CloudFormation 模板创建

如果您更喜欢使用 AWS CLI 运行 CloudFormation 模板，您可以轻松做到。例如，模板文件位于 home/user/templates/simple-s3.json。我们还设置了堆栈名称为 my-simple-stack，并传递了 YourBucketName 参数，其值为 my-simple-s3。您可以输入以下命令：

$ aws cloudformation create-stack --stack-name my-simple-stack 
 --template-body file://home/user/templates/simple-s3.json 
 --parameters YourBucketName=my-simple-s3

AWS CLI 将根据其模板文件部署您的 CloudFormation。

这是我们的演示的结束部分。我们已经创建了一个资源，Amazon S3，并传递了一个参数来定义存储桶名称。您可以通过不同的参数在 Amazon AWS 资源中进行更多实践。

接下来，我们将构建 CloudFormation 设计器。

介绍 AWS CloudFormation 设计器

我们已经学习了如何通过编写脚本手动创建 CloudFormation 模板，使用 JSON 或 YAML 格式，并通过文本编辑器进行编辑。在本节中，我们将使用 CloudFormation Designer 以图形化方式构建 CloudFormation 模板。您可以点击并拖动 AWS 资源到模板中。这个工具会生成 JSON 或 YAML 文件。然后，您可以将模板上传到 AWS CloudFormation。

在这个演示中，我们将使用 CloudFormation 设计器构建一个 CloudFormation 模板。我们将使用 Amazon S3 来展示 CloudFormation 设计器的工作方式。您可以按照以下步骤进行演示：

打开您的浏览器并导航到 AWS CloudFormation 控制台：console.aws.amazon.com/cloudformation。您应该能看到 AWS CloudFormation 控制台仪表盘。
要使用 CloudFormation 设计器，请点击仪表盘顶部的“设计模板”按钮。您应该看到以下 CloudFormation 设计器表单：

图 3.10：CloudFormation 设计器的表单

您应该能在左侧看到 AWS 资源类型列表（参见 图 3.10）。在列表中找到 S3 存储桶并将其拖到右侧面板，如下图所示：

图 3.11：将 Amazon S3 添加到设计器中

将 AWS 资源类型拖到右侧面板后，底部将显示框架脚本。
点击“属性”选项卡，您应该能看到从 CloudFormation 设计器生成的 JSON 或 YAML 脚本。
通过点击带有向上箭头图标的云来将模板上传到 Amazon S3。您应该会得到一个对话框，如图 3.12所示。
点击 Amazon S3 存储桶选项卡，填写模板名称，如mysimples3.template，然后点击“保存”按钮：

图 3.12：将模板保存到 Amazon S3 存储桶

您应该获得一个用于创建堆栈的仪表板。由于我们已将模板上传到 Amazon S3，仪表板已选择了 Amazon S3 上的 URL，如下屏幕截图所示。点击“下一步”按钮：

图 3.13：上传设计者以创建一个堆栈

按照说明进行操作，直到您审查配置，如下面的屏幕截图所示：

图 3.14：确认创建 CloudFormation

AWS CloudFormation 基于您的模板生成 Amazon S3。您可以通过在 Amazon S3 控制台上检查来验证它：

图 3.15：Amazon S3 由 CloudFormation 设计者创建

我们已经完成了创建 CloudFormation 模板并将其部署到 AWS CloudFormation。现在您可以使用各种资源类型进行其他实验。

接下来，我们将处理模板描述。

给出模板描述

CloudFormation 模板提供了Description属性，用于显示有关您的模板的信息。您必须设置一个长度为 0 到 1,024 字节的文字字符串作为描述。您可以看到我们对Description属性的示例实现。JSON 的示例程序如下所示：

"AWSTemplateFormatVersion": "2010-09-09",
    "Description": "Amazon S3 with custom Bucket name",
    "Parameters": { 
      "YourBucketName":{
          "Description": "Amazon S3 Bucket name",
          "Type": "String"
      }
    }

对于 YAML，您可以使用以下脚本实现它：

AWSTemplateFormatVersion:
  "2010-09-09"
Description:
  "Amazon S3 with custom Bucket name"
Parameters:
  YourBucketName:
    Description:
      "Amazon S3 Bucket name"
    Type:

这个属性是可选的。当你在模板的Description属性上应用词语时，你可以在审查模板时看到它。更多信息请参见图 3.7。

接下来，我们将学习如何在 CloudFormation 中从各种选项中选择值。

从选项中选择输入

有时，在 CloudFormation 中构建基础架构时，您需要从用户那里获取输入。在前一节中，我们学习了如何通过填写 Amazon S3 存储桶名称从用户那里获取输入。现在，我们想学习如何从各种选项中选择输入。

可以说明场景以获取 EC2 实例类型大小。用户可以选择我们在Parameters部分定义的实例类型。您可以在 JSON 中的实现脚本中看到以下脚本：

{
 "AWSTemplateFormatVersion": "2010-09-09",
 "Description": "Amazon EC2 instance with Amazon Linux AMI.",
 "Parameters": { 
    "InstanceType": {
      "Description": "EC2 instance type",
      "Type": "String",
      "Default": "t1.micro",
      "AllowedValues": [
        "t1.micro",
        "t2.nano",
        "t2.micro",
        "t2.small"
      ],
      "ConstraintDescription": "must be a valid EC2 instance type."
    } 
 }

对于 YAML，你可以使用以下脚本：

AWSTemplateFormatVersion: '2010-09-09'
Description: Amazon EC2 instance with Amazon Linux AMI.
Parameters:
  InstanceType:
  Description: EC2 instance type
  Type: String
  Default: t1.micro
  AllowedValues:
    - t1.micro
    - t2.nano
    - t2.micro
    - t2.small
  ConstraintDescription: must be a valid EC2 instance type.

你可以看到我们定义了四种实例类型，这些类型在AllowedValues属性中有定义。用户可以选择其中一种实例类型。以下是选项列表：

t1.micro
t2.nano
t2.micro
t2.small

EC2 有许多实例类型。在此演示中，我只设置了四种类型。您可以在docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html找到支持 EC2 实例的类型列表。如果需要，您可以列出所有实例类型。

我们还可以为我们的选项设置默认值。我们可以使用Default属性并将其值设置为默认值。例如，我将t1.micro设置为默认值。

现在，我们可以在EC2Instance的InstanceType属性中设置用户的选择。以下是 JSON 格式的示例程序：

"Resources": {
   "EC2Instance": {
     "Type": "AWS::EC2::Instance",
     "Properties": {
        "InstanceType": {
           "Ref": "InstanceType"
        },

在 YAML 格式中，执行以下操作：

Resources:
 EC2Instance:
   Type: AWS::EC2::Instance
   Properties:
     InstanceType:
       Ref: InstanceType

现在，如果您将此模板文件（simple-ec2.json或simple-ec2.yaml）部署到 CloudFormation，您应该会看到Parameters部分的选择项，如下图所示：

图 3.16：为 EC2 选择实例类型

这是一个简单的示例，用于获取一些选项的输入。您可以通过探索一些 AWS 资源来进行更多练习。

接下来，我们将学习如何在 CloudFormation 中使用Mappings属性。

映射参数

一些 AWS 资源需要特定的属性类型，这些属性类型可能无法通过用户输入获得。在这种情况下，我们可以在 CloudFormation 中利用Mappings属性。例如，我们可以根据区域映射 EC2 实例类型。我们可以在Mapping属性中声明如下：

"Mappings" : {
   "RegionMap" : {
     "us-east-1" : { "32" : "ami-6411e20d"},
     "us-west-1" : { "32" : "ami-c9c7978c"},
     "eu-west-1" : { "32" : "ami-37c2f643"},
     "ap-southeast-1" : { "32" : "ami-66f28c34"},
     "ap-northeast-1" : { "32" : "ami-9c03a89d"}
   }
}

这是前面的代码的 YAML 格式：

Mappings
 RegionMap
  us-east-1
    32: ami-6411e20d
  us-west-1
    32 : ami-c9c7978c
  eu-west-1
    32 : ami-37c2f643
  ap-southeast-1
    32 : ami-66f28c34
  ap-northeast-1
    32 : ami-9c03a89d

如您所见，RegionMap将根据区域输入映射各种值，例如us-east-1、us-west-1和eu-west-1。如果我们选择eu-west-1，则会获得ami-37c2f643用于32架构。

在实际程序中，我们通常使用Mappings属性与Fn::FindInMap内建函数，该函数可在docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-findinmap.html找到。此函数返回在Mappings部分声明的两级映射中与键对应的值。Fn::FindInMap可以按如下方式定义：

以下是 JSON 格式：

{ "Fn::FindInMap" : [ "MapName", "TopLevelKey", "SecondLevelKey"] }

这里是 YAML 格式的代码：

Fn::FindInMap: [ MapName, TopLevelKey, SecondLevelKey ]

例如，我们想要从EC2Instance中设置ImageId属性。我们可以从Mappings属性中查找AWSRegionArch2AMI和AWSInstanceType2Arch。您可以在以下 JSON 脚本中看到Fn::FindInMap的示例实现：

     "Mappings": {
      "AWSInstanceType2Arch": {
        "t1.micro": {
          "Arch": "PV64"
        },
        "t2.nano": {
          "Arch": "HVM64"
        },
        "t2.micro": {
          "Arch": "HVM64"
        },
        "t2.small": {
          "Arch": "HVM64"
        }
      },
       "AWSRegionArch2AMI": {
        "us-east-1": {
          "PV64": "ami-2a69aa47",
          "HVM64": "ami-6869aa05",
          "HVMG2": "ami-61e27177"
        },
        "us-west-2": {
          "PV64": "ami-7f77b31f",
          "HVM64": "ami-7172b611",
          "HVMG2": "ami-60aa3700"
        },
        "us-west-1": {
          "PV64": "ami-a2490dc2",
          "HVM64": "ami-31490d51",
          "HVMG2": "ami-4b694d2b"
        }
      }
    },
    "Resources": {
      "EC2Instance": {
        "Type": "AWS::EC2::Instance",
        "Properties": {
          "InstanceType": {
            "Ref": "InstanceType"
          }, 
          "ImageId": {
            "Fn::FindInMap": [
              "AWSRegionArch2AMI",
              {
                "Ref": "AWS::Region"
              },
              {
                "Fn::FindInMap": [
                  "AWSInstanceType2Arch",
                  {
                    "Ref": "InstanceType"
                  },
                  "Arch"
                ]
              }
            ]
          }
        }
      }
    }

以下脚本适用于 YAML：

Mappings:
  AWSInstanceType2Arch:
    t1.micro:
      Arch: PV64
    t2.nano:
      Arch: HVM64
    t2.micro:
      Arch: HVM64
    t2.small:
      Arch: HVM64
  AWSInstanceType2NATArch:
    t1.micro:
      Arch: NATPV64
    t2.nano:
      Arch: NATHVM64
    t2.micro:
      Arch: NATHVM64
    t2.small:
      Arch: NATHVM64
  AWSRegionArch2AMI:
    us-east-1:
      PV64: ami-2a69aa47
      HVM64: ami-6869aa05
      HVMG2: ami-61e27177
    us-west-2:
      PV64: ami-7f77b31f
      HVM64: ami-7172b611
      HVMG2: ami-60aa3700
    us-west-1:
      PV64: ami-a2490dc2
      HVM64: ami-31490d51
      HVMG2: ami-4b694d2b
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      InstanceType:
        Ref: InstanceType
      ImageId:
        Fn::FindInMap:
        - AWSRegionArch2AMI
        - Ref: AWS::Region
        - Fn::FindInMap:
          - AWSInstanceType2Arch
          - Ref: InstanceType
          - Arch

继续使用 CloudFormation 中的Mappings属性进行练习。接下来，我们将学习如何在 CloudFormation 模板中使用内建函数。

使用内建函数

内建函数使我们能够在 CloudFormation 模板中插入逻辑函数。从技术上讲，我们在之前的 CloudFormation 模板中已经使用了内建函数，例如Ref和Fn::FindInMap。

通常，Amazon AWS 提供一些内建函数，我们可以在 CloudFormation 模板中应用。以下是内建函数的列表：

Fn::Base64
Fn::Cidr
Condition Functions
Fn::FindInMap
`Fn::GetAtt`
Fn::GetAZs
Fn::ImportValue
Fn::Join
Fn::Select
Fn::Split
Fn::Sub
Ref

各种内建函数的解释如下：

Fn::Base64 内置函数返回输入字符串的 Base64 表示。Fn::Base64 可以这样定义。

这里是 JSON 格式：

{ "Fn::Base64" : valueToEncode }

这里是 YAML 格式：

Fn::Base64: valueToEncode

Fn::Cidr 内置函数返回指定的 CIDR 地址块。你可以按如下方式声明此函数。

这里是 JSON 格式：

{ "Fn::Cidr" : [ipBlock, count, sizeMask]}

这里是 YAML 格式：

Fn::Cidr: [ ipBlock, count, sizeMask ]

条件函数在 CloudFormation 模板中应用逻辑条件。我们可以使用以下条件函数：
- Fn::And
- Fn::Equals
- Fn::If
- Fn::Not
- `Fn::Or`

例如，我们想要决定 EC2 的磁盘大小。如果 CreateLargeSize 为真，我们设置磁盘大小为100，否则我们设置为 10。以下是一个 JSON 的示例程序：

"NewVolume" : {
  "Type" : "AWS::EC2::Volume",
  "Properties" : {
    "Size" : {
      "Fn::If" : [
        "CreateLargeSize",
        "100",
        "10"
      ]}, 
  }
}

这里是 YAML 格式：

NewVolume:
  Type: "AWS::EC2::Volume"
  Properties: 
    Size: 
      !If [CreateLargeSize, 100, 10]

Fn::FindInMap 返回在 Mappings 部分声明的两级映射中与键对应的值。我们也学会了如何使用这个函数。
Fn::GetAtt 内置函数返回模板中某个资源的属性值。我们可以通过以下 JSON 方式定义 Fn::GetAtt：

{ "Fn::GetAtt" : [ "logicalNameOfResource", "attributeName" ] }

这里是 YAML 格式：

Fn::GetAtt: [ logicalNameOfResource, attributeName ]

Fn::GetAZs 返回一个数组，列出指定区域的 可用区 (AZs)。当你在多个区域工作时，这个函数非常有用。
Fn::Join 内置函数将一组值连接成一个值，值之间由指定的分隔符分隔。
Fn::Select 函数通过索引从对象列表中返回单个对象。Fn::Select 函数用于将一个字符串分割成多个字符串值。
Fn::Sub 用指定的值替换输入字符串中的变量。

要了解更多内置函数的信息，请查看 docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html。

在 CloudFormation 模板中使用元数据

CloudFormation 模板提供了一个可选的属性 Metadata，用于提供关于模板的详细信息。例如，你可以在其中包含特定资源的模板实现细节，如 AWS::ElasticLoadBalancing::LoadBalancer 资源。你可以按如下方式编写脚本：

  "Resources" : {
    "ElasticLoadBalancer" : {
      "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
      "Metadata" : {
        "Comment1" : "Configure the Load Balancer with a simple health check and cookie-based stickiness",
        "Comment2" : "Use install path for healthcheck to avoid redirects - ELB healthcheck does not handle 302 return codes"
      },

更新 CloudFormation 模板后，你无法更改 Metadata 属性。

CloudFormation 资源

Resources 属性是 CloudFormation 模板中的必需属性之一。你可以在模板中声明一个或多个 AWS 资源。例如，你可以在一个模板中使用 Amazon EC2 实例和 Amazon S3 桶。一般来说，CloudFormation 中的 Resources 属性可以这样定义：

"Resources" : {
    "Logical ID" : {
        "Type" : "Resource type",
        "Properties" : {
            Set of properties
        }
    }
}

这里是 YAML 格式：

Resources:
  Logical ID:
    Type: Resource type
    Properties:
      Set of properties

Logical ID是 AWS 资源的唯一 ID。您可以以字母数字形式（A-Z a-z 0-9）声明它。Type属性定义了 AWS 资源类型。您可以查看可以在模板中使用的资源类型列表。请访问docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html。

每种资源类型都有其属性。您可能想要在Properties属性上设置资源属性。您应该确保资源类型和资源属性之间相匹配。

CloudFormation 输出

如果我们希望在 AWS 资源部署后获取响应，我们可以将这些响应导入到 CloudFormation 中。我们可以使用Outputs属性，它将作为响应返回（用于描述堆栈调用），或者在 AWS CloudFormation 控制台中查看。

Outputs部分由关键字Outputs、一个空格和一个冒号组成。您可以在模板中声明最多 60 个输出。

我们可以在 JSON 中声明Outputs属性，如下所示：

"Outputs" : {
  "Logical ID" : {
    "Description" : "Information about the value",
    "Value" : "Value to return",
    "Export" : {
      "Name" : "Value to export"
    }
  }
}

这里是 YAML 格式：

Outputs:
  Logical ID:
    Description: Information about the value
    Value: Value to return
    Export:
      Name: Value to export

在演示中，我们希望在创建 Amazon S3 存储桶时获取存储桶名称。我们将存储桶资源传递到Outputs部分。我们可以通过以下 JSON 脚本实现这一点：

{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "Amazon S3 with output", 
    "Resources" : {
        "MySimpleBucket" : {
            "Type" : "AWS::S3::Bucket" 
        }

    },
    "Outputs" : {
        "BucketName" : {
            "Value" : { "Ref" : "MySimpleBucket" }
        }
    }
}

这里是 YAML 格式：

AWSTemplateFormatVersion: '2010-09-09'
Description: Amazon S3 with custom Bucket name
Resources:
  MySimpleBucket:
    Type: AWS::S3::Bucket 
Outputs:
  BucketName:
    Value:
      Ref: MySimpleBucket

将此文件保存为simple-s3-outputs.json或simple-s3-outputs.yaml。

然后，您可以将此模板上传到 CloudFormation。如果上传成功，您应该在堆栈的“输出”标签页中看到 Amazon S3 存储桶的名称：

图 3.17：来自 CloudFormation 的输出消息

您已经了解了 CloudFormation 输出。通过从各种 AWS 资源中应用一些输出，继续练习。

接下来，我们将尝试使用 CloudFormation 构建 EC2 实例。

演示 - 使用 AWS CloudFormation 构建 Amazon EC2

在本节中，我们将使用 CloudFormation 构建 Amazon EC2。在前面的章节中，我们已经探讨了关于 EC2 的一些 CloudFormation 属性。需要提醒的是，Amazon EC2 可能不是免费的，因此您可能会被收费。

接下来，我们将在构建 EC2 实例之前进行准备。

准备中

为了操作 EC2 实例，我们需要一个密钥对来访问 EC2。如果您还没有密钥对，您可以通过 EC2 管理控制台创建它。

打开您的浏览器并导航到console.aws.amazon.com/ec2。您应该看到 EC2 管理控制台的仪表板。您可以点击左侧菜单中的“密钥对”选项，您将看到如下界面：

图 3.18：AWS EC2 控制台管理

您可以点击“创建密钥对”按钮来创建一个新的密钥对。您应该会看到一个对话框，如下图所示。填写密钥对名称字段，然后点击对话框中的“创建”按钮：

图 3.19：在 AWS EC2 管理控制台创建密钥对

现在，你已经有了一个可以在 EC2 实例中使用的密钥对。接下来，我们将为 EC2 开发一个 CloudFormation 模板。

开发 CloudFormation 模板

在本节中，我们将开发一个用于 EC2 的 CloudFormation 模板。某些属性已经在本章的前面部分解释过。由于我们需要在 EC2 上使用密钥对，因此我们将其设置在 Parameters 属性中，以便用户可以选择他们的密钥对。以下是一个 JSON 格式的示例程序：

"KeyName": {
        "Description": "Name of an existing EC2 KeyPair to enable SSH 
        access to the instance",
        "Type": "AWS::EC2::KeyPair::KeyName",
        "ConstraintDescription": "must be the name of an existing EC2 
        KeyPair."
},

这是 YAML 格式的：

  KeyName:
    Description: Name of an existing EC2 KeyPair to enable SSH access  
    to the instance
    Type: AWS::EC2::KeyPair::KeyName
    ConstraintDescription: must be the name of an existing EC2 KeyPair.

KeyName 参数中的密钥对将用于 EC2 实例。我们将其放在资源中，如下所示：

   "Resources": {
      "EC2Instance": {
        "Type": "AWS::EC2::Instance",
        "Properties": {
          ...
          "KeyName": {
            "Ref": "KeyName"
          },

这是 YAML 格式的：

   Resources:
      EC2Instance: 
        Type: AWS::EC2::Instance
        Properties: 
          ...
          KeyName: 
            Ref: KeyName

我们还需要一个 EC2 实例的公共 IP 地址，以便通过 SSH 访问。我们在 Parameters 属性中的 SSHLocation 部分定义它。JSON 格式如下：

      "SSHLocation": {
        "Description": "The IP address range that can be used to SSH to the EC2 instances",
        "Type": "String",
        "MinLength": "9",
        "MaxLength": "18",
        "Default": "0.0.0.0/0",
        "AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
        "ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
      }

这是 YAML 格式的：

SSHLocation:
    Description: The IP address range that can be used to SSH to the EC2 instances
    Type: String
    MinLength: '9'
    MaxLength: '18'
    Default: 0.0.0.0/0
    AllowedPattern: "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})"
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.

有关 EC2 实例模板的详细信息，请查看 ec2demo.json 和 ec2demo.yaml。你可以开始将这个模板部署到 AWS CloudFormation。我们将在下一节执行此任务。

部署模板

完成 EC2 的 CloudFormation 模板后，你可以将其上传到 AWS CloudFormation。你需要在模板中选择 KeyName 和其他选项：

图 3.20：通过 AWS CloudFormation 部署 EC2

你可能已经在 SSHLocation 参数中设置了用于 SSH 访问的 IP 地址。然后，按照说明部署模板。

创建完成后，你可以在 CloudFormation 仪表板上查看 CloudFormation 部署的进度：

图 3.21：AWS EC2 实例已创建

创建 EC2 实例后，你可以在 EC2 管理控制台上验证这一点。你应该能看到如下截图所示的 EC2 实例：

图 3.22：在 EC2 管理控制台上验证 EC2 实例

现在，你可以在管理控制台上管理你的 EC2 实例。如果你想修改 EC2 实例，你可以更新 CloudFormation 模板。然后，你可以部署该模板。

总结

我们已经学习了如何使用 JSON 和 YAML 构建 AWS CloudFormation 模板。我们回顾了 CloudFormation 模板格式。然后，我们查看了一些 CloudFormation 模板中的属性。最后，我们使用 CloudFormation 模板部署了 Amazon EC2。

在下一章中，我们将学习 CloudFormation StackSets。

问题

什么是 CloudFormation 模板？
我们如何开发 CloudFormation 模板？
如何在 CloudFormation 模板中实现 AWS 资源？

第四章：AWS CloudFormation StackSets

为全球客户提供来自多个区域的服务需要更多关注在设计应用程序和基础设施时。有时，将基础设施部署到某些区域并不容易。此外，我们还应该在多个区域执行基础设施变更。本章将探讨如何通过应用 CloudFormation StackSets 来设计和构建多区域基础设施。

本章将涵盖以下主题：

AWS CloudFormation StackSets 简介
准备 CloudFormation StackSets
使用管理控制台实现 StackSets
使用 AWS CLI 创建 StackSets
编辑 CloudFormation StackSets
删除 CloudFormation StackSets

AWS CloudFormation StackSets 简介

一家面向全球客户的公司在为客户提供服务时可能会遇到问题。我们应该能够提供接近客户位置的服务。在 IT 问题的背景下，我们应当将应用程序和服务部署到多个区域，以解决网络延迟问题。

我们可以像图 4.1所示那样描述我们的全球客户服务问题。我们有来自美国、亚洲和欧洲的客户。我们有一些应用程序和服务需要部署到这些区域。有时，每个区域的应用程序和服务可能具有独特的特性。如果我们更改我们的应用程序和服务，并将其部署到不同的服务器上，问题将变得更加复杂：

图 4.1：具有区域特性的基础设施设计

为了解决这个问题，我们可以应用 AWS CloudFormation 模板来构建动态基础设施。我们还可以将 AWS CloudFormation 模板部署到多个区域。有些 CloudFormation 模板只能在特定区域进行部署。

在本章中，我们将探讨如何使用 AWS CloudFormation StackSets 将 CloudFormation 堆栈部署到特定区域。

准备 CloudFormation StackSets

为了使用 CloudFormation StackSets，我们需要执行一些任务。这些任务是 AWS CloudFormation 的安全规则的一部分。让我们首先执行以下任务，开始使用 CloudFormation StackSets：

作为 AWS CloudFormation 管理员从 IAM 用户获取用户 ID
创建 IAM 角色，AWSCloudFormationStackSetAdministrationRole
创建服务角色，AWSCloudFormationStackSetExecutionRole

我们将在接下来的章节中讨论这些任务。

从 IAM 用户获取用户 ID

首先，您应该在 AWS IAM 上拥有管理员账户。复制您的 IAM 账户中的 ARN 用户，您可以在 AWS IAM 管理控制台的console.aws.amazon.com/iam/查看。例如，您可以拥有如下 ARN 用户账户：

arn:aws:iam::123456789012:user/myusername

从 ARN 用户的账户号中获取用户 ID。从前面的 ARN 用户中，我们可以获得123456789012作为用户 ID。我们将使用此用户 ID 来附加 CloudFormation 策略。

接下来，我们将在 IAM 管理控制台创建名为AWSCloudFormationStackSetAdministrationRole的 IAM 角色。

创建 AWSCloudFormationStackSetAdministrationRole IAM 角色

要构建 CloudFormation StackSets，我们应创建一个名为AWSCloudFormationStackSetAdministrationRole的 IAM 角色。这是 AWS 要求的。如果我们不创建，创建 CloudFormation StackSet 时将会遇到错误。

我们可以使用 CloudFormation Stack 创建一个名为AWSCloudFormationStackSetAdministrationRole的 IAM 角色。首先，我们需要创建 CloudFormation 模板。在本例中，我们使用以下 YAML 格式：

AWSTemplateFormatVersion: 2010-09-09
Description: Configure the AWSCloudFormationStackSetAdministrationRole to enable use of AWS CloudFormation StackSets.

Resources:
  AdministrationRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: AWSCloudFormationStackSetAdministrationRole
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service: cloudformation.amazonaws.com
            Action:
              - sts:AssumeRole
      Path: /
      Policies:
        - PolicyName: AssumeRole-AWSCloudFormationStackSetExecutionRole
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - sts:AssumeRole
                Resource:
                  - "arn:aws:iam::*:role/AWSCloudFormationStackSetExecutionRole"

您可以将这些脚本保存到名为AWSCloudFormationStackSetAdministrationRole.yaml的文件中。

现在，您可以导航到 AWS CloudFormation 仪表板，console.aws.amazon.com/cloudformation/，并创建一个新的 CloudFormation 堆栈。上传AWSCloudFormationStackSetAdministrationRole.yaml文件。为其指定堆栈名称，例如AWSCloudFormationStackSetAdministrationRole，如下图所示：

图 4.2：添加 CloudFormation 堆栈以创建 IAM 角色，AWSCloudFormationStackSetAdministrationRole

完成后，点击“下一步”按钮，直到完成此任务。阅读第二章《构建您的第一个 AWS CloudFormation 项目》和第三章《开发 AWS CloudFormation 模板》，了解如何使用 CloudFormation 堆栈。创建 CloudFormation 堆栈后，您应能在 CloudFormation 堆栈仪表板上看到您的 CloudFormation 堆栈，如下图所示：

图 4.3：创建AWSCloudFormationStackSetAdministrationRole角色已完成

如果您看到堆栈状态为 CREATE_COMPLETE，则表示您的 CloudFormation 堆栈已成功创建。现在，您可以通过打开 IAM AWS 管理控制台来验证它。打开浏览器并访问console.aws.amazon.com/iam/。

在管理控制台中，点击左侧菜单中的“角色”。您应该能在角色列表中看到AWSCloudFormationStackSetAdministrationRole：

图 4.4：检查 AWSCloudFormationStackSetAdministrationRole IAM 角色仪表板

您已在 AWS IAM 中创建了AWSCloudFormationStackSetAdministrationRole角色。接下来，我们应创建一个名为AWSCloudFormationStackSetExecutionRole的服务角色。

创建服务角色 – AWSCloudFormationStackSetExecutionRole

现在我们已经在 IAM 角色中创建了AWSCloudFormationStackSetAdministrationRole角色，接下来我们将创建一个名为AWSCloudFormationStackSetExecutionRole的服务角色。

我们可以使用 CloudFormation 创建服务角色。您可以编写以下脚本来创建 CloudFormation 模板：

AWSTemplateFormatVersion: 2010-09-09
Description: Configure the AWSCloudFormationStackSetExecutionRole to enable use of your account as a target account in AWS CloudFormation StackSets.

Parameters:
  AdministratorAccountId:
    Type: String
    Description: AWS Account Id of the administrator account (the account in which StackSets will be created).
    MaxLength: 12
    MinLength: 12

Resources:
  ExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: AWSCloudFormationStackSetExecutionRole
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              AWS:
                - !Ref AdministratorAccountId
            Action:
              - sts:AssumeRole
      Path: /
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/AdministratorAccess

将这些脚本保存到名为AWSCloudFormationStackSetExecutionRole.yaml的文件中。

此服务需要一个管理员帐户，以便它可以在 CloudFormation 上运行服务。我们已经准备了 IAM 用户并复制了该用户的 ARN。现在，您可以打开浏览器并导航至 CloudFormation 仪表盘。将AWSCloudFormationStackSetExecutionRole.yaml文件上传到 AWS CloudFormation 堆栈。填写您的堆栈名称和 IAM 用户的 ARN，例如123456789012。

您可以在以下截图中看到堆栈屏幕：

图 4.5：创建服务角色，AWSCloudFormationStackSetExecutionRole

您可以按照已创建的堆栈说明进行操作。完成后，您可以检查堆栈的创建状态。确保堆栈完成：

图 4.6：AWSCloudFormationStackSetExecutionRole 服务角色已完成

我们已经创建了服务角色AWSCloudFormationStackSetExecutionRole。现在，我们准备创建一个 StackSet。接下来，我们将使用管理控制台和 AWS CLI 创建一个 StackSet。

使用管理控制台实现 StackSets

在本节中，我们将使用Web 管理控制台（WMC）创建一个 StackSet。您应该已经创建了 IAM 角色AWSCloudFormationStackSetAdministrationRole和服务角色AWSCloudFormationStackSetExecutionRole。

现在，您可以打开浏览器并导航至 CloudFormation StackSet 仪表盘：console.aws.amazon.com/cloudformation/stacksets/home。您应该看到如图 4.7所示的仪表盘：

图 4.7：CloudFormation StackSets 仪表盘

默认情况下，CloudFormation 管理控制台显示堆栈仪表盘。您可以通过点击主菜单中的 StackSets 菜单来选择 StackSets 仪表盘，如图 4.8所示：

图 4.8：从主菜单打开 CloudFormation StackSets 仪表盘

在本节中，我们将执行以下任务：

创建新的 StackSet
将一个 CloudFormation 堆栈添加到 StackSet
从 StackSet 中删除 CloudFormation 堆栈

我们将在接下来的部分中执行这些任务。

创建新的 StackSet

在本节中，我们将使用管理控制台创建一个 StackSet。一个 StackSet 由在一个或多个区域部署的堆栈组成。

创建 StackSet 时需要遵循一些步骤。执行以下步骤：

打开浏览器并导航至 CloudFormation StackSets 仪表盘：console.aws.amazon.com/cloudformation/stacksets/home。
您应该看到如图 4.7所示的 CloudFormation StackSets 仪表盘。
要创建一个新的 StackSet，点击创建 StackSet 按钮。
点击后，您应该看到如图 4.9所示的屏幕：

图 4.9：通过选择模板创建 StackSet

选择以下模板中的一个样本模板选项。
点击启用 AWS Config 模板。完成后，点击下一步按钮。
你应该看到如图 4.10所示的屏幕：

图 4.10：填写 StackSet 名称和属性

填写你的 StackSet 名称，例如 my-stackset。完成后，点击下一步按钮。
你应该看到如图 4.11所示的屏幕。选择“在账户中部署堆栈”选项。
在文本框中输入你的 ARN 用户。你可以为该 StackSet 填写一些账户：

图 4.11：为 StackSet 设置账户

向下滚动，直到看到如图 4.12所示的屏幕。为你的账户选择一个或多个区域。
在我们的演示中，我选择了美国东部（弗吉尼亚州北部）和亚太地区（新加坡）区域。
完成后，点击下一步按钮：

图 4.12：设置目标区域

你应该会看到如图 4.13所示的屏幕。在此表单中，我们不进行任何操作。点击下一步按钮继续：

图 4.13：为 StackSet 设置选项

你将看到审核屏幕，如图 4.14所示。审核你的输入。点击创建按钮以开始创建 StackSet：

图 4.14：创建 StackSet 的确认

你应该会看到如图 4.15所示的屏幕。你应该看到带有启用 AWS Config 模板的 StackSet：

图 4-15：StackSet 已创建

若要查看你的 StackSet 是否创建成功，请向下滚动查看操作和堆栈的状态。你应该看到如图 4.16所示的屏幕。你可以看到你的操作和区域堆栈状态。如果 StackSet 操作状态是 SUCCEEDED，说明你的 StackSet 创建成功。你还应该看到所有堆栈的状态为 CURRENT，如以下截图所示：

图 4.16：检查操作和堆栈的状态

有关操作和堆栈部分的一些状态信息可以在表 4.1和表 4.2中找到：

StackSets 操作状态	操作
RUNNING	操作当前正在进行
SUCCEEDED	操作已完成，且未超出操作的失败容忍度
FAILED	无法完成操作的堆栈数量超过了用户定义的失败容忍度
STOPPING	操作正在停止中，应用户请求
STOPPED	操作已停止，应用户请求

表 4.1：StackSets 操作状态信息列表

堆栈实例状态	操作
CURRENT	堆栈当前与堆栈集保持最新状态
OUTDATED	堆栈当前不是最新的
INOPERABLE	删除 Stack 实例操作失败，导致堆栈处于不稳定状态

表 4.2：Stack 实例的状态信息列表

现在，你已经通过管理控制台在 CloudFormation 上创建了 StackSet。接下来，我们将为 StackSet 创建一个或多个堆栈。

添加新的 CloudFormation 堆栈

您可以在现有 StackSet 上添加额外的堆栈。在这种情况下，您不能使用新的 CloudFormation 堆栈模板。您应当使用已经部署的 StackSet 中的现有堆栈模板。我们可以使用跨账户和跨区域的配置。

在本演示中，我将为现有的 StackSet 添加一个新区域。执行以下任务以将 CloudFormation 堆栈添加到 StackSet 中：

打开浏览器，导航到 CloudFormation StackSets 仪表盘：console.aws.amazon.com/cloudformation/stacksets/home。
您应该会看到如图 4.17所示的屏幕：

图 4.17：CloudFormation StackSets 列表

选择一个将要添加堆栈的 StackSet。点击 Actions 按钮，您将看到如下截图中的菜单：

图 4.18：StackSets 仪表盘上的操作菜单

点击 Manage stacks in StackSet 菜单。您应该会看到如图 4.19所示的屏幕。选择 Create stacks 选项：

图 4.19：选择一个选项以添加堆栈

完成后，点击 Next 按钮。您应该会看到如图 4.20所示的屏幕。选择 Create stacks in accounts 选项。填写您的 AWS IAM 账户信息。您还应当指定用于目标部署的区域：

图 4.20：设置账户及其区域

填写完数据后，点击 Next 按钮。您应该会看到如图 4.21所示的屏幕。设置堆栈参数。完成后，点击 Next 按钮：

图 4.21：设置 StackSet 参数

您将看到一个确认屏幕，如图 4.22所示。检查您的输入数据。完成后，点击 Create 按钮来配置您的堆栈：

图 4.22：添加堆栈的确认界面

点击后，CloudFormation 将执行此任务。您应该会看到您的堆栈出现在 StackSet 属性中：

图 4.23：在现有 StackSet 上创建新堆栈

添加堆栈的操作已经结束。如果需要，您可以继续添加更多堆栈。接下来，您将学习如何从 StackSets 中删除堆栈。

删除 CloudFormation 堆栈

如果您认为某些堆栈将不再使用，您可以从 StackSets 中删除它们。在本节中，我们将学习如何从 StackSets 中删除堆栈。

按照以下步骤删除堆栈：

打开浏览器，导航到 CloudFormation StackSets（参见图 4.17）。选择并打开您的 StackSet。
点击 Manage StackSet 按钮，您将看到如下截图所示的屏幕：

图 4.24：选择删除现有堆栈的选项

选择 Delete stacks 选项。点击 Next 按钮。点击后，您应该会看到如下截图中的屏幕：

图 4.25：填写将要删除的账户和区域

填写您的账户及其区域信息。点击 Next 按钮继续。
您应该会看到如图 4.26所示的确认屏幕。点击删除堆栈按钮以确认删除：

图 4.26：确认删除栈账户和区域

您可以继续删除其他栈。这是删除栈的结束。接下来，您可以使用 AWS CLI 执行 StackSets 操作。

使用 AWS CLI 创建 StackSets

在上一节中，我们使用 CloudFormation 管理控制台构建了 StackSets。在本节中，我们将使用 AWS CLI 来管理 CloudFormation StackSets。AWS CLI 的 CloudFormation 命令列表可以在docs.aws.amazon.com/cli/latest/reference/cloudformation/index.html#cli-aws-cloudformation找到。

我们将使用 AWS CLI 创建一个 StackSet。请按照以下步骤操作：

配置您的工作区域。AWS 区域的列表可以在docs.aws.amazon.com/general/latest/gr/rande.html找到。
例如，我将我的区域更改为us-east-1区域。您可以在终端中输入以下命令：

$ aws configure get region
$ aws configure set region us-east-1

执行后，您可以使用aws configure get region命令来验证。您可以在下方的截图中看到我的程序输出：

图 4.27：在 AWS CLI 上配置工作区域

使用 Enable AWS Config 模板创建 StackSet。该模板可在s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSConfig.yml获取。
创建一个名为my-stackset的 StackSet。您可以使用create-stack-set命令。输入以下命令：

$ aws cloudformation create-stack-set --stack-set-name my-stackset --template-url https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSConfig.yml --capabilities CAPABILITY_IAM

执行后，您应该获得 StackSetId，可以用来检索您的 StackSet 信息。您可以在下方的截图中看到我创建 StackSet 时的 StackSetId：

图 4.28：通过 AWS CLI 创建 StackSet

要从您的 StackSet 获取创建状态，请使用list-stack-sets命令。
如果您的 StackSet 创建成功，您应该看到 StackSet 状态为 ACTIVE：

图 4.29：通过 AWS CLI 获取 StackSets 列表

我们可以继续创建栈实例。我们定义账户及其区域。
当传入 StackSet 名称、账户和区域时，使用create-stack-instances命令。
我在名为my-stackset的 StackSet 上创建了一个栈实例。我设置了一个账户，123456789012，目标区域为us-east-1和us-east-2。您可以输入以下命令：

$ aws cloudformation create-stack-instances --stack-set-name my-stackset --accounts '["123456789012"]' --regions '["us-east-1","us-east-2"]' --operation-preferences FailureToleranceCount=0,MaxConcurrentCount=1

执行后，您应该获得 OperationId 字段。它将用于检查您的执行情况。您可以在下方的截图中看到我的程序输出：

图 4.30：创建栈实例

要检查并验证您的操作状态，使用describe-stack-set-operation命令，传入 StackSet 名称和operation-id。
例如，我想检查名为 my-stackset 的 StackSet，操作 ID 为 7c5d3b1e-844c-4e02-9cb2-ad42e3e4d53d。我输入以下命令：

$ aws cloudformation describe-stack-set-operation --stack-set-name my-stackset --operation-id 7c5d3b1e-844c-4e02-9cb2-ad42e3e4d53d

您可以在 图 4.31 中看到我的程序输出示例。如果您看到您的操作 ID 状态为 SUCCEEDED，说明您的堆栈实例已经创建：

图 4.31：检查操作状态

这就是使用 AWS CLI 创建 CloudFormation StackSet 的结束。您可以进一步练习 CloudFormation StackSet 的开发。

接下来，我们将学习如何编辑 CloudFormation StackSets。

编辑 CloudFormation StackSets

有时，您可能需要编辑 StackSet 参数。您可以执行此任务。在本节中，我们将探讨如何使用 CloudFormation 管理控制台修改 StackSets。

您可以执行以下步骤来编辑 StackSet：

打开浏览器并导航到 StackSets 仪表板，如 图 4.17 所示。选择您想要编辑的 StackSet。
点击 Actions 按钮并选择 Manage stacks in StackSet 菜单（见 图 4.18）。
您应该会看到 图 4.32 所示的屏幕：

图 4.32：选择编辑 StackSet

选择 Edit StackSet 选项。完成后，点击 Next 按钮。
您应该会看到以下截图所示的屏幕：

图 4.33：选择要编辑的 StackSet 模板

在这种情况下，我们将修改当前模板，因此选择 Current template: Update my-stackset 选项。完成后，点击 Next 按钮。
您应该能看到显示模板的屏幕。例如，以下截图显示的是启用 AWS Config 模板：

图 4.34：配置 StackSet 参数

点击 Next 按钮。按照下一步确认并执行您的 StackSet 更改。完成后，您的 StackSet 已被修改。

您已经学会了如何修改 StackSet 模板。接下来，我们将学习如何删除 StackSets。

删除 CloudFormation StackSets

在本节中，我们将学习如何删除 StackSets。要删除 StackSet，您应该先删除 StackSet 中的所有堆栈。如果没有删除，您在删除 StackSet 时将会遇到错误。

您可以执行以下步骤来删除 StackSet：

打开浏览器并导航到 CloudFormation StackSets 仪表板，网址为 console.aws.amazon.com/cloudformation/stacksets/home。选择您想要删除的 StackSet。
点击 Actions 按钮，您应该会看到以下截图所示的菜单：

图 4.35：删除 StackSet 的菜单

您应该会看到如 图 4.36 所示的确认对话框。点击“是，删除”按钮：

图 4.36：删除 StackSet 的确认界面

如果您的 StackSet 中有堆栈，您应该先删除这些堆栈再删除 StackSet。如果不这样做，将会出现错误，如下图所示：

图 4.37：删除 StackSet 时出现错误

你可以设置需要移除的账户和目标区域。你可以在图 4.38中查看正在删除的账户和区域。完成后，你可以返回执行第 2 步中的操作：

图 4.38：从 StackSet 中移除所有堆栈

你已经从 CloudFormation 中删除了一个 StackSet。我建议你删除不再使用的 StackSets。我还建议你学习与 CloudFormation StackSets 相关的最佳实践，你可以在 docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-bestpractices.html 中找到这些最佳实践。

总结

你已经学习了如何使用 WMC 和 AWS CLI 创建 CloudFormation StackSets。你还学习了如何通过附加账户和目标区域将堆栈添加到 StackSet 中。然后，你学习了如何从 StackSet 中管理堆栈，例如编辑和删除它们。最后，你学习了如何修改和删除当前的 StackSet。

在下一章，我们将学习如何使用 AWS CloudFormation 构建 AWS Lambda 函数。

问题

请回答以下问题以评估你的学习成果：

什么是 CloudFormation StackSet？
StackSet 中最多可以有多少个堆栈？

第五章：使用 AWS CloudFormation 构建 Lambda 函数

无服务器解决方案是一种解决动态基础设施问题的技术手段。在本章中，我们将探讨如何使用 AWS Lambda 实现无服务器解决方案。我们将通过 AWS CloudFormation 构建 AWS Lambda。

本章将涵盖以下主题：

介绍 AWS Lambda
构建 AWS Lambda
为 AWS Lambda 函数创建 CloudFormation 模板
通过 CloudFormation 部署 AWS Lambda
通过 CloudFormation 部署 AWS Lambda 和 DynamoDB
通过 CloudFormation 将 AWS Lambda 部署到特定区域

介绍 AWS Lambda

AWS Lambda 是一种 AWS 服务，提供无服务器计算服务。我们可以使用多种编程语言构建函数，然后 AWS Lambda 将负责我们的基础设施及其扩展。

我们可以通过 Lambda 函数访问其他 AWS 资源。在下图中，您可以看到 Lambda 函数如何访问 AWS 资源。客户端应用，如浏览器、移动设备或 CLI，可以调用我们的 Lambda 函数：

图 5.1：互联网环境中的 Lambda 函数

在本章中，我们将使用 CloudFormation 探讨 Lambda 函数。我们还将结合其他 AWS 资源，嵌入 Lambda 函数中。

接下来，我们将构建一个简单的 Lambda 函数，以便理解 Lambda 函数如何工作。

构建 AWS Lambda

在我们通过 CloudFormation 构建 AWS Lambda 之前，我们将首先开发 AWS Lambda 应用。目标是让没有 AWS Lambda 经验的读者了解 AWS Lambda 开发。

AWS Lambda 可在多个 AWS 区域中运行。访问 AWS Lambda 管理控制台：console.aws.amazon.com/lambda/。可以在图 5.2中看到 AWS Lambda 管理控制台窗口的示例。然后，选择您用于 AWS Lambda 开发的区域。

在测试阶段，我们构建一个简单的 AWS Lambda 应用。我们使用 Node.js 来实现 Lambda 函数。为了实现 AWS Lambda 函数，我们将完成以下三个任务：

创建 IAM 角色
开发 AWS Lambda 函数
测试 AWS Lambda

接下来的章节将遵循这些步骤。AWS Lambda 管理控制台如下所示：

图 5.2：AWS Lambda 管理控制台

创建 IAM 角色

亚马逊 AWS 对 AWS 资源应用安全策略。为了访问 AWS Lambda 资源，我们需要应用一个策略，以便创建和执行 AWS Lambda。在这一节中，我们将在 IAM 角色部分创建角色。

要创建 IAM 角色，可以按照以下步骤操作：

打开浏览器并访问 console.aws.amazon.com/iam/。
点击“角色”菜单打开 IAM 角色列表；你应该会看到以下截图：

图 5.3：AWS IAM 管理控制台

要创建角色，点击“创建角色”按钮，进入图 5.4所示的界面。
选择 AWS 服务中的 Lambda 选项，然后点击“下一步: 权限”按钮：

图 5.4: 选择受信实体

点击按钮后，您应该会看到 图 5.5 中显示的截图。系统会提示您选择权限策略。
选择 AWSLambdaFullAccess 策略以便完全访问 AWS Lambda 资源，然后点击“下一步: 审查”按钮：

图 5.5: 为 IAM 角色附加权限策略

您会看到一个审查屏幕，如 图 5.6 所示。请检查您的输入。
填写您的新角色名称，例如my-simple-lambda-role。完成后，点击“创建角色”按钮以创建 IAM 角色：

图 5.6: 审查已创建的角色

完成后，您可以在 IAM 角色中查看您的新角色。例如，以下是我的 IAM 角色，my-simple-lambda-role：

图 5.7: IAM 管理控制台中的 IAM 角色列表

您已成功创建一个 IAM 角色。在下一部分中，您将开发 AWS Lambda。

使用 Web 管理控制台 (WMC) 开发 AWS Lambda

我们已创建一个将应用于 AWS Lambda 的 IAM 角色。在本节中，我们将开发一个简单的 AWS Lambda 函数。我们使用 Node.js 应用程序。我们接收一个消息输入 msg，然后将其发送给调用者。

执行以下步骤来开发 AWS Lambda 函数：

打开浏览器，导航至 AWS Lambda 管理控制台：console.aws.amazon.com/lambda/。
点击“创建函数”按钮来创建一个新的 Lambda 函数。完成后，您将看到以下屏幕：

图 5.8: 创建 AWS Lambda

填写 Lambda 函数的名称，例如my-simple-lambda。
从运行时下拉菜单中选择 Node.js。在此演示中，我使用的是 Node.js 6.10。您可以使用最新版本的 Node.js。
在角色下拉菜单中，选择“选择现有角色”选项，然后选择您创建的 IAM 角色。
完成后，点击“创建函数”按钮以创建您的 Lambda 函数。
您应该会得到一个带有 Web 编辑器的 Lambda 函数，如下图所示：

图 5.9: 编写 Lambda 函数代码

我们在 Web 编辑器中编写我们的 Node.js 程序。请编写以下脚本：

exports.handler = (event, context, callback) => {
    var data = event['msg'];
    callback(null, 'Received: ' + data);
};

点击“保存”按钮保存您的函数，然后发布您的 Lambda 函数。
在操作下拉菜单中点击“发布新版本”。系统会提示您填写版本描述，如下图所示：

图 5.10: 发布 AWS Lambda 时提供版本说明

现在，您的 AWS Lambda 已发布。接下来，我们将测试我们的 AWS Lambda。

测试 AWS Lambda

在前面的部分中，我们使用 WMC 创建并发布了 AWS Lambda。在本节中，我们将对我们的 AWS Lambda 函数进行测试。我们将使用两种方法进行测试：

来自 AWS Lambda 管理控制台的测试事件工具
AWS CLI

第一种方法是使用 AWS Lambda 管理控制台。按照以下步骤操作：

打开你的浏览器并访问 AWS Lambda 管理控制台。
打开你的 Lambda 函数，然后点击 Test 按钮（见 图 5.9）。你应该会看到以下界面：

图 5.11：创建测试事件

选择创建新的测试事件选项并填写事件名称。
在代码表单中，你可以编写以下脚本：

{
  "msg": "testing value"
}

完成后，点击 Create 按钮。
通过点击 Test 按钮测试你的 Lambda 函数。如果成功，你应该会收到来自 Lambda 的响应，如下所示：

图 5.12：显示测试结果

你已经通过管理控制台完成了 Lambda 函数的测试。

接下来，我们可以使用 AWS CLI 进行测试。要安装 AWS CLI，请阅读 aws.amazon.com/cli/ 上的说明。对于 Windows，你可以从 s3.amazonaws.com/aws-cli/AWSCLI64.msi 下载 64 位版本，或从 s3.amazonaws.com/aws-cli/AWSCLI32.msi 下载 32 位版本：

如果你使用的是 Linux 或 macOS，可以通过 pip 安装 AWS CLI。你可以输入以下命令：

$ pip install awscli

现在，我们可以进行 AWS Lambda 测试；Lambda 函数名称是 my-simple-lambda。输入以下命令：

$ aws lambda invoke --invocation-type RequestResponse --function-name my-simple-lambda --payload '{"msg": "this is AWS CLI"}' output.txt

一旦成功，你应该看到以下响应输出：

图 5.13：通过 AWS CLI 测试 AWS Lambda

打开输出文件 output.txt，使用你的文本编辑器。例如，我使用 nano 并输入以下命令：

$ nano output.txt

你应该能看到输出文件的内容，这是来自 AWS Lambda 的响应。例如，这是我的输出文件：

图 5.14：通过调用 Lambda 打开输出文件

你已经完成了 AWS Lambda 函数的测试。接下来，我们将通过 AWS CloudFormation 构建 AWS Lambda。

AWS Lambda 函数的 CloudFormation 模板

AWS CloudFormation 提供了一个 基础设施即代码（IaC）解决方案，用于构建动态基础设施。在前一部分中，我们学习了如何构建 AWS Lambda。现在，我们将继续通过 CloudFormation 来构建 AWS Lambda。

AWS Lambda 的 CloudFormation 模板可以在 docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html 找到。该模板可以用 JSON 描述如下：

{
  "Type" : "AWS::Lambda::Function",
  "Properties" : {
    "Code" : Code,
    "DeadLetterConfig" : DeadLetterConfig,
    "Description" : String,
    "Environment" : Environment,
    "FunctionName" : String,
    "Handler" : String,
    "KmsKeyArn" : String,
    "MemorySize" : Integer,
    "ReservedConcurrentExecutions" : Integer,
    "Role" : String,
    "Runtime" : String,
    "Timeout" : Integer,
    "TracingConfig" : TracingConfig,
    "VpcConfig" : VPCConfig,
    "Tags" : [ Resource Tag, ... ]
  }
}

对于 YAML，我们可以如下定义 AWS Lambda 的 CloudFormation 模板：

Type: "AWS::Lambda::Function"
Properties: 
  Code:
    Code
  DeadLetterConfig:
    DeadLetterConfig
  Description: String
  Environment:
    Environment
  FunctionName: String
  Handler: String
  KmsKeyArn: String
  MemorySize: Integer
  ReservedConcurrentExecutions: Integer
  Role: String
  Runtime: String
  Timeout: Integer
  TracingConfig:
    TracingConfig
  VpcConfig:
    VPCConfig
  Tags: 
    Resource Tag

并非所有来自 Lambda 的 CloudFormation 模板属性都是必需的。以下是必需的属性：

Code：来自 Lambda 函数的源代码内容。你可以将源代码作为内联文本插入，也可以将其放入 Amazon S3。
Handler：Lambda 函数（在你的源代码中）的名称，Lambda 调用它来启动执行你的代码。
Role：应用于执行 AWS Lambda 函数的 IAM 角色。这是 AWS 身份的 Amazon 资源名称（ARN）。确保你的 IAM 角色具有执行 Lambda 函数的权限，包括其他所需资源的权限。
Runtime：Lambda 函数的运行环境。例如，它可以是 Python 或 Node.js。

接下来，我们将使用 CloudFormation 部署 AWS Lambda。

使用 AWS CloudFormation 部署 Lambda 函数

在这一部分，我们将学习如何使用 AWS CloudFormation 部署 Lambda 函数。我们的 Lambda 函数场景类似于之前示例中的 my-simple-lambda 函数。

首先，我们创建一个 CloudFormation 模板来创建 AWS Lambda。然后，我们将模板上传到 CloudFormation。接着，我们启动 AWS Lambda。在接下来的部分，我们将执行这些任务。

为 Lambda 函数创建一个 CloudFormation 模板

在通过 CloudFormation 部署 Lambda 函数之前，我们应该准备 CloudFormation 模板。我们可以使用 JSON 或 YAML 编写模板。

在这个示例中，我们按照之前的示例创建了 Lambda 函数。我们的 Lambda 函数接收 msg 输入，并将其传递给函数输出。我们还定义了一个参数 LambdaFunctionName 来获取 Lambda 函数的名称。对于 IAM 角色，我们创建了一个新的 IAM 角色，名为 TestLambdaExecutionRole，它将传递给 Lambda 函数。

以下是一个完整的 CloudFormation 模板（JSON 格式）：

{
    "Description" : "This is a simple Lambda function is Node.js",
    "Parameters": { 
        "LambdaFunctionName":{
            "Description": "AWS Lambda function name",
            "Type": "String"
        }
      },
    "Resources":{
        "TestLambdaFunction" : {
            "Type" : "AWS::Lambda::Function",
            "Properties" : {
                "FunctionName" : {
                    "Ref": "LambdaFunctionName"
                },
                "Handler" : "index.handler",
                "Role" : { "Fn::GetAtt" : ["TestLambdaExecutionRole", "Arn"] },
                "Code" : {
                    "ZipFile" : { "Fn::Join" : [ "\n", [ 
                        "exports.handler = (event, context, callback) => {",
                        " var data = event['msg'];",
                        " callback(null, 'Received: ' + data);", 
                        "}"
                    ]]}
                },
                "Timeout" : "10", 
                "Runtime" : "nodejs6.10"
            }
        },
        "TestLambdaExecutionRole": {
            "Type": "AWS::IAM::Role",
            "Properties": {
                "AssumeRolePolicyDocument": {
                    "Version": "2012-10-17",
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {
                                "Service": [
                                    "lambda.amazonaws.com"
                                ]
                            },
                            "Action": [
                                "sts:AssumeRole"
                            ]
                        }
                    ]
                },
                "Path": "/"
            }
        }
    }
}

将这些脚本保存到名为 Lambda-CloudFormation.json 的文件中。

以下是 YAML 格式的 CloudFormation 模板：

Description: This is a simple Lambda function is Node.js
Parameters:
  LambdaFunctionName:
    Description: AWS Lambda function name
    Type: String
Resources:
  TestLambdaFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName:
        Ref: LambdaFunctionName
      Handler: index.handler
      Role:
        Fn::GetAtt:
        - TestLambdaExecutionRole
        - Arn
      Code:
        ZipFile:
          Fn::Join:
          - "\n"
          - - exports.handler = (event, context, callback) => {
            - " var data = event['msg'];"
            - " callback(null, 'Received: ' + data);"
            - "}"
      Timeout: '10'
      Runtime: nodejs6.10
  TestLambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Principal:
            Service:
            - lambda.amazonaws.com
          Action:
          - sts:AssumeRole
      Path: "/"

将这些脚本保存到名为 Lambda-CloudFormation.yaml 的文件中。我们创建完 CloudFormation 模板文件后，将其部署到 CloudFormation。

将 AWS Lambda 部署到 CloudFormation

我们继续将 AWS Lambda 函数部署到 CloudFormation。我们上传 Lambda-CloudFormation.json 或 CloudFormation.yaml 文件作为 CloudFormation 模板。在这一部分，我们将创建一个 CloudFormation 堆栈，然后将模板文件放入堆栈中。

为了实现我们的示例，执行以下步骤：

打开浏览器并导航到 AWS CloudFormation 页面：console.aws.amazon.com/cloudformation/home。你应该看到以下界面：

图 5.15：来自 CloudFormation 管理控制台的表单

要创建一个新堆栈，请点击“创建新堆栈”按钮，你将看到如 图 5.16 所示的界面。
选择“上传模板到 Amazon S3”选项。
选择我们已经创建好的 CloudFormation 模板文件，然后点击“下一步”按钮：

图 5.16：选择 CloudFormation 模板

你应该看到如图 5.17所示的界面。填写堆栈名称和函数名称。例如，我设置堆栈名称为 test-lambda，函数名称为 my-lambda-cloudformation。完成后，点击下一步按钮：

图 5.17：填写堆栈和 Lambda 函数名称

你应该看到以下界面。在此界面上无需执行任何操作。只需点击下一步按钮：

图 5.18：设置 CloudFormation 参数

你应该看到以下回顾界面。检查所有输入，然后点击创建按钮以创建堆栈：

图 5.19：创建堆栈的回顾

点击创建按钮后，你应该看到 CloudFormation 仪表盘。确保你的堆栈已经创建并显示为 CREATE_COMPLETE 状态。以下截图确认了我的堆栈已被创建：

图 5.20：显示堆栈状态

你也可以在 AWS Lambda 管理控制台验证你的 Lambda 函数。
打开浏览器，访问 console.aws.amazon.com/lambda/home。你应该能看到通过 CloudFormation 创建的 Lambda 函数：

图 5.21：显示 AWS Lambda 列表

现在我们可以使用 AWS CLI 进行测试。例如，Lambda 函数名称是 my-lambda-cloudformation。我们可以通过输入以下命令来执行此测试：

$ aws lambda invoke --invocation-type RequestResponse --function-name my-lambda-cloudformation --payload '{"msg": "this is AWS CLI"}' output-lambda.txt

如果成功，你将得到以下响应输出：

图 5.22：通过 AWS CLI 调用 AWS Lambda 函数

如果你在通过 AWS CLI 调用 Lambda 函数时遇到安全问题，请验证你的账户权限。你可以在 IAM 管理控制台检查：console.aws.amazon.com/iam/。你的账户应该拥有 AWSLambdaExecute 和/或 AWSLambdaRole 权限。

调用 Lambda 函数后，打开输出文件以查看输出文件的内容。输入以下命令：

$ nano output-lambda.txt

你应该看到以下响应输出：

图 5.23：打开输出文件 output-lambda.txt

你已经学会了如何使用 CloudFormation 构建 AWS Lambda。接下来，我们将通过 CloudFormation 模板探索与 DynamoDB 数据库结合的 AWS Lambda 函数。

AWS Lambda 和 DynamoDB 的 CloudFormation

有时我们希望构建一个具备存储功能的 Lambda 函数。Amazon AWS 提供了可以与 AWS Lambda 集成的存储服务。在本节中，我们将探索如何在 AWS Lambda 中使用 DynamoDB。

AWS DynamoDB 是 AWS 提供的一项存储服务。它基于 NoSQL 存储。你可以通过访问其官方网站来查看 DynamoDB 的特点：aws.amazon.com/dynamodb/。AWS DynamoDB 提供了多种 SDK API，帮助你在自己的程序中访问 DynamoDB，例如 Java、JavaScript、Node.js、.NET、PHP、Python 和 Ruby。

从技术上讲，DynamoDB 操作起来非常简便。你可以使用 DynamoDB 管理控制台，访问 console.aws.amazon.com/dynamodb/。然后，你可以创建一个带有键属性的表。你可以在多个区域部署 DynamoDB，并且它能够带来客户访问的便利。

在本节中，我们将构建一个 Lambda 函数，将数据插入 DynamoDB。我们通过 CloudFormation 部署方法，使用 Node.js 实现 Lambda 函数：

图 5.24：Lambda 与 DynamoDB 的交互

为了实现我们的演示，我们将执行以下任务：

为 Lambda 和 DynamoDB 创建 CloudFormation 模板
部署 CloudFormation 模板
配置 Lambda 调用策略
测试 Lambda 函数

这些任务将在接下来的章节中探讨。

为 AWS DynamoDB 创建 CloudFormation 模板

AWS DynamoDB 的 CloudFormation 模板可以在 docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html 找到。该模板可以用 JSON 描述如下：

{
  "Type" : "AWS::DynamoDB::Table",
  "Properties" : {
    "AttributeDefinitions" : [ AttributeDefinition, ... ],
    "GlobalSecondaryIndexes" : [ GlobalSecondaryIndexes, ... ],
    "KeySchema" : [ KeySchema, ... ],
    "LocalSecondaryIndexes" : [ LocalSecondaryIndexes, ... ],
    "PointInTimeRecoverySpecification" : PointInTimeRecoverySpecification,
    "ProvisionedThroughput" : ProvisionedThroughput,
    "SSESpecification" : SSESpecification,
    "StreamSpecification" : StreamSpecification,
    "TableName" : String,
    "Tags" : [ Resource Tag, ... ],
    "TimeToLiveSpecification" : TimeToLiveSpecification
  }
}

我们可以按如下方式在 YAML 中定义模板：

Type: "AWS::DynamoDB::Table"
Properties:
  AttributeDefinitions:
    - AttributeDefinition
  GlobalSecondaryIndexes:
    - GlobalSecondaryIndexes
  KeySchema:
    - KeySchema
  LocalSecondaryIndexes:
    - LocalSecondaryIndexes
  PointInTimeRecoverySpecification: 
    PointInTimeRecoverySpecification
  ProvisionedThroughput:
    ProvisionedThroughput
  SSESpecification:
    SSESpecification
  StreamSpecification:
    StreamSpecification
  TableName: String
  Tags: 
    - Resource Tag
  TimeToLiveSpecification: 
    TimeToLiveSpecification

你应该定义三个必需的属性——AttributeDefinitions、KeySchema 和 ProvisionedThroughput：

AttributeDefinitions：由描述表和索引的键架构的属性列表组成。
KeySchema：由构成表主键的属性组成。你可以在 HASH 或 RANGE 中定义 KeySchema 类型。
ProvisionedThroughput：这描述了吞吐量值，即 ReadCapacityUnits 和 WriteCapacityUnits 属性的值。

接下来，我们将创建一个 CloudFormation 模板来构建 Lambda 和 DynamoDB 资源。

为 Lambda 和 DynamoDB 构建 CloudFormation 模板

为了构建 Lambda 和 DynamoDB 的 CloudFormation 模板，我们可以修改之前的 Lambda CloudFormation 模板。我们添加 DynamoDB 资源和策略，并替换 Lambda 函数以访问 DynamoDB。

接下来，我们将开始创建 Lambda 函数。

从 Lambda 函数访问 DynamoDB

我们在 Lambda 函数中的场景是从 Lambda 函数的参数输入中获取 JSON 数据，然后将其插入 DynamoDB。

我们可以通过 AWS SDK 从 Node.js 应用程序中使用 DynamoDB 对象。在从 Lambda 函数获取数据后，我们可以使用 putItem() API 将数据插入 DynamoDB。你可以在 docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html 阅读更多关于该 API 的信息。

例如，我们将数据插入名为 mydynamodb 的 DynamoDB 表中。我们可以按如下方式实现我们的 Lambda 函数：

var AWS = require('aws-sdk');
var ddb = new AWS.DynamoDB();
exports.handler = (event, context, callback) => {
    var params = {
        TableName: 'mydynamodb',
        Item: {
           'id': {S:new Date().getTime().toString()},
           'email': {S:event.email},
           'name': {S:event.name},
           'country' : {S:event.country},
           'age' : {N:event.age},
        }
    };
    ddb.putItem(params, function(err, data) {
       if (err) {
          callback(err, 'Error');
       } else {
          callback(null, 'Insert data was successful');
       }
    });
}

如果操作成功，此 Lambda 函数将返回Insert data was successful消息。否则，我们将收到Error消息，并附有详细的错误描述。

创建 CloudFormation 模板

我们修改了上一节中的 Lambda CloudFormation 模板。我们将 Code 属性的内容替换为我们的 Lambda 函数代码。我们还定义了一个名为 myDynamoDBTable 的 DynamoDB 资源。

由于我们的 Lambda 函数需要访问 DynamoDB，我们应该在 TestLambdaExecutionRole 中配置额外的策略。我们添加了 ManagedPolicyArns 属性，以授予调用 dynamodb:PutItem 操作的权限。

以下是我们为 Lambda 和 DynamoDB 修改后的 CloudFormation 模板（JSON 格式，lambda-dynamodb.json）：

{ 
  .....

        },
        "myDynamoDBTable" : {
            "Type" : "AWS::DynamoDB::Table",
            "Properties" : {
                "TableName": "mydynamodb",
                "AttributeDefinitions": [ 
                  {"AttributeName" : "id", "AttributeType" : "S"}
                ],
                "KeySchema": [
                  { "AttributeName": "id", "KeyType": "HASH" }
                ],
                "ProvisionedThroughput" : {
                   "ReadCapacityUnits" : "5",
                   "WriteCapacityUnits" : "5"
                } 
            }
        },
        "TestLambdaExecutionRole": {
...                
                            "Resource": [
                                {"Fn::Join" : ["", ["arn:aws:dynamodb:", {"Ref": "AWS::Region"}, ":", {"Ref": "AWS::AccountId"}, ":table/mydynamodb"]]}
                            ]
                        }]
                    }
                }],
...
        }
    }
  }

以下是 CloudFormation 模板的 YAML 版本（lambda-dynamodb.yaml）：

...
Resources:
  ...
      Code:
        ZipFile:
          Fn::Join:
          - "\n"
          -
      Timeout: '10'
      Runtime: nodejs6.10
  myDynamoDBTable:
    Type: AWS::DynamoDB::Table
    Properties:
 ...
      - AttributeName: id
        KeyType: HASH
      ProvisionedThroughput:
        ReadCapacityUnits: '5'
        WriteCapacityUnits: '5'
  TestLambdaExecutionRole:
...
      ManagedPolicyArns:
      - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      Policies:
      - PolicyName: dynamodb
        PolicyDocument:
          Version: '2012-10-17'
...

保存所有 CloudFormation 模板文件，lambda-dynamodb.json 和/或 lambda-dynamodb.yaml。

接下来，我们将把模板文件部署到 AWS CloudFormation。

部署 CloudFormation 模板

准备好 CloudFormation 模板文件后，我们可以继续在 AWS CloudFormation 中部署该模板。在本节中，我们将使用 CloudFormation 管理控制台。

我们使用相同的方法将 CloudFormation 模板文件上传到 AWS CloudFormation。请执行以下步骤：

打开您的浏览器并访问 CloudFormation 管理控制台，网址为 console.aws.amazon.com/cloudformation。
上传我们创建的 CloudFormation 模板文件，以访问 Lambda 和 DynamoDB 资源。
您可以上传 lambda-dynamodb.json 或 lambda-dynamodb.yaml。
完成后，系统将要求您填写堆栈名称和 Lambda 函数名称：

图 5.25：创建一个新的 CloudFormation 堆栈

点击“下一步”按钮并按照指示完成上传过程。
处理完成后，检查 CloudFormation 仪表板上的 CloudFormation 状态：

图 5.26：CloudFormation 堆栈已创建

确保您的 CloudFormation 堆栈具有 CREATE_COMPLETE 状态，以便继续执行下一步。
您可以在 DynamoDB 管理控制台中验证名为 mydynamodb的 DynamoDB 表，地址为 console.aws.amazon.com/dynamodb/。您应该能看到如下截图中的 DynamoDB 表 mydynamodb：

图 5.27：通过 CloudFormation 创建的 DynamoDB 表，mydynamodb

在 Lambda 管理控制台（console.aws.amazon.com/lambda/）中验证您的 Lambda 函数。您应该能在以下截图中看到您的 Lambda 函数 lambda-dynamodb-func：

图 5.28：通过 CloudFormation 创建的 Lambda 函数，lambda-dynamodb-func

现在，你已经完成了通过 CloudFormation 将 Lambda 函数与 DynamoDB 资源部署完成。

接下来，我们将配置用户策略以调用 Lambda 函数。

配置 Lambda 调用策略

我们将继续通过 AWS CLI 调用 Lambda 函数。为了能够调用 Lambda 函数，你的 AWS CLI 用户应具有访问 Lambda 和 DynamoDB 的访问策略。

在本节中，我们添加 DynamoDB 权限以访问此资源。请按照以下步骤操作：

打开浏览器并访问 IAM 管理控制台，console.aws.amazon.com/iam/。
打开你的账户，点击“用户”菜单，然后添加权限。
添加 AmazonDynamoDBFullAccess 权限：

图 5.29：向 IAM 用户添加权限

完成后，点击“下一步：审查”按钮。你应该会看到以下审查界面：

图 5.30：添加 AmazonDynamoDBFullAccess

如果你认为已经完成，点击“添加权限”按钮。你的账户应该拥有 DynamoDB 权限：

图 5.31：已将 AmazonDynamoDBFullAccess 权限添加到 IAM 用户

你已经完成了通过 AWS CLI 调用 Lambda 函数所需权限的添加。接下来，我们将测试调用 Lambda 函数。

测试我们的 Lambda 函数

要使用 AWS CLI 测试我们的 Lambda 函数，打开终端。我们将发送如下的 JSON 数据：

{"email": "user1@email.com", "name":"hessa", "country":"DE", "age":"32"}

我们在调用 AWS Lambda 函数时传递这些数据。Lambda 函数是lambda-dynamodb-func。我们还设置了输出文件lambda-dynamodb.txt。

你可以输入此命令来调用我们的 Lambda 函数：

$ aws lambda invoke --invocation-type RequestResponse --function-name lambda-dynamodb-func --payload '{"email": "user1@email.com", "name":"hessa", "country":"DE", "age":"32"}' lambda-dynamodb.txt

如果成功，你应该会看到以下200状态码：

图 5.32：调用 Lambda 函数

你还会得到一个输出文件lambda-dynamodb.txt。你可以使用nano命令打开它：

$ nano lambda-dynamodb.txt

然后，你应该看到来自 Lambda 函数的响应消息。例如，这是我的输出文件：

图 5.33：显示输出文件lambda-dynamodb.txt

你可以验证数据是否已插入到 DynamoDB 表中。你可以打开 DynamoDB 管理控制台，console.aws.amazon.com/dynamodb/查看数据。你可以在以下截图中看到我的数据输出：

图 5.34：在 DynamoDB 管理控制台中显示数据

你已经完成了通过 CloudFormation 构建具有 DynamoDB 访问权限的 Lambda 函数。

接下来，我们将通过 CloudFormation 将 Lambda 函数部署到不同区域。

将 Lambda 函数部署到多个区域

我们已经学习了如何通过 CloudFormation 部署 Lambda 函数，并且我们还在 Lambda 函数内部访问了 DynamoDB 资源。在本节中，我们将通过 CloudFormation 将 Lambda 函数部署到不同区域。

你可以按照以下步骤实现我们的演示并将 Lambda 函数部署到多个区域。

准备工作

要在 CloudFormation 中处理特定区域，我们可以使用 CloudFormation StackSet。您在第四章，AWS CloudFormation StackSets中已了解此内容。在此演示中，我们将构建一个 Lambda 函数，部署到特定区域。

要跟随本次演示，您应已为 CloudFormation StackSet 配置了安全策略。您在第四章，AWS CloudFormation StackSets中完成了这一操作。您应将这些模板文件部署到 CloudFormation Stack 中，文件为AWSCloudFormationStackSetAdministrationRole.yml和AWSCloudFormationStackSetExecutionRole.yml。

请阅读第四章，AWS CloudFormation StackSets，了解如何将它们部署到 CloudFormation 模板文件中。在以下截图中，您可以看到AWSCloudFormationStackSetAdministrationRole.yml和AWSCloudFormationStackSetExecutionRole.yml CloudFormation 模板文件已被部署：

图 5.35：为 CloudFormation StackSet 应用安全权限

接下来，我们将为 Lambda 函数开发一个面向多个区域的 CloudFormation 模板。

为 Lambda 函数开发 CloudFormation 模板

在本次演示中，我们将修改我们的 CloudFormation 模板文件Lambda-CloudFormation.json/Lambda-CloudFormation.yaml。

以下是我们的 Lambda 函数代码：

var region = process.env.AWS_REGION; 
exports.handler = (event, context, callback) => {
     var data = event['msg'];
     callback(null, 'Received: ' + data + ' . Region: ' + region); 
}

此函数返回包含区域信息的消息。它是通过调用process.env.AWS_REGION API 实现的。将 CloudFormation 模板文件保存为Lambda-multi-regions.json或Lambda-multi-regions.yaml。

接下来，我们将把这个 CloudFormation 模板部署到 CloudFormation StackSet 中。

将 Lambda 函数部署到多个区域

一旦我们准备好了 CloudFormation StackSet 并创建了 CloudFormation 模板文件，我们就可以继续将模板部署到 StackSet。

在本次演示中，我们使用 CloudFormation StackSet 管理控制台。请按照以下步骤操作：

打开浏览器，访问 CloudFormation StackSet 管理控制台：console.aws.amazon.com/cloudformation/stacksets/。
点击“创建 StackSet”按钮，您应该会看到以下屏幕：

图 5.36：为 CloudFormation StackSet 选择模板

选择“上传模板到 Amazon S3”选项，并通过点击“浏览”按钮上传Lambda-multi-regions.json或Lambda-multi-regions.yaml。
点击“下一步”按钮后，您将看到以下屏幕：

图 5.37：填写 StackSet 和 Lambda 函数名称

填写 StackSet 和 Lambda 函数名称后，点击“下一步”按钮。您将看到以下截图：

图 5.38：设置账户和目标区域

在 Deploy stacks in accounts 选项中填写你账户的 ARN 代码。你还需要填写部署目标区域。在本示范中，我选择了三个区域——美国东部（弗吉尼亚州北部）、亚太地区（新加坡）和欧洲（法兰克福）。
点击 Next 按钮，直到你看到以下屏幕：

图 5.39：查看 CloudFormation StackSet

审查所有输入内容，并在完成审查后点击 Create 按钮。
CloudFormation 为目标区域提供你的模板。如果成功，你应该在 StackSet 中看到 SUCCEEDED：

图 5.40：CloudFormation StackSet 已创建，包含三个区域

现在，你已经完成了带有 Lambda 函数的 AWS CloudFormation StackSet 部署。接下来，我们将调用这个函数。

调用 Lambda 函数

现在，你可以调用你的 Lambda 函数。在这个示范中，我使用 AWS CLI。我们发送的数据如下：

{"msg": "this is AWS CLI"}

Lambda 函数是lambda-multiregions-func。你可以通过 AWS CLI 调用这个 Lambda 函数，如下所示：

$ aws lambda invoke --invocation-type RequestResponse --function-name lambda-multiregions-func --payload '{"msg": "this is AWS CLI"}' output-multiregion.txt

如果成功，你将得到一个状态码 200，如下截图所示：

图 5.41：在美国东部区域调用 Lambda 函数

打开你的输出文件，以获取来自 AWS Lambda 函数的响应：

$ nano output-multiregion.txt

示例输出如下所示：

图 5.42：打开输出文件

你已完成通过 CloudFormation 在特定区域部署 Lambda 函数。

总结

我们学习了如何通过 CloudFormation 部署 Lambda 函数。接着，我们在 Lambda 函数代码中加入了 DynamoDB 资源。最后，我们通过 CloudFormation 将 Lambda 函数部署到多个区域。

在下一章中，我们将学习如何通过 CloudFormation 与 AWS IoT 部署进行互动。

问题

使用这些问题来测试你对本章内容的理解：

列出通过 CloudFormation 部署 AWS Lambda 函数的步骤。
如何为 Lambda 函数开发 CloudFormation 模板？
如何使用 CloudFormation 将 Lambda 函数部署到特定区域？

第六章：AWS CloudFormation 安全

设计和部署基础设施时，涉及安全问题时需要特别小心。在本章中，我们探讨了如何构建符合安全要求的基础设施即代码（IaC）。我们还探讨了一些安全最佳实践和建议，以便应用于安全的 AWS CloudFormation。

以下是我们将要探讨的主题列表：

AWS CloudFormation 的安全威胁和模型
AWS 安全最佳实践
管理所有 AWS 资源的安全
减少对 CloudFormation 堆栈的安全访问
堆栈策略
CloudFormation 的 IAM 条件
AWS 安全检查清单

AWS CloudFormation 的安全威胁和模型

Amazon AWS 由 AWS 服务组成。你在系统中使用 AWS 服务越多，系统面临的安全风险也就越大。每个 AWS 服务都需要特别关注，以解决安全问题。

理解我们系统中的安全威胁和模型，可以帮助我们解决安全问题。Amazon AWS 提供了 AWS 安全资源，帮助我们加强系统的安全性。请参考aws.amazon.com/security/security-resources/。

AWS 安全基于共享安全责任模型。这意味着 Amazon 负责保护其基础设施，而你需要为自己在云中部署和存储的数据与应用程序设置安全控制措施。你可以通过此链接找到 AWS 安全责任模型的详细信息，aws.amazon.com/compliance/shared-responsibility-model/。

AWS 保护运行在 AWS Cloud 中的所有服务的基础设施。该基础设施包括运行 AWS Cloud 服务的硬件、软件、网络和设施。除此之外，客户需要负责满足 AWS 配置安全要求，确保每个 AWS 资源部署到其系统中时的安全性。我们在图 6-1中描述了这一模型。作为客户，我们应该更多关注系统的实现，如数据和配置/设置。

图 6-1：AWS 安全责任模型的示意图

我们还将回顾一些安全威胁建模，以便了解系统风险。一个简单的安全威胁建模示例是 STRIDE 模型，由微软创建。技术上讲，这一模型应用于计算机系统，但我们可以将其应用于我们的 AWS 安全威胁模型。以下表格简要描述了 STRIDE 模型。有关 STRIDE 的更多信息，可以访问docs.microsoft.com/en-us/previous-versions/commerce-server/ee823878(v=cs.20)。

安全威胁	缓解措施	缓解示例

| 欺骗 | 身份验证 | 密码多因素身份验证

数字签名 |

篡改	完整性	权限/ACLs 数字签名
否认	不可否认	安全日志记录与审计数字签名
信息泄露	保密性	加密权限/访问控制列表（ACLs）

| 拒绝服务（DoS） | 可用性 | 权限/ACLs 过滤

配额 |

权限提升	授权	权限/ACLs 输入验证

亚马逊 AWS 还提供安全服务，帮助你调查系统实现情况。它们可以分析你的系统，识别安全威胁和风险。它们还可以对你的 AWS 平台进行渗透测试。如果你有兴趣，可以在此网站上申请此服务，aws.amazon.com/security/penetration-testing/。

以下是 AWS 可以帮助你进行渗透测试的 AWS 资源列表。

EC2
RDS
Aurora
CloudFront
API Gateway
Lambda
Lightsail
DNS 区域漫游

一些第三方本地和全球公司也可以帮助你调查安全威胁。例如，ThreatModeler 提供工具帮助你识别安全威胁，然后建立其 AWS 威胁模型。你可以通过以下链接阅读 ThreatModeler 关于 AWS Web 应用程序威胁模型的总结报告，threatmodeler.com/wp-content/uploads/2018/04/AWS-Basic-Web-App-Hosting-Summary-Report.pdf。

AWS 安全最佳实践

降低 AWS 系统安全风险的更简单方法是遵循最佳实践。一般来说，最佳实践是安全专家基于其处理安全问题经验的安全建议。

亚马逊 AWS 提供了 AWS 安全最佳实践，帮助其客户在 AWS 平台上部署系统时加强安全。你可以在d1.awsstatic.com/whitepapers/Security/AWS_Security_Best_Practices.pdf阅读此内容。

管理所有 AWS 资源的安全性

AWS Amazon 提供了一个安全中心，用于管理所有 AWS 资源的安全访问。我们可以通过 AWS IAM 查看用户、角色及其访问 AWS 资源时的权限。可以在console.aws.amazon.com/iam/查看此内容。

图 6-2展示了一个 IAM 用户。我们可以配置其权限和策略，确保用户的安全。如果你认为该用户未被使用，应该从 AWS IAM 中删除它。

图 6-2：管理 AWS IAM 上角色的权限

你还应该注意你的 IAM 角色。应审查所有角色权限。如果 IAM 角色未使用某些权限，应将其移除。图 6-3展示了一个 IAM 角色及其权限：

图 6-3：管理 AWS IAM 上的用户权限

降低对 CloudFormation 堆栈的安全访问

所有 AWS 资源都可以通过 AWS IAM 进行管理，包括策略和用户或角色。AWS CloudFormation 使用 IAM 控制其模板部署的安全性。我们可以在 CloudFormation 模板上使用 IAM 策略。CloudFormation 策略可以如下定义。

{
  "Statement" : [
    {
      "Effect" : "Deny_or_Allow",
      "Action" : "update_actions",
      "Principal" : "*",
      "Resource" : "LogicalResourceId/resource_logical_ID",
      "Condition" : {
        "StringEquals_or_StringLike" : {
          "ResourceType" : [resource_type, ...]
        }
      }
    } 
  ]
}

建议您限制对 CloudFormation 中资源的安全访问。此方法应用最小权限原则。例如，我们从 IAM 用户或角色中移除对 CloudFormation 堆栈的更新和删除访问权限。以下是一个模板示例。

{
    "Version":"2012-10-17",
    "Statement":[{
        "Effect":"Allow",
        "Action":[ 
            "cloudformation:*"
        ],
        "Resource":"*"
    },
    {
        "Effect":"Deny",
        "Action":[ 
            "cloudformation:UpdateStack",
            "cloudformation:DeleteStack"
        ],
        "Resource":"arn:aws:cloudformation:us-east-1:123456789012:stack/MyStack/*"
    }]
}

该 CloudFormation 模板允许访问所有 CloudFormation API，但拒绝UpdateStack和DeleteStack API 访问您的 MyStack 堆栈。

您应该审查所有资源的使用情况，并分析应应用于模板的安全访问类型。关于 CloudFormation 操作，我们可以使用以下操作并应用最小权限原则。

取消更新堆栈
继续更新回滚
创建堆栈
删除堆栈
描述堆栈事件
描述堆栈资源
描述堆栈资源
描述堆栈
估算模板成本
获取堆栈策略
获取模板
获取模板摘要
列出导出
列出导入
列出堆栈资源
列出堆栈
设置堆栈策略
更新堆栈
更新终止保护
验证模板

您可以查看此网站上的所有操作，docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/Welcome.html。

堆栈策略

在某些情况下，由于对资源的意外更改，您可能会导致框架崩溃。您的团队可能会对 CloudFormation 进行更改，导致框架不稳定。CloudFormation 提供堆栈策略，可以防止堆栈资源在堆栈更新过程中意外被刷新或删除。我们可以与 IAM 和堆栈策略集成，以防止意外和恶意的资源更改。

您应该设置或更新策略，您的 IAM 用户或角色应能够调用cloudformation:SetStackPolicy操作。默认情况下，设置堆栈策略会通过拒绝所有堆栈资源的更新，除非您显式指定允许。例如，我们在系统上线后，保护特定资源不被更新。您可以查看以下 CloudFormation 模板。

{
  "Statement" : [
    {
      "Effect" : "Deny",
      "Action" : "Update:*",
      "Principal": "*",
      "Resource" : "<certain_resource>"
    },
    {
      "Effect" : "Allow",
      "Action" : "Update:*",
      "Principal": "*",
      "Resource" : "*"
    }
  ]
}

CloudFormation 的 IAM 条件

如果我们拥有相应的 IAM 策略，我们可以通过 CloudFormation 创建或删除特定的 AWS 资源。有时，您不需要 CloudFormation 操作中的创建任务。我们可以实施 IAM 条件来应用这种情况。

总的来说，CloudFormation 提供与 IAM 条件相关的 IAM 策略。以下是 IAM 条件策略的列表：

cloudformation:TemplateURL
cloudformation:ResourceTypes
cloudformation:StackPolicyURL

当您应用 IAM 条件时，可以确保针对堆栈操作的 API 调用（例如创建、更新实例或针对特定模板）仅限于特定资源。

cloudformation:TemplateURL 是一个 CloudFormation 属性，表示 CloudFormation 模板文件的位置。它可以是 .json、.yaml 或 .template 文件格式。例如，我们在 CloudFormation 模板上应用一个 IAM 条件，如下所示。

{
    "Version":"2012-10-17",
    "Statement":[{
        "Effect": "Deny",
        "Action": [
            "cloudformation:CreateStack",
            “cloudformation:UpdateStack”
        ],
        "Resource": "*",
        "Condition": {
            "StringNotEquals": {
                "cloudformation:TemplateURL": [
                    "https://s3.amazonaws.com/cloudformation-templates-us-east-1/IAM_Users_Groups_and_Policies.template"
                ]
            }
        }
    },
    {
        "Effect": "Deny",
        "Action": [
            "cloudformation:CreateStack",
            "cloudformation:UpdateStack"
        ],
        "Resource": "*",
        "Condition": {
            "Null": {
                "cloudformation:TemplateURL": "true"
            }
        }
    }]
}

此模板确保对于所有 CreateStack 或 UpdateStack API 调用，用户必须使用指定的模板。否则，操作将被拒绝。

Condition:StackPolicyURL 使您的 CloudFormation 在创建时能够使用 StackPolicyURL 条件应用堆栈策略。以下是来自 AWS 的一个 CloudFormation 模板，示范如何在模板中使用 cloudformation:StackPolicyUrl。

{
    "Version":"2012-10-17",
    "Statement":[
    {
            "Effect": "Deny",
            "Action": [
                "cloudformation:SetStackPolicy"
            ],
            "Resource": "*",
            "Condition": {
                "ForAnyValue:StringNotEquals": {
                    "cloudformation:StackPolicyUrl": [
                        "https://s3.amazonaws.com/samplebucket/sampleallowpolicy.json"
                    ]
                }
            }
        }, 
       {
        "Effect": "Deny",
        "Action": [
            "cloudformation:CreateStack",
            "cloudformation:UpdateStack"
        ],
        "Resource": "*",
        "Condition": {
            "ForAnyValue:StringNotEquals": {
                "cloudformation:StackPolicyUrl": [
                    “https://s3.amazonaws.com/samplebucket/sampledenypolicy.json”
                ]
            }
        }
    },
    {
        "Effect": "Deny",
        "Action": [
            "cloudformation:CreateStack",
            "cloudformation:UpdateStack",
            “cloudformation:SetStackPolicy”
        ],
        "Resource": "*",
        "Condition": {
            "Null": {
                "cloudformation:StackPolicyUrl": "true"
            }
        }
    }]
}

AWS 安全检查清单

在通过 CloudFormation 设计并部署系统到 AWS 平台后，最后一项任务是确保您的系统符合 AWS 安全要求。AWS 提供了一个安全检查清单，其中包含安全检查操作。您可以通过以下文档了解安全检查清单：d1.awsstatic.com/whitepapers/Security/AWS_Security_Checklist.pdf。该文档包括以下三个关于不同 AWS 资源的安全检查清单：

一般安全检查清单
EC2/VPC/EBS 安全检查清单
S3 安全检查清单

使用 AWS 安全检查清单，您的系统可能存在较低的安全风险。但再次提醒，定期进行渗透测试总是更好的。

总结

在本章中，我们学习了如何确保使用 AWS CloudFormation 部署的资源的安全性。最后，我们深入了解了 CloudFormation 的安全威胁和模型。

第七章：评估

第一章

基础设施即代码（IaC）是 IT 基础设施的一种类型，通过代码自动管理和配置，而不是使用手动过程。
IaC 的好处是最小化构建和部署基础设施的风险，并实现基础设施的自动化管理。
AWS CloudFormation 的主要目标是通过 AWS 资源优化你的 IaC 设计，并提供一个完整的解决方案来基于 Amazon AWS 技术堆栈构建现代基础设施。
AWS CloudFormation 旨在简化 IaC 开发。从使用文件（JSON 或 YAML）设计 IaC 或使用设计器生成 CloudFormation 模板文件开始。然后，上传该模板文件到 AWS CloudFormation 服务器。接着，CloudFormation 将生成我们在模板文件中已定义的所有资源，AWS 将在特定的容器中部署它们。这个过程是自动运行的。
我们可以通过在文件中编写脚本或使用 CloudFormation 设计器来构建 CloudFormation 模板。我们可以使用 JSON 和 YAML 格式开发 CloudFormation 模板文件。
在某些情况下，我们希望在基础设施环境中部署某个特定资源。这个资源由多个不同的资源组成，这些资源也被其他资源使用。这个场景可以通过在 CloudFormation 中实现嵌套堆栈来完成。资源模块化是轻松管理基础设施的关键。
实现 CloudFormation StackSets 的目的是在不同区域部署同一资源单元。如果我们想要在不同区域部署相同的资源，可以使用 CloudFormation StackSets。你还可以在不同区域配置某些设置。

第二章

CloudFormation 堆栈是 CloudFormation 的一个实例，它由一组 AWS 资源组成，基于 Amazon AWS 技术堆栈构建基础设施。
使用 Web 管理控制台构建 CloudFormation 的主要好处是更易于使用，因为我们可以通过图形化操作进行。我们不需要记住 AWS CLI 的所有命令。
通过 AWS CLI 构建 CloudFormation 可以带来简化的好处。因为 AWS CLI 在终端上运行，如果与使用管理控制台相比，它不需要更多的带宽。

第三章

CloudFormation 模板是一个脚本文件，通常以 JSON 或 YAML 格式编写，用于基于 Amazon AWS 技术构建基础设施。
要开发一个 CloudFormation 模板，你需要掌握编写 JSON 或 YAML 格式的知识。一个 CloudFormation 模板的骨架 JSON 格式如下：

{
 "AWSTemplateFormatVersion" : "version date",
 "Description" : "JSON string",
 "Metadata" : {
   template metadata
 },
 "Parameters" : {
   set of parameters
 },
 "Mappings" : {
   set of mappings
 },
 "Conditions" : {
   set of conditions
 },
 "Transform" : {
   set of transforms
 },
 "Resources" : {
   set of resources
 },
 "Outputs" : {
   set of outputs
 }
}

你也可以用 YAML 编写它：

AWSTemplateFormatVersion: "version date"
Description:
 String
Metadata:
 template metadata
Parameters:
 set of parameters
Mappings:
 set of mappings
Conditions:
 set of conditions
Transform:
 set of transforms
Resources:
 set of resources
Outputs:
 set of outputs

要实现 CloudFormation 模板，你可以手动在文件中编写 CloudFormation 的 JSON 或 YAML。你也可以通过 AWS 的 CloudFormation 设计工具来构建模板。然后，你应该了解 AWS 资源类型。你可以在 docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-product-property-reference.html 上阅读相关内容。最后，你可以做更多的实践。你可以使用 AWS 上的模板示例，链接在 docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-sample-templates.html。

第四章

CloudFormation StackSet 是一组跨账户和区域部署的 Stack 集合。你可以在一些区域执行多个区域的预配。
根据 AWS 文档，我们最多可以在管理员账户中创建 20 个 StackSet，每个 StackSet 最多包含 500 个 Stack 实例。参考链接：docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-limitations.html

第五章

一般来说，我们可以使用管理控制台和 AWS CLI 部署 AWS Lambda 函数，步骤如下：

- 基于这个模板创建 CloudFormation 模板，链接：docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html
- 使用 Web 管理控制台或 AWS CLI 部署模板
- 配置 IAM 权限，以便能够调用 Lambda 函数的用户

要为 Lambda 函数开发 CloudFormation 模板，你应该按照 docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html 上的模板说明进行操作。

以下是 JSON 模板：

{
  "Type" : "AWS::Lambda::Function",
  "Properties" : {
    "Code" : Code,
    "DeadLetterConfig" : DeadLetterConfig,
    "Description" : String,
    "Environment" : Environment,
    "FunctionName" : String,
    "Handler" : String,
    "KmsKeyArn" : String,
    "MemorySize" : Integer,
    "ReservedConcurrentExecutions" : Integer,
    "Role" : String,
    "Runtime" : String,
    "Timeout" : Integer,
    "TracingConfig" : TracingConfig,
    "VpcConfig" : VPCConfig,
    "Tags" : [ Resource Tag, ... ]
  }
}

以下是 YAML 模板：

Type: "AWS::Lambda::Function"
Properties: 
  Code:
    Code
  DeadLetterConfig:
    DeadLetterConfig
  Description: String
  Environment:
    Environment
  FunctionName: String
  Handler: String
  KmsKeyArn: String
  MemorySize: Integer
  ReservedConcurrentExecutions: Integer
  Role: String
  Runtime: String
  Timeout: Integer
  TracingConfig:
    TracingConfig
  VpcConfig:
    VPCConfig
  Tags: 
    Resource Tag

首先，我们需要在 CloudFormation 上配置权限。你应该部署以下 Stack 文件：AWSCloudFormationStackSetAdministrationRole.yml 和 AWSCloudFormationStackSetExecutionRole.yml 文件。阅读第四章，AWS CloudFormation StackSets 以了解更多步骤。然后，你可以像平常一样部署 StackSet。

posted @ 2025-06-29 10:38 绝不原创的飞龙阅读(84) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

CloudFormation-学习指南-全-

CloudFormation 学习指南（全）

前言

本书适用对象

本书内容

最大化本书的使用效果

下载示例代码文件

下载彩色图像

使用的约定

联系我们

评价

第一章：介绍 AWS CloudFormation

介绍 IaC

AWS CloudFormation

它是如何工作的？

控制 IaC 源脚本

CloudFormation 模板

CloudFormation 堆栈

CloudFormation StackSets

探索 AWS CloudFormation 管理控制台

使用 AWS CLI 管理 CloudFormation

总结

问题

第二章：构建您的第一个 AWS CloudFormation 项目

CloudFormation 项目场景

准备工作

使用管理控制台实现 CloudFormation 项目

使用 AWS CLI 实现 CloudFormation 项目

设置 AWS 命令行界面（CLI）

配置 CloudFormation 的安全访问

构建和部署 CloudFormation

编辑一个 CloudFormation 项目

使用管理控制台编辑 CloudFormation

使用 AWS CLI 编辑 CloudFormation

删除 CloudFormation 项目

使用管理控制台删除 CloudFormation

使用 AWS CLI 删除 CloudFormation 堆栈

总结

问题

第三章：开发 AWS CloudFormation 模板

审查 AWS CloudFormation 模板格式

回顾 JSON 和 YAML 编程

JSON 编程

YAML 编程

AWS CloudFormation 模板的编程模型

编写 JSON 和 YAML 以创建 AWS CloudFormation 模板

从 CloudFormation 模板获取输入。

介绍 AWS CloudFormation 设计器

给出模板描述

从选项中选择输入

映射参数

使用内建函数

在 CloudFormation 模板中使用元数据

CloudFormation 资源

CloudFormation 输出

演示 - 使用 AWS CloudFormation 构建 Amazon EC2

准备中

开发 CloudFormation 模板

部署模板

总结

问题

第四章：AWS CloudFormation StackSets

AWS CloudFormation StackSets 简介

准备 CloudFormation StackSets

从 IAM 用户获取用户 ID

创建 AWSCloudFormationStackSetAdministrationRole IAM 角色

创建服务角色 – AWSCloudFormationStackSetExecutionRole

使用管理控制台实现 StackSets

创建新的 StackSet

添加新的 CloudFormation 堆栈

删除 CloudFormation 堆栈

使用 AWS CLI 创建 StackSets

编辑 CloudFormation StackSets

删除 CloudFormation StackSets

总结

问题

第五章：使用 AWS CloudFormation 构建 Lambda 函数

介绍 AWS Lambda