EDUCBA-Chef-云基础设施自动化笔记-全-

EDUCBA Chef 云基础设施自动化笔记（全）

001：项目导论 🚀

在本课程中，我们将学习如何应用Chef自动化工具，创建一个在线大学注册平台。这是一个基于真实场景的案例研究，旨在通过实践掌握Chef的核心概念和应用。

概述

Chef是一个非常流行且重要的工具。根据需求，它可以作为配置管理工具、项目自动化工具或编排工具使用。用更简单的话来说，它是一个能让你的工作变得更轻松的工具。这个定义适用于所有DevOps工具。自DevOps出现以来，它使得部署和配置管理等工作变得容易得多。

本课程的目标是让你有信心将Chef引入自己的基础设施。你可以模仿和使用我在这里演示的所有功能和基础设施。你应该对此充满信心。

项目难度与背景

本项目的难度级别为高级。在开始之前，让我们讨论一下课程背景以及你需要熟悉的内容。

学习Chef的一个重要部分是能够讨论基础设施即代码。在本课程中，你会多次听到这个词。我们实际上是在这个案例研究中创建基础设施即代码。不用担心，你会在后续视频中看到所有相关内容。

当你能够描述基础设施即代码时，部分工作将使用Linux风格的命令行工具。因此，在开始课程之前，请确保你熟悉导航、更改目录或列出目录内容等操作。你还需要具备查看和编辑文本文件的技能。在本课程中，你可能会发现需要直接在主机上编辑文件。因此，如果你从未使用过像Vi、Nano、Emacs这样的文本编辑器，你可能需要在尝试远程编辑文件之前先了解一下。我们将在本案例研究中大量进行此类操作。

此外，你还应该意识到你正在使用基础设施即代码，并且在本课程中会看到大量代码。需要明确的是，你不需要成为一名开发人员就可以开始学习Chef。但由于Chef依赖于Ruby编程语言，你需要对变量、循环、数组以及如何传递变量、函数和数组等有基本的理解。这是基本的编程语言概念，不仅限于Ruby。如果你熟悉任何编程语言，你应该了解如何引入循环、变量以及如何在脚本中传递参数。因此，你需要具备一些这方面的知识。这就是为什么我们将此案例研究定义为高级难度。

简而言之，只需对Ruby有高层次的概念理解即可开始本案例研究。

重要前提

需要指出的是，学习本案例研究并不需要深入的Chef知识，但你应该对Chef架构、其遵循的树状层次结构有基本的了解。

除此之外，你需要的是一台控制机器，最好使用Linux。在本课程中，我们将使用Linux作为控制机器。如果你想模仿我在这里演示的内容，请使用Ubuntu或OpenSUSE等Linux发行版。

你需要能够通过SSH进行通信的虚拟机节点。SSH意味着节点之间的安全传输。一旦安装了节点，它们就会进行通信，因为我们保存了公钥和私钥，并使它们能够相互通信。因此，节点之间应该能够相互通信。

关于服务器的知识，你可以为此案例研究选择任何物理服务器或云服务器。我们将使用AWS，但你也可以使用Azure、Google Cloud、阿里云等公有云。我建议使用AWS，因为我们在这里使用它，这样如果你想演示相同的内容，对你来说会更容易。

我们将详细介绍每个安装过程，不用担心节点机器或虚拟机，我们会在后续视频中讨论。

另外还需要的是基本的HTML知识。HTML也是一种编程语言，你在HTML中所做的更改将托管在Web服务器上，它只是包含页面的网站。我不期望你成为HTML专家，但你应该对HTML标签、字段、如何定义字段、如何插入标签以及如何用CSS级联等有概念性的理解。这样，当我编写代码时，你应该能够熟悉正在发生的事情以及我们如何调用所有这些内容。因此，需要基本的HTML标签知识，因为本课程最终依赖于HTML内容。我们将通过Web服务器上的HTML发布所有网站或网页。

最后是你的管理员技能。这里的管理员技能指的是中级技能。你将会有很多命令，比如启动和停止服务器、检查服务器状态或检查你使用的Chef服务器版本等。你将在后续视频中学到更多技能，但需要对这些管理员技能有基本的理解。

项目目标

参与者将能够安装Chef工作站，实现到节点的无密钥或免密码访问，并在项目中引入这些设置。

如果你在本案例研究中描述所有这些内容，你将安装Chef工作站。我们将为此设置一个集中式工作站，安装Chef，并拥有节点。我们将在节点上实现自动化。我们将有一个主服务器和一个工作站，在那里编辑所有文件。

我们需要节点，因为节点是客户端机器。我们在主服务器上所做的任何自动化，其最终目的都是要传输到节点，因为它应该在客户端机器上完成。节点将如何通信？假设在你的组织中有50个节点，50台客户端机器，你的更改需要在那里复制。无论你在工作站上做什么，都会在那里被模仿和复制。因此，节点将如何配置、节点之间如何通信、节点如何与你的Chef工作站通信？为此，我们将确保实现无密钥或免密码访问，这样当你的节点需要与其他节点或工作站通信时，不需要任何人工干预，它应该是免密码的。如果不是免密码的，每次你在主机上做所有事情时，都必须去那里输入密码。确保对节点的访问是无密钥或免密码的。

第三件事是管理基础设施即代码。正如我讨论过的，你会听到很多关于基础设施即代码的内容，因为Chef就是基础设施即代码。我们正在用代码创建基础设施。我们编写所有设置基础设施所需的代码。

最后一件事是创建和上传Chef Cookbook。在这个案例研究中，你将创建配方（recipes）并将配方上传到中央服务器和节点上，这将作为基础设施记录使用。

你刚刚听到“Cookbook”这个词。Chef就像一个准备食物的人。配方就像他在准备食谱，而Cookbook就是食谱书。类似地，在Chef中，Cookbook包含配方。一捆配方被称为Cookbook。在配方中，我们将拥有所有我们尝试安装的模块，比如安装服务器、删除服务器、创建内容、部署某些东西或自动化某些事情。所有事情都将通过你的配方完成，而你的配方将位于Cookbook内部，这就是层次结构。

你将学到什么

在这个项目中，你将学习如何为项目自动化在AWS上创建和分配虚拟机。

你将在AWS机器上创建节点。我们将为你的节点或集中式工作站分配专用的虚拟机。这是第一件事，就像创建基础设施和设置一样。

之后，我们将创建Chef服务器、工作站和节点。在此之前，我们只是创建架构，接下来我们将托管它。现在，我们只是安装Chef服务器，我们想要安装的Web服务器或Chef服务器版本，我们将安装在一个节点上。我们将配置工作站并设置我们的节点。

之后，我们将编写Chef配方，正如我之前解释的。配方将包含你的代码，这些代码将用于自动化目的。

下一件事是安装Apache和数据库服务器。这是主要的事情，实际上是你案例研究的核心。没有Apache，你就不会有Web服务器，不会有网站，也不会有我们做这个案例研究的目的。这个案例研究是关于进行无纸化在线交易，就像一个大学注册表单。如果没有Web服务器，因为Web服务器是用来托管Web应用程序的，那么什么应用程序会制作HTML应用程序呢？它们将托管在Web服务器上，所以我们需要Apache服务器，或者我们可以使用Nginx服务器作为你的Web服务器，并且我们需要数据库服务器。

为什么？因为数据库服务器服务于最终目的。没有数据库服务器，你几乎无法想象任何事情。假设你进入一个在线商店，比如亚马逊，尝试做任何事情。从你登录的那一刻起，你导航到某些产品、购买某些产品或结账的所有细节，所有时候，一切都存储在数据库服务器中。从你登录数据库服务器的那一刻起，我们要做的第一件事就是安装数据库服务器，因为所有交易都应该进入数据库。没有数据库，你如何存储东西？大学想要存储所有申请者的信息，他们实际上倾向于某些科目或类似的东西。如果你进行输入，你必须把它保存在某个地方，对吧？以前人们用文件保存，现在我们把所有这些东西保存在数据库位置，那是虚拟的。

最后一件事是在Web服务器上部署Web内容。这就是我们讨论过的，Web服务器将是Apache、Nginx或任何服务器，部署Web内容就像部署你的HTML内容或其他内容。对于这个案例研究，我们也将托管这些内容。

项目要求与先决条件

我们已经讨论过这一点，让我们简要回顾一下。

正如我之前告诉你的，需要Ruby DSL语言的基本知识、Chef架构的知识，因为当我演示Chef如何工作以及所有内容时，我需要你对架构、它遵循的层次结构有一个清晰的了解。当然，还需要HTML标签，这对我们的案例研究是必需的，以及Linux语言。说到Linux，我不是要求你具备脚本知识，只需要Linux的基本命令语言。

目标学员

任何想学习Chef作为DevOps工具的人都可以。可以是任何人，可以是你，可以来自酒店行业，可以来自跨国公司。任何想学习Chef作为DevOps工具的人，因为DevOps让事情变得更容易。任何想学习Chef作为DevOps工具并希望将其集成到自己的架构和基础设施中的人，都可以从这个案例研究中获得大量知识。

下一类学员是从事DevOps工程师工作的参与者。因为Chef是DevOps的一部分，所以任何DevOps工程师都需要获得Chef的知识。还有很多其他DevOps工具可以做Chef所做的同样的事情，比如你有Ansible、Puppet。对于Ansible，人们过去常常编写Playbook，然后将其传播到所有节点，他们只需要一个中央服务器，不需要在节点上安装代理，只需要在所有节点上安装Python。当你编写节点时，Ansible节点实际上正在被推送所有这些内容，节点在你推送所有代码后实际上正在被自动化。所以Ansible就是你的推送机制。而这里，Chef是你的拉取机制。你在工作站（也就是主服务器）上安装Chef，你的Chef机器将不断从中央服务器拉取，以获取你部署的最新副本，这样你的子节点或节点将拥有最新的部署。这是一个基本的区别。

因此，从事自动化或开发工程师工作的参与者将需要它，因为Chef是一个有助于你部署目的的工具。如果你是开发人员，并且想将某些东西部署到服务器上，你将学习本课程。如果你是工程师，你想自动化你的代码，或者你不想去10台服务器做同样的事情，只需在你的Chef目录中自动化代码，它将被传播到所有节点。所以它基本上完成了你的自动化开发工作。你可以使用编排工具。

最后但同样重要的是，从事自动化项目编排的学生。如果你是大学生或工程师，想实际进行自动化项目，他们可以使用Chef作为自动化工具，因为Chef完全满足DevOps工具所需的所有自动化。他们可以学习本课程，他们将获得大量关于如何将Chef用作DevOps自动化或开发工具的知识，并可以用于这个项目编排。

你将获得的技能

在本项目结束时，你将拥有以下技能：

  • 实践经验和真实场景：关于配置Chef服务器实时环境的实践经验。当然，如果你完成了所有这些内容，你可以在你的实时环境、你的办公室中创建所有这些Chef服务器。如果你在跨国公司工作，显然是在某些服务器上工作，你可以模仿所有这些内容到你的架构中，并且你将有足够的信心引入Chef。
  • 运行Web和数据库服务器：在代理机器上运行Web和数据库服务器，并确保其在重启后保持最新运行状态。正如我告诉你的，必须在你的代理机器上配置Web和数据库服务器，因为代理机器就是你的客户端机器，你希望在那里进行所有更改。如果你完成了所有这些自动化，制作了所有Web内容，假设你目标部署内容的Web服务器没有运行，那么自动化就失败了，你一无所有。因此，需要所有这些自动化内容在一个正常运行的Web服务器上。必须确保即使你的虚拟机宕机，一旦你的虚拟机恢复，你也不需要单独去启动你的Web服务器或数据库服务器。我们将编写代码，确保每当你的数据库服务器启动时，你的Web服务器也启动；每当你的虚拟机启动时，你的Web服务器和数据库服务器都处于运行状态。
  • 创建和上传Chef Cookbook：你将创建和上传Chef Cookbook。
  • 编写项目HTML文件并托管在Apache服务器上：你将编写项目HTML文件并将其托管在Apache服务器上，你将在后续视频中看到。

案例研究核心

现在让我们进入重点，即本案例研究的核心。案例研究讲述了一所大学希望升级其招生流程，旨在实现注册过程的数字化。

如果你想将这种情况与现实生活情况联系起来，现在是疫情时期，全球都面临新冠病毒问题，这是一场大流行。每项业务都受到影响，你的大学、商场等一切都不景气。一所典型的学生过去线下学习的大学正遭受巨大损失，他们必须支持员工，必须教学生，必须维持业务。他们将如何做到这一点？现在他们计划推出数字表单，你过去所做的一切，比如在纸上填写所有信息、支付和注册，比如你的姓名、年龄、性别、地址？你想学什么课程？假设这是一所工程学院，那么工程学院有土木工程、机械工程、IT、化学等各类工程。为了选修这些课程，你需要注册。只有这样，它才会进行，你才能在你的视频上看到所有内容，或者你能够进行实时培训或视频会议，所有事情都在你的OTT机器上进行。在这种情况下，我们想要演示并实现这一点。

此外，它希望拥有以下功能：

  • 功能完整的注册表单和学生注册表单。所谓功能完整的注册，意味着注册表单将包含注册所需的一切，比如需要你的姓名、年龄、电子邮件地址、你选择的课程（比如如果你选择计算机科学工程，你将选择计算机科学工程）、邮寄地址等。一旦学生填写了所有详细信息，他们将能够注册。一旦你能够注册，所有详细信息将进入你的数据库服务器。一旦大学验证了数据库服务器，就会进入支付页面。一旦你完成支付，你将能够观看所有内容，并获得大学要求你获得的所有学习资料。这是本案例研究的基本目标。
  • 为此，我们需要一个专用的最新Web服务器来托管应用程序，因为这些表单将托管在Web服务器上。如果Web服务器不存在或不是最新的，那么将会有困难，因为你将无法模仿这些内容，也无法进行更改。
  • 为什么我们需要这个最新的Web服务器？我们需要最新的Web服务器，因为在早期版本的Web服务器中可能存在母公司已在最新版本中修复的错误或问题。如果你有最新版本，我们为什么不使用最新的呢？我们将只使用最新的Web服务器，并且在我们的代码中，我们将注明，每当Web服务器有变化，比如Web服务有新版本时，请自动安装最新的Web服务器，而无需停机。我们将做到这一点。
  • 下一件事是集中式数据库，用于存储你的所有详细信息。
  • 第三件事是详细的课程信息，当然，可供注册，正如我们已经讨论过的。

这些场景将作为本案例研究的一部分涵盖，正如我们之前讨论的，即配置Chef服务器到实时环境的真实场景、对主机的免密码访问、配置你的集中式数据库服务器、确保你使用的工具是最新的、在Web服务器上部署Web项目以测试你的Chef配置、创建注册表单以在多个课程中选择和注册。

总结

在本节课中，我们一起学习了本Chef自动化项目的概述、目标、先决条件以及核心案例研究内容。我们了解到，本项目旨在通过构建一个在线大学注册平台，实践应用Chef实现基础设施即代码、自动化部署和管理。这是一个高级项目，需要你具备Linux命令行、基础编程概念和HTML的基本知识。接下来，我们将开始动手搭建环境并实施自动化。

002：AWS节点与Chef连接配置 🚀

在本节课中，我们将学习如何配置AWS EC2实例，并将其作为节点连接到Chef服务器。我们将完成从启动实例到通过SSH成功连接的完整流程。

环境设置

上一节我们介绍了Chef的基本概念，本节中我们来看看如何准备运行Chef的基础设施环境。首先，我们需要在AWS上创建虚拟机实例。

访问AWS控制台

登录AWS管理控制台。在顶部导航栏的“服务”菜单下，找到“计算”分类，并点击“EC2”。

请注意：EC2实例是区域特定的服务，而非全局服务。你创建的服务仅存在于所选区域。请根据你的地理位置选择合适区域，例如亚太地区（孟买）或美国东部（弗吉尼亚北部）。

启动EC2实例

在EC2控制面板，点击“启动实例”按钮。

以下是配置实例的详细步骤：

  1. 选择Amazon Machine Image (AMI)：进入“社区AMI”选项卡，搜索并选择“Ubuntu Server 18.04 LTS (HVM)， SSD Volume Type”。请确保选择64位版本。
  2. 选择实例类型：为了使用免费套餐，选择 t2.micro 实例类型。
  3. 配置实例数量：在本课程中，我们需要创建两个实例，一个作为Chef服务器（主节点），另一个作为被管理的节点。在“配置实例”步骤，将实例数量设置为 2。其他高级设置保持默认即可。
  4. 配置存储：在“添加存储”步骤，使用默认的根卷设置（通常为8GB gp2卷），无需添加额外存储。
  5. 配置安全组：这是关键步骤，需要开放必要的端口。
    • 安全组名称可自定义，例如“chef-sg”。
    • 编辑默认的SSH规则，将“源”设置为“任何位置”（0.0.0.0/0, ::/0）。注意：在生产环境中，这存在安全风险，应仅允许特定IP访问。此处为演示目的暂时放宽限制。
    • 点击“添加规则”，选择“所有流量”，同样将“源”设置为“任何位置”。这将开放所有端口以便Chef通信。
  6. 审核与启动：检查所有配置，确认无误后点击“启动”。

创建并下载密钥对

在弹出的对话框中，需要选择密钥对以安全连接实例。

  1. 选择“创建新密钥对”。
  2. 为密钥对命名，例如 my-private-key-for-chef。
  3. 点击“下载密钥对”，将私钥文件（.pem格式）保存到本地安全位置。
  4. 点击“启动实例”。实例将开始初始化。

为实例添加标签

实例启动后，返回EC2实例列表。为了便于区分，我们为两个实例添加名称标签。

  1. 选中第一个实例，在“标签”选项卡或右键菜单中，选择“管理标签”。
  2. 添加一个标签，键为 Name，值为 master-repo。这个实例将作为我们的Chef服务器。
  3. 选中第二个实例，同样添加标签，键为 Name，值为 node-1。这个实例将作为被管理的节点。

配置SSH连接

现在我们的实例已经运行，接下来需要配置SSH客户端来连接它们。我们将使用PuTTY和PuTTYgen工具（适用于Windows用户）。

转换密钥格式

PuTTY需要使用.ppk格式的私钥。我们需要转换下载的.pem文件。

  1. 打开 PuTTYgen 工具。
  2. 点击“Load”（加载）按钮。
  3. 在文件选择器中，将文件类型过滤器改为“All Files (.)”，然后找到并选择你下载的 .pem 文件。
  4. 加载成功后，点击“Save private key”（保存私钥）按钮。
  5. 将文件保存为 private-key.ppk。你可以忽略关于是否保存空密码的警告。

使用PuTTY连接实例

现在，我们可以使用转换后的密钥连接到Ubuntu实例。

  1. 打开 PuTTY。
  2. 在“Session”（会话）界面：
    • 在“Host Name (or IP address)”（主机名）字段，粘贴你的EC2实例的公有IPv4地址（可在AWS控制台实例列表中查看）。
    • 端口保持为 22。
    • 在“Saved Sessions”（已保存的会话）下输入一个名称（如“Chef-Master”），然后点击“Save”（保存）以便下次使用。
  3. 在左侧目录树中，展开“Connection” -> “SSH” -> “Auth”（认证）。
  4. 在“Private key file for authentication”（用于认证的私钥文件）栏，点击“Browse”（浏览），选择刚才保存的 private-key.ppk 文件。
  5. 返回“Session”界面，点击“Open”（打开）以启动连接。
  6. 首次连接会弹出安全警告，点击“Accept”（接受）。
  7. 登录用户名是 ubuntu（对于Ubuntu AMI）。连接成功后，你将看到终端提示符。

优化终端与系统更新

为了提高可读性，可以调整PuTTY的显示设置（如颜色和字体大小）。连接成功后，第一件事是更新系统软件包，确保实例拥有最新的安全补丁和软件。

执行以下命令：

sudo apt-get update
sudo apt-get upgrade -y

sudo apt-get update 命令会刷新软件包索引列表。sudo apt-get upgrade -y 命令则会自动升级所有可更新的软件包。

等待更新完成。现在，你的AWS EC2实例已经准备就绪，可以作为Chef节点进行后续配置。

本节课中我们一起学习了配置AWS基础设施的核心步骤：从启动EC2实例、配置安全组、管理密钥对，到使用PuTTY建立SSH连接并初始化系统。这些是后续将节点纳入Chef自动化管理的基础。下一节，我们将在这些准备好的服务器上安装和配置Chef客户端与服务端。

003：AWS节点连接用于Chef继续

在本节中，我们将学习如何配置第二台服务器（节点），并建立从主服务器到节点的SSH无密码连接。这是配置Chef自动化环境的关键步骤。

创建并配置第二个节点

上一节我们配置了主服务器。本节中我们来看看如何配置第二个节点服务器。

现在，创建另一台服务器，即另一个节点。

转到节点1的控制台，执行与主服务器相同的初始配置步骤。使用切换身份验证方式，选择你的密钥文件。

接下来，进行一些调整。我们为主服务器做了一些后台配置更改。

为了让界面更易于区分，我们更改这个系统的颜色主题。

为了让操作更清晰，我们将终端字体调大一些。进入外观设置进行调整。

现在更新这台机器的软件包。我们使用 sudo 命令，因为它代表超级用户权限。

你可以直接使用 sudo 作为 su 的替代。现在你是root用户。

你不需要为每个命令都输入 sudo，可以执行 sudo -i 切换到root会话。

执行更新命令：

sudo apt update && sudo apt upgrade -y

更新完成。你的机器将在此过程中更新。

通过这种方式，我们配置好了两台基于Ubuntu的机器，并且它们都已更新。

配置主节点间的SSH连接

现在我们已经创建了两台机器，下一步是为你的主服务器配置SSH访问权限到节点。这意味着如果你在主服务器上输入 ssh 加上节点的IP地址，可以无需密码直接进入节点终端。

让我们尝试一下，在主服务器上输入：

ssh <node1的IP地址>

看看我们是否能无任何问题地连接。

系统询问“是否确定要继续连接？”，输入 yes。

然后我们遇到了“权限被拒绝”的问题。同时，该主机的密钥已被永久添加到已知主机列表。

这个步骤中出现问题的原因是，节点之间的SSH尚未配置。当主服务器尝试连接到节点时，连接失败，因为主服务器的公钥不在节点的授权密钥列表中。每台机器安装后都有自己独特的密钥指纹，只有指纹匹配才能建立无密码连接。

现在我们必须解决这个问题以实现SSH无密码访问，因为这是安装Chef的基本步骤。我们必须让节点能够接受来自主服务器的连接，而不需要任何密钥文件或密码。

解决SSH连接问题

让我们看看如何解决这个问题。首先，列出 .ssh 目录的内容：

ls -la ~/.ssh

在这个目录中，有 authorized_keys 和 known_hosts 文件。

这些是SSH连接所需的密钥文件。known_hosts 文件存储了这台机器已知的所有主机列表。如果你查看它，会发现刚才尝试连接的主机IP已被添加。因为机器“认识”了那台主机，所以将其加入了列表。

如果我们用 cat 命令查看 known_hosts 文件：

cat ~/.ssh/known_hosts

你会看到里面有机器的IP地址信息（实际上是加密后的形式）。当你首次尝试SSH连接并输入yes时，该主机的加密IP地址就被保存到了这里。

我们看到的另一个重要文件是 authorized_keys。这个文件包含了所有被允许无密码访问本系统的机器的公钥。

查看授权密钥文件：

cat ~/.ssh/authorized_keys

你会看到当前已有的密钥。如果你删除了这里所有的密钥，那么将没有任何机器能无密码登录到本系统。因此，这个文件对本机至关重要。

生成并配置SSH密钥

要解决连接问题，我们需要在主服务器上生成一个SSH密钥对，并将公钥添加到节点的 authorized_keys 文件中。

以下是需要添加的密钥生成步骤。要为你的系统生成密钥，只需输入：

ssh-keygen -t rsa

按回车接受默认设置。它将在默认位置为你生成密钥。

一旦你看到“RSA”密钥生成的提示，意味着你的密钥已创建成功。你得到了一个可以用于其他机器的密钥。如果你将公钥放到节点上，就能实现无密码导航。

现在，再次列出 .ssh 目录的内容：

ls -la ~/.ssh

你会看到新的文件，例如 id_rsa（私钥）和 id_rsa.pub（公钥）。

你需要做的是，复制公钥的内容：

cat ~/.ssh/id_rsa.pub

你将看到公钥字符串。

关键操作：将上面显示的全部公钥内容，复制并添加到节点服务器的 ~/.ssh/authorized_keys 文件中。你可以使用 vim、nano 编辑器或 echo 命令追加。

在节点上执行：

echo \"<粘贴主服务器的公钥>\" >> ~/.ssh/authorized_keys

完成此操作后，返回主服务器，再次尝试SSH连接节点IP。这次应该可以无需密码直接登录，为后续安装和配置Chef客户端做好准备。

总结

本节课中我们一起学习了配置第二个Chef节点，并解决了主节点间SSH无密码连接的核心问题。我们通过生成SSH密钥对，并将主服务器的公钥添加到节点的授权列表中，成功建立了安全的自动化管理通道。这是构建Chef自动化基础设施的基础。

004：配置无密码SSH与Visual Studio Code连接 🚀

概述

在本节课程中，我们将学习两个核心技能。首先，我们将配置主节点与代理节点之间的无密码SSH连接，这是自动化基础设施管理的基础。其次，我们将设置Visual Studio Code编辑器，使其能够通过SFTP协议连接到我们的Ubuntu工作站，从而实现本地编辑、远程执行的便捷工作流。

配置无密码SSH连接 🔑

上一节我们完成了节点的基本设置，本节中我们来看看如何实现节点间的安全、无密码通信。这是实现自动化管理的关键一步。

我们首先查看主节点的公钥文件内容。

cat /path/to/master_public_key.pub

接着，我们将此公钥内容复制到代理节点的授权密钥文件中。

# 在代理节点上执行
echo "复制的公钥内容" >> ~/.ssh/authorized_keys

操作完成后，我们尝试从主节点通过SSH连接到代理节点。

ssh ubuntu@<代理节点IP地址>

连接成功，且无需输入密码。这证明我们已经建立了无密码SSH连接。

现在，我们可以验证代理节点的主机名。

hostname

输出应为代理节点的IP地址，例如 172.3.3.14。

核心概念：无密码SSH架构。其原理是主节点持有私钥，代理节点持有对应的公钥。当主节点发起连接时，代理节点使用存储的公钥进行验证，从而无需手动输入密码。公式可表示为：主节点(私钥) <--验证--> 代理节点(公钥)。

我们已成功实现一个重要的里程碑：建立无密码或密钥式基础设施。这意味着节点之间可以自由通信，无需交互式密码验证，为后续的自动化操作铺平了道路。

完成此设置后，我们退出代理节点，返回主节点。

设置Visual Studio Code远程连接 💻

基础架构已准备就绪，现在让我们来配置代码编辑环境。我将展示我偏好的设置：使用Visual Studio Code连接AWS EC2工作站。

首先，打开Visual Studio Code。如果你尚未安装，可以从官网下载。

为了组织代码，我将创建一个新的工作区文件夹。

  1. 在桌面上创建一个名为 Chef_workstation 的文件夹。
  2. 在VS Code中，通过“文件”->“打开文件夹”来打开这个新文件夹。

接下来，我们需要安装一个扩展，以便将Ubuntu工作站“映射”到VS Code中。以下是具体步骤。

安装并配置SFTP扩展

我们将使用SFTP扩展来连接Ubuntu虚拟机。

  1. 点击左侧活动栏的“扩展”图标（或按 Ctrl+Shift+X）。
  2. 在搜索框中输入 SFTP。
  3. 找到名为“SFTP”的扩展并点击“安装”。

安装完成后，我们需要配置连接信息。操作如下：

  1. 按下 Ctrl+Shift+P 打开命令面板。
  2. 输入 sftp config 并选择“SFTP: Config”命令。
  3. 系统会提示你选择一个文件夹来存放配置文件，选择我们刚创建的 Chef_workstation 文件夹。

这将在项目根目录下生成一个 sftp.json 配置文件。我们需要编辑此文件以填入连接详情。

以下是 sftp.json 文件的标准配置模板，你需要根据实际情况修改：

{
    "name": "Ubuntu_Workstation",
    "host": "你的_EC2_实例_IP_地址",
    "protocol": "sftp",
    "port": 22,
    "username": "ubuntu",
    "remotePath": "/home/ubuntu",
    "uploadOnSave": true,
    "privateKeyPath": "C:\\Users\\你的用户名\\.ssh\\your_key.pem"
}

配置项说明：

  • host：你的Ubuntu工作站（EC2实例）的公有IP地址。
  • username：连接使用的用户名，通常是 ubuntu。
  • remotePath：远程服务器上的默认工作目录，例如 /home/ubuntu。
  • uploadOnSave：设置为 true 后，当你在VS Code中保存文件时，它会自动上传到远程服务器。
  • privateKeyPath：指向你本地存放的.pem私钥文件的Windows路径。注意，Windows路径中的反斜杠\需要转义，即写成双反斜杠\\。

保存 sftp.json 文件后，连接就配置好了。此时，在VS Code的文件资源管理器中，你可以右键点击文件夹或文件，选择“SFTP: Download”来将远程文件同步到本地进行编辑。

验证连接

配置完成后，你可以在VS Code中直接浏览和编辑远程Ubuntu机器上的文件。例如，你可以找到之前配置SSH时修改过的 ~/.ssh/known_hosts 文件，在VS Code中打开并查看。

工作流程：你在VS Code（本地Windows）中编辑文件 -> 保存文件 -> 文件通过SFTP自动上传到Ubuntu服务器。这样，你就能在熟悉的本地编辑器环境中，无缝地对远程服务器进行代码和配置管理。

为了保持演示清晰，避免混淆，在后续课程中，我将主要使用Visual Studio Code来编辑文件，而在终端中执行命令。

总结

本节课中我们一起学习了两个至关重要的实践技能。

  1. 建立了无密码SSH连接：通过在代理节点的authorized_keys文件中添加主节点的公钥，我们实现了节点间的密钥认证，为自动化工具管理多节点打下了基础。
  2. 配置了Visual Studio Code远程开发环境：通过SFTP扩展，我们将远程Ubuntu工作站映射到本地编辑器，实现了“本地编辑、远程生效”的高效工作模式，这将极大方便后续Chef食谱和资源的编写与管理。

至此，我们的自动化基础设施和开发环境都已就绪，接下来就可以开始创建Chef资源、食谱，并推进我们的案例研究了。

005：在厨师工作站上设置Chef开发工具包 🛠️

在本节课中，我们将学习如何在Chef工作站上安装和配置Chef开发工具包（Chef DK），这是编写、测试和部署Chef代码的核心环境。我们将通过实际操作演示其功能，并验证安装是否成功。

工具功能演示

上一节我们介绍了工作站的基本概念，本节中我们来看看Chef DK附带的一个强大工具。这个工具允许我们方便地在本地编辑远程服务器上的文件。

我将登录到一台名为open2的虚拟机，并在其上创建一个空文件。

以下是创建文件的步骤：

  1. 在open2虚拟机上创建一个名为Du.txt的空文件。
  2. 该文件目前没有任何内容。

接下来，我将在工作站上使用SFTP工具连接到这台虚拟机。这个工具已经预先配置了连接所需的主机和密钥信息。

连接后，刷新文件列表，可以看到远程服务器上刚创建的Du.txt文件。如果直接双击尝试编辑，会提示错误。正确的方法是右键点击文件，选择“在本地编辑”。

在本地编辑器中，我可以为文件添加任意内容，例如输入“Just a check”。保存后，这些更改会自动同步回远程服务器。

现在，如果再次登录到open2服务器查看该文件，会发现内容已经更新。

这个工具非常强大，它允许我们在终端中并排操作，一边编写代码一边查看输出。不过，为了让学习过程更简单直观，在本课程中，我将主要使用这个工具进行文件编辑。大部分Linux操作和文件创建仍将在虚拟机终端中完成。

下载Chef开发工具包

现在，让我们进入准备Chef环境的最后一步：下载Chef开发工具包（Chef DK）。

Chef DK包含了用于构建、测试和部署Chef代码的一系列工具。我们可以从Chef官方网站下载它。

  1. 访问下载页面：downloads.chef.io。
  2. 在页面上找到Chef开发工具包的下载链接并打开。

  1. 在发布版本中，我选择3.4.38这个版本。为了确保课程演示的一致性，建议你也使用相同版本。当然，你也可以尝试更新的版本，但由于我的系统配置限制，我选择了这个兼容性更好的较低版本。
  2. 在操作系统列表中选择Ubuntu。因为我使用的是Ubuntu 18.04，所以选择对应的Ubuntu版本下载链接。
  3. 复制这个下载链接的URL。

安装Chef开发工具包

接下来，我们需要在工作站上下载并安装这个工具包。

首先，使用wget命令下载软件包到本地工作站。

wget [复制的下载链接URL]

下载完成后，使用dpkg命令来安装这个.deb软件包。

sudo dpkg -i [下载的.deb文件名]

安装过程需要超级用户权限，因此需要使用sudo。安装程序会解压文件、设置依赖，并完成所有必要的配置。

安装成功后，会显示“感谢安装Chef开发工具包”的提示信息。至此，我们已经成功安装了Chef DK。

验证安装

为了验证Chef DK是否安装成功，我们可以检查其版本信息。

运行以下命令：

chef --version

该命令会显示Chef DK及其所有组件的版本号，例如：

  • Chef DK版本：3.4.38
  • Delivery CLI版本
  • Berkshelf版本
  • Test Kitchen版本
  • InSpec版本

看到这些版本信息，就证明Chef开发工具包已经准备就绪。现在，我们可以开始编写自动化代码，并让Chef DK来执行和管理它们了。

本节课总结

在本节课中，我们一起学习了：

  1. 演示了Chef DK附带工具的功能：如何通过SFTP在本地编辑远程服务器文件。
  2. 下载了Chef开发工具包：从官网选择了适合的版本（3.4.38 for Ubuntu 18.04）并获取了下载链接。
  3. 安装并验证了Chef DK：使用wget下载，用dpkg安装，最后通过chef --version命令成功验证了安装。现在，我们的Chef工作站环境已经搭建完成，可以开始进行自动化编码了。

006：资源与Ruby编程原则 🧱

在本节课中，我们将学习Chef的核心构建单元——资源，并理解其如何基于Ruby编程语言实现基础设施即代码。

什么是Chef资源？

上一节我们介绍了Chef的基本概念，本节中我们来看看构成Chef代码的基础元素——资源。

资源是Chef的基本构建块，它定义了将配置项带入期望状态所需的步骤。资源本质上是一段代码，这段代码用于实现自动化配置。我们提到了“期望状态”这个术语，它指的是你希望某个特定组件被配置成的最终形态。

例如，如果你有一个名为“Web服务器”的资源，其期望状态就是该服务器被安装并处于运行状态。为了达到这个状态，资源会执行一系列动作，如安装软件包、确保服务启动，甚至创建并托管一个HTML文件。

基础设施即代码与Ruby DSL

你或许听说过“基础设施即代码”，Chef正是这一理念的实践。之所以如此，是因为我们使用Ruby编程语言的抽象形式来声明系统组件的配置方式。

Chef代码本质上是内嵌在Chef配方单中的Ruby编程。这种抽象被称为领域特定语言。因此，Chef是一种构建在Ruby之上的领域特定语言。

如何定义资源？

让我们通过一个例子来具体看看如何定义资源。以下代码展示了如何编写一个资源。

# 这将安装Nginx
package 'nginx' do
  action :install
end

首先，我们通过#符号添加注释，说明代码意图。这有助于他人或未来的你理解代码目的。

接着，我们定义了一个package资源，并指定其名称为'nginx'。在do和end构成的Ruby代码块中，我们声明了Chef应对此资源执行的操作：安装(:install)。这个简单的资源定义了将Nginx软件包安装到期望状态的步骤。

更多资源示例

除了软件包，Chef还支持多种资源类型。以下是另一个定义file资源的例子。

file '/etc/test.txt' do
  action :create
  content 'This is Nginx setup guide.'
end

在这个例子中：

  1. 资源类型是 file。
  2. 资源名称（即路径）是 /etc/test.txt。
  3. 在代码块中，我们指定的动作为创建(:create)。
  4. 我们还通过content属性定义了文件的内容。

请注意，每个动作（如:install、:create）前面都有一个冒号，这在Ruby中称为符号。动作是资源特定的，例如，:create动作只适用于文件资源，而不适用于软件包资源。

当Chef在节点上运行这段代码时，它会检查/etc/test.txt文件是否存在。如果不存在，则创建该文件并写入指定内容；如果已存在，则会确保其内容符合定义。

资源、配方单与食谱的关系

理解资源的层级关系至关重要：

  • 资源是基础的代码构建块。
  • 将多个资源组合在一个代码文件中，就构成了配方单。
  • 将多个相关的配方单组织在一起，就形成了一个食谱。

因此，其关系可以总结为：食谱包含配方单，配方单包含资源。掌握了各种资源的使用方法，你就能编写配方单，进而构建出功能完整的食谱来自动化你的基础设施。

总结

本节课中我们一起学习了：

  1. Chef资源是定义基础设施组件期望状态的基本单元。
  2. Chef通过Ruby领域特定语言实现“基础设施即代码”。
  3. 我们通过package和file资源的代码示例，了解了如何定义资源类型、名称和动作。
  4. 明确了资源、配方单和食谱之间的层级包含关系。

理解并熟练使用资源，是开始用Chef自动化你的云基础设施项目的第一步。

007：在本地模式下部署配方 🧑‍🍳

在本节课中，我们将学习如何创建并运行你的第一个Chef配方（Recipe）。我们将从创建一个空的配方文件开始，逐步添加配置资源，并最终在本地模式下使用Chef客户端来执行它，以验证自动化过程。

创建第一个配方

上一节我们介绍了Chef的基本概念，本节中我们来看看如何动手创建配方。配方是Chef中定义配置策略的核心，它声明了资源和资源类型，这些是配置系统所需的一切。

配方本质上是扩展名为 .rb 的Ruby文件。现在，让我们创建一个名为 first_recipe.rb 的空文件。

# 这是一个空的Ruby文件，我们将用它来配置系统。

Ruby是一种动态的通用编程语言，其语法易于阅读和使用，因此被选为Chef的配置语言。

定义配方内容

我们已经创建了文件，接下来需要在其中定义具体的配置资源。我们将声明两种资源类型：一个用于安装软件包，另一个用于创建文件。

以下是配方文件的内容：

# 声明一个‘package’资源来安装名为‘tree’的软件包
package 'tree' do
  action :install
end

# 声明一个‘file’资源，在指定路径创建文件
file '/home/ubuntu/test.txt' do
  action :create
  content 'Hello, this is my first recipe.'
end

在这段代码中：

  • package ‘tree’ 是一个资源声明，它告诉Chef需要管理名为 tree 的软件包。
  • do … end 块定义了该资源应执行的操作（action）。
  • action :install 指定了期望的操作是安装该软件包。
  • 类似地，file 资源声明了需要在 /home/ubuntu/test.txt 路径创建一个文件，其内容为指定的字符串。

理解Chef客户端

配方文件编写完成后，需要有一个“执行者”来读取并应用这些配置。这个执行者就是Chef客户端代理。

Chef客户端是一个运行在每个由Chef管理的机器上的本地代理。当它运行时，会检查配方中定义的资源状态，并在必要时将这些资源调整到配方所描述的期望状态。例如，如果 tree 软件包没有安装，Chef客户端就会执行安装命令；如果指定的文件不存在，就会创建它。

简而言之，Chef客户端是实现所有自动化“魔法”发生的地方。

在本地模式下运行配方

通常，Chef客户端默认会连接Chef服务器来获取要执行的配方（即默认模式）。但为了测试，我们将在本地模式下运行，这意味着客户端会直接从本地文件系统读取配方文件，而无需服务器。

要启用本地模式，需要在运行 chef-client 命令时加上 --local-mode 标志。同时，我们需要通过 -o (override run list) 参数来指定要运行的配方。

运行配方的命令格式如下：

sudo chef-client --local-mode -o “recipe[<cookbook_name>::<recipe_name>]”

由于我们目前还没有将配方组织到正式的Cookbook结构中，可以暂时使用一个简化的路径格式来直接运行我们的文件。但请注意，在生产环境中，配方通常被组织在Cookbook中。

以下是运行我们刚刚创建的配方的命令示例：

sudo chef-client --local-mode -o “recipe[first_recipe]”

执行此命令后，Chef客户端将：

  1. 解析 first_recipe.rb 文件。
  2. 检查当前系统状态（tree 包是否已安装？/home/ubuntu/test.txt 文件是否存在？）。
  3. 执行必要的操作，使系统状态与配方中定义的期望状态一致。
  4. 在终端输出详细的执行日志，报告它做了哪些事情。

你可以通过检查软件包是否安装和文件是否被成功创建，来验证配方是否执行成功。

总结

本节课中我们一起学习了Chef自动化配置的实践第一步。我们创建了一个包含 package 和 file 资源的简单配方文件，理解了Chef客户端作为“执行者”的角色及其期望状态模型，并掌握了如何使用 --local-mode 参数在本地模式下运行配方以进行测试。这为后续学习更复杂的Cookbook结构和服务器模式打下了基础。

008：在本地模式下部署配方

概述

在本节课中，我们将学习如何在本地模式下执行一个Chef配方（recipe）。我们将通过一个具体的例子，演示如何运行配方来安装软件包和创建文件，并验证执行结果。这是理解Chef自动化工作流程的基础。

执行配方

上一节我们介绍了配方的基本结构，本节中我们来看看如何实际运行它。由于我们使用的是Ubuntu系统，需要超级用户权限来执行命令。可以使用sudo命令来获取权限。

以下是执行配方的命令：

sudo chef-client --local-mode recipe.rb

运行此命令将启动Chef客户端，并开始执行我们定义的配方。

处理语法错误

在执行过程中，我们可能会遇到语法错误。例如，在资源定义中错误地使用了冒号。

以下是修正后的文件资源定义：

file '/tmp/bak.txt' do
  content 'This is my first ever recipe'
  action :create
end

修正错误后，需要确保文件已正确保存，然后重新运行执行命令。

分析执行结果

命令执行完成后，Chef客户端会输出详细的执行报告。报告显示了资源的收敛过程。

执行结果摘要如下：

  • 执行状态：Chef运行完成，成功更新了2个资源。
  • 资源详情：我们定义了两个资源（一个package和一个file），两者均已成功处理。
  • 警告信息：输出中可能包含关于缺少Cookbook目录的警告，这在仅运行独立配方文件时是正常的，可以暂时忽略。

理解Chef执行流程

Chef客户端的执行分为两个主要阶段：

  1. 编译阶段：Chef解析配方文件，检查语法并将所有资源编译成内部对象。如果此阶段发现错误（如之前的语法错误），执行会中止。
  2. 收敛阶段：Chef执行所有已成功编译的资源，使系统状态符合配方的定义。只有成功通过编译，才会进入此阶段。

验证资源执行效果

我们需要验证配方中的两个资源是否按预期生效。

验证软件包安装：
运行以下命令检查cowsay软件包是否安装成功：

which cowsay
cowsay "Hello Chef!"

如果安装成功，which命令会显示可执行文件路径，并且cowsay命令会打印出一头牛和消息。

验证文件创建：
运行以下命令检查文件是否创建并包含正确内容：

cat /tmp/bak.txt

此命令应显示我们在配方中定义的文件内容：“This is my first ever recipe”。你也可以在文件浏览器或编辑器中查看该文件以进行确认。

总结

本节课中我们一起学习了Chef配方在本地模式下的完整执行流程。我们经历了从执行命令、排查语法错误、分析执行报告到最终验证资源状态的全过程。关键点在于理解Chef的编译与收敛两阶段模型，以及其“声明式”的特性——例如，我们只需声明安装package 'cowsay'，Chef会自动根据操作系统选择合适的包管理器（如Ubuntu上用apt）。这是后续将配方组织进Cookbook，并部署到服务器与节点的基础。掌握本地执行和验证，对后续学习至关重要。

009：创建食谱 🍳

在本节课中，我们将学习如何创建和使用Chef食谱。食谱是Chef配置管理的基本构建块，所有具体的配置指令都包含在食谱中。

上一节我们介绍了食谱的基本概念，本节中我们来看看如何实际创建一个食谱。

创建食谱目录

首先，需要创建一个名为cookbooks的目录来存放所有食谱。如果你在本地模式下运行食谱，大部分食谱都应存放在此目录下。

mkdir cookbooks

执行上述命令后，可以检查目录是否创建成功。

使用Chef生成器

创建食谱最简单的方法是使用Chef开发工具包自带的生成器。Chef命令chef随开发工具包一同安装。

要了解生成器的帮助信息，可以运行：

chef --help

这将显示所有可用的命令选项。其中，generate关键字用于生成食谱或其组件。

要详细了解generate命令的用法，可以运行：

chef generate --help

此命令会列出所有可用的生成器。目前，我们关注的是生成食谱。

要生成一个名为chef-workstation的食谱，并指定其路径为cookbooks目录，可以运行以下命令：

chef generate cookbook cookbooks/chef-workstation

命令执行成功后，会显示相关信息。默认情况下，Git会用来跟踪食谱中的所有更改。

管理食谱文件

食谱生成后，你可能想知道如何执行其中的配方文件。之前我们执行的是独立的配方文件，而现在配方文件位于食谱目录结构中。

假设你有一个名为first_recipe.rb的配方文件，需要将其移动到新创建的食谱中。可以使用mv命令：

mv first_recipe.rb cookbooks/chef-workstation/recipes/

移动后，可以进入食谱目录查看结构：

cd cookbooks/chef-workstation
ls -la

你会看到由生成器创建的多个目录。进入recipes目录，可以看到已存在的default.rb文件和我们刚移动进来的first_recipe.rb文件。

运行食谱中的配方

现在，是时候运行我们的配方了。你可能会尝试使用之前的方法：

sudo chef-client --local-mode --recipe-path cookbooks/chef-workstation/recipes/first_recipe.rb

但是，当配方位于食谱中时，这种方法可能无法正常工作。因为Chef客户端可能会困惑于执行哪个配方，而且食谱中可能包含其他配方（如default.rb）。

标准的做法是，通过指定食谱名和配方名来运行。通常，一个食谱的入口点是default.rb文件。如果你想运行first_recipe.rb，一种方法是在default.rb文件中包含它。

本节课中我们一起学习了如何创建Chef食谱目录、使用chef generate命令生成食谱结构、将配方文件移动到食谱中，并了解了在食谱上下文中运行配方的正确方法。掌握这些是组织和管理复杂基础设施代码的基础。

010：在Chef Solo环境下运行

概述

在本节课程中，我们将学习如何在Chef Solo环境下运行一个简单的自动化脚本。我们将通过修改默认的recipe文件，并正确配置运行列表，来确保Chef客户端能够找到并执行我们编写的recipe。

配置默认Recipe文件

上一节我们介绍了如何编写一个基础的recipe。本节中，我们来看看如何将其包含到Chef的运行流程中。

首先，需要编辑cookbook中的默认recipe文件。这个文件通常名为 default.rb，它负责包含所有你希望在运行时执行的recipe。

以下是需要执行的步骤：

  1. 打开你的cookbook目录。
  2. 找到并编辑 recipes/default.rb 文件。
  3. 在该文件中，使用 include_recipe 语句来包含你编写的recipe。

例如，如果你的cookbook名为 chef-workstation，recipe文件名为 first_recipe.rb，则应在 default.rb 文件中添加如下代码：

include_recipe 'chef-workstation::first_recipe'

请注意，在引用recipe时，不需要添加 .rb 文件扩展名，因为Chef客户端能够识别Ruby文件格式。

运行Chef客户端并指定Recipe

保存 default.rb 文件后，直接运行Chef客户端可能会失败，因为它不知道去哪里寻找被引用的recipe文件。

为了解决这个问题，我们需要在运行命令时明确指定运行列表和cookbook的路径。

以下是运行Chef客户端的命令格式：

chef-client -z -r "recipe[cookbook_name::recipe_name]"

在这个命令中：

  • -z 参数表示在本地模式运行。
  • -r 参数用于指定运行列表。
  • recipe[cookbook_name::recipe_name] 指明了要运行的cookbook和具体的recipe。

例如，要运行 chef-workstation cookbook下的 default recipe，命令如下：

chef-client -z -r "recipe[chef-workstation::default]"

当运行这个命令时，Chef客户端会执行 default.rb 文件，而该文件已经包含了 first_recipe，因此两个recipe都会被执行。

简化命令与默认行为

为了简化命令，可以利用Chef的默认行为。如果你只指定cookbook名称而不指定具体的recipe，Chef客户端会自动寻找并执行该cookbook下的 default.rb 文件。

因此，以下命令是等效的：

chef-client -z -r "recipe[chef-workstation]"

这条命令会直接运行 chef-workstation::default recipe。我们在 default.rb 中已经通过 include_recipe 包含了 first_recipe，所以它也会被一并执行。这种方式减少了需要输入的参数，使命令更简洁。

从本地模式到服务器模式

目前，我们一直在使用 -z 参数在本地（Solo）模式下运行Chef。这种模式适合学习和测试。

在实际的生产环境中，通常会使用Chef服务器模式。其工作流程如下：

  1. 一个中央Chef服务器作为主工作站。
  2. 开发者将编写好的recipe代码上传到该服务器。
  3. 当需要对节点（如服务器或虚拟机）进行自动化配置时，Chef服务器将相应的指令和信息分发给目标节点。
  4. 节点需要安装Chef客户端（或Chef DK）才能与Chef服务器通信并接收自动化指令。

这种架构允许集中管理配置，并轻松地将自动化策略应用到大量节点上。

总结

本节课中我们一起学习了在Chef Solo环境下运行自动化脚本的关键步骤。我们首先学会了如何在默认recipe文件中包含其他recipe，然后掌握了通过指定运行列表来执行特定cookbook和recipe的命令行方法。我们还了解了简化命令的技巧，并对比了本地模式与未来将使用的服务器模式的基本概念。这些是使用Chef进行自动化配置的基础操作。

011：配置基于云的Chef服务器 🚀

概述

在本节课中，我们将学习如何配置一个基于云的Chef服务器。这个服务器将作为中央管理点，用于存储和分发所有需要在客户端节点上运行的配置（食谱和菜谱）。在大型组织中，手动管理成百上千个节点是不现实的，因此一个集中的自动化服务器至关重要。

上一节我们介绍了Chef的基本概念和工作站设置，本节中我们来看看如何建立这个中央管理服务器。

创建Chef管理账户

首先，我们需要在Chef官网上创建一个管理账户。这个账户将用于管理你的组织、节点和所有自动化配置。

以下是创建账户的步骤：

  1. 访问Chef官网并点击“Get Started”按钮。
  2. 填写你的姓名、公司名称、邮箱地址和一个未被占用的用户名。
  3. 同意相关条款，然后点击“Get Started”。
  4. 接下来，你需要创建一个组织（Organization）。输入组织的全名和简称。

我已经拥有一个账户，因此我将直接登录。登录后，你会进入管理界面。

下载Starter Kit（入门工具包）

成功创建组织后，你需要下载一个名为“Starter Kit”的压缩包。这个工具包包含了将你的服务器实例连接到Chef管理平台所需的所有配置文件。

如果你还没有创建组织，可以点击“Administration”然后创建。创建组织后，导航到“Starter Kit”部分进行下载。


点击“Download Starter Kit”按钮，将ZIP文件保存到本地。这个文件需要上传到我们计划用作Chef服务器的EC2实例上。

准备EC2实例作为Chef服务器

回顾之前的课程，我们已经创建了一个主服务器和一个节点。现在，我们需要将其中一个实例专门用作Chef服务器。

我将把之前的主服务器重命名为“Chef-Server”，它将作为我们所有自动化操作的中心工作站。


所有自动化配置都将在这个服务器上创建和管理，而各个客户端节点会定期向这个服务器拉取最新的配置。

在服务器上安装Chef Development Kit (ChefDK)

在将Starter Kit上传到服务器之前，必须确保服务器上已经安装了ChefDK。ChefDK是运行Chef工具链所必需的开发套件。

首先，通过SSH连接到你的EC2实例（Chef服务器）。

然后，从Chef官网获取ChefDK的安装链接。选择适合你操作系统（如Ubuntu）的版本，复制其下载链接。

在服务器终端中，使用wget命令下载该安装包：

wget [复制的ChefDK下载链接]

下载完成后，使用dpkg命令安装它：

sudo dpkg -i [下载的ChefDK包文件名]

安装过程可能需要一些时间。安装完成后，你可以通过运行以下命令来验证安装是否成功：

which chef

如果命令返回了Chef的安装路径，说明安装成功。

上传并配置Starter Kit

现在，我们需要将之前从网站下载的chef-starter.zip文件上传到服务器。我使用WinSCP工具在Windows和Linux机器之间传输文件。

打开WinSCP，输入你的EC2实例（Chef服务器）的公共IP地址、用户名（如ubuntu），并使用与实例关联的.pem密钥文件进行身份验证。







连接成功后，将本地的chef-starter.zip文件拖放到服务器的远程目录中（例如用户主目录）。

回到服务器的终端，导航到文件所在目录并解压它：

unzip chef-starter.zip

如果系统提示未找到unzip命令，你需要先安装它：

sudo apt-get install unzip

解压后，你会得到一个名为chef-repo的目录。进入该目录，可以看到其中包含cookbooks、roles等子目录以及关键的.chef隐藏目录。

cd chef-repo
ls -la

.chef目录里存放着knife.rb配置文件和你用户的验证密钥，这些是服务器与Chef管理平台通信的凭证。

验证服务器配置

最后，我们验证服务器是否已成功与云端Chef管理平台连接。在chef-repo目录下，运行以下命令：

knife client list

这个命令会列出已注册到你的Chef组织下的客户端。如果它能成功执行并返回信息（例如你组织的验证客户端名称），则表明你的Chef服务器配置成功，已经可以开始管理节点了。

总结

本节课中我们一起学习了如何配置一个基于云的Chef服务器。我们完成了从创建Chef管理账户、下载Starter Kit、准备EC2实例、安装ChefDK，到上传配置并最终验证服务器连接的完整流程。现在，你已经拥有了一个功能完整的中央自动化服务器，为后续在大量节点上批量部署和管理应用配置打下了坚实的基础。下一节，我们将学习如何将节点注册到这个服务器并开始应用自动化配置。

012：配置云端持续集成

概述

在本节课中，我们将学习Chef中一个强大的命令行工具——knife。我们将了解它的作用，如何使用它从Chef Supermarket下载社区食谱（cookbook），以及如何在Chef工作站和服务器之间传输文件。最后，我们将为自动化流程准备一个节点（Node）机器。

上一节我们介绍了Chef的基本架构和组件，本节中我们来看看连接和管理这些组件的核心工具。

理解Knife工具

knife是Chef生态系统中一个非常流行的命令行接口。它主要用于与Chef服务器进行交互。

具体来说，knife的作用是检查您的Chef服务器状态，并将您的节点（Node）与服务器连接起来。它是一个在线的命令行模式工具。例如，当我们执行 knife client list 命令时，它实际上会连接到我们的服务器，并检查组织内的客户端列表。

探索Chef Supermarket

为了更深入地理解knife和Chef服务器的强大之处，我们需要知道，服务器上预存了大量社区贡献的食谱（recipes）。我们可以直接获取这些食谱，无需自行修改，即可在系统中安装软件。

knife和服务器的一个强大功能在于，Chef服务器提供了一个集中位置来获取所有类型的食谱。这个位置被称为“Supermarket”。您可以访问 supermarket.chef.io 来浏览。

例如，如果您需要Apache的配置食谱，只需在Supermarket中搜索“Apache2”，即可找到相关食谱。您只需点击获取，并使用knife命令即可将其下载到您的Chef机器上。

同样，如果您想配置MySQL服务器，也可以搜索“MySQL server”。Supermarket上会列出所有相关的代码、默认配置和软件包信息。

使用Knife下载Cookbook

以下是如何使用knife命令直接从Supermarket下载一个cookbook的演示。

假设您想下载MySQL的cookbook，您需要执行以下命令：

knife cookbook site download mysql

这个命令会从Supermarket下载名为“mysql”的cookbook。下载完成后，您会收到提示信息，并且cookbook会以tar压缩包的形式保存在您的Chef仓库目录中。

您可以使用 ls -ltr 命令来查看下载的文件。接着，可以使用以下命令解压这个tar文件：

tar -xzf mysql-*.tar.gz -C cookbooks/

解压后，您可以在 cookbooks/ 目录下找到mysql相关的文件夹和文件。通过这种方式，您就成功地从服务器使用knife命令下载了所需的配置。

在服务器与工作站间传输Cookbook

knife命令不仅能下载，还能上传食谱。我们已经在本地的Chef工作站上创建了一个食谱。现在，我们将把这个食谱复制到Chef服务器上。

首先，我们位于工作站的cookbooks目录中，例如 ~/chef-repo/cookbooks/sample_cookbook。这个cookbook内部有 recipes/ 目录，其中包含了 default.rb 等配方文件。

我们将使用 scp 命令安全地将整个cookbook目录结构复制到服务器上。命令格式如下：

scp -r /path/to/local/cookbook opentech@<server_ip>:/tmp/

这个命令会将本地cookbook递归地复制到服务器的 /tmp/ 目录下。操作成功后，您可以在服务器上验证文件是否已存在。

接着，在服务器上，我们需要将这些文件移动到正确的Chef仓库目录中。通常路径是 ~/chef-repo/cookbooks/。您可以使用以下命令：

cp -r /tmp/sample_cookbook ~/chef-repo/cookbooks/

完成之后，进入 ~/chef-repo/cookbooks/ 目录，您应该能看到名为 sample_cookbook 的文件夹。这表示我们成功地在工作站和服务器之间建立了通信，并传输了配置。

准备自动化节点（Node）

目前我们的设置包含两台机器：一台作为开发工作站，另一台作为Chef服务器。为了实现完整的自动化，我们还需要至少一台作为被管理节点的机器。

我们可以创建任意数量的节点机器，并仅通过工作站和服务器这两台机器来维护它们。服务器作为开发机，工作站作为自动化控制机。

现在，让我们快速创建一台新的EC2实例作为节点。在AWS控制台中，启动一个新实例，选择适当的AMI（例如Amazon Linux 2），配置安全组以允许所有流量（仅用于实验目的），然后启动实例。

创建完成后，我们就拥有了一台新的节点机器。接下来的关键步骤是将这个节点与我们的Chef工作站，尤其是Chef服务器连接起来，以便开始推送和管理配置。

总结

本节课中我们一起学习了Chef的核心命令行工具knife。我们了解了它作为与Chef服务器交互的桥梁作用，实践了如何使用它从Chef Supermarket下载社区cookbook，以及如何在Chef工作站和服务器之间传输我们自己的cookbook。最后，我们为自动化流程创建了一个新的节点机器，为后续将配置自动化部署到节点上做好了准备。

013：引导启动Chef节点 🚀

在本节课中，我们将学习如何将已创建的Chef节点引导启动，使其与Chef服务器建立连接，并自动安装必要的软件和配置。我们将使用knife bootstrap命令来完成这一自动化过程。

概述

上一节我们成功创建了Chef节点。本节中，我们来看看如何通过引导启动（Bootstrap）流程，将该节点与我们的Chef服务器关联起来，并自动应用我们上传的食谱（Cookbook）。

上传食谱到Chef服务器

首先，我们需要将本地工作站上创建的食谱上传到中央Chef服务器。以下是具体步骤。

我将使用knife命令来上传我们的食谱。knife是用于与Chef服务器交互、执行上传或下载操作的主要工具。

  • 命令：knife cookbook upload chef-workstation
  • 说明：此命令将连接到我们创建的云端Chef服务器账户，并将名为chef-workstation的食谱安装到服务器上。

执行此命令后，系统显示上传成功。我们可以通过另一个命令来验证服务器上现有的食谱。

  • 验证命令：knife cookbook list
  • 预期结果：执行此命令后，应列出已上传的食谱，例如chef-workstation。在上传之前，此命令会返回零个食谱。

我们也可以登录Chef服务器的Web管理界面，在“策略”（Policy）部分查看到workstation食谱及其所有内容和权限，这进一步确认了上传成功。

理解引导启动（Bootstrap）

目前，虽然节点已创建，但并未与Chef服务器关联。节点不知道应该联系哪个服务器来获取食谱和指令。引导启动过程将自动化解决这个问题。

引导启动 是指Chef服务器自动为节点安装必要软件、创建身份验证密钥并将其添加到组织中的过程。我们的节点虚拟机目前甚至没有安装Chef客户端软件，引导启动将管理这一切。

简单来说，引导启动会告诉节点：“我是你的服务器，你需要联系我来获取运行所需的食谱”，并提供所有必要的登录凭证和软件。

更新节点系统（可选）

在开始引导启动之前，可以选择先更新节点虚拟机的系统。这是一个可选但通常有益的操作，可以确保系统补丁和软件包是最新的。

我将通过运行系统更新命令来完成此步骤。更新过程需要一些时间。

执行引导启动命令

当系统更新进行时，我们可以在Chef工作站上准备并执行引导启动命令。我将切换到Chef代码仓库目录。

引导启动使用knife bootstrap命令。我们需要指定节点的IP地址或域名、登录用户名以及要应用的食谱。

  • 核心命令示例：
    knife bootstrap <NODE_IP_ADDRESS> -x <USERNAME> -P <PASSWORD> --sudo --use-sudo-password -N <NODE_NAME> -r 'recipe[<COOKBOOK_NAME>::<RECIPE_NAME>]'
  • 过程说明：该命令会为节点创建新的客户端和节点记录，下载并安装Omnibus（包含Chef客户端），然后自动编译并运行指定的食谱。

执行命令后，一个自动化的安装和配置过程开始。它安装了所有必需的软件包，并应用了我们食谱中定义的配置。整个过程大约耗时45秒。

验证引导启动结果

引导启动完成后，我们需要验证配置是否已成功应用到目标节点。

我们可以在目标节点上检查，是否生成了食谱中定义的文件。例如，我们的食谱可能包含创建特定配置文件的指令。

  • 验证方法：登录目标节点，检查预期文件是否存在并包含正确内容。
  • 结果：在目标节点上，我们找到了由食谱指令创建的文件（例如factor.txt），并且其内容与我们食谱中定义的一致。这证明引导启动成功，配置已从Chef服务器复制并应用到了节点。

总结

本节课中，我们一起学习了Chef自动化中的关键步骤——引导启动节点。我们首先将本地食谱上传到了Chef服务器，然后理解了引导启动的概念，即自动化安装软件、建立认证和关联节点的过程。最后，我们通过一条knife bootstrap命令，成功地将新节点接入Chef管理体系，并验证了自动化配置部署的结果。至此，一个基本的“服务器-节点”自动化管理链路已经建立。

014：安装MySQL服务器 🗄️

在本节课中，我们将学习如何使用Chef自动化安装MySQL数据库服务器。我们将创建一个专门的Cookbook和Recipe，并将其应用到目标节点上，为后续的Web应用项目提供数据存储支持。

概述

上一节我们介绍了如何引导（Bootstrap）一个节点。我们引导了一个名为web1的节点。本节中，我们将创建一个数据库服务器节点，并编写一个Chef Recipe来自动化安装MySQL服务器。

回顾节点引导过程

节点引导的语法非常简单。我们使用knife命令行工具。基本命令结构如下：

knife bootstrap <IP_ADDRESS> -x <USERNAME> -i <PATH_TO_PEM_FILE> -N <NODE_NAME> --sudo --run-list 'recipe[<COOKBOOK_NAME>::<RECIPE_NAME>]'

以下是命令各部分的解释：

  • knife bootstrap: 引导节点的主命令。
  • <IP_ADDRESS>: 目标节点的IP地址。
  • -x <USERNAME>: 用于SSH连接的用户名（例如，Ubuntu系统常用ubuntu，EC2常用ec2-user）。
  • -i <PATH_TO_PEM_FILE>: SSH私钥文件的路径。
  • -N <NODE_NAME>: 为节点定义的名称（例如web1）。
  • --sudo: 以sudo权限执行命令。
  • --run-list: 指定节点需要运行的Recipe列表。

执行此命令后，Chef服务器会连接到目标节点，安装必要的Chef客户端软件包，并根据run-list执行指定的Recipe，从而完成节点的配置。

目前，我们有两个节点：一个Web服务器（web1）和一个即将配置的数据库服务器。

创建MySQL Cookbook

我们将创建一个新的Cookbook来管理MySQL服务器的安装。这个Cookbook将在工作站（Workstation）上创建，任何安装了Chef Development Kit（ChefDK）的机器都可以执行此操作。

进入Cookbooks目录，使用以下命令生成Cookbook：

chef generate cookbook cookbooks/mysql

此命令会创建名为mysql的Cookbook及其所需的全部目录结构。

创建数据库服务器Recipe

接下来，我们在mysql Cookbook中创建一个专门用于安装数据库的Recipe。

进入新创建的mysql Cookbook目录，使用生成命令创建Recipe：

chef generate recipe db_server

此命令会在recipes目录下创建名为db_server.rb的Recipe文件。使用生成命令可以确保文件符合Chef的标准格式并包含必要的元数据。

现在，编辑db_server.rb文件，编写安装MySQL服务器的逻辑。

编写安装MySQL的Recipe

Recipe的编写非常简洁。我们使用Chef的package资源来声明需要安装的软件包。Chef会根据目标节点的操作系统自动选择正确的包管理工具（如APT、YUM）。

打开cookbooks/mysql/recipes/db_server.rb文件，输入以下内容：

package 'mysql-server'

这行代码告诉Chef：“确保在此节点上安装名为mysql-server的软件包”。Chef会自动处理安装过程，无需我们指定具体的操作（如action :install），因为安装是package资源的默认行为。

保存文件。至此，安装MySQL服务器的Recipe就编写完成了。

上传Cookbook并引导数据库节点

我们的实验环境包含三台机器：工作站、Chef服务器、一个Web主机和一个数据库主机。目前，我们只在工作站上创建了Cookbook。

为了在数据库节点上运行这个Recipe，我们需要将Cookbook上传到Chef服务器，然后引导数据库节点并指定运行此Recipe。

首先，将工作站上生成的mysql Cookbook复制到Chef服务器的相应目录。假设Chef服务器的仓库路径为/chef-repo/cookbooks/，可以使用scp命令进行复制：

scp -r cookbooks/mysql root@<CHEF_SERVER_IP>:/chef-repo/cookbooks/

复制完成后，登录Chef服务器验证mysql Cookbook已存在于/chef-repo/cookbooks/目录中。

最后，引导数据库节点。使用与之前类似的knife bootstrap命令，但将节点名称改为db1，并将运行列表指向我们刚创建的Recipe：

knife bootstrap <DB_NODE_IP> -x ubuntu -i /path/to/your.pem -N db1 --sudo --run-list 'recipe[mysql::db_server]'

执行此命令后，Chef服务器将配置新的数据库节点，并自动安装MySQL服务器。

总结

本节课中我们一起学习了如何为数据库服务器创建专门的Chef Cookbook和Recipe。我们完成了以下步骤：

  1. 回顾了使用knife bootstrap引导节点的命令语法。
  2. 使用chef generate cookbook命令创建了mysql Cookbook。
  3. 使用chef generate recipe命令在Cookbook中创建了db_server Recipe。
  4. 编写了用于安装mysql-server软件包的简单Recipe代码。
  5. 了解了将Cookbook上传至Chef服务器并引导新节点运行该Recipe的流程。

通过本节学习，你掌握了使用Chef自动化安装基础服务（如MySQL）的方法，这是构建自动化云基础设施的关键一步。

015：集中式Chef服务器 🚀

在本节中，我们将学习如何将编写好的Cookbook上传到Chef服务器，并通过服务器将配置应用到节点上。我们将涵盖上传Cookbook、引导节点、管理节点列表以及通过Web界面管理运行清单等核心操作。

上一节我们介绍了如何编写Cookbook。本节中，我们来看看如何通过Chef服务器集中管理并应用这些Cookbook。

首先，我们需要将本地的Cookbook上传到Chef服务器。命令非常简单，使用 knife upload 即可。

以下是上传名为 mysql 的Cookbook的命令：

knife upload cookbook mysql

此命令会将 mysql Cookbook上传至服务器。之后创建新节点时，就无需手动复制Cookbook，可以直接从服务器获取并运行。

上传完成后，我们需要引导一个节点（例如DB服务器）并将其加入Chef服务器的管理。引导命令会初始化节点并安装Chef客户端。

以下是引导节点的命令格式，需要指定节点的IP地址、SSH用户和密钥：

knife bootstrap <NODE_IP_ADDRESS> --ssh-user <USERNAME> --sudo --identity-file <PATH_TO_PEM_FILE> --node-name <NODE_NAME> --run-list 'recipe[<COOKBOOK_NAME>]'

例如，引导一个名为 db01 的节点并运行 mysql Cookbook：

knife bootstrap 192.168.1.100 --ssh-user ubuntu --sudo --identity-file ~/.ssh/mykey.pem --node-name db01 --run-list 'recipe[mysql]'

命令执行后，Chef会连接到节点，检查并安装Chef客户端，同步Cookbook，并执行指定的配方单。

接下来，我们可以验证节点是否成功加入以及Cookbook的执行情况。

要查看所有已注册到Chef服务器的客户端节点，可以使用以下命令：

knife client list

此命令会列出所有关联的客户端，例如 db01 和 web-server。

要查看服务器上所有可用的Cookbook，可以使用：

knife cookbook list

此命令会显示例如 workstation 和 mysql 这两个Cookbook。

如果需要查看某个节点（如 db01）的详细信息，包括其IP地址和已分配的配方单，可以使用：

knife node show db01

除了命令行，我们还可以通过Chef服务器的Web管理界面来管理节点和运行清单。

登录Web界面后，在“Nodes”部分可以看到所有节点。点击一个节点（如 db01），然后选择“Edit Run List”。在这里，你可以通过图形化界面添加或删除该节点需要运行的Cookbook，例如添加 workstation 或 mysql。保存后，配置即会更新。

最后，在目标节点上，我们可以手动触发Chef客户端运行，以从服务器拉取最新的配置并应用。

在节点上执行以下命令：

sudo chef-client

该命令会联系Chef服务器，获取当前节点的运行清单，并执行所有指定的配方单，确保节点状态符合预期。

本节课中我们一起学习了Chef服务器的核心管理操作。我们掌握了如何将Cookbook上传至服务器、如何引导新节点、如何使用命令行和Web界面查看与管理节点及运行清单，最后还学会了在节点上手动运行Chef客户端以应用配置。通过这些步骤，你可以实现云基础设施配置的集中化与自动化管理。

016：设置数据库

概述

在本节课程中，我们将学习如何解决Chef节点通信错误，并手动设置一个MySQL数据库。我们将创建一个用于“大学注册表单”的数据库和表结构，为后续部署Web应用做好准备。

解决节点通信错误

上一节我们介绍了Chef的基本配置，但在实际使用中，你可能会遇到节点通信问题。

以下是常见的错误场景：使用AWS EC2 T2 Micro实例时，如果服务器被关闭后重启，其IP地址会动态变化。这会导致之前通过引导（bootstrap）配置的节点（如Web服务器、数据库服务器）无法与Chef服务器正常通信。

每次发生IP地址变更时，你都需要重新运行引导命令来配置节点。解决此问题的方法是再次引导节点。

运行命令 chef-client 或重新执行引导命令后，通信问题通常可以得到解决。

手动设置MySQL数据库

既然我们已经解决了节点问题并安装了MySQL服务器，现在让我们进入MySQL并手动设置我们的数据库。

首先，登录到MySQL控制台。使用以下命令，其中 -u 指定用户，-p 表示需要密码。

mysql -u root -p

输入密码后，你将进入MySQL命令提示符界面。

查看与创建数据库

登录后，我们可以先查看当前已存在的数据库。

SHOW DATABASES;

系统会显示预安装的数据库，例如 information_schema, mysql, performance_schema, sys。

对于我们的案例——创建一个大学注册表单，我们需要一个专门的数据库来存储用户信息。以下是创建数据库的步骤：

  1. 使用 CREATE DATABASE 语句。
  2. 为数据库命名，例如 registration。
CREATE DATABASE registration;

执行后，再次使用 SHOW DATABASES; 命令，你将看到新创建的 registration 数据库。

使用数据库并创建表

数据库创建成功后，我们需要进入该数据库并创建存储数据的具体表格。

使用以下命令切换到 registration 数据库：

USE registration;

现在，我们位于目标数据库内。数据存储在表中，但目前还没有任何表。可以验证一下：

SHOW TABLES;

结果显示为空，表示没有表。接下来，我们创建一个名为 user_signup 的表，用于定义注册表单的字段结构。

以下是创建表的SQL语句。我们定义了多个字段，并规定它们不能为空（NOT NULL），以确保数据的完整性。

CREATE TABLE user_signup (
    first_name VARCHAR(25) NOT NULL,
    middle_name VARCHAR(25) NOT NULL,
    last_name VARCHAR(25) NOT NULL,
    course VARCHAR(30) NOT NULL,
    address VARCHAR(300) NOT NULL,
    email VARCHAR(45) NOT NULL,
    password VARCHAR(255) NOT NULL
);

执行上述命令后，表就创建成功了。

验证表结构

现在，让我们验证表是否已创建及其结构是否正确。

首先，查看当前数据库中的所有表：

SHOW TABLES;

你应该能看到 user_signup 表。接着，使用 DESCRIBE 命令查看表的详细结构：

DESCRIBE user_signup;

结果将显示我们定义的所有字段：first_name, middle_name, last_name, course, address, email, password，以及它们的类型（VARCHAR）和约束（NOT NULL）。

总结与后续步骤

本节课中，我们一起学习了两个关键操作。

首先，我们解决了因EC2实例IP动态变化导致的Chef节点通信错误，方法是重新引导节点。

其次，我们手动设置了一个MySQL数据库。我们创建了名为 registration 的数据库，并在其中定义了 user_signup 表，该表包含了注册表单所需的所有字段。

至此，我们的数据库已经准备就绪。接下来的任务是创建一个HTML表单文件（例如 .html 或 .php 文件），将其部署到Apache Web服务器上，并配置其与数据库的连接，最终完成整个应用的部署。

017：配置网络服务器 🖥️

在本节课中，我们将学习如何使用Chef自动化配置一个Apache网络服务器。我们将创建一个Cookbook，编写一个Recipe来安装Apache、配置网页文件并确保服务自动启动。

概述

我们将通过以下步骤创建一个Apache网络服务器：

  1. 生成一个名为“Apache”的Cookbook。
  2. 在该Cookbook中生成一个名为“web_server”的Recipe。
  3. 在Recipe中编写代码，使用Chef资源来安装Apache软件包、配置默认网页并管理服务状态。
  4. 配置默认Recipe以包含我们的web_server Recipe。
  5. 在目标节点上运行Chef Client来应用配置，并通过curl命令验证结果。

生成Cookbook与Recipe

首先，我们需要在Chef工作站上生成一个Cookbook。Cookbook是Chef中配置管理的基本单元，它包含了所有的Recipes、属性、模板等。

以下是生成Cookbook的命令：

chef generate cookbook cookbooks/apache

这个命令会在cookbooks目录下创建一个名为apache的Cookbook，并生成其标准目录结构。

接下来，我们需要为这个Cookbook生成一个具体的Recipe。Recipe是包含一系列资源声明（如安装软件包、创建文件、启动服务）的Ruby文件。

以下是生成Recipe的命令：

chef generate recipe cookbooks/apache web_server

此命令在cookbooks/apache/recipes/目录下创建了一个名为web_server.rb的Recipe文件。

编辑Recipe文件

现在，我们将在web_server.rb文件中编写配置Apache服务器的逻辑。我们将使用三种主要的Chef资源：package、file和service。

1. 安装Apache软件包

首先，我们需要确保Apache软件包（在Ubuntu/Debian系统中名为apache2）被安装。我们使用package资源来实现。

package 'apache2' do
  action :install
end

这段代码声明了一个package资源，其名称为apache2，并指定动作为安装(:install)。

2. 创建默认网页

仅仅安装Apache是不够的，我们还需要提供一个网页供其服务。我们将使用file资源在服务器的默认网站目录下创建一个index.html文件。

file '/var/www/html/index.html' do
  content '<h1>Hello, World!</h1>'
  action :create
end

这段代码创建了一个文件，路径为/var/www/html/index.html，内容是一个简单的HTML标题，动作为创建(:create)。

3. 启动并启用Apache服务

最后，我们需要确保Apache服务正在运行，并且设置为开机自动启动。这通过service资源完成，我们可以使用一个数组来指定多个动作。

service 'apache2' do
  action [:start, :enable]
end

这段代码管理名为apache2的服务。动作[:start, :enable]表示启动服务，并启用它在系统启动时自动运行。

配置默认Recipe

为了让Chef在运行Cookbook时自动执行我们的web_server Recipe，我们需要修改默认的Recipe文件default.rb。通常的做法是在其中包含（include_recipe）我们自定义的Recipe。

打开cookbooks/apache/recipes/default.rb文件，添加以下内容：

include_recipe 'apache::web_server'

这行代码告诉Chef，当执行apache Cookbook的默认Recipe时，去执行apache::web_server这个Recipe。

应用配置与验证

所有代码编写完成后，我们需要将Cookbook上传到Chef Server，并在目标节点（我们的Web服务器）上运行chef-client来应用配置。

  1. 上传Cookbook：在Chef工作站上执行 knife cookbook upload apache。
  2. 运行Chef-Client：在目标节点上执行 sudo chef-client。

应用成功后，我们可以通过curl命令来验证Apache服务器是否正常工作。

curl http://localhost

如果配置正确，此命令将返回我们在index.html文件中编写的“Hello, World!”内容。

总结

本节课中，我们一起学习了如何使用Chef自动化配置Apache网络服务器。我们掌握了从生成Cookbook和Recipe，到使用package、file、service等核心资源编写配置代码的完整流程。关键步骤包括：安装软件包、部署网页文件、管理服务状态，以及通过默认Recipe组织执行顺序。最后，通过运行chef-client和应用curl验证，我们确保了自动化配置的成功执行。

018：配置Web服务器（续）

在本节课中，我们将继续配置Web服务器。我们将学习如何在Chef配方单中定义资源，包括安装软件包、创建网页文件以及管理服务。通过实践，你将掌握编写一个完整Web服务器配方单的核心步骤。

上一节我们介绍了Chef配方单的基础结构，本节中我们来看看如何具体定义资源来配置一个Apache Web服务器。

创建软件包资源

首先，我们需要创建一个软件包资源来安装Apache2。软件包资源负责在目标节点上管理软件包的安装、升级或移除。

以下是定义软件包资源的代码：

package 'apache2' do
  action :install
end

在这个资源块中，package是资源类型，'apache2'是资源名称。action :install指定了要执行的操作。即使省略action参数，Chef在运行时通常也会默认执行安装操作。

创建文件资源

接下来，我们需要创建一个文件资源。这个资源将在Web服务器的默认目录下生成一个HTML索引文件，用于测试。

以下是定义文件资源的代码：

file '/var/www/html/index.html' do
  action :create
  content 'Hey, this is just a normal index file for testing. I will create web page post successful deployment.'
end

在这个资源块中，file是资源类型，'/var/www/html/index.html'是文件的目标路径。action :create指示Chef创建该文件。content参数定义了文件的具体内容。在实际生产环境中，更常见的做法是使用source参数来指定一个模板文件的位置，而不是直接将内容写在配方单里。

创建服务资源

最后，我们需要创建一个服务资源来管理Apache2服务。服务资源可以启动、停止、启用或禁用系统服务。

以下是定义服务资源的代码：

service 'apache2' do
  action [:enable, :start]
end

在这个资源块中，service是资源类型，'apache2'是服务名称。action参数接收一个数组[:enable, :start]，这表示Chef将依次执行“启用服务”和“启动服务”两个操作。重要提示：一个资源块只能有一个action参数。如果需要多个操作，必须将它们放在同一个数组内，而不是为同一个资源定义多个action块。

至此，我们已经完成了Web服务器配方单的编写。它包含了安装Apache2、创建测试网页以及确保服务开机启动并立即运行的全部逻辑。

整合配方单

现在，我们需要在主配方单（例如 default.rb）中引用刚刚编写的Web服务器配方单，这样Chef在运行时才会执行它。

以下是引用其他配方单的语法：

include_recipe 'cookbook_name::recipe_name'

根据我们的配置，具体代码如下：

include_recipe 'apache::webserver'

请确保拼写正确，任何错误都可能导致语法问题，需要重新修正。

测试配方单

配方单编写完成后，可以在本地工作站进行测试。虽然理想情况下应该通过Chef服务器部署到目标节点，但本地测试可以快速验证语法和基本逻辑。

可以使用以下命令在本地执行配方单：

chef-client --local-mode --runlist 'recipe[apache::webserver]'

如果运行成功，你将看到Chef客户端执行了一系列操作。可以通过以下命令验证Apache2服务状态：

systemctl status apache2

如果服务显示为“enabled”和“active (running)”，则说明配方单运行成功。此外，可以测试我们创建的网页文件：

curl localhost

这条命令应该会输出我们在文件资源中定义的HTML内容。你也可以在浏览器中输入工作站的IP地址来查看这个测试页面。

本节课中我们一起学习了如何编写一个完整的Chef配方单来配置Web服务器。我们定义了三个核心资源：package 用于安装软件，file 用于创建配置文件，以及 service 用于管理系统服务。我们还学习了如何通过 include_recipe 整合配方单，并初步尝试了在本地运行测试。在后续课程中，我们将学习如何将编写好的Cookbook上传到Chef服务器，并通过引导（bootstrap）流程将其部署到目标云服务器节点上。

019：配置网络服务器的进阶内容

在本节中，我们将学习如何将包含网站内容的Cookbook上传到Chef服务器，并将其应用到目标节点（Web服务器）上。我们将涵盖文件传输、Cookbook上传以及节点引导（Bootstrap）等关键步骤。

上一节我们介绍了如何编写基础的Cookbook来配置Apache服务器。本节中，我们来看看如何将包含实际网站内容的Cookbook部署到服务器上。

传输Cookbook文件

首先，我们需要将编写好的Cookbook从工作站传输到Chef服务器。在我们的示例中，Cookbook名为apache，其中包含网站文件。

以下是传输Cookbook目录到Chef服务器临时目录的命令：

scp -r apache/ ubuntu@<chef-server-ip>:/tmp/

此命令使用scp（安全复制）将本地的apache目录递归地复制到Chef服务器的/tmp目录下。-r参数确保复制目录内的所有内容。

在Chef服务器上整理Cookbook

文件传输完成后，我们需要登录到Chef服务器，将文件移动到正确的Chef仓库位置。

  1. 登录到Chef服务器。
  2. 导航到临时目录，确认文件已成功复制。
  3. 使用cp -r命令将apache目录复制到Chef仓库的Cookbooks目录中。
cp -r /tmp/apache/ /path/to/chef-repo/cookbooks/

注意：在单台机器内复制目录时，必须使用-r参数进行递归复制。跨机器复制（如scp）的语法类似，但需要指定主机、用户和密钥信息。

上传Cookbook到Chef Server

Cookbook放置到本地Chef仓库后，即可将其上传至Chef Server，供所有节点使用。

关键点：knife命令必须在Chef仓库的根目录下执行，因为它依赖于初始化时生成的配置文件。

以下是上传名为app_server的Cookbook的命令：

knife cookbook upload app_server

此命令会将Cookbook及其所有文件上传到Chef Server。如果上传成功，你将在Chef管理界面或通过其他knife命令看到这个Cookbook。

引导（Bootstrap）Web服务器节点

最后一步是将这个Cookbook应用到目标Web服务器节点上。我们使用knife bootstrap命令来完成，该命令会在目标节点安装Chef客户端并将其注册到Chef Server，同时指定初始的运行列表（Run List）。

以下是引导节点的命令示例：

knife bootstrap <web-server-ip> -x ubuntu -i ~/.ssh/chef.pem -N web2 --sudo --run-list 'recipe[app_server]'

命令参数解析：

  • <web-server-ip>： 目标Web服务器的IP地址。
  • -x ubuntu： 指定用于SSH登录的用户名。
  • -i ~/.ssh/chef.pem： 指定SSH私钥文件的路径。
  • -N web2： 为节点在Chef Server中命名。
  • --sudo： 以sudo权限执行命令。
  • --run-list 'recipe[app_server]'： 指定节点首次运行时需要执行的食谱（Recipe）。

执行此命令后，Chef Server会指导目标节点完成Chef客户端的安装和配置，并立即运行app_server这个Cookbook，从而完成Web服务器的自动化配置。

注意：引导命令较长，需确保所有参数（如用户名、密钥路径、Cookbook名称）都正确无误，否则可能导致失败。如果遇到权限或连接问题，需要根据错误信息进行排查。

本节课中我们一起学习了将Cookbook部署到生产环境的完整流程：从工作站传输文件到Chef服务器，在服务器端整理Cookbook结构，使用knife upload命令上传Cookbook，最后通过knife bootstrap命令将Cookbook应用到新的节点上。这个过程是使用Chef进行自动化配置的核心环节。

020：部署与验证

在本节课中，我们将学习如何解决Chef部署过程中遇到的常见问题，并完成一个Web服务器的自动化部署与验证。我们将通过一个具体的例子，展示如何修复cookbook名称不匹配导致的错误，执行部署命令，并最终验证部署结果。

部署问题与修复

上一节我们介绍了Chef的基本部署流程，本节中我们来看看在实际操作中可能遇到的问题及其解决方法。

在部署过程中，我们遇到了一个错误。问题恰好出在服务器应用上。我们曾将文件移动过位置。我们将一个服务器应用移动到了应用服务器目录。当时我们认为服务器上可能存在命名约定问题。但这个操作本身引发了一些相同的问题。

如果你查看这里的路径，会发现它指向了外部。但这就是当时存在的一个问题。我们已经修复了它。所以，主要错误是解析运行清单的cookbook时出错，原因是缺少cookbook。这是因为在我们编译这个cookbook时，名称是不同的。我们后来更改了它。你可以看到客户端在那里失败了。前置条件未满足。

为了修复这个问题，我执行了以下操作。我回到了cookbook所在的位置。然后我将其重命名回原始名称。它原本是app_server，但原始名称是apache。所以我将其移回apache目录。这样，无论何时编译，它都会以apache的名义进行编译。然后我再次使用了相同的命令。这次完全没有问题。

当你遇到类似问题时，需要进行一些隐藏的试错方法来发现并解决这些问题。命令本身没有问题。我再次以相同用户ubuntu的身份执行了相同的命令，并将PEM文件放在了正确的位置。这是文件名。然后创建了这个名为web_server的节点，其运行清单为recipe[apache]。之前使用的是app_server，所以出现了差异。现在它显示Web服务器节点已存在，因为第一次运行时它创建了节点，但未能成功执行或编译你的cookbook，所以当时失败了。

这里还有一个客户端的问题。记得吗，客户端会被安装，即Chef DK，它已经存在了，所以系统询问是否覆盖。我选择了是，覆盖它。覆盖之后，它为Web服务器创建了一个新的客户端。每次执行此操作时，你都会遇到选择：是，覆盖或否。如果你确定可以覆盖，就选择是，因为它总是会安装正确且最新的版本。

执行部署与收敛

然后它为Web服务器创建了一个新节点。接着，它联系我们在引导命令中指定的Web服务器地址。它到达了这个位置。现在，它正在安装你的cookbook。在从你的Chef服务器获取所有cookbook并安装之后，它开始收敛你的Chef服务器。这是你的apache配方单，这是你的Web服务器节点。

它有两个任务需要执行。第一个任务是下载Apache软件包。这就是我们需要安装的。如果你在这里看到绿色的消息，意味着你的软件包已成功下载。如果你发现任何红色的内容，则说明存在问题。这里有两个状态信息。第一个状态是下载文件，第二个是创建网页的HTML文件。你可以看到后台发生的所有事情。这些过程实际上是在后台进行的。

这是我们为网页定义的内容。这只是一个HTML页面。它刚刚完成，你可以在这里查看日志。

验证部署结果

现在，如果你打开你的服务器，你将能够在你的节点上找到已安装的Apache服务器。最后一条消息是我们写入的内容。这是一条成功消息，例如“service[apache2] action start (up to date)”。这是我们配方文件中定义的服务资源，而不是软件包资源。之后，我们将其设置为启用状态。因此，无论何时重启虚拟机，你的服务器都会自动启用。最后一条消息是：“Chef Client finished, 2/2 resources updated in 18 seconds”。这花费了18秒完成，并已上传到你的Chef客户端，我们将其命名为你的Web服务。

现在进行验证，我们将访问这个服务器。复制这个地址。然后粘贴到这里。这就是我们在HTML页面中定义的内容。这没问题。

接下来，我将登录到这个节点机器内部进行检查。

以下是登录和检查的步骤：

  1. 使用SSH认证和私钥登录。
  2. 以ubuntu用户身份登录。
  3. 我将更改一些颜色设置以便于区分。
  4. 调整终端外观以增加辨识度。
  5. 使用systemctl status apache2命令检查Apache是否已安装并运行。
  6. 确认服务状态为“active (running)”。
  7. 我们之前提供的内容是“dummy content”。现在我们需要更改这个内容。
  8. 进入/var/www/html目录。
  9. 编辑index.html文件。当前该文件是只读的。
  10. 首先切换到root用户：sudo su。
  11. 现在可以登录并修复这个问题。
  12. 删除文件中的所有现有内容。
  13. 开始编写注册表单所需的所有HTML标签，如<body>和标题。
  14. 表单需要的字段包括：用户名（或名字）、中间名、姓氏以及电子邮件地址。
  15. 我将在这里打开HTML标签。
  16. 然后添加<body>标签。在这个HTML文件中，我将整合所有CSS样式、字体大小、颜色等设置。
  17. 这部分内容超出了本课程的范围，我将简要说明，因为编写整个HTML文件需要时间。我会在构建文件时定期解释我所做的工作。这里不需要深入的HTML知识，你只需要了解基本语法，知道需要编写哪些标题和列。我假设你正在观看视频，我会定期展示编写的内容。

例如，到目前为止，我已经初始化了HTML标签，然后在<head>里设置了标题“Registration Page”，并将背景颜色设置为浅天蓝色。你可以将其改为红色或其他颜色，但我觉得浅天蓝色便于书写和定制。之后，我开始了<body>和<form>标签，并在<label>标签内添加了“First Name”标签，然后关闭标签，再指定输入类型<input type=。

本节课中我们一起学习了如何诊断和修复Chef部署中的cookbook名称错误，使用knife bootstrap命令成功部署了一个Apache Web服务器节点，并通过登录节点验证了软件包的安装、服务的运行以及自定义网页内容的部署。关键在于确保cookbook名称的一致性，并理解部署命令的输出信息以进行问题排查。

021：Apache Web服务器部署与自动化

在本节课中，我们将学习如何使用Chef自动化部署一个Apache Web服务器，并创建一个简单的学生注册表单页面。我们将涵盖从编写HTML文件到通过Chef服务器管理多节点部署的完整流程。

编辑HTML文件

上一节我们配置了基础环境，本节中我们来看看如何创建Web应用的内容。

我编辑了一个HTML文件，其中包含一个课程注册表单。这个表单根据用户选择的工程学科（如机械工程、计算机科学、信息科学、化学工程、电子通信工程等）提供不同的选项。

以下是表单包含的主要字段：

  • 姓名：分为名、中间名和姓。
  • 课程选择：下拉菜单，包含多种工程学科选项。
  • 性别：通过单选按钮选择男性或女性。
  • 国家代码与电话号码：用于输入联系方式。
  • 地址：文本输入框。
  • 邮箱与密码：用于注册和登录的凭证字段。

这个HTML文件已经完成，应该没有问题。现在保存文件。

运行与测试HTML文件

文件已保存，接下来我们运行它。但请注意，Web服务器可能尚未感知到index.html文件的变更。

最初刷新页面时，可能看不到变化。这是因为我们需要触发服务器重新加载配置。由于我们在Apache配置中设置了start和enable参数，服务器会定期检查更新。一旦index.html文件发生变更，服务器将获取最新版本。

再次刷新页面后，注册表单成功显示。

处理服务状态问题

有时，页面可能无法加载，这通常是因为Web服务器服务状态异常。以下是排查步骤：

首先，检查Apache服务的状态，它应始终处于运行状态。

systemctl status httpd

如果发现服务已停止，页面将无法访问并显示空白或错误信息。此时，需要重新启动服务。

systemctl start httpd

服务启动后，它将自动获取最新的HTML文件。刷新浏览器，表单和所有预设的样式、字段都会正常显示。

表单功能总结

至此，我们完成了注册页面的基础功能。当学生进行在线注册时，他们将看到此页面。页面背景设为天蓝色，当然颜色可以调整。

学生需要完成以下步骤：

  1. 填写姓名。
  2. 选择要攻读的课程。
  3. 选择性别。
  4. 提供电话号码和地址。
  5. 设置邮箱和密码以接收学院提供的学习资料。

点击提交按钮后，流程将转向支付页面。完成课程费用支付后，学生即可使用凭证登录，访问学院提供的所有学习内容。

Chef自动化架构的优势

通过这个案例，我们借助Chef自动化完成了整个设置。我们所做的只是：

  1. 创建Web服务器。
  2. 安装数据库服务器（此案例中未深入，但流程类似）。
  3. 编写HTML文件。

Chef的强大之处在于管理多节点部署。与Ansible或Puppet相比，Chef拥有一个中心化服务器，这对于管理大量机器非常高效。

假设组织中有上百甚至上千台节点需要部署此应用。你无需登录每台机器手动操作。Chef的工作流程如下：

  1. 在工作站上创建所有配方和文件。
  2. 使用knife命令将配方上传到Chef服务器。
  3. 在Chef服务器上，为特定节点（如Web服务器）编辑run-list，添加需要运行的食谱（例如Apache食谱）。
  4. 在客户端节点上，以root权限执行chef-client命令。
  5. Chef客户端将自动从服务器拉取配方并执行，完成所有安装和配置。

这个过程非常简便、高效。关键在于理解其层次结构、架构和流程。熟练掌握knife命令行工具至关重要，因为它可以用于管理节点、查看结构、以及从市场上下载食谱等。

本节课总结

本节课中，我们一起学习了：

  1. 如何创建并部署一个包含学生注册表单的HTML页面。
  2. 如何管理Apache Web服务器的服务状态以确保应用可访问。
  3. 深入了解了Chef自动化架构的核心价值，即通过中心化服务器和run-list管理，实现一键式、批量化的应用部署到多个节点。
  4. 通过实际案例，看到了Chef如何将复杂的部署流程简化为简单的配方管理和命令执行。

我们成功实现了预期的输出，并验证了Chef在云基础设施自动化中的高效性。

posted @ 2026-03-29 09:12  绝不原创的飞龙  阅读(2)  评论(0)    收藏  举报