Vagrant-DevOps-实用指南-全-

Vagrant DevOps 实用指南（全）

原文：annas-archive.org/md5/20a7a5d99feb2ebe68524dc10fbfe7c1

译者：飞龙

协议：CC BY-NC-SA 4.0

序言

Vagrant 是一个开源工具，允许你通过编程创建和管理虚拟环境。Vagrant 的主要目标是创建可以在全球各地的团队之间共享的开发环境。它解决了“在我机器上运行正常”的问题，任何拥有 Vagrantfile 配置的人都可以创建一个与原始机器完全相同的副本。

Vagrant 由 Mitchell Hashimoto 和 HashiCorp 创建并维护，持续获得支持和更新。自 2010 年创建以来，它已经逐步壮大，成为一款不断进步的软件。

这本书适合谁

在本书中，我们将涵盖 Vagrant 的多个方面。本书适合那些对 Vagrant 几乎没有或完全没有经验的初学者。我们将介绍如何安装 Vagrant 以及启动所需的所有基础知识。

本书也适用于那些希望更好地理解和使用 Vagrant 的高级用户。我们将涵盖可用的命令、网络配置、多机器以及如何使用配置管理工具如 Chef 和 Ansible 进行资源配置。

无论你处于什么水平，本书都会教你一些新东西，或者帮助你巩固知识并提供一些技巧和窍门。

本书所涉及的内容

第一章，介绍，是通向 Vagrant 世界的一个极好的入门。它将帮助你打下知识基础，引导你继续阅读本书。你将了解 Vagrant 是什么，Vagrant 的好处，什么是 VirtualBox，以及什么是 DevOps。你还将学习 Vagrant 如何融入 DevOps 生态，如何作为一个 DevOps 工具使用，并且了解其他一些软件。

第二章，安装 VirtualBox 和 Vagrant，Windows、macOS 和 Linux，带你动手操作，教授你如何安装 VirtualBox 和 Vagrant。我们将覆盖三大主流操作系统：Windows、macOS 和 Linux。你将学习如何浏览两个网站（www.virtualbox.org 和 www.vagrantup.com），下载、安装并验证软件的安装情况。

第三章，命令行界面 - Vagrant 命令，教你 Vagrant 提供的各种有用命令。你将学习所有可用的命令和子命令。你还将了解 Vagrant 命令的结构，如何使用help命令获取更多信息，以及每个命令的简要描述。通过本章的学习，你将能够自信地通过命令行管理 Vagrant。

第四章，发现 Vagrant 盒子 - Vagrant Cloud，涵盖了 Vagrant 盒子的所有方面。我们将学习如何管理它们：安装、删除和版本管理。我们还将创建一个具有构建 Vagrant 环境最小要求的基础盒子。在这一章中，我们还将介绍 Vagrant Cloud 及其为你提供的内容。Vagrant Cloud 是一个可以搜索的 Vagrant 盒子索引，所有盒子都可以直接下载。我们将讨论如何使用 Vagrant Cloud 网站、如何搜索特定盒子以及如何安装该盒子。

第五章，使用 Vagrantfile 配置 Vagrant，探讨了 Vagrantfile，它允许你轻松自定义你的 Vagrant 虚拟机。Vagrantfile 提供了多种不同的配置选项，例如网络、文件夹同步、多机器选项、配置管理和特定提供者设置。你还将学习 Vagrantfile 的语法和格式，并了解如何在创建后验证它。

第六章，Vagrant 中的网络配置，解释了 Vagrant 中如何轻松配置网络，并可以用来创建一些强大的设置。在本章中，你将学习三种关键的网络配置选项：端口转发、公共网络和私有网络。你将通过示例学习如何使用每一个选项，并查看每个选项的优点。

第七章，多机器，介绍了多机器选项，该选项允许你创建多个 Vagrant 虚拟机，并使用单个 Vagrantfile 对它们进行管理和配置。你将创建一个模拟现实世界场景的多机器环境。你将创建一台运行 Web 服务器的机器和一台运行数据库的机器。这些机器将通过网络配置进行通信。这将为你打下坚实的基础，帮助你开始使用多机器选项创建强大的环境。

第八章，探索 Vagrant 插件和文件同步，讲解了尽管 Vagrant 提供了许多功能，但有时你可能需要一些额外的功能。在本章中，你将了解 Vagrant 插件的所有内容。你将看到如何轻松安装和使用 Vagrant 插件。这里还有许多命令和子命令需要学习。在这一章中，你还将学习如何使用 Vagrant 同步文件，并了解不同的配置选项。

第九章，Shell 脚本 - 配置 Vagrant 环境，讲解了在 Vagrant 中的配置过程，这是 Vagrant 另一个强大的功能，使你能够轻松配置 Vagrant 虚拟机。本章作为配置介绍，将帮助你了解更多关于配置管理工具、Shell 配置和文件配置的内容。当使用这些配置类型时，还有多种配置选项可供学习。

第十章，Ansible - 使用 Ansible 配置 Vagrant 环境，教你如何使用 Ansible 和 Ansible 剧本来配置 Vagrant 环境。你还将简要了解如何在 Vagrant 虚拟机上安装 Ansible，然后学习如何在主机上使用 Ansible 来配置 Vagrant 虚拟机。

第十一章，Chef - 使用 Chef 配置 Vagrant 环境，教你如何使用 Chef 和 Chef 食谱来配置 Vagrant 环境。你将学习如何使用基本选项 Chef Solo 和高级选项 Chef Client 来配置机器。

第十二章，Docker - 使用 Docker 配置 Vagrant 环境，深入探讨了如何使用 Docker 配置 Vagrant 环境。我们将学习如何从 Docker Hub 搜索并拉取镜像，然后将其作为容器运行。我们还将了解使用 Docker 作为 Vagrant 配置工具时 Docker 接受的不同选项。

第十三章，Puppet - 使用 Puppet 配置 Vagrant 环境，探讨了如何使用 Puppet 配置 Vagrant 环境。你将学习 Vagrant 提供的两个主要选项：Puppet Apply 和 Puppet Agent。使用 Puppet Agent，你将看到如何连接到 Puppet 主控并从中获取指令。

第十四章，Salt - 使用 Salt 配置 Vagrant 环境，讲解了如何使用 Salt 配置 Vagrant 环境。你还将了解 Salt 状态，它允许我们指定在配置过程中应该添加哪些包和服务。

为了最大限度地发挥本书的作用

本书适合初学者和高级用户。它将教你如何安装所需的软件。如果你已经安装了这些软件，请检查你安装的版本，因为可能与你所使用的版本存在差异。你可能需要升级软件。你将需要：

• VirtualBox 版本：5.2.10

• Vagrant 版本：2.0.4

• Ubuntu 虚拟机（来自 Vagrant cloud）版本：ubuntu/xenial64 20180510.0.0

值得多读几遍每一章，确保不会遗漏任何信息。如果需要更多信息或澄清，官方 Vagrant 网站的文档非常棒。

下载示例代码文件

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

你可以按照以下步骤下载代码文件：

1. 登录或注册到www.packtpub.com。

2. 选择“支持”标签。

3. 点击“代码下载与勘误”。

4. 在搜索框中输入书名，并按照屏幕上的指示操作。

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

• WinRAR/7-Zip for Windows

• Zipeg/iZip/UnRarX for Mac

• 7-Zip/PeaZip for Linux

本书的代码包也托管在 GitHub 上，网址是github.com/PacktPublishing/Hands-On-DevOps-with-Vagrant。如果代码有任何更新，它将会在现有的 GitHub 仓库中更新。

我们的丰富图书和视频目录中还提供了其他的代码包，网址为github.com/PacktPublishing/。快来看看吧！

下载彩色图像

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

使用的约定

本书中使用了多种文本约定。

CodeInText：表示文本中的代码词汇、数据库表名、文件夹名称、文件名、文件扩展名、路径名、虚拟网址、用户输入和 Twitter 用户名。例如："该元数据通常存储为 JSON 文档。文件名将是metadata.json。"

一段代码如下所示：

Vagrant.configure("2") do |config|
     config.vm.box = "base"
 end

所有命令行输入或输出都如下所示：

config.vm.network "public_network", ip: "192.168.1.123"

粗体：表示一个新术语、重要单词或屏幕上显示的单词。例如，菜单或对话框中的单词在文本中会以这种方式出现。示例："这里列出了受支持的操作系统，但我们需要点击 macOS 上的Latest Releases部分。"

警告或重要提示会以这种方式显示。

提示和技巧以这种方式显示。

联系我们

我们欢迎读者的反馈。

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

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

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

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

评论

请留下评论。一旦你阅读并使用了本书，为什么不在你购买它的站点上留下评论呢？潜在的读者可以看到并参考你的公正意见，从而做出购买决策，我们 Packt 也能了解你对我们产品的看法，而我们的作者则能看到你对他们书籍的反馈。谢谢！

如需了解更多关于 Packt 的信息，请访问packtpub.com。

第一章：介绍

您即将开始一段充满激情的旅程，专注于 Vagrant 及其在 DevOps 中的角色。在这些章节中，您将学习有关 Vagrant 的有趣和实用的信息，以及技巧和窍门。最初，我们将关注 Vagrant 的基础知识，并在您的计算机上安装并运行它。然后，我们将深入了解 Vagrant 的方方面面，重点关注 Vagrant 的重要部分，如命令、网络、多机器、Vagrantfiles 和使用配置管理工具（如 Chef、Docker 和 Ansible）。到本书结束时，您将对 Vagrant 有扎实的基础知识，并具备在日常 DevOps 工作流中使用它的必要技能。

在本章中，我们将打下一个坚实的基础，帮助您了解 Vagrant 是什么，VirtualBox 是什么，以及 Vagrant 如何与 DevOps 环境结合。我们将学习 DevOps 中当前开发工具的现状，并重点讨论 Vagrant 如何被组织中的许多不同团队使用——不仅仅是开发人员！到本章结束时，您将对 Vagrant、VirtualBox 和 DevOps 的基础知识有一个清晰的理解。

开始使用 Vagrant 和 DevOps

在本节中，您将了解 Vagrant，并学习其功能、优势以及它在 DevOps 世界中开发工具中的作用。

理解 Vagrant

Vagrant 表面看起来非常简单，但实际上它在后台非常复杂。它允许您快速轻松地创建虚拟环境（称为 Vagrant box）并对其进行自定义。Vagrant 可以轻松与多个提供者集成，如 VirtualBox、VMware 和 Docker。这些提供者实际驱动虚拟环境，但 Vagrant 提供了一个可自定义的 API 来管理这些虚拟机。

Vagrant 拥有大量的命令，可以通过命令行/终端来管理虚拟环境。这些命令可以快速从 Vagrant 云中下载并设置环境，Vagrant 云托管了许多流行的环境，如 Ubuntu 或 PHP 的 Laravel。

Vagrant 是一个在许多程序员工具箱中都能找到的重要软件。它常常用于解决那个著名的说法，在我的机器上能运行，通过允许每个人拥有相同环境的副本来解决这个问题。

Vagrant 是由 Mitchell Hashimoto 创建的，并于 2010 年 3 月发布。Vagrant 现在是 HashiCorp 公司的一个组成部分，该公司由 Mitchell Hashimoto 和 Armon Dadgar 于 2012 年共同创办。Vagrant 是一款开源软件，使用 Ruby 语言构建，目前采用 MIT 许可证。Vagrant 可以在 macOS、Windows、FreeBSD 和 Linux 上运行。

Vagrant 本质上是虚拟化堆栈中的另一层。它充当一个易于编程的接口，用于控制虚拟环境。Vagrant 依赖于一个提供者，如 VirtualBox，来运行这些环境，但它也可以配置提供者，使它们协调工作——例如，Vagrant 控制环境的内存（RAM）大小。

Vagrant 功能

Vagrant 提供了许多功能，帮助你构建和配置虚拟环境。Vagrant 的功能可以分为几个关键领域——Vagrantfile、boxes、网络、配置和插件。Vagrant 主要通过两种方式进行管理——命令行和 Vagrantfile。命令行方法通常用于管理员任务，如下载/导入新 Vagrant box 或删除旧的。

Vagrantfile

Vagrantfile 是一个使用 Ruby 编程语言语法的配置文件。它易于理解，并且可以通过修改配置后，运行 vagrant up 命令来快速测试是否得到预期的结果。Vagrantfile 可以轻松共享并添加到版本控制中。它轻量且包含了其他用户复制你的虚拟环境/应用所需的一切。

Boxes

Vagrant box 是类似于 Vagrantfile 的包，可以共享并用于复制虚拟环境。可以通过运行vagrant box add命令轻松下载 Vagrant box。Vagrant cloud 提供了一个易于搜索的 box 目录。Vagrant cloud 提供了关于 box 的大量信息，例如创建者、版本、下载次数以及简短描述。

网络

Vagrant 在创建虚拟环境时支持三种主要的网络类型：公有网络、私有网络和端口转发。最简单的网络选项是端口转发，它允许你通过来宾操作系统访问特定的端口，并进入 Vagrant 机器。公有和私有网络更为复杂，并提供更多配置选项，但我们将在未来的章节中讨论这些内容。

提供配置

Vagrant 中的配置功能让你可以进一步配置 Vagrant 机器。你可以在机器创建过程中安装软件和依赖项。配置 Vagrant 机器时，可以使用 shell 脚本、Docker、Chef、Ansible 以及其他配置管理软件，如 Puppet。

插件

Vagrant 插件提供了另一种定制和扩展 Vagrant 功能的方式。它们允许你与 Vagrant 的低级功能进行交互，并经常提供新的命令，作为 Vagrant 命令行的一部分使用。

Vagrant 的优势

Vagrant 允许你轻松地打包一个可以在开发者之间共享的虚拟环境。这个打包的虚拟环境通常被称为 Vagrant box。可以将 Vagrant box 配置为模拟你的 web 应用程序或代码运行的生产环境。这有助于最小化当你的应用程序/代码部署到生产环境时出现的任何 bug 或问题。

Vagrant 配置文件（称为 Vagrantfile）的美妙之处在于它通常很小，且可以轻松编辑和测试。Vagrantfile 的语法易于理解，并且提供了一种简单的方式来构建复杂的环境。

Vagrant 可以被团队中的许多不同成员使用，包括开发团队、运维团队和设计团队的成员。

开发团队

对于开发者来说，Vagrant 可以让他们将自己的代码/应用程序打包成一个易于共享的完整开发环境。这样即使是使用不同操作系统（如 macOS、Linux 或 Windows）的开发者也可以使用该环境。

运维团队

运维团队可以轻松快捷地使用 Vagrant 测试部署工具和脚本。Vagrant 支持许多运维/DevOps 世界中流行的部署工具，如 Puppet、Docker 和 Chef。Vagrant 可以是测试部署脚本和基础设施拓扑的更便宜、更快速的方式。所有操作都可以在本地完成，或者可以与像亚马逊 Web 服务这样的服务一起使用。

设计团队

Vagrant 使开发团队和运维团队能够创建运行代码的虚拟环境，并且让应用程序准备好供设计师在自己的机器上轻松运行该环境并开始编辑应用程序。无需配置，反馈可以是即时的，从开发者进行更改到开发者更新 Vagrantfile 都可以迅速反映。

什么是 VirtualBox？

VirtualBox 是 Vagrant 支持的众多提供商之一。VirtualBox 是一个强大的虚拟化工具，允许你在现有的操作系统上创建虚拟环境。它允许你完全自定义虚拟机的硬件，如 RAM、CPU、硬盘、音频和图形。

VirtualBox 最初由 Innotek GmbH 公司于 2007 年 1 月发布，后来被 Sun Microsystems 收购，而 Sun 又被甲骨文公司（Oracle Corporation）收购。甲骨文公司目前正在积极维护并发布 VirtualBox 的新版本。

VirtualBox 是用 x86 汇编、C++ 和 C 编写的。它可以运行并支持许多不同的操作系统，如 Windows、Linux、Solaris 和 OS X。

什么是 DevOps？

DevOps 是当前 IT 领域的一个流行术语。关于 DevOps 到底是什么，有许多不同的看法。简单来说，DevOps 是开发和运维的结合。它本质上是在培养一种“混合型程序员”，既了解运维和基础设施，又懂得编程并能够开发应用程序，或者是一位了解编程并能够开发应用的系统管理员。

DevOps 是方法论、实践、哲学和软件的混合体。DevOps 通过创建一个适用于所有部门的工作流程来简化整个项目生命周期。DevOps 没有固定的规则或法律，但通常它是通过提供一种便捷的方式连接开发者与基础设施团队，进而开发和交付代码的过程。

DevOps 的魅力在于任何公司都可以开始遵循其理念、方法论和最佳实践。大公司可能会有一个完整的 DevOps 部门/团队，而小公司可能只需要一两个专门的 DevOps 员工。在创业公司中，由于必须精打细算，一个员工可能同时担任开发者和 DevOps 的角色。

Vagrant 与 DevOps

在这一章中，你将了解 DevOps 中当前的开发状态，Vagrant 如何融入 DevOps，并且如何将 Vagrant 作为日常 DevOps 工具使用。在本章结束时，你将更好地理解如何将 Vagrant 作为 DevOps 流程的一部分进行开发。

DevOps 中的当前开发状态

如前所述，DevOps 是软件开发、运维/系统管理和测试/质量保证的混合体。DevOps 并不是一个新的运动，但它确实没有一个明确的领导者或一套固定的规则和标准。每个公司对 DevOps 的理解和实施方式都有不同。很多公司遵循类似的路径或大致的指南。由于 DevOps 缺乏治理，当前的开发状态也呈现出多样化的局面。

传统上，开发与运维和服务器团队是分开的，但近年来，我们已经看到许多 DevOps 工具架起了这座桥梁，使两方的工作变得更轻松。

过去，当网页开发者构建一个网页应用时，他们会在本地机器上编写代码，构建应用，然后通过 FTP（文件传输）将文件上传到生产服务器上运行代码——如果有任何问题或漏洞，开发者必须对服务器环境进行更改并调试代码。仍然有很多开发者使用这种工作流程，可能是因为他们的工作环境，或者是因为别无选择。

今天，现代网页开发者的工作流程可能是这样的：

1. 开发者在本地编写代码，但通过像 Vagrant 这样的虚拟环境/虚拟机进行操作。这使得开发者能够设置一个类似于生产环境的环境。

2. 开发者编辑代码，并使用版本控制（如 Git 或 Subversion）来管理变更。版本控制的设置方式使得开发者能够将测试/新代码与生产代码分开。

3. 持续集成（CI）工具（如 Jenkins 或 Travis CI）用于创建一个包含三个独立阶段的流水线——开发、预发布和生产。CI 工具可以用于对软件进行测试，并运行脚本，如通过合并和压缩资源文件来执行任务。版本控制软件可以与 CI 工具连接，通常会触发这些构建和测试。当开发者将新代码推送到预发布环境时，可以在它进入生产环境之前先运行测试。

4. 通常，如果测试通过且没有问题，代码可能会直接推送到版本控制的生产分支中。在这个时点，CI 工具可能会触发一个新的构建，这将本质上重新启动与该代码相关的服务。这可能很简单，也可能很复杂，取决于生产环境和软件架构。

5. 在这个过程中，某些阶段可能需要 QA（质量保证/测试）团队或更资深的开发者进行人工干预，他们希望在代码进入生产环境之前进行检查。

当然，这只是一个示例工作流，不同公司和开发团队的工作流会有所不同。现代的工作流看起来可能更加复杂和繁琐，但这样做是为了确保安全。在每个阶段，你会发现都会进行检查和测试，确保代码能够到达一个真实的生产环境，在那里真实用户可能与这些代码进行交互。当涉及到金融软件和其他业务关键性软件时，这一点尤为重要。现代工作流大大降低了错误的可能性。

当今 DevOps 世界中的现代开发，注重速度和自动化。速度的重点在于能够快速构建特性或修复漏洞，并将“代码推送到生产环境”（你可能听过这个词语！）。这意味着单个开发者或一个开发团队在处理代码时面临的障碍较少。开发者不应担心配置服务器或环境。

自动化是 DevOps 的重要组成部分，这也影响到开发环节。你可以想象，如果开发者对代码进行修改后，还需要等操作团队的成员手动运行测试和脚本来检查这些修改，然后才会告诉开发者结果，这将是多么缓慢的一个过程。

Vagrant 与 DevOps

我相信在当今以 DevOps 为中心的世界里，Vagrant 是开发者工具箱中的一个关键工具。Vagrant 本质上是一套工具，允许开发者编写代码，同时也能与配置管理工具（如 Puppet、Chef 和 Ansible）进行连接，这些工具用于自动化服务器上的工作流和环境。

Vagrant 的主要关注点是开发，并为团队中的每个开发者提供一种轻松使用相同环境的方法。在 Vagrant 环境中，你可以运行版本控制，这可以与 CI 工作流连接，从而允许你运行测试并将代码移动到不同的阶段。

将 Vagrant 作为日常 DevOps 工具

Vagrant 是一个灵活的工具，通过让你轻松测试 DevOps 工作流的想法，增强了日常开发的便利性。它让你能够将软件代码与基础设施分开，而无需深入了解 DevOps、基础设施、服务器和配置管理工具。

作为日常 DevOps 工具，Vagrant 可以用于许多任务，包括以下内容：

• 在不同的环境和操作系统中测试软件代码

• 使用配置管理工具（如 Chef 和 Puppet）测试不同的工作流

• 与团队/公司中的其他开发人员在相同的环境中工作

• 轻松修改 Vagrant 配置并立即查看结果

• 运行多个环境/虚拟环境来测试网络、文件共享和其他多服务器用例

小结

在本章中，我们了解到 Vagrant 是一个非常强大且灵活的工具，帮助创建可以模拟业务或应用程序使用的暂存和开发环境的虚拟环境。我们探讨了 DevOps 的当前发展状态，Vagrant 在其中的作用，以及如何将 Vagrant 用作日常开发工具。

在第二章，安装 VirtualBox 和 Vagrant中，我们将安装 Vagrant 及其提供程序 VirtualBox。我们将介绍如何在 Windows、Mac 和 Linux 机器上安装这些软件。你还将学会如何查看系统的版本及其 CPU 架构。

第二章：安装 VirtualBox 和 Vagrant

VirtualBox 是一个非常重要的软件，我们称之为提供者。它的工作是进行繁重的工作，创建和维护虚拟机和环境。Vagrant 本质上是对提供者（在我们的例子中是 VirtualBox）进行的封装，并暴露出一个强大的 API，允许您通过代码和配置（如 Vagrantfile）来创建和管理虚拟机。

安装 VirtualBox 后，我们将几乎不再需要直接操作它。它将在后台等待 Vagrant 的命令来管理虚拟机。

在本章中，我们将开始亲自操作 Vagrant。我们将关注以下主题：

• 查找操作系统版本

• 查找您的 CPU 架构

• 在 Windows、Linux 和 macOS 上安装 VirtualBox

• 在 Windows、Linux 和 macOS 上安装 Vagrant

• 通过命令行/终端运行 Vagrant，以查看您拥有的 Vagrant 版本

到本章结束时，您将拥有一个完全工作的 Vagrant 和 VirtualBox，准备开始创建虚拟环境。

在 Windows 上安装 VirtualBox 和 Vagrant

本节中，您将学习如何在 Windows 环境中安装 VirtualBox 和 Vagrant，如何查找您的 CPU 架构，以及您正在运行的 Windows 操作系统版本。我们将以 Windows 10 64 位企业版作为示例操作系统和计算机设置。

前提条件

在安装 VirtualBox 和 Vagrant 之前，我们需要了解您的系统的一些基本信息。这些信息有助于您选择下载哪个软件包。

系统版本

查找您正在运行的 Windows 版本将有助于选择下载哪个软件包安装程序。每个版本的 Windows 都不同，但我们将介绍如何在 Windows 10 上执行此操作。

有两种方法可以做到这一点；第一种是使用 Windows 中的命令提示符，这是一个相对快速简单的方法：

1. 按下 Windows 键 + R键（或点击开始并搜索run）

2. 这将打开一个提示窗口，在该窗口中输入winver

3. 按下Enter键，您应该会看到一个新的关于 Windows屏幕弹出，其中包含您操作系统的所有信息

第二种方法需要稍微多一点的努力，但可以通过 Windows 图形用户界面来实现：

1. 进入 Windows 设置并点击“关于”

2. 您可以通过点击任务栏中的齿轮图标或在任务栏中输入settings来访问系统设置

3. 在关于屏幕中，您会看到一个名为“Windows 规格”的部分

4. 在这一部分中，我们需要关注的是“编辑值”

5. 该值为Windows 10 Enterprise Evaluation

CPU 架构

系统的 CPU 架构通常是 32 位或 64 位。当您下载 VirtualBox 或 Vagrant 软件包安装程序时，您需要定义所需的版本。

要查找 Windows 10 系统的 CPU 架构，请按照以下步骤操作：

1. 进入 Windows 设置并点击“关于”

2. 您可以通过点击任务栏中的齿轮图标或在任务栏中输入设置来访问系统设置。

3. 在关于屏幕上，您将看到一个标题为“设备规格”的部分。

4. 在本部分中，我们需要关注的内容是“系统类型”值。

5. 值为64 位操作系统，x64 架构处理器

在 Windows 10 上安装 VirtualBox

在进入此部分之前，值得一提的是，Vagrant 版本 1.8 及之后的版本会自动将 VirtualBox 安装到您的系统中，以提供更顺畅的体验。您可以跳过本部分，继续进行名为在 Windows 10 上安装 Vagrant的部分。如果您遇到任何问题，欢迎随时返回此部分并尝试手动安装 VirtualBox。

在我们安装 Vagrant 之前，建议先安装其提供者——VirtualBox。要开始，您需要访问官方的 VirtualBox 网站，www.virtualbox.org/。最好的方法是使用系统的浏览器，如 Internet Explorer。

按照以下步骤进行安装：

1. 点击左侧菜单中的“下载”链接。我们将关注最新版本（截至撰写时为版本 5.2.10）。

2. 在此部分下方，您应该看到四个平台包链接的列表。

3. 点击 Windows 主机选项。系统会提示您选择版本，例如 x86（32 位 CPU）或 AMD64（64 位 CPU）。如果是这种情况，请根据“关于”部分（CPU 架构）中的信息下载相应的包。

4. 当您点击该包时，浏览器应自动开始下载。下载完成后，选择“运行”以立即开始安装。安装程序启动后，您将看到欢迎界面。

5. 点击“下一步”按钮继续。

6. 为了简单起见，我们将保持默认配置。如果需要，您可以在此处进行更改。这可能只是更改安装位置等简单操作。准备好后，点击“下一步”按钮继续。

7. 您应该看到另一个包含自定义选项的屏幕。为了简单起见，我们将保留所有选项勾选。

8. 点击“下一步”继续。

在此阶段，您将看到一条大的红色警告信息。不要担心，这是安装过程中的正常现象。安装程序需要暂时禁用并重新启动您计算机上的网络服务。这会影响您当前需要互联网连接的任何操作，例如下载或流媒体播放：

1. 当您准备好时，点击“是”以继续到下一个屏幕。

2. 这是在 VirtualBox 软件安装到您的系统之前，您进行任何更改的最后机会。如果您愿意继续，请点击“安装”按钮继续。

3. 根据您的用户访问控制安全设置，Windows 可能会要求您确认安装。点击“是”以允许软件安装程序继续。

4. 安装将开始。如果你需要取消安装，只需点击“取消”按钮。

5. 安装应该已经完成。我建议保持勾选“安装后启动 Oracle VM VirtualBox 5.2.10”框，因为这将允许你看到 VirtualBox 软件启动。点击“完成”按钮继续。

6. 如果你在安装阶段勾选了该选项，你应该在桌面上看到一个 Oracle VM VirtualBox 快捷方式。你可以点击该快捷方式打开 VirtualBox，或者通过搜索框输入virtualbox并点击结果来打开它。

完成后，你将看到有关默认安装的屏幕。恭喜你完成了这一步。接下来我们将通过安装 Vagrant 来结束。

在 Windows 10 上安装 Vagrant

现在是安装 Vagrant 的时候了。以下是安装 Vagrant 的步骤：

1. 访问 Vagrant 的官方网站，www.vagrantup.com/。最好的方式是使用你系统的互联网浏览器，比如 Firefox。我们将使用 Vagrant 的最新版本。

2. 点击“下载 2.0.4”链接或顶部导航菜单中的“下载”链接。你应该会看到下载页面。

3. 我们可以专注于 Windows 部分，但你需要根据你的系统选择 32 位或 64 位选项。我的系统是 64 位的，所以我会选择那个选项。下载应该会自动开始。

4. 选择“运行”，这将自动下载软件并启动安装程序。

下载完成后，安装程序应该会自动启动。你将看到安装程序的欢迎屏幕：

1. 点击“下一步”按钮继续。

2. 阅读完条款和条件后，如果你同意并接受，请勾选相应选项。点击“下一步”按钮继续。

3. 如果需要，你可以更改安装目标位置。当你满意后，点击“下一步”按钮继续到下一屏幕。

4. 在 Vagrant 安装到你的系统之前，你可以选择进行任何更改。如果你不再需要做任何更改，点击“安装”按钮。

5. Windows UAC 会询问你是否同意允许安装程序继续。点击“是”按钮。

6. Vagrant 将开始安装。如果你需要取消安装，请点击“取消”按钮。

7. 在成功安装 Vagrant 后，点击“完成”按钮以关闭安装程序。

8. 你必须重启系统，才能使 Vagrant 在你的系统上完全安装。

9. 点击“是”按钮以重启。这将打断你当前在系统上的工作，因此请确保保存所有需要保存的文件。

10. 要验证 Vagrant 是否已安装并正在运行，我们需要使用命令提示符。要访问命令提示符，请在系统的搜索功能中搜索cmd：

1. 通过输入 vagrant -v 命令并按下 Enter 键运行。你应该看到类似于前面截图的输出。我的 Vagrant 版本是 2.0.4。

在 Linux 上安装 VirtualBox 和 Vagrant

在本节中，你将学习如何在 Linux 环境中安装 VirtualBox 和 Vagrant。你还将学习如何查找你的 CPU 架构以及你正在运行的 Linux 操作系统版本。在本节中，我们将使用 Ubuntu 16.04 64 位作为示例操作系统和计算机设置。

先决条件

在安装 VirtualBox 和 Vagrant 之前，我们需要了解一些关于系统的基本信息。这些信息将帮助你选择要下载的包。

系统版本

查找你正在运行的 Ubuntu 版本将帮助你选择下载哪个包安装程序。

查找 Ubuntu 版本最简单快捷的方法是进入终端并运行 cat /etc/*-release 命令。

现在你应该会看到一些输出。我们可以关注几个部分，它们是 DISTRIB_DESCRIPTION、VERSION 和 VERSION_ID。在我的情况下，是 Ubuntu 版本 16.04。

CPU 架构

系统的 CPU 架构通常是 32 位或 64 位。当你下载 VirtualBox 或 Vagrant 软件包安装程序时，你需要确定你需要哪个版本。

查找 Ubuntu 系统的 CPU 架构最简单快捷的方法是进入终端并运行 uname -mrs 命令。

现在你应该会看到一些输出。我们要找的是最后一部分；在我的情况下，显示的是 x86_64。

这表明我有一个 64 位的 CPU 架构。如果你的系统是 32 位的，你可能会看到 i686 或 i386。

在 Ubuntu 16.04 上安装 VirtualBox

在安装 Vagrant 之前，最好先安装它的提供者，即 VirtualBox：

1. 访问官方 VirtualBox 网站，www.virtualbox.org/。最好的方式是使用系统的浏览器，例如 Firefox。

2. 点击左侧导航菜单中的 Downloads 选项。

3. 在这一节下面，你应该会看到四个平台包的链接列表。点击 Linux 发行版选项。

4. 选择一个版本，如 x86（32 位 CPU）或 AMD64（64 位 CPU）。使用关于（CPU 架构）中的信息，并下载相应的包。我将选择与我的系统匹配的 Ubuntu 16.04 AMD64 版本。点击链接，下载应自动开始。你的系统可能会提示你选择“用某个应用程序打开”或“保存文件”。

5. 我将选择“用软件安装（默认）”选项，因为这将下载包并自动启动安装程序。当你选择好选项后，点击 OK 按钮。

Ubuntu 安装程序应该会打开。点击“安装”选项以开始软件安装。根据系统的安全设置，您可能会被要求输入密码。如果是这种情况，请输入密码并点击“认证”按钮继续。我们现在可以检查安装情况：

1. 应该在您的系统上安装 VirtualBox，除非在安装过程中出现任何错误信息。为了确认 VirtualBox 是否已安装，可以使用 Ubuntu 的搜索功能并输入virtualbox。

2. 您应该看到它出现在“应用程序”部分下方。

3. 打开 VirtualBox 时，您将看到一个欢迎界面。这是默认的安装界面。

4. 如果您在系统中找不到 VirtualBox，也可以在 Ubuntu 的终端中运行virtualbox命令。如果软件被找到，它应该会打开 VirtualBox。

完成后，您将看到与默认安装相关的屏幕。恭喜您完成了这一步。接下来我们将通过安装 Vagrant 完成安装过程。

在 Ubuntu 16.04 上安装 Vagrant

现在是安装 Vagrant 的时候了：

1. 访问官方 Vagrant 网站，www.vagrantup.com/。最好的方法是使用您系统的互联网浏览器，如 Firefox。

2. 我们将坚持使用最新版本的 Vagrant。点击“下载 2.0.4”链接或顶部导航菜单中的“下载”链接。您应该会看到下载页面。

3. 由于我们使用的是基于 Debian 的 Ubuntu，我们将重点关注该软件包。根据之前的知识，我们知道应该选择 64 位下载选项。

4. 当您点击该链接时，系统应该会提示您下载软件。我选择了“用软件安装程序打开（默认）”选项，因为这将下载软件并自动启动安装程序。

5. 点击“安装”按钮以开始。

6. 系统会要求您输入密码以开始安装。输入您的密码并点击“认证”按钮。

7. 当 Vagrant 安装完成后，您应该注意到安装按钮已经变成了移除按钮。如果您想删除 Vagrant，可以使用此选项：

您还可以在 Ubuntu 终端中运行vagrant -v命令。如果 Vagrant 安装成功，您应该看到一些输出。您可以看到我系统的版本是Vagrant 2.0.4。

在 macOS 上安装 VirtualBox 和 Vagrant

在本节中，您将学习如何在 macOS 环境中安装 VirtualBox 和 Vagrant。您将了解如何查找您的 CPU 架构以及运行的 macOS 操作系统版本。在本节中，我们将使用 macOS High Sierra 10.13.3 64 位作为我们的示例操作系统和计算机设置。

前提条件

在安装 VirtualBox 和 Vagrant 之前，我们需要了解一些关于您系统的基本信息。这些信息对于帮助您选择要下载的软件包非常重要。

系统版本

了解你运行的是哪个版本的 macOS，有助于你选择要下载的安装包。

查找 Mac 系统信息最简单快捷的方法之一是运行 sw_vers 命令，在终端中输入：

这里有两个关键值可以关注：ProductName，它是 Mac OS X；以及 ProductVersion，它是 10.13.3。

CPU 架构

系统的 CPU 架构通常是 32 位或 64 位。当你下载 VirtualBox 或 Vagrant 软件包安装程序时，你需要定义所需的版本。

我们可以运行 sysctl hw.cpu64bit_capable 命令，这样可以知道我们的系统是否支持运行 64 位软件。在这张我的系统截图中，你可以看到返回值是 1：

这意味着我有一个支持 64 位的 Mac 系统。如果你的值返回为空或 0，则表示你的系统仅支持 32 位。

在 Mac OS 10.11.3 上安装 VirtualBox

在进入这一部分之前，值得一提的是，Vagrant 1.8 版本及之后的版本会自动在你的系统上安装 VirtualBox，以提供更顺畅的体验。你可以跳过这一部分，继续下一部分，即 在 macOS 上安装 Vagrant。如果遇到问题，请随时返回此部分并尝试手动安装 VirtualBox。

在安装 Vagrant 之前，最好先安装它的提供者，即 VirtualBox：

1. 访问 VirtualBox 官方网站，www.virtualbox.org/。最好的方法是使用你系统的互联网浏览器，如 Firefox。

2. 点击左侧导航菜单中的下载链接。

3. 这应该会加载网站的下载页面。对于本书，我们将使用 VirtualBox 版本 5.2.10，请导航到该页面的相关部分。当页面出现时，点击 OS X hosts 链接，下载应该会自动开始。

4. 下载完成后，点击 .dmg 文件以运行 VirtualBox 安装包。你的 Mac 系统将打开并验证安装程序。你将看到一个临时屏幕，显示几个不同的选项。按步骤 1 点击并打开 VirtualBox.pkg 文件。

5. VirtualBox 安装程序将运行。点击继续按钮。

6. 系统已验证你可以安装此 VirtualBox 软件。点击继续按钮开始安装过程。

7. 在下一个屏幕上，你可以选择更改安装位置。你可以根据需要进行更改，但为了简洁和一致性，我们将其保持为默认位置。如果你同意继续，点击安装按钮。

8. 系统可能会要求你登录以允许安装程序继续。请输入你的用户名（此项可能已经自动填写）和系统密码。然后点击安装软件按钮继续。

9. 安装程序将安装所需的文件和配置。如果安装过程中没有问题，你应该会看到 The ivag

10. 要验证并运行 VirtualBox，你可以在应用程序文件夹中找到它，可能也会出现在桌面上。当你打开安装程序时，应该会看到 VirtualBox 默认的欢迎界面。

恭喜！你已成功在 macOS 系统上安装了 VirtualBox。

在 macOS 10.13.3 上安装 Vagrant

现在是时候安装 Vagrant 了：

1. 访问 Vagrant 官方网站，www.vagrantup.com/。最好的方法是使用你系统的互联网浏览器，例如 Firefox。

2. 点击主页上的下载 2.0.4 或顶部右侧导航菜单中的下载链接。这将加载 Vagrant 下载页面。

3. 当前版本的 Vagrant 仅支持 64 位 macOS 系统。我们将使用该版本。点击链接开始下载。

4. 下载完成后，点击 .dmg 文件以打开 Vagrant 安装程序。Mac 系统将会打开并验证 Vagrant 安装程序。

5. 验证完成后，你将看到一个临时的启动屏幕。点击 vagrant.pkg 图标运行安装程序。

6. 你应该会看到安装程序的 介绍 页面。点击继续按钮开始安装过程。

7. 你可以选择更改 Vagrant 的安装位置。你可以根据需要进行更改，但为了简洁性和一致性，我们将保持默认位置。如果你同意继续，请点击安装按钮。

8. 系统可能会要求你登录以允许安装程序继续进行。请输入你的用户名（可能已经填写好）和系统密码。点击安装软件按钮继续。

9. 安装将开始。如果安装成功，你应该会看到 安装成功 页面。

现在你可以点击关闭按钮来关闭安装程序。Vagrant 没有图形用户界面，因此我们可以通过运行 vagrant -v 命令来验证它是否已安装成功，命令将输出我们正在运行的 Vagrant 版本：

如你在我的终端输出中所见，macOS 系统正在运行 Vagrant 版本 2.0.4。恭喜！你已成功将 Vagrant 安装到 macOS 系统上。

概要

在本章中，我们学习了如何在 Windows、Mac 和 Linux 机器上安装 Vagrant 及其提供者 VirtualBox。现在你已经拥有了基础环境，可以开始使用 Vagrant 创建虚拟环境。

在第三章，命令行界面 - Vagrant 命令，我们将学习 Vagrant 的所有命令和子命令。这些强大的命令为我们提供了 Vagrant 的完整功能集，从基本功能（例如返回 Vagrant 的软件版本），到管理 Box（例如从 Vagrant Cloud 导入并安装它们）。

第三章：命令行界面 - Vagrant 命令

在本章中，我们将学习如何通过各种命令和子命令控制 Vagrant。Vagrant 没有图形用户界面，因此我们将通过终端/命令提示符运行命令。通过本章的学习，您将对 Vagrant 命令及其用法有扎实的基础知识。我们将涵盖以下主题：

• Vagrant 命令、子命令和标志

• 格式化命令

• 一般 Vagrant 命令和子命令

• Vagrant 配置命令和子命令

• 日常 Vagrant 命令和子命令

• 应用程序特定的 Vagrant 命令和子命令

• 故障排除

Vagrant 命令概述

Vagrant 主要是一个命令行工具。默认情况下，没有图形用户界面，尽管您可以在网上找到一些第三方的图形界面。Vagrant 提供了一个简单且强大的命令和子命令集合，共有 25 个以上的命令。

要开始使用 Vagrant 命令，请打开命令提示符/终端并运行vagrant --help命令。您现在应该能看到一系列常见命令，其中包括box、destroy和status。

要查看完整的可用命令列表（包括不常用命令），请运行vagrant list-commands。您将看到更长的命令列表，并附有每个命令的简要说明。

要获取某个特定命令的更多信息并查看其子命令，请在命令末尾添加--help标志。举例来说，vagrant box --help命令会返回以下信息：

当某个命令有子命令时，您还可以为子命令添加--help标志，以了解更多信息。在这种情况下，我们的命令将是vagrant box add --help，其返回内容为：

如您在截图中看到的，关于该子命令的信息非常丰富。Vagrant 的文档非常完善，您在命令行/终端中无法找到的信息，您应该能在 Vagrant 网站上找到：www.vagrantup.com/。

深入了解 Vagrant 命令

在本节中，您将学习所有可用的 Vagrant 命令和子命令。我们将探讨最常见的命令及其功能。我们还会讨论与命令相关的错误以及如何克服这些问题。

我们将把命令和子命令分为以下四个类别：

• 一般

• 配置

• 日常

• 应用程序特定

在本节结束时，您将对可用的命令和子命令有较好的了解，知道它们的作用以及如何在日常工作中使用它们。

格式化命令简要说明

在本章中，我将使用某些关键词作为占位符。这些占位符是供你在命令和子命令中输入值的。例如，一个典型的占位符会像这样：[INSERT VALUE]。例如，vagrant login --user [INSERT VALUE]，其中[INSERT VALUE]可能是myusername，最终你输入的命令就是vagrant login --user myusername。不需要使用大写字母或方括号。

当你看到[VMNAME]占位符时，它指的是你想要在系统上运行该命令的特定 Vagrant 机器名称。默认的 Vagrant 机器名为default，例如，命令vagrant resume default将从暂停状态恢复该机器。

一般的 Vagrant 命令和子命令

Vagrant 中的一般命令和子命令没有特定类别。它们可能只使用一次，或执行非常特定的任务。

list-commands 命令

list-commands命令将列出主vagrant命令范围内的所有可用命令。它将按字母顺序列出每个命令并给出简要描述。

选项/标志

该命令只有一个标志-h/--help，它将打印该命令的帮助屏幕。

一个例子是vagrant list-commands --help命令。

帮助命令

help命令将显示命令的正确语法，并列出一些最常用的 Vagrant 命令。

版本命令

version命令将返回当前安装在系统上的 Vagrant 版本、最新的可用版本，并提供一个 Vagrant 官方网站下载页面的 URL。

选项/标志

该命令只有一个标志-h/--help，它将打印该命令的帮助屏幕。

一个例子是vagrant version --help命令。

global-status 命令

global-status命令将返回当前用户所有 Vagrant 环境的信息。它将返回 Vagrant 环境 ID、名称、提供者、状态和目录。此命令对于给你一个系统中 Vagrant 环境的概览非常有用。

选项/标志

该命令有两个标志：

• -h/--help：打印该命令的帮助屏幕

• --prune：修剪任何无效的条目

一个例子是vagrant global-status --help命令。

Vagrant 的配置命令和子命令

在本节中，我们将查看 Vagrant 的配置命令和子命令。这些命令通常用于配置 Vagrant，比如安装包或创建环境快照。

登录命令

login命令用于登录到你的 HashiCorp Vagrant Cloud 账户。登录 Vagrant Cloud 后，你可以访问并下载受保护的盒子以及 Vagrant Share 服务，这使你能够与任何人分享你的 Vagrant 环境。

选项/标志

这个命令有六个标志：

• -c/--check：检查你是否已经登录。

• -d/--description [INSERT VALUE]：接受一个参数，用来设置 token 的描述。

• -k/--logout：如果你已经登录，则登出。

• -t/--token [INSERT VALUE]：接受一个参数，用来设置 Vagrant Cloud token。

• -u/--username [INSERT VALUE]：接受一个参数，指定你的 Vagrant Cloud 邮箱或用户名。

• -h/--help：打印该命令的帮助屏幕。

一个例子是 vagrant login --check 命令。

package 命令

package 命令允许你从运行中的 Vagrant 环境创建一个 Vagrant box。

选项/标志

这个命令有五个标志：

• --base [INSERT VALUE]：接受一个参数，指定一个虚拟机的名称（在 VirtualBox 中）作为基础 box 进行打包。这个标志仅在你使用 VirtualBox 提供者时有效。

• --output [INSERT VALUE]：接受一个参数，用来命名输出文件。

• --include [INSERT VALUE, INSERT VALUE]：接受以逗号分隔的参数，以便在打包过程中包含额外的文件。

• --vagrantfile [INSERT VALUE]：接受一个参数，指定你希望打包到该 box 中的 Vagrantfile。

• -h/--help：打印该命令的帮助屏幕。

一个例子是 vagrant package --help 命令。

snapshot 命令

snapshot 命令允许你管理 Vagrant 环境的快照。你可以保存、删除和恢复快照。只有某些提供者支持快照功能，如果你的提供者不支持，运行此命令时 Vagrant 会返回一个警告。

子命令

snapshot 命令有六个子命令：

• vagrant snapshot delete [INSERT VALUE] [INSERT VALUE]：第一个参数是虚拟机名称，第二个参数是你希望删除的快照名称。

• vagrant snapshot list [INSERT VALUE]：参数可以选择是 Vagrant 机器名称。此命令将列出系统上所有可用的快照，或者如果指定了参数，则列出某个 Vagrant 机器的所有快照。

• vagrant snapshot push：用于创建正在运行的 Vagrant 环境的新快照。它会将此快照添加到快照堆栈中。

• vagrant snapshot pop：可以作为 push 命令的反向操作，用来撤销已推送的快照。

• vagrant snapshot save [INSERT VALUE] [INSERT VALUE]：保存当前机器的快照。它类似于 push 命令，但不建议将此命令与 push 或 pop 混用，因为它不安全。第一个参数是虚拟机名称，第二个参数是快照名称。

• vagrant snapshot restore [INSERT VALUE] [INSERT VALUE]：恢复一个指定的快照。第一个参数是虚拟机名称，第二个参数是你希望恢复的快照名称。

provider 命令

provider 命令会返回当前运行机器的提供者，或者它可以接受一个环境 ID。

选项/标志

此命令有三个标志：

• --install：尝试安装提供者。

• --usable：检查提供者是否可用。

• -h/--help：打印此命令的帮助屏幕。

一个示例是vagrant provider --install命令。

plugin 命令

plugin命令允许你管理 Vagrant 插件。你可以安装、列出、修复、卸载和更新插件。

子命令

plugin命令有七个可用的子命令：

• vagrant plugin expunge：删除所有用户安装的插件。这将删除与这些插件相关的数据和依赖项。如果你希望一次性删除所有插件，这是一个有用的命令。

• vagrant plugin install [INSERT VALUE]：通过提供插件名称作为命令参数来安装插件。你可以从已知的 Gem 或系统中的本地 Gem 文件安装插件。

• vagrant plugin license [INSERT VALUE] [INSERT VALUE]：安装专有的 Vagrant 插件许可证。第一个参数是插件名称，第二个是许可证文件。

• vagrant plugin list：列出你系统上所有已安装的插件。它将列出插件信息，如其版本。此命令对于找出你已安装的插件及其版本非常有用。

• vagrant plugin repair：尝试修复任何存在问题且无法正常工作的插件。问题可能出现在自定义插件的安装过程中，或者是plugins.json文件的错误。

• vagrant plugin uninstall [INSERT VALUE]：使用提供的插件名称作为第一个参数删除插件。此命令支持多个参数，每个参数都是一个插件名称。你可以使用此命令删除一个或多个插件。

• vagrant plugin update [INSERT VALUE]：如果提供了插件名称作为第一个参数，则更新特定插件。如果没有提供参数，此命令将更新所有已安装的插件。

cap 命令

cap命令允许你运行或检查来宾机器的功能。这些功能通常是特定于来宾的，并且是专门配置的，例如在 Vagrant 插件开发中。

选项/标志

此命令有两个标志：

• --check [INSERT VALUE] [INSERT VALUE]：检查某个功能。第一个参数是功能名称，第二个参数是功能参数。此命令不会运行该功能。

• -h/--help：打印此命令的帮助屏幕。

一个示例是vagrant cap --help命令。

日常的 Vagrant 命令和子命令

日常的 Vagrant 命令和子命令是你最常使用的。这些命令通常用于管理你的 Vagrant 盒子，例如创建、启动和停止它们。

box命令

box命令允许你管理系统上的 Vagrant 盒子。你可以安装、更新、删除和修剪盒子。

子命令

box命令有七个可用的子命令：

• vagrant box add [INSERT VALUE]：将 Vagrant box 添加并下载到你的系统中。然后可以在 Vagrantfile 中使用该 box 来创建 Vagrant 虚拟机。

• vagrant box list：列出系统中已安装的所有 Vagrant box。

• vagrant box outdated：检查当前使用的 Vagrant box 是否过时。你可以添加 --global 标志，它会检查所有已安装的 Vagrant box。

• vagrant box prune：删除已安装 box 的旧版本。如果你当前使用的是旧版本的 box，它想删除时会要求确认。

• vagrant box remove [INSERT VALUE]：根据提供的第一个参数（名称）删除 Vagrant box。

• vagrant box repackage [INSERT VALUE] [INSERT VALUE] [INSERT VALUE]：使用第一个参数作为名称，第二个参数作为提供程序，第三个参数作为版本，将 Vagrant box 打包为 .box 文件。你可以通过 vagrant box list 命令获取参数值。然后可以分发该 box。

• vagrant box update：检查并更新当前使用的 box。你可以使用 --box [INSERT VALUE] 标志，其中第一个参数是你希望特定更新的 box 名称。

destroy 命令

destroy 命令将停止并删除 Vagrant 虚拟机。

选项/标志

这个命令有三个标志：

• -f/--force：在不询问确认的情况下销毁 Vagrant 虚拟机。

• --parallel/--no-parallel：仅在提供程序支持时启用或禁用并行性。在本书中我们使用 VirtualBox 作为提供程序，而在写作时它不支持并行执行。运行此标志也会启用 force 标志。

• -h/--help：打印此命令的帮助信息。

一个示例是 vagrant destroy --force 命令。

halt 命令

halt 命令将停止/暂停正在运行的 Vagrant 虚拟机。

选项/标志

这个命令有两个标志：

• --force [INSERT VALUE]：强制关闭正在运行的虚拟机。如果你的虚拟机未保存，运行此命令时可能会丢失数据，就像断开计算机电源一样。你可以使用可选参数指定机器名称或 ID。

• -h/--help：打印此命令的帮助信息。

一个示例是 vagrant halt --force 命令。

init 命令

init 命令生成一个新的 Vagrantfile，用于配置新的 Vagrant 环境。

选项/标志

这个命令有六个标志：

• --box-version [INSERT VALUE]：将提供的第一个参数的 box 版本添加到 Vagrantfile 中

• -f/--force：如果同一目录下已经存在 Vagrantfile，则覆盖该文件

• -m/--minimal：生成一个最小的 Vagrantfile，删除不必要的部分，如注释

• --output [INSERT VALUE]：使用第一个参数指定的输出路径

• --template [INSERT VALUE]：当提供的路径作为第一个参数时，使用自定义 Vagrantfile 模板

• -h/--help：打印该命令的帮助屏幕。

一个例子是 vagrant init --force 命令。

port 命令

port 命令返回从客机到 Vagrant 环境的端口映射。

选项/标志

此命令有三个标志：

• --guest [INSERT VALUE]：当第一个参数是客机上的端口时，输出特定的端口信息。它将返回主机映射的端口。此命令对于某些网络级别的调试或测试非常有用。

• --machine-readable：返回/显示更易机器读取的输出。

• -h/--help：打印该命令的帮助屏幕。

一个例子是 vagrant port --machine-readable 命令。

provision 命令

provision 命令将根据可用的 Vagrantfile 为 Vagrant 机器提供配置。如果成功，你将获得一个正在运行并且已完全配置的 Vagrant 环境。

选项/标志

此命令有两个标志：

• --provision-with [INSERT VALUE]：使用指定的配置器为 Vagrant 机器提供配置。你可以通过提供一个以逗号分隔的列表来使用多个配置器类型。

• -h/--help：打印该命令的帮助屏幕。

一个例子是 vagrant provision --help 命令。

push 命令

push 命令将使用你在 Vagrantfile 中配置的方法部署代码。你可以使用 FTP/SFTP 和 Heroku 作为部署方法。

选项/标志

该命令只有一个标志 -h/--help，它将打印该命令的帮助屏幕。

一个例子是 vagrant push --help 命令。

reload 命令

reload 命令用于在你更改 Vagrantfile 并希望将更改应用到正在运行的机器时使用。此命令会停止当前环境，应用新的 Vagrantfile，并重新启动环境。

选项/标志

此命令有三个标志：

• --provision/--no-provision：在重新加载过程中启用或禁用配置。

• --provision-with [INSERT VALUE]：使用指定的配置器为 Vagrant 机器提供配置。可以通过提供以逗号分隔的参数列表来使用多个配置器类型。

• -h/--help：打印该命令的帮助屏幕。

一个例子是 vagrant reload --no-provision 命令。

resume 命令

resume 命令将启动一个暂停的 Vagrant 环境。它可以在执行 vagrant halt 命令后使用。

选项/标志

此命令有三个标志：

• --provision/--no-provision：在机器恢复时启用或禁用配置。

• --provision-with [INSERT VALUE]：仅使用第一个参数中指定的某些配置器。要使用多个配置器，可以提供一个以逗号分隔的列表。提供的值可以是配置器的名称或类型。

• -h/--help：打印该命令的帮助屏幕。

一个例子是 vagrant resume --no-provision 命令。

status 命令

status命令将返回 Vagrant 机器的状态。它会返回诸如stopped或running之类的信息。

选项/标志

这个命令只有一个标志，-h/--help，它将打印该命令的帮助页面。

一个示例是vagrant status --help命令。

suspend命令

suspend命令类似于vagrant halt命令，但它不会完全停止并关闭机器，而是会保存状态，这会占用额外的磁盘空间，但当你重新启动机器时，它会快速从该精确点开始，不会像冷启动那样经历长时间的启动过程。

选项/标志

这个命令只有一个标志，-h/--help，它将打印该命令的帮助页面。

一个示例是vagrant suspend --help命令。

up命令

up命令将启动一个 Vagrant 环境。在启动过程中，它还将配置机器，类似于vagrant provision命令。

选项/标志

这个命令有七个标志：

• --provision/--no-provision：启用或禁用在 Vagrant 机器启动时的配置。

• --provision-with [INSERT VALUE]：仅使用在第一个参数中指定的特定配置器。要使用多个配置器，可以使用逗号分隔的列表。提供的值可以是配置器的名称或类型。

• --destroy-on-error/--no-destroy-on-error：如果发生致命错误，将销毁机器。除非使用--no-destroy-on-error标志，否则这是默认行为。

• --parallel/--no-parallel：仅在提供者支持的情况下启用或禁用并行处理。本书中使用的是 VirtualBox 作为提供者，在写作时，它不支持并行执行。如果你运行此命令，则不会发生任何事情。

• --provider [INSERT VALUE]：使用作为第一个参数提供的提供者。

• --install-provider/--no-install-provider：如果可能并且尚未安装，将尝试安装提供者。

• -h/--help：打印该命令的帮助页面。

一个示例是vagrant up --no-parallel命令。

validate命令

validate命令将验证 Vagrantfile 并返回任何错误。它会检查 Vagrantfile 中的问题，如语法错误。

选项/标志

这个命令只有一个标志，-h/--help，它将打印该命令的帮助页面。

一个示例是vagrant validate --help命令。

针对特定应用的 Vagrant 命令和子命令

针对特定应用的 Vagrant 命令和子命令，专注于外部应用程序或与 Vagrant 或 VirtualBox 不直接相关的软件。在本节中，我们将讨论 Docker、RDP、RSync、SSH 和 PowerShell 命令及其子命令。

docker-exec命令

docker-exec命令用于直接在运行的docker容器中执行命令。当使用 Docker 作为 Vagrant 的提供者时，执行此操作。

选项 / 标志

该命令有八个标志：

• --no-detach/--detach：启用或禁用命令在后台运行。

• -i/--interactive：即使未附加，也保持标准输入（STDIN）打开。

• --no-interactive：即使未附加，也不保持标准输入（STDIN）打开。

• -t/--tty：启用伪终端（pseudo-tty），即 pty。

• --no-tty：禁用伪终端（pseudo-tty），即 pty。

• -u [INSERT VALUE]/--user [INSERT VALUE]：将用户或 UID 作为第一个参数与命令一起发送。

• --prefix/--no-prefix：启用或禁用带有机器名称的前缀输出。这在区分不同的机器/容器时很有用。

• -h/--help：打印该命令的帮助页面。

一个示例是 vagrant docker-exec --no-tty 命令。

docker-logs 命令

docker-logs 命令将返回正在运行的容器的日志。这在将 Docker 作为 Vagrant 提供程序时使用。

选项/标志

该命令有三个标志：

• --no-follow/--follow：启用或禁用将 Docker 日志数据流式传输到输出中。

• --no-prefix/--prefix：启用或禁用带有机器名称的前缀输出。这在区分不同的机器/容器时很有用。

• -h/--help：打印该命令的帮助页面。

一个示例是 vagrant docker-logs --no-follow 命令。

docker-run 命令

docker-run 命令与 vagrant docker-exec 命令非常相似，都允许你在 Docker 容器上运行命令。与 docker-exec 命令相比，它的选项更少，配置性也较差。再次提醒，这个命令是在将 Docker 作为 Vagrant 提供程序时使用的。

选项/标志

该命令有六个标志：

• --no-detach/--detach：启用或禁用命令在后台运行。

• -t/--tty：启用伪终端（pseudo-tty），即 pty。

• --no-tty：禁用伪终端（pseudo-tty），即 pty。

• -r/--rm：执行后删除容器。

• --no-rm：执行后不删除容器。

• -h/--help：打印该命令的帮助页面。

一个示例是 vagrant docker-run --no-detach 命令。

rdp 命令

rdp 命令用于在 Vagrant 环境中创建远程桌面客户端。此命令只能用于支持远程桌面协议的 Vagrant 环境。

选项/标志

该命令有一个标志 -h/--help，它将打印该命令的帮助页面。

一个示例是 vagrant rdp --help 命令。

rsync 命令

rsync 命令将强制同步任何已配置为使用 RSync 作为同步选项的文件夹到远程机器。同步通常只有在你手动启动或重新加载 Vagrant 环境时才会发生。

选项/标志

该命令有一个标志 -h/--help，它将打印该命令的帮助页面。

一个示例是 vagrant rsync --help 命令。

rsync-auto 命令

如何运行vagrant rsync-auto：rsync-auto命令类似于vagrant rsync命令，它强制同步任何配置的 RSync 文件夹，但现在它会监听所有配置的目录，自动同步文件更改。

选项/标志

这个命令有三个标志：

• --poll：强制轮询文件系统。此选项性能较差，可能比较慢。

• --no-poll：禁用文件系统的轮询。

• -h/--help：打印此命令的帮助信息。

一个例子是vagrant rsync-auto --no-poll命令。

ssh 命令

ssh命令将通过 SSH 协议/连接将你连接到远程 Vagrant 虚拟机。此命令使你能够访问虚拟机的 shell，允许你直接在虚拟机上运行命令。

选项/标志

这个命令有五个标志：

• -c [插入值]/--command [插入值]：通过 SSH 直接运行使用第一个参数提供的命令。

• -p/--plain：以普通模式连接，允许你选择身份验证方式。

• -t/--tty：启用tty，当你运行 SSH 命令时使用。默认值为启用。

• --no-tty：禁用tty，当你运行 SSH 命令时。

• -h/--help：打印此命令的帮助信息。

一个例子是vagrant ssh --plain命令。

ssh-config 命令

ssh-config命令将生成一个配置，可以在 SSH 配置文件中使用，然后可以用来通过 SSH 连接到 Vagrant 虚拟机。

选项/标志

这个命令有两个标志：

• --host [插入值]：在提供第一个参数时，为配置指定主机名称。

• -h/--help：打印此命令的帮助信息。

一个例子是vagrant ssh-config --host testname命令。

powershell 命令

powershell命令将打开到 Vagrant 虚拟机的 PowerShell 连接。powershell命令只适用于支持此命令的客户端机器和 Vagrant 虚拟机。例如，当你尝试在客户端机器（如 Mac）上运行此命令时，将返回以下错误：

Your host does not support PowerShell. A remote PowerShell connection can only be made from a windows host.

选项/标志

这个命令有两个标志：

• --c [插入值]/--command [插入值]：运行通过第一个参数提供的 PowerShell 命令。

• -h/--help：打印此命令的帮助信息。

一个例子是vagrant powershell --help命令。

使用命令的典型 Vagrant 工作流

在本节中，你将看到如何通过几个 Vagrant 命令和子命令创建一个基本的工作流：

1. 确保你在一个新的空目录中（这不是必须的，但有助于将项目与其他文件分开）。

2. 运行vagrant init ubuntu/xenial64 https://vagrantcloud.com/ubunutu/xenial64.box。这将创建一个默认的 Vagrantfile，但 box 会设置为 Ubuntu 16.04.4 64 位版本。第一个参数是官方的 box 名称，第二个参数是它的下载 URL。

3. 运行vagrant validate命令，确保 Vagrantfile 没有错误且可以正常使用。由于我们只使用了基本的默认 Vagrantfile，这里应该不会有任何错误。你应该能看到Vagrantfile validated successfully的提示信息。

4. 启动 Vagrant 虚拟机。为此，运行vagrant up命令。如果你还没有安装那个 Ubuntu box，Vagrant 将在配置过程中下载它。根据你的网速，这可能需要一些时间。

5. 在启动过程中，你会看到许多操作发生。Vagrant 将配置网络连接，导入 box，配置并启动 SSH 服务，转发你机器与虚拟 Vagrant 机器之间的端口，并挂载共享文件夹。

6. 当 box 启动完成且 Vagrant 配置完毕后，你将能够通过 SSH 登录并直接在 Vagrant 环境中运行命令。为此，运行vagrant ssh命令。

7. 几秒钟后，你应该会看到 Ubuntu 终端和当天的消息。第一行应该类似于Welcome to Ubuntu 16.04.04 LTS。你现在可以在 Vagrant 环境内运行命令，比如安装 Ubuntu 软件包。

8. 退出并停止 Vagrant 虚拟机。在 Ubuntu 终端中运行exit命令。

9. 你可以通过运行vagrant status命令来检查 Vagrant 环境的状态。此命令将返回系统上 Vagrant 机器的列表。你应该看到你的机器仍在运行，机器名称可能是Default，状态将是running (virtualbox)，其中 VirtualBox 是我们用来提供 Vagrant 机器的虚拟化工具。

10. 让我们保存当前环境的快照。我们可以运行vagrant snapshot save default first_snapshot命令，这将告诉 Vagrant 使用名为 default 的机器保存快照，并将该快照命名为first_snapshot。

11. 为了确认快照是否已保存，运行vagrant snapshot list命令，应该会返回first_snapshot。该命令初次运行时只会返回一个快照，因为这是我们保存的唯一快照，但随着你保存更多快照，最终你会看到一个列表。然后，你可以使用快照来恢复环境到保存时的状态。

12. 通过运行vagrant suspend命令停止 Vagrant 虚拟机。这将花费几分钟时间。

恭喜你！你已经成功创建了一个 Vagrant 虚拟机，安装了 Ubuntu，使用了 SSH，保存了 Vagrant 机器的快照，并挂起了它。

这是一个相当简单的工作流程，因为我们没有在机器上做任何操作，也没有安装任何额外的功能。在后续章节中，我们将学习如何自定义 Vagrantfile 并更改配置过程。我们还将探讨如何使用配置管理工具（如 Chef 和 Ansible）为 Vagrant 虚拟机进行配置。

故障排除

在如此众多的 Vagrant 命令、子命令、参数和标志中，很容易输入命令后出现错误信息。

如果你输入错误的命令，Vagrant 会非常善于返回错误。有几种原因可能导致命令返回错误：

• 当没有 Vagrant 机器在运行时，你尝试运行命令。

• 你尝试在一个不存在或名称/ID 错误，或者已被删除的 Vagrant 机器上运行命令。

• 你的命令中有一个拼写错误。

• 你把参数放错顺序了。

• 当需要时，你没有指定任何参数。

• 你把标志放错顺序了。

• 当需要时，你没有指定任何标志。

• 当你没有使用那个提供程序时，你正在运行特定于该提供程序的命令。

• 当你没有使用那个操作系统时，你却在运行特定于该操作系统的命令。

这里有一些故障排除的小贴士：

• 慢慢阅读错误信息，看看你可能遗漏了什么。

• 运行vagrant [INSERT VALUE] --help命令，其中[INSERT VALUE]是你尝试运行的命令。这将给你该命令的语法、顺序、参数和标志。

• 确保你的命令字符串中没有拼写错误。

• 检查 Vagrantfile 也是值得的，看看它是否在某种程度上引起了问题或干扰。你可以运行vagrant validate命令，确保它没有问题。

• 你可以随时访问 Vagrant 的官方网站，确保你所使用的 Vagrant 版本包含你正在尝试运行的命令或支持该命令。

• 如果你完全卡住，无法排查问题，搜索具体的错误信息可能非常有用。你很可能会找到有相同问题的人，通常他们会在像 Stack Overflow 或 Vagrant 项目的 GitHub 问题版块上发布。

• 在最极端的情况下，你可能需要卸载 Vagrant（有时还包括 VirtualBox），然后重启你的机器。之后你需要重新安装 Vagrant（可能还需要重新安装 VirtualBox）。全新安装有时是最后的选择，但往往是正确的答案！

总结

在本章中，我们涵盖了 Vagrant 的命令和子命令。你现在应该对每个命令的功能及其适用场景有了良好的理解。你可以随时翻阅本章，作为参考。

在第四章，发现 Vagrant Boxes - Vagrant Cloud中，我们将学习 Vagrant boxes 和 Vagrant Cloud。你将学习如何安装 Vagrant box，管理它，创建你自己的 Vagrant box，并在 Vagrant Cloud 平台上搜索其他社区和公司创建的 boxes。

第四章：发现 Vagrant Boxes - Vagrant Cloud

在本章中，你将全面了解 Vagrant boxes。你将学习什么是 box，以及如何通过我们在前一章中介绍的 Vagrant 命令和子命令来管理它。我们还将学习 Vagrant Cloud，它是一个公共和私有 Vagrant box 的在线目录，供你搜索并安装到系统中，准备好用于你的 Vagrant 环境！

到本章结束时，你将对 Vagrant boxes 和 Vagrant Cloud 有扎实的基础知识。你还将学习以下主题：

• Vagrant box 的结构

• 如何安装 Vagrant box

• 如何删除 Vagrant box

• box 版本管理

• 什么是 Vagrant Cloud？

• 如何创建自己的 box（重新打包）

• 如何将自定义 box 上传到 Vagrant Cloud

• 企业级解决方案用于 Vagrant boxes

理解 Vagrant boxes

Vagrant box 是一种用于包含 Vagrant 环境的特定包格式。Vagrant box 文件使用 .box 文件扩展名。Vagrant box 可以在任何 Vagrant 支持的平台和系统上使用，通过按照 box 文件中的步骤来创建相同的环境。

Vagrant box 文件结构

Vagrant box 文件由三个组成部分组成：box 文件、box 元数据和 box 信息。这些组件有助于将所需的所有内容打包成一个文件。在使用和安装新 box 时，Vagrant 会使用这些组件中的不同部分来创建正确的环境。让我们深入了解这三大组件，看看它们各自的作用。

box 文件

box 包含的不同信息取决于提供商。它是特定于提供商的，可能采用不同的格式，如 ZIP、tar.gz 或 TAR。Vagrant 不使用这些信息，而是将其传递给提供商。

box 元数据

box 目录元数据通常用于 Vagrant 云平台。它包含诸如 box 名称、不同版本、描述、不同支持的提供商以及指向特定 box 文件的 URL 等信息。这些元数据通常以 JSON 文档形式存储，文件名为 metadata.json。

box 信息

box 信息是你可以添加的额外细节。这些额外的细节会在用户运行 vagrant box list --box-info 命令时显示。你可以设置作者姓名/公司名和 URL。此文件是一个 JSON 文档，文件名通常为 info.json。

如何安装 Vagrant box

在本节中，你将学习如何安装 Vagrant box。有多种方式可以安装 Vagrant box：

• 一个指向 box 文件的 URL

• 公共 box 名称的简写/别名，如 debian/jessie64

• 指向特定目录中 box 的文件路径或 URL

通常，最简单的选项是使用简写，因为它不需要你知道完整的 box URL 或目录 URL。

当一个 Vagrant box 支持多个提供商时，你将可以选择你希望安装的提供商：

您还可以使用--provider标志来指定要安装的盒子的提供者版本。Vagrant 提供了易于使用的选项，如前面的截图所示，或者在使用命令行时提供更全面的工具。

直接 URL 到盒子文件

使用此选项需要知道完整的盒子文件 URL，并且必须使用--name标志，以便 Vagrant 能够引用该盒子。此引用有助于更新和版本管理。

下面是命令的示例：vagrant box add --name "mybox" http://www.example.com/boxname.box。

此命令将安装boxname.box盒子，命名为mybox，并从www.example.com域下载。

盒子文件的简称/别名

如果您知道盒子的简称/别名名称，使用此方法相对简单直接。

下面是命令的示例：vagrant box add debian/jessie64。

此命令将安装 64 位的Jessie版本的 Debian 操作系统。您通常可以通过搜索引擎或使用 Vagrant Cloud 平台来查找盒子的简称/别名。

指定目录中盒子文件的文件路径或 URL

这种方法与直接 URL 到盒子文件部分中提到的第一种方法类似，您可以使用 URL 或文件路径直接下载并安装盒子文件。

下面是命令的示例：vagrant box add https://app.vagrantup.com/ubuntu/boxes/trusty64。

此命令将安装 64 位的Trusty版本的 Ubuntu。对于此方法，您无需使用--name标志，因为 Vagrant 会从盒子元数据和盒子信息文件中获取该信息。

如何删除 Vagrant 盒子

在某些时候，您可能需要从系统中删除 Vagrant 盒子。可能有以下几个原因：

• 释放系统空间

• 删除损坏版本

• 删除不再需要的旧版本

无论您的原因是什么，在本节中，您将学习如何删除 Vagrant 盒子。在删除盒子之前，建议您获取正确的名称/格式，以防不小心删除了错误的盒子！

要列出系统上可用的盒子，请运行vagrant box list -i命令，该命令将返回系统上已安装的盒子、它们的名称、提供者以及最新版本。使用-i标志将提供额外的描述，帮助您选择正确的盒子。

删除特定版本的盒子

您可以在不完全删除系统中盒子的情况下，删除特定版本的 Vagrant 盒子。这样可以释放不再使用的旧版盒子占用的空间。

您可以运行vagrant box prune --dry-run命令查看系统中过时的盒子版本列表。此命令的输出将显示将保留的盒子（如果您选择运行prune命令）以及将被删除的盒子。

下面是前述命令的示例输出：

如果你希望从系统中移除所有过时的盒子，可以运行vagrant box prune命令。

要删除特定版本的盒子，你可以运行vagrant box remove [BOXNAME] --box-version [BOXVERSION]命令，其中第一个参数是盒子的名称，第二个参数是特定版本。以下是示例输出：

删除所有版本的盒子

要删除所有版本的 Vagrant 盒子，你可以运行vagrant box remove [BOXNAME]命令，其中第一个参数是盒子的名称。在运行此命令时，你的终端会在删除盒子之前要求确认。

以下是示例输出：

如果你因为某种原因希望直接删除盒子而不需要确认，你可以运行vagrant box remove [BOXNAME] --force命令，使用--force标志。

盒子版本控制

Vagrant 盒子可以有多个版本，可以在你的系统上安装。在前面的章节中，我们讨论了如何prune过时的盒子版本以及如何通过特定版本删除盒子。

Vagrant Cloud

在本节中，我们将重点讨论 Vagrant Cloud。我们将了解它是什么，如何使用它，你可以如何使用它，以及如何在 Vagrant Cloud 中搜索可以安装到你系统上的 Vagrant 盒子。

了解 Vagrant Cloud

Vagrant Cloud 是 HashiCorp 的云平台，它允许你搜索、上传和下载 Vagrant 盒子。它允许你创建帐户，并提供三种不同的帐户层级，这些层级结合了免费和付费选项。

Vagrant Cloud 网站

你可以通过访问app.vagrantup.com来访问 Vagrant Cloud 网站，尽管它可能会将你重定向到app.vagrantup.com/boxes/search。

目前有三种不同的定价层级，根据你的需求提供不同的功能。以下是这三种层级：

• 免费：此选项提供无限量的公共盒子。

• 个人：此选项提供无限量的公共盒子，并且每个私有盒子的费用为每月$5。

• 组织：此选项提供无限量的公共盒子，每个私有盒子的费用为每月$25，并且可以与团队共享私有盒子。

选择合适的定价层级，实际上取决于你的使用场景以及你希望如何使用 Vagrant Cloud。你可以从免费层级开始，如果需要，随时升级。

在 Vagrant Cloud 上安装 Vagrant 盒子–第一部分，搜索

让我们使用搜索功能来查找可以安装到我们系统上的盒子。搜索功能非常简单，但提供了一些筛选器。你可以访问搜索框：app.vagrantup.com/boxes/search。

你应该会看到类似以下截图的部分：

Vagrant Cloud 提供三种不同的搜索选项：

• 主要的文本输入区域，你可以在这里输入几乎任何内容 —— box 名称、操作系统、架构以及包含的软件。

• 你可以根据 Provider 进行筛选，例如 virtualbox、vmware 和 docker。如果你没有特别偏好，可以选择任何选项。

• 你还可以根据下载量（总下载次数）、最近创建时间和最近更新时间对结果进行排序。

让我们搜索一个支持 VirtualBox 提供者的 Laravel（这是一个 PHP 框架）box，并按下载量排序：

让我们点击第一个结果，查看更多关于该 box 的信息：

此页面包含大量信息，包括 box 版本历史。最新的 box 版本按时间顺序列出，你应该总能看到最新的版本在最上面。

第一部分，标题为 如何使用此 box 与 Vagrant，提供了两个关于在系统上安装和使用该 box 的基本示例。默认显示的是 Vagrantfile 标签页，其中显示了可以添加到 Vagrantfile 中的三行内容。第二个标签页，标题为“新建”，展示了如何通过终端命令安装和运行该 box，你可以在这里看到该选项：

让我们来看一下 6.0.0 版本，这是 当前发布的版本。你可以看到这个版本的创建时间（在我们的例子中，它是 20 天前创建的），并且提供了一个 GitHub URL，方便你查看该版本的发布信息。

在这一部分，你还可以查看该版本支持哪些提供者以及该 box 的文件大小。在我们的例子中，我们可以看到 6.0.0 版本支持三个提供者：hyperv、vmware_desktop 和 virtualbox。我们可以看到 hyperv 的文件大小是 1.26 GB，而 vmware_desktop 和 virtualbox 的文件大小是 1.38 GB。

安装来自 Vagrant Cloud 的 Vagrant box – 第二部分，安装

现在我们已经找到了想要的 Vagrant box，接下来我们将安装并在系统上使用它。我们将使用 init 命令创建一个新的 Vagrantfile 并安装该 box。

首先创建一个新的空目录，进入该目录，并运行 vagrant init laravel/homestead 命令，正如 Vagrant Cloud 网站所描述的那样：

你现在应该能在当前目录中看到一个新的 Vagrantfile，运行 ls 命令查看：

让我们来看看 Vagrantfile。我已经使用 Atom 文本编辑器打开了 Vagrantfile。让我们关注前几行（忽略注释部分）：

你可以在第 15 行看到，config.vm.box 键已设置为 laravel/homestead。这就是 init 命令的作用，它创建/初始化一个新的 Vagrantfile，并根据命令的参数设置指定的值。

现在我们可以启动 Vagrant box，这将安装 laravel/homestead box。运行 vagrant up 命令：

如果你的系统上没有安装该盒子，首先需要下载.box文件。这个文件大约是 1.38 GB（根据我们尝试下载的当前版本 6.0.0 在 Vagrant Cloud 网站上的信息）；下载可能需要一些时间，具体取决于你的网络连接和速度。

安装完成后，你应该看到绿色的成功信息，盒子开始导入：

一旦导入，Vagrant 将继续初始化盒子，这将配置网络、SSH 和存储挂载。你可以通过运行vagrant ssh命令连接 SSH 来开始实验：

让我们运行一个简单的命令来确保 Vagrant 盒子一切正常。在运行ssh命令后，运行php -v命令，这将输出系统上安装的 PHP 版本。PHP 应该已安装，因为这是 Laravel 框架的要求之一。你应该看到类似以下的输出：

我们可以看到 PHP 已安装，版本是7.2.4-1。如果你想退出 Vagrant 盒子，只需运行exit命令。你可以通过运行vagrant status查看 Vagrant 盒子的状态，状态值应该是virtualbox (running)。你可以通过运行vagrant halt命令来停止盒子：

你现在可以再次运行vagrant status命令来检查状态：

你可以看到状态已经变更为poweroff (virtualbox)。

上传 Vagrant 盒子到 Vagrant Cloud

在本节中，你将学习如何创建自己的 Vagrant 盒子，并将该盒子上传到 Vagrant Cloud。你将学习如何将基础盒子打包，以便与 VirtualBox 提供者一起使用。

在继续之前，请在 Vagrant Cloud 平台上创建一个帐户。你可以通过访问app.vagrantup.com/account/new来完成此操作，或者访问 Vagrant Cloud 网站并点击菜单中的“Create an Account”链接。

创建一个 Vagrant 盒子

在我们能将任何东西上传到 Vagrant Cloud 平台之前，我们需要创建一个盒子。我们的 Vagrant 盒子将是ubuntu/xenial64基础盒子的重新打包版本，可以在 Vagrant Cloud 平台上找到。为了简化，我们将仅重新打包这个盒子，并使用不同的名称上传它。

首先，你需要确保你的系统上已经安装了ubuntu/xenial64盒子。你可以通过运行vagrant box list命令来检查。你可以看到我已经在系统上安装了它，如下图所示：

如果你没有安装它，请运行vagrant box add ubuntu/xenial64命令来将盒子安装到你的系统中。

让我们运行这个盒子，确保它能正常工作。运行vagrant init ubuntu/xenial64命令生成一个基本的 Vagrantfile，然后运行vagrant up命令启动盒子并使其运行。

一旦运行起来，你应该能够通过vagrant ssh进入机器。一切应该正常工作，现在我们可以exit退出盒子并运行vagrant halt命令来停止机器。

现在是时候在 Vagrant Cloud 仪表板中设置 Vagrant 盒子了。登录你的账户并点击“Dashboard”按钮，你应该会看到一个名为“New Vagrant Box”的按钮。点击该按钮，你应该会看到以下屏幕：

名称分为两部分：你的用户名和盒子名称，中间用斜杠分隔。我的盒子将通过abraunton/alextest访问，但最好使用更具描述性的名称。除非你有付费账户，否则不能使用私人模式。我建议尽可能添加简短描述。准备好后，点击“Create box”按钮继续。

现在我们需要为这个盒子添加一个版本。让我们从0.0.1开始，因为这是我们盒子的第一个版本。你也可以为这个特定版本添加描述：

准备好后，点击“Create version”按钮。现在我们需要为 Vagrant 盒子添加一个提供商。你可以在新版本中点击“Add a provider”按钮来完成：

现在你需要选择这个盒子文件支持的提供商。在这个示例中，我们将继续使用 VirtualBox，并选择“Upload to Vagrant Cloud”选项，因为我们希望直接上传盒子文件：

在继续之前，我们必须将盒子打包成文件。你可以通过在与要打包的盒子所在目录中运行vagrant package --output alextest.box命令来实现：

这可能需要几分钟时间，具体取决于你的机器大小。完成后，返回 Vagrant Cloud 页面并点击“Continue to upload”按钮：

选择文件（必须是.box文件），上传应该会自动开始。根据你的网络速度，可能需要一些时间。完成后，状态应该会变成“Upload Complete”。

恭喜！你已经成功创建并将 Vagrant 盒子上传到 Vagrant Cloud。你可以通过点击“Dashboard”菜单来查看；这将列出你添加的所有盒子：

你可以看到在“My Vagrant Boxes”部分，我的abraunton/alextest盒子已经出现。它显示了我们添加的描述，并且指出没有已发布版本。这意味着该盒子无法下载，但我们可以改变这一点。点击进入该盒子，你应该能看到以下信息：

向下滚动，你应该能看到我们上传的 0.0.1 版本的盒子。点击“Release...”按钮开始发布过程：

现在你会看到一个确认页面，系统会要求你点击“Release version”按钮来完成过程：

现在你应该看到一个绿色的成功发布消息。恭喜你！你已经将第一个 Vagrant box 公布到 Vagrant Cloud：

现在进行真正的测试；让我们检查一下确保我们的 box 可用，并且可以在系统上安装和运行它。运行vagrant init abraunton/alextest --box-version 0.0.1命令：

这将生成一个 Vagrantfile，指示 Vagrant 使用 abraunton/alextest box 和特定版本 0.0.1。接下来，运行vagrant up命令。这将从 Vagrant Cloud 安装我们的 box，并创建我们的环境：

如果你的 box 可用并且有发布版本，你应该能够成功下载它。如果一切顺利，你应该在终端中看到这条绿色的消息：

Vagrant box 现在应该已经启动并运行，让我们使用vagrant ssh进入 box，看看有什么内容。SSH 连接后，你应该看到 Ubuntu 欢迎信息。没错，因为我们重新打包了一个 Ubuntu box：

恭喜！你已成功从 Vagrant Cloud 安装并运行了你的 Vagrant box。你现在可以停止机器、删除 box 或进行实验。祝你玩得开心！

企业级 Vagrant box 解决方案

如果你在寻找更多企业级的解决方案来托管和管理你的 boxes，现有一些服务可以满足你的需求。

这些服务提供的产品和功能包括：

• Box 托管

• Box 版本管理

• 私有 box 访问与安全性

• 离线 box 访问的本地仓库

• 高级/智能搜索

这种类型的服务的一个例子是Artifactory，由 JFrog 开发。Artifactory 是一个二进制工件管理工具。Artifactory 允许你以安全的方式托管、管理和版本化 Vagrant boxes。它们对安全的关注通常吸引那些可能需要托管敏感数据的企业客户。

Artifactory 提供一种通过使用本地仓库的现场托管方式。它仍然允许你在组织内部的员工和团队之间共享访问。这些仓库如果需要共享到本地网络外部，还可以克隆到其他 Artifactory 服务。

根据你的需求和公司规定，这种解决方案可能值得考虑。Vagrant Cloud 是一个值得考虑的优秀服务。

总结

在本章中，我们涵盖了 Vagrant boxes 的许多方面。我们了解了 Vagrant box 是什么，box 的构成，如何安装 box，如何删除 box，box 版本管理，以及我们自己创建了（重新打包的）box 并将其上传到 Vagrant Cloud。然后，我们从 Vagrant Cloud 安装了该 box，并在我们的系统上进行了测试。

在第五章，使用 Vagrantfile 配置 Vagrant中，我们将重点讨论 Vagrantfile。我们之前简要提到过这个文件，但还没有充分利用它的潜力。Vagrantfile 用于配置 Vagrant，并提供了一种非常强大且易于使用的语法。你将学习如何创建 Vagrantfile，如何验证它，以及它所使用的语法。

第五章：使用 Vagrantfile 配置 Vagrant

在本章中，我们将重点介绍如何通过使用 Vagrantfile 来配置 Vagrant。我们将关注 Vagrantfile 的关键方面，如其结构和语法。在本节结束时，我们将涵盖以下主题：

• 理解 Vagrantfile

• 创建 Vagrantfile

• Vagrantfile 的结构和语法

• 排查 Vagrantfile 问题

理解 Vagrantfile

Vagrantfile 是配置 Vagrant 环境的主要方式。这个文件没有扩展名；它只是作为Vagrantfile出现在您的系统上，而不是.Vagrantfile或vagrantfile.Vagrantfile。

使用 Vagrantfile 可以管理 Vagrant 环境的依赖和设置。最好每个 Vagrant 项目有一个 Vagrantfile，并将 Vagrantfile 包含在源代码管理中。

使用 Vagrantfile 的主要好处之一是能够将该文件与任何安装了 Vagrant 的开发人员共享。他们只需运行vagrant up命令，就能拉取任何依赖项，如 boxes，并设置任何配置，使 Vagrant 环境与您的一致。

创建 Vagrantfile

在我们创建自己的 Vagrantfile 之前，首先创建并进入一个新的目录。在这个示例中，我们将创建一个名为vagrantfiletest的新目录，简化操作！按照以下顺序运行命令：

1. mkdir vagrantfiletest

2. cd vagrantfiletest

3. vagrant init

通过使用vagrant init命令，我们已经在当前的vagrantfiletest目录中初始化了一个新的 Vagrantfile，如下图所示：

默认的 Vagrantfile 有一个基本结构，可以帮助您入门。如果您希望创建一个非常简洁的 shell，您可以运行vagrant init --minimal或vagrant init -m命令，任一命令将生成一个非常基础的 Vagrantfile，没有注释或额外设置，如下所示：

Vagrant.configure("2") do |config|
 config.vm.box = "base"
 end

现在让我们继续进入下一部分，深入了解 Vagrantfile 的语法。

Vagrantfile 语法

Vagrantfile 使用 Ruby 语言语法，但不需要了解 Ruby。使用 Vagrantfile 时，它是一种简单、表达力强且易于理解的语言。在大多数情况下，您只需设置一个变量和一个值，例如config.vm.box = "ubuntu/trusty64"，该设置将 box 设置为ubuntu/trusty64，即 64 位版本的 Ubuntu 14.04。

一个 Vagrantfile 的配置包含在configure块中。第一行是Vagrant.configure("2") do |config|，最后一行是end。在这个块内，我们可以定义各种值，例如 Vagrant box、网络、文件系统、配置和更多。

Vagrantfile 选项

在本节中，我们将介绍 Vagrantfile 中可配置的各个部分。你将学习如何直接配置虚拟机、配置提供者（VirtualBox），以及配置 Vagrant 如何通过 SSH 或其他通信工具连接到你的机器。

Vagrant 机器配置（config.vm）

使用 config.vm 命名空间，我们将查看配置 Vagrant 机器的某些部分，如 box 信息和其他设置，包括同步文件夹、配置和提供者。可配置的元素如下：

• config.vm.boot_timeout 用于指定（以秒为单位）Vagrant 等待机器启动并准备好使用的时间。默认时间为 300 秒。

• config.vm.box 用于为机器设置特定的 box。你可以引用已经安装在系统上的 box，或者使用 Vagrant 云中的简写语法，如 ubuntu/trusty64。

• config.vm.box_check_update 被 Vagrant 用来检查你选择的 box 或当前机器正在使用的 box 是否是最新的。默认设置为 true，但只有某些类型的 box 可以检查更新——主要是 Vagrant 云上的 box。如果在 Vagrant 启动过程中发现更新，屏幕上会显示黄色消息提示用户。

• config.vm.box_download_checksum 用于比较 box 的校验和与给定的校验和；如果它们不匹配，则会抛出错误。Vagrant 仅在需要下载 box 时执行此检查。此值需要设置 config.vm.box_download_checksum_type 的值。

• config.vm.box_download_checksum_type 是在比较 config.vm.box_download_checksum 值使用的校验和哈希类型。这里有几个支持的选项，分别是 md5、sha1 和 sha256。

• config.vm.box_download_client_cert 用于提供在下载 box 时使用的客户端证书路径。此设置没有默认值。

• config.vm.box_download_ca_cert 用于提供直接下载 box 时使用的 CA 证书包的路径。默认值使用 Mozilla CA 证书包。

• config.vm.box_download_ca_path 用于提供在直接下载 box 时包含 CA 证书的目录路径。类似地，默认使用的值是 Mozilla CA 证书包。

• config.vm.box_download_insecure 用于验证服务器的 SSL 证书。如果设置为 true，则不进行验证。如果 box 的 URL 是 HTTPS，则会验证 SSL 证书。

• config.vm.box_download_location_trusted 用于在值设置为 true 时信任所有重定向。默认过程中，Vagrant 会信任初始请求，并使用任何指定的凭据。

• config.vm.box_url 用于设置特定的盒子 URL。这类似于 config.vm.box，但不支持 Vagrant 云的简写语法，如果在 Vagrantfile 中已设置 config.vm.box，则无需在此处指定值。指定的值可以是单个 URL 或多个 URL，Vagrant 会按顺序尝试这些 URL。如果您已经配置了其他设置（如证书），它们将应用于所有提供的 URL。Vagrantfile 也支持使用 file:// 缩写和方案来指定本地文件。

• config.vm.box_version 用于指定要使用的盒子版本。此值支持以逗号分隔的约束条件，例如 (大于或等于) >= 0.2 和 < 2.0（小于），Vagrant 会在这些约束范围内查找盒子版本。Vagrant 将尽力获取符合这些约束条件的最新盒子版本。默认值为 >= 0，表示使用最新版本。

• config.vm.communicator 用于设置连接到来宾机器的通信类型。默认值为 ssh，但建议 Windows 客户端使用 winrm。

• config.vm.graceful_halt_timeout 用于设置 Vagrant 等待机器停止的时间（单位为秒）。当使用 vagrant halt 命令时应用此设置，默认值为 60 秒。

• config.vm.guest 用于设置将运行在机器中的来宾操作系统。Vagrant 会尝试自动检测使用的正确操作系统。这些信息对于执行某些操作系统特定的操作（如网络配置）是必要的。默认值为 :linux。

• config.vm.hostname 用于为机器设置主机名。值应作为字符串提供，例如 elite。默认值为 nil，这意味着 Vagrant 不会管理主机名。如果这是一个提供者，它将在启动时设置该主机名。

• config.vm.network 用于设置机器的网络选项。这个设置有很多可用选项，稍后的章节中会详细讲解。其中一些主要选项包括 forwarded_port、private_network 和 public_network。每个选项有各种子值或子选项可以设置。

• config.vm.post_up_message 用于在运行 vagrant up 命令后显示一条消息给用户。这类似于服务器或其他软件上找到的每日消息，您可以登录查看。

• config.vm.provider 是一个配置块，用于设置特定于提供者的值。每个提供者支持不同的值，但可以有多个配置块针对不同的提供者。由于我们使用 VirtualBox 作为提供者，可以设置特定的值，例如 memory（设置内存）、cpus（设置 CPU 核心数）和 gui（当设置为 true 时，Vagrant 会在 GUI 中打开虚拟机，您可以与其交互）。

• config.vm.provision 用于指定一个配置器，它可以在创建过程中安装和配置软件。这是一个相当高级的话题，我们将在后续章节中讨论。支持的某些提供程序包括 Chef、Ansible、Puppet 和标准脚本。

• config.vm.synced_folder 用于配置主机和来宾机器之间的同步文件夹。这将允许你在系统上（在同步文件夹中）创建或编辑文件，并使该更改在 Vagrant 机器中生效并可见。

• config.vm.usable_port_range 用于指定 Vagrant 可用的端口范围。默认值或端口范围为 220..2250。Vagrant 会使用这些值来处理发生的任何端口冲突。

Vagrant SSH 配置（config.ssh）

使用 config.ssh 命名空间，我们将配置 Vagrant，使其通过 SSH 连接到来宾机器。在这里，我们将查看一些值，如 SSH 用户名、密码、端口和密钥，如下所示：

• config.ssh.username 用于设置 Vagrant 在尝试通过 SSH 连接时使用的用户名。默认用户名为 vagrant。

• config.ssh.password 用于设置 Vagrant 在尝试通过 SSH 连接时使用的密码。

• config.ssh.host 用于设置在 SSH 连接时使用的主机名或 IP 地址。默认情况下，这个值通常为空，因为提供者可以自动检测正确的值。

• config.ssh.port 用于设置用于 SSH 连接的端口。默认值为 22。

• config.ssh.guest_port 用于设置在来宾机器上运行 SSH 的端口号。Vagrant 可以将此与 config.ssh.port 一起使用，以智能地连接到正确的 SSH 端口。如果存在转发端口，通常会使用此设置。

• config.ssh.private_key_path 用于设置连接机器时要使用的私钥路径。默认值是一个不安全的密钥，Vagrant 和许多公共箱子都使用这个密钥。

• config.ssh.keys_only 用于在希望使用 Vagrant 提供的 SSH 密钥时使用。默认设置为 true。

• config.ssh.verify_host_key 用于执行主机密钥验证。默认值为 false。

• config.ssh.forward_agent 用于启用 SSH 的代理转发。默认值为 false。

• config.ssh.forward_x11 用于启用通过 SSH 转发 X11。默认值为 false。

• config.ssh.forward_env 用于向来宾机器提供一组主机环境变量。

• config.ssh.insert_key 在设置为 true（根据默认设置）时用于插入一个新的密钥对，以便与 SSH 一起使用，替代不安全的默认 Vagrant 密钥对。当设置为 true 时，该值也会与 config.ssh.password 选项一起使用。

• config.ssh.proxy_command 用于通过 stdin 通过 SSH 代理一个命令行命令。

• config.ssh.pty 不建议使用，除非你真的需要使用它。设置为 true 时，将使用 pty 进行配置。pty 可能会破坏 Vagrant 的某些功能，因此使用时要小心。

• config.ssh.keep_alive 在设置为 true 时，将每 5 秒通过 SSH 发送保持连接的包，以保持连接活跃。

• config.ssh.shell 用于设置在 Vagrant 中运行 SSH 命令时使用的 shell。

• config.ssh.export_command_template 是生成活动会话中的环境变量时使用的模板。

• config.ssh.sudo_command 用于设置运行 sudo 命令时的命令。默认值为 sudo -E -H %c，其中 %c 被替换为要运行的命令。

• config.ssh.compression 用于在通过 SSH 连接时发送压缩设置，如果设置为 true。要禁用此功能，将值设置为 false。

• config.ssh.dsa_authentication 用于在通过 SSH 连接时发送 DSA 身份验证设置，如果设置为 true。要禁用此功能，将值设置为 false。

• config.ssh.extra_args 用于将额外的命令传递到 SSH 可执行文件中。它支持单个值或一个值的数组。通过此设置，可以启用 SSH 的更多高级操作，如反向隧道。

Vagrant 设置（config.vagrant）

使用 config.vagrant 命名空间，我们将专门看一下如何配置 Vagrant。与我们已经看过的其他命名空间相比，这个命名空间中的选项并不多。config.vagrant 命名空间的命令如下：

• config.vagrant.host 用于设置运行 Vagrant 的主机。默认值为 :detect，允许 Vagrant 智能地自动检测主机。Vagrant 提供的某些功能是特定于主机的，只有在自动检测失败时才建议更改此值。

• config.vagrant.sensitive 用于提供一个不在 Vagrant 输出或日志输出中显示的项目列表或数组。这些值通常是密码或密钥。

其他 Vagrantfile 设置

还有两个其他的命名空间设置可以在 Vagrantfile 中进行配置。虽然本书不会详细讲解这些设置，但以下章节将概述它们。

WinRM 设置（config.winrm）

config.winrm 命名空间用于在使用 Windows 客户机时配置 Vagrant。要使用这些设置，必须将 config.vm.communicator 设置为 winrm。

有大约 12 个不同的配置选项可用，包括 config.winrm.username、config.winrm.password、config.winrm.port 和 config.winrm.transport。使用 config.winrm 命名空间可以让你对使用 Windows 客户机时 Vagrant 的行为有更多控制。

WinSSH 设置（config.ssh 和 config.winssh）

这使用了config.ssh命名空间，类似于我们之前讨论的命名空间。它使用了 WinSSH 软件，这是 OpenSSH 的 Windows 原生版本。Vagrant 的官方文档指出，WinSSH 处于预发布阶段，因此尚未准备好生产环境使用。

有大约 17 个不同的选项可用，它们是config.ssh和config.winssh命名空间的组合，包括：config.ssh.username、config.ssh.password、config.winssh.forward_agent、config.winssh.upload_directory以及config.winssh.export_command_template。

排查 Vagrantfile 的错误

Vagrantfile 可以是一个相当复杂的配置选项集合。它包含多个选项，如基本的字符串值、配置块、数组值等等。编写完 Vagrantfile 后，运行vagrant up或类似命令时遇到错误是非常常见的。

运行vagrant up命令后，Vagrant 错误的一个示例如下：

让我们分析前面截图中的错误。第一个线索是指向行号Vagrantfile:24，换句话说，就是 Vagrantfile 的第 24 行。这个错误还给出了错误的类型：syntax error, unexpected tIDENTIFIER, expecting keyword_end # accessing "localhost:8080" will access port on。这可能意味着某个配置块或循环没有设置结束值，或者我们尝试设置了一个不完整的变量。

在对 Vagrantfile 进行任何更改并尝试运行或配置 Vagrant 虚拟机后，检查 Vagrantfile 的一个简单方法是使用vagrant validate命令。在下面的截图中，您可以看到即使使用vagrant validate命令，我们仍然会收到相同的错误和 Vagrant 的输出：

现在让我们打开 Vagrantfile，仔细查看第 24 行，如下图所示：

查看第 24 行，我们可以看到错误中提到的值# accessing "localhost:8080" will access port 80 on。现在，虽然这只是一个注释，但我们可以看到localhost:8080的值被暴露出来，因为它被双引号（"）包裹。如果我们回溯到文件的开头，我们应该能找到第 15 行，它看起来有点奇怪。这里，我们看到的值是config.vm.box = "base，但没有关闭的双引号。

所以，让我们在这一行的末尾加上一个双引号，保存文件，并运行vagrant validate命令：

太好了！正如您在前面的截图中看到的，我们成功找到了错误并已修复。

总结

在本章中，我们学习了如何使用 Vagrantfile 配置 Vagrant。我们还查看了 Vagrantfile 的各个部分，例如如何创建它、它支持的命令、选项和值、它的语法和布局，以及如何在出现问题时进行故障排除。在接下来的章节中，我们将更多地使用 Vagrantfile，重点关注 Vagrant 的特定领域，如配置。

在第六章，Vagrant 中的网络配置，我们将了解 Vagrant 中的网络配置。在这一章中，我们将学习三种主要的网络配置类型：端口转发、公共网络和私有网络。

第六章：Vagrant 中的网络

在本章中，我们将重点讲解 Vagrant 中的网络。到本章结束时，你将对 Vagrant 中不同的网络选项有一个清晰的了解。你将能够使用简单的方法（如端口转发）来配置 Vagrant 中的网络，或者使用公共和私有网络设置自定义 IP 地址。

以下是 Vagrant 中存在的三种网络类型，你将在本章中学习到：

• 端口转发

• 私有网络

• 公共网络

端口转发

配置 Vagrant 中的网络设置有一个强大而简单的方法——使用端口转发。这不需要你具备任何高级知识或配置。

端口转发是将宿主机上的端口链接到客机上的端口。操作就是这么简单，但它可以非常强大，因为它允许你快速启动和运行。

以下是配置端口转发的步骤：

1. 打开我们的 Vagrantfile。我们将从一个非常基础的 Vagrantfile 开始，使用ubuntu/xenial64盒子和一个基本的 shell 配置脚本来安装 nginx 网页服务器：

1. 保存 Vagrantfile 后，运行vagrant up命令：

1. 一旦盒子安装完 nginx 并启动运行，打开浏览器并尝试访问localhost:8080：

1. nginx 应该可以访问（可能不在port 8080端口），但如你所见，我们无法访问它。这是因为我们还没有设置端口转发。如果我们从 Vagrant 机器内部访问 localhost，就能正常访问。

2. 运行vagrant ssh命令。进入 Vagrant 机器后，运行curl localhost命令。此时应返回 nginx 的默认页面 HTML 代码：

1. 设置端口转发，以便我们能够从宿主机（Vagrant 外部）访问该页面。

2. 退出机器并重新打开 Vagrantfile。在以下代码中（你可以在以下截图的第 8 行看到）– config.vm.network "forwarded_port", guest: 80, host: 8080：

让我们来逐步分析我们刚刚在 Vagrantfile 中添加的那行代码。首先，我们调用了config.vm.network命名空间，告诉 Vagrant 我们想要更改网络设置。我们传递的第一个参数是forwarded_port，后面跟着两个不同的端口号。第一个端口是我们将在客机/Vagrant 机器内部访问的端口。在上面的示例中，我们将访问端口 80，这通常是网站/网页服务器的默认端口。最后一个参数是宿主机端口，这是我们从宿主机连接到的端口。在我们的示例中，它是8080，通过 URL 我们可以在http://localhost:8080访问它，这将连接到 Vagrant 并访问机器的port 80。

1. 保存 Vagrantfile 并运行vagrant reload --provision命令。

2. 这将重启 Vagrant 虚拟机并强制重新执行配置过程。你会看到，在以下屏幕截图的底部，现在已经包含了我们新端口的 default: Forwarding ports... 部分：

1. 一旦 Vagrant 虚拟机完成配置并启动，尝试在浏览器中打开 localhost:8080：

你应该看到 "Welcome to nginx!" 默认页面。恭喜！你已经成功配置了 Vagrant 虚拟机的端口转发。

端口转发注意事项

在 Vagrantfile 中使用端口转发选项时，有一些技巧可以帮助你。

如果你希望转发多个端口，只需创建新的一行并添加新的 guest/host 端口。如果需要管理很多端口，可能会显得有些混乱。此时，你可能需要考虑本章后面介绍的公共和私有网络选项。

你可以使用更多的选项/参数来配置此设置：

• auto_correct：用于端口冲突处理。如果设置为 true，Vagrant 会检查是否与已使用的端口发生冲突。如果发现冲突，Vagrant 会自动更改端口号。

• guest_ip：你希望绑定到转发端口的虚拟机的 IP 地址。

• host_ip：你希望绑定到转发端口的主机的 IP 地址。

• protocol：通过转发端口允许的协议。你可以选择 udp 或 tcp 作为选项。

• id：在 VirtualBox 中可见的规则名称。它的格式为 [protocol][guest]，例如 udp111。

这些参数是可选的。然而，你必须指定 guest 和 host 端口值。

私有网络

私有网络允许将你的 Vagrant 虚拟机分配并通过私有地址空间 IP 地址进行访问。一个私有 IP 地址的例子可能是你在本地网络中见过的，如 192.168.1.2。

使用这种方法可以比端口转发方法提供更少的限制，因为默认情况下，你可以访问该本地 IP 地址上的任何可用端口。

要使用私有网络，有两种主要选项。你可以允许 IP 地址由 动态主机配置协议 (DHCP) 自动分配，或者你可以手动添加静态 IP 地址。

DHCP

按照以下步骤使用 DHCP 选项：

1. 你必须选择 dhcp 作为 type 参数的值。在你的 Vagrantfile 中，添加以下行来启用 DHCP 私有网络：

config.vm.network "private_network", type: "dhcp"

1. 保存 Vagrantfile 后，你可以运行 vagrant up --provision 来查看更改：

1. 要查找新启动的 Vagrant 虚拟机的 IP 地址，我们必须通过 SSH 进入虚拟机本身。

2. 运行 vagrant ssh 命令。进入 Vagrant 虚拟机后，运行 ifconfig 命令（此网络命令依赖于操作系统）。以下是示例输出：

1. 在enp0s8部分，您可以看到以inet addr:开头的红色下划线数值。这是我们的 Vagrant 机器正在使用的私有 IP 地址。该数值为172.28.128.3。让我们看看是否现在可以通过此 IP 地址访问该机器。

2. 在主机机器上打开 Internet 浏览器，输入在 Vagrant 机器内返回的 IP 地址。

您应该仍然在 Vagrant 机器内运行port 80上的 nginx，以查看结果。

1. 以下是我导航到该私有 IP 地址并查看从 Vagrant 机器内部提供的 nginx Web 服务器默认页面的示例：

静态 IP

要使用静态 IP 选项：

1. 将一个私有地址空间 IP 地址作为ip参数的值。在您的 Vagrantfile 中，添加以下行以启用静态 IP 私有网络：

config.vm.network "private_network", ip: "10.10.10.10"

1. 当您保存 Vagrantfile 后，请运行vagrant up --provision以强制更改。为确认更改已生效，请在主机机器上的 Internet 浏览器中输入10.10.10.10 IP 地址，查看是否显示 nginx 主页：

1. 您还可以vagrant ssh进入机器，运行ifconfig命令（这取决于操作系统），并查找返回值中的该 IP 地址：

1. 在使用（静态 IP）选项与私有网络时，您可以提供一个可选参数。auto_config参数允许您启用或禁用自动配置。如果希望手动配置网络接口，可以使用false值将其禁用：

config.vm.network "private_network", ip: "10.10.10.10", auto_config: false

我发现在某些情况下，有时必须禁用auto_config才能使静态 IP 地址正常工作。

IPv6

您还可以在 Vagrantfile 中使用类似格式指定 IPv6 地址：

config.vm.network "private_network", ip: "fd12:3456:789a:1::1"

使用 IPv6 地址不受 DHCP 选项支持，必须由主机机器/网络适配器支持。值得一提的是，IPv6 的默认子网是/64。

公共网络

Vagrant 中的公共网络可能是一个令人困惑的概念。本质上，它是私有网络，但 Vagrant 将尝试允许从主机机器外部访问（如果您的提供商和机器允许），而不仅仅允许从主机机器内部访问。

通过执行以下步骤，您应该能够通过本地网络上的另一设备的 IP 地址访问您的 Vagrant 机器。确保已安装 nginx，以便在成功通过 HTTP 连接到 IP 地址时获得通知。我已经能够在同一本地网络上使用我的智能手机查看 nginx 默认页面。如果使用private_networking选项，则此操作将无效，我的智能手机将无法加载页面或找到设备，这将导致超时。

有两种设置公共网络的主要方式：您可以使用 DHCP 或手动分配静态 IP 地址。

DHCP

开始使用公共网络的最快和最简单的方法是允许 DHCP 为 Vagrant 虚拟机分配 IP 地址：

1. 在你的 Vagrantfile 中，使用config.vm.network "public_network"来启动它。

不需要像在私有网络的 DHCP 配置中那样指定type参数。

1. 运行vagrant up --provision命令启动 Vagrant 虚拟机。由于我们使用的是公共网络，你将被提示选择一个桥接网络接口。根据你的需求和可能的试错过程，选择一个。我将选择第一个选项，1) en0: (Wi-Fi) Airport：

1. 要找出新启动的 Vagrant 虚拟机的 IP 地址，我们必须 SSH 进入虚拟机本身。运行vagrant ssh命令。进入 Vagrant 虚拟机后，运行ifconfig命令（这个网络命令将根据操作系统有所不同）。

使用 DHCP 时可以提供一个可选参数。这是DHCP 分配的默认路由。在某些情况下，这个选项可能是必需的。

1. 这个参数的示例可以是将config.vm.network "public_network", use_dhcp_assigned_default_route: true添加到你的 Vagrantfile 中。

静态 IP

配置你选择的静态 IP 地址与公共网络结合使用非常简单。你只需要在 Vagrantfile 中提供ip参数，并添加你希望使用的 IP 地址。以下是我 Vagrantfile 中的配置示例：

config.vm.network "public_network", ip: "192.168.1.123"

保存你的 Vagrantfile 并运行vagrant up --provision命令，启动 Vagrant 虚拟机。由于我们使用的是公共网络，你将被提示选择一个桥接网络接口。根据你的需求和可能的试错过程来选择一个。我将选择第一个选项，1) en0: (Wi-Fi) Airport：

网络桥接

正如你在公共网络 DHCP 和静态 IP 地址中看到的，当你运行vagrant up或vagrant up --provision命令时，系统会要求你选择使用哪个网络桥接。为了避免这一步，你可以在 Vagrantfile 中提供默认的网络桥接作为额外参数：config.vm.network "public_network", bridge: "en0: Wi-Fi (AirPort)"。

摘要

在本章中，我们讨论了如何配置和管理 Vagrant 中的网络设置。我们重点介绍了三种主要的网络类型：端口转发、私有网络和公共网络。你现在应该能够根据你的网络需求配置 Vagrant。

在第七章《多机配置》中，我们将介绍 Vagrant 的多机功能。这个酷炫的功能允许我们从一个 Vagrantfile 配置中配置并管理多个 Vagrant 虚拟机。我们将创建一个真实世界的场景，其中有多台 Vagrant 虚拟机——一台作为负载均衡器，分发 HTTP 流量到两台 Vagrant 虚拟机上，其中一台作为 Web 服务器。

第七章：多机器

在本章中，您将了解 Vagrant 的多机器功能。我们将通过多机器的各个方面，最终您应该能很好地理解以下主题：

• Vagrant 多机器简介

• 在 Vagrantfile 中配置多机器

• 通过网络连接多机器

Vagrant 多机器简介

使用 Vagrant 的多机器功能，您可以轻松管理一个 Vagrantfile 中的多个 Vagrant 机器。如果您希望将测试环境的模型与生产环境类似，这将非常有用。您可以轻松地将服务器分离，例如 Web 服务器、文件服务器和数据库服务器。

在本节中，我们将通过以下两个用例来了解如何使用多机器：

• 在第一个用例中，我们将管理三个 Vagrant 机器。在这里，我们将创建一个基本的负载均衡设置，其中一台机器将在两台提供网站服务的机器之间分配流量。

• 在第二个用例中，我们将管理两台 Vagrant 机器。我们将创建一台提供网站的机器和另一台运行 MySQL 数据库的机器。Web 机器将与数据库机器通信，以在网页上显示数据。

使用 Vagrant 多机器进行负载均衡

在本节中，我们将使用 nginx 作为 HTTP 负载均衡器，将流量分配到两台 nginx Web 机器之间。我们将使用轮询方法进行负载均衡，该方法均匀分配传入的流量。

首先，让我们设置我们的 Vagrantfile，包含这三台机器，然后使用 Ubuntu 16.04 64 位操作系统安装 nginx。

为了开始，让我们通过运行vagrant init -m命令来创建一个最小化的 Vagrantfile。之后，让我们编辑 Vagrantfile，并按如下方式创建三个配置区域：

Vagrant.configure("2") do |config|
    # Configure load balancer machine
     config.vm.define "lb1" do |lb1|
    end
    # Configure first web machine
     config.vm.define "web1" do |web1|
     end
    # Configure second web machine
     config.vm.define "web2" do |web2|
    end
 end

现在我们的 Vagrantfile 应该包含主要的|config|块，该块封装了所有代码和其中的三个define块。Vagrant 中的多机器设置非常简单；您只需定义一个新机器，然后在该块中配置该机器即可。

定义新块时，您必须为新机器指定一个名称，该名称将在配置过程中成为其引用。我设置的第一台机器命名为lb1，即负载均衡器 1。这种命名约定在处理大型 Vagrantfile 和多台机器时非常有用；当团队中多位开发人员使用和查看 Vagrantfile 时，它也很有帮助。

要定义一个新机器，请输入以下两行代码：

config.vm.define "lb1" do |lb1|
 end

这台机器现在已经准备好进行配置！如果我们运行vagrant up，什么也不会发生，因为该盒子没有值——没有盒子、网络、配置或文件处理。

让我们通过设置一个盒子和一个 IP 地址来开始配置我们的负载均衡器机器。可以通过访问lb1命名空间，在我们的配置块中进行配置，如下所示：

config.vm.define "lb1" do |lb1|
     lb1.vm.box = "ubuntu/xenial64"
     lb1.vm.network "private_network", ip: "10.0.0.10"
 end

如前面的示例所示，我们已经设置了lb1.vm.box和lb1.vm.network的值。现在我们为两个 Web 机器做相同的配置，但设置不同的 IP 地址，以便我们能够单独访问它们并避免冲突，具体如下：

 config.vm.define "web1" do |web1|
     web1.vm.box = "ubuntu/xenial64"
     web1.vm.network "private_network", ip: "10.0.0.11"
 end
 config.vm.define "web2" do |web2|
     web2.vm.box = "ubuntu/xenial64"
     web2.vm.network "private_network", ip: "10.0.0.12"
 end

我们现在已经配置了三个 Vagrant 机器，但在我们启动并测试它们之前，我们需要为它们配置 nginx 并设置 nginx 以支持我们的负载均衡设置。

让我们创建两个 shell 脚本来配置我们的机器。（我们将在后续章节中更深入地讲解 shell 脚本；这里我们使用它来展示它如何在多机器环境中工作。）

在你Vagrantfile所在的目录下，创建一个lb.sh文件和一个web.sh文件。

lb.sh

让我们先关注lb.sh文件。将以下行添加为该文件的内容：

#!/bin/bash
echo 'Starting Provision: lb1'
 sudo apt-get update
 sudo apt-get install -y nginx
 sudo service nginx stop
 sudo rm -rf /etc/nginx/sites-enabled/default
 sudo touch /etc/nginx/sites-enabled/default
 echo "upstream testapp {
     server 10.0.0.11;
     server 10.0.0.12;
 }
server {
     listen 80 default_server;
     listen [::]:80 default_server ipv6only=on;
    root /usr/share/nginx/html;
     index index.html index.htm;
    # Make site accessible from http://localhost/
     server_name localhost;
    location / {
         proxy_pass http://testapp;
     }
}" >> /etc/nginx/sites-enabled/default
 sudo service nginx start
 echo "Machine: lb1" > /var/www/html/index.html
 echo 'Provision lb1 complete'

上面的代码片段包含了很多内容，我们来逐一分析。

在第一部分，我们声明了应该运行此脚本的程序位置（bin/bash），这在 shebang（#!）之后。

在第 2 到第 7 行，我们正在更新 Ubuntu、安装 nginx 并删除默认的 nginx 配置文件。

在第 8 到第 22 行，我们插入了新的配置作为默认的 nginx 配置，基本上设置了负载均衡并将我们的可用 Web 服务器设置为10.0.0.11和10.0.0.12。

在第 23 到第 25 行，我们启动了 nginx 服务（它将读取我们的新默认配置文件并应用这些设置），设置了默认的 index HTML 文件，并完成了配置过程。

我们在配置脚本的开始和结束时分别使用echo输出Starting Provision: lb1和Provision lb1 complete。这虽然不是必须的，但当你运行vagrant up --provision命令时，你会看到这些信息输出到终端，这在你尝试理解发生了什么以及当前处于配置过程的哪个阶段时非常有用。

web.sh

现在让我们创建web.sh bash 脚本，它将处理我们 Web 服务器的配置。这个脚本比我们之前创建的负载均衡器脚本简单很多，内容如下：

#!/bin/bash
echo 'Starting Provision: web'$1
 sudo apt-get update
 sudo apt-get install -y nginx
 echo "<h1>Machine: web"$1 "</h1>" > /var/www/html/index.html
 echo 'Provision web'$1 'complete'

同样，在前面的代码片段中，我们在配置进度的开始和结束时回显了进度信息。在第 2 到第 4 行，我们更新了 Ubuntu 并安装了 nginx。在第 5 行，我们用一个基本的标题覆盖了默认的 index HTML 文件，这将帮助我们区分两个 Web 服务器。

在这个脚本中，你会注意到使用了$1。这是 bash 中的一个变量，引用的是第一个参数。在接下来的章节中，你将学习如何将参数传递给 shell 脚本，因为这将帮助我们区分 Web 服务器 1 和 Web 服务器 2。

Vagrant 多机器 shell 配置

现在我们已经设置好了lb.sh和web.sh配置脚本，让我们将它们添加到 Vagrantfile 中，准备好设置和测试我们的负载均衡应用。

以下代码块是我们完整的 Vagrantfile 副本：

Vagrant.configure("2") do |config|
    # Configure load balancer machine
     config.vm.define "lb1" do |lb1|
         lb1.vm.box = "ubuntu/xenial64"
         lb1.vm.network "private_network", ip: "10.0.0.10"
         lb1.vm.provision :shell do |shell|
             shell.path = "lb.sh"
         end
     end
    # Configure first web machine
     config.vm.define "web1" do |web1|
         web1.vm.box = "ubuntu/xenial64"
         web1.vm.network "private_network", ip: "10.0.0.11"
         web1.vm.provision :shell do |shell|
             shell.args = "1"
             shell.path = "web.sh"
        end
    end
    # Configure second web machine
     config.vm.define "web2" do |web2|
         web2.vm.box = "ubuntu/xenial64"
         web2.vm.network "private_network", ip: "10.0.0.12"
         web2.vm.provision :shell do |shell|
             shell.args = "2"
             shell.path = "web.sh"
        end
     end
end

我们可以使用 .vm.provision 命名空间来配置一个盒子。在前面的示例中，你可以看到我们通过 shell.args 值将参数传递给 web1 和 web2。这些值将可以在我们的 web.sh 脚本中访问。

现在，保存你的 Vagrantfile 并运行 vagrant up --provision 命令来启动并配置机器。你会注意到启动过程比平时要长，因为现在需要管理三台机器，而不是通常的那一台。

在启动过程中，你应该会注意到我们在配置过程的不同阶段打印的回显语句，如下图所示：

在前面的截图中，你会看到 lb1 的配置器已经启动。在接下来的截图中，你会看到 web2 的配置器已经完成：

当 Vagrant 机器启动完成后，我们可以继续并测试负载均衡器。为此，我们将负载均衡器的 IP 地址设置为 10.0.0.10 并在浏览器中打开。你应该能看到其中一台网页服务器机器，如下图所示：

现在，如果你刷新页面，负载均衡器应该会将你的请求发送到另一个网页服务器机器，正如下图所示：

如果你持续刷新页面，你会在两台网页服务器之间切换。你还可以通过直接访问它们的 IP 地址，去到某一台网页服务器。例如，如果你在浏览器中访问 10.0.0.11，你将只会看到网页服务器 1 机器，如下图所示：

恭喜！你已经成功配置了一个多机器的 Vagrant 环境，并设置了基本的 HTTP 负载均衡。

多机 SSH

现在，机器已启动并运行，你可能想通过 SSH 连接到它们，进行一些更改并进行测试。为此，我们可以运行 vagrant ssh 命令。这时会给出一个错误，如下图所示：

在这里，我们必须指定机器名称，否则 ssh 命令将不知道我们要连接哪台机器。提供的名称应该是我们在 Vagrantfile 中定义的名称，例如 lb1、web1 或 web2。现在，我们通过运行 vagrant ssh lb1 命令来 SSH 连接到负载均衡机器，如下所示：

你现在可以通过 SSH 单独管理每台机器。

让我们通过停止并销毁机器来完成机器生命周期。我们可以通过运行 vagrant halt 命令来停止所有三台机器，如下图所示：

接下来，如果你愿意，你可以销毁你的机器以释放系统内存。运行 vagrant destroy -f 命令。在我们的示例中，我们使用 -f 标志强制销毁机器，否则会提示我们每台机器都进行确认。运行以下命令：

如你在前面的截图中看到的，命令告诉 Vagrant 循环遍历每台机器并销毁它们。

使用 Vagrant 多机配置的 Web 服务器和数据库设置

在本节中，我们将使用 Vagrant 的多机功能来创建一个传统的 Web 服务器和数据库设置。我们将在一台机器上安装 Web 服务器（nginx 和 PHP），在另一台机器上安装数据库服务器（MySQL）。

这个设置比上一节中的更简单，但它仍然有助于加深对如何设置和管理 Vagrant 多机环境的理解。

首先，让我们在一个新的文件夹中创建一个新的 Vagrantfile。我们将创建两台机器来开始，具体如下：

Vagrant.configure("2") do |config|
    # Configure web server machine
     config.vm.define "web1" do |web1|
         web1.vm.box = "ubuntu/xenial64"
         web1.vm.network "private_network", ip: "10.0.0.50"
         web1.vm.provision :shell do |shell|
             shell.path = "web.sh"
         end
     end
    # Configure database server machine
     config.vm.define "db1" do |db1|
         db1.vm.box = "ubuntu/xenial64"
         db1.vm.network "private_network", ip: "10.0.0.51"
         db1.vm.provision :shell do |shell|
             shell.path = "db.sh"
         end
     end
end

同样，我们将为这些机器使用 shell 配置。我们将使用 Ubuntu 16.04 镜像，并启用私有网络，每台机器将获得自己的私有 IP 地址。

web.sh

现在让我们创建我们的 web 服务器配置脚本来安装 nginx 和 PHP。在 web.sh 文件中，我们输入以下代码：

#!/bin/bash
echo 'Starting Provision: web server'
 sudo apt-get update
 sudo apt-get install -y nginx
 touch /var/www/html/index.php
 sudo apt-get install -y php-fpm php-mysql
 echo 'Provision web server complete'

我们将需要登录到机器上手动进行一些配置更改，但前面的代码片段将为我们提供一个良好的开端。

db.sh

我们现在可以创建我们的数据库服务器配置脚本来安装 MySQL。在 db.sh 文件中，我们输入以下代码：

#!/bin/bash
echo 'Starting Provision: database server'
 sudo apt-get update
 echo 'Provision database server complete'

这个阶段还需要一些手动配置，我们可以通过登录到数据库机器来完成。

现在让我们通过运行 vagrant up --provision 命令启动我们的 Vagrant 机器。

Nginx 和 PHP 配置

现在让我们在我们的 web 服务器机器上配置 Nginx 和 PHP。通过运行 vagrant ssh web1 命令登录到该机器。

一旦登录，我们需要完成 nginx 的配置。这可以通过以下命令编辑默认配置文件来完成：

sudo nano /etc/nginx/sites-available/default

我们现在需要在这个文件中添加 PHP，以便 nginx 处理 PHP 文件和代码。我们需要编辑的第一行是索引文件列表，找到以下行：

index index.html index.htm index.nginx-debian.html;

将其更改为以下内容：

index index.php index.html index.htm index.nginx-debian.html;

我们需要执行的最后一个更改是添加 PHP 处理。这需要我们在主 server {} 块中编辑一个代码块。以下代码片段是我们需要编辑的内容：

 #location ~ \.php$ {
 #    include snippets/fastcgi-php.conf;
 #
 #    # With php7.0-cgi alone:
 #    fastcgi_pass 127.0.0.1:9000;
 #    # With php7.0-fpm:
 #    fastcgi_pass unix:/run/php/php7.0-fpm.sock;
 #}

将前面的代码片段更改为以下内容：

location ~ \.php$ {
     include snippets/fastcgi-php.conf;
    # With php7.0-fpm:
     fastcgi_pass unix:/run/php/php7.0-fpm.sock;
 }

现在保存并关闭文件。如果需要，你可以使用 sudo nginx -t 命令来测试你刚刚编辑的配置文件的代码和语法。成功消息如下：

现在让我们重新启动 nginx 以应用新的设置；为此，请运行以下命令：

sudo systemctl reload nginx

为了确认 PHP 已安装并正常工作，请在 /var/www/html/ 目录中创建一个 test.php 文件。在 test.php 文件中，添加以下行：

<?php
phpinfo();
?>

保存文件后，在主机机器的 web 浏览器中，打开 http://10.0.0.50/test.php。你现在应该能够看到 PHP 信息页面，如下图所示：

在我们这里时，应该返回到 test.php 文件并编辑其内容。接下来，我们将创建一个基本的 PHP 脚本，连接到我们的 MySQL 数据库并检索一些数据。请编辑文件，使其包含以下代码段：

<?php
$conn = new mysqli("10.0.0.51", "external", "password", "VagrantDatabase");
$result = $conn->query("SELECT VagrantText FROM VagrantTable WHERE VagrantId = 1");
while($row = $result->fetch_assoc()) {
     echo $row['VagrantText'];
 }
?>

这是一个非常基础的脚本，用于帮助您入门。此脚本并不安全，也未必遵循 PHP 最佳实践。建议不要在生产环境中使用此脚本。

在继续之前，我们必须在另一台 Vagrant 机器上设置 MySQL 服务器，否则 PHP 脚本将因没有数据库而失败。

MySQL 配置

让我们通过安装和配置 MySQL 数据库来完成设置。在本节的末尾，您应该能够看到最终的工作代码，并且您的 Web 服务器可以通过 PHP 访问数据库服务器。

不建议在生产环境中使用此配置。我们没有遵循安全最佳实践，而是进行了基本的配置设置。

按照以下步骤配置 MySQL 数据库：

1. 首先，通过运行 vagrant ssh db1 命令 SSH 进入数据库机器。

2. 现在通过运行以下命令安装 MySQL：run sudo apt-get install mysql-server。

接下来，系统会要求您设置一个 root 密码。您可以设置任何密码，因为我们并没有将其用作生产环境。接着，系统会要求您重复并确认 root 密码。

现在，您可以通过终端运行 mysql -u root -p 登录 MySQL。请输入您刚刚设置的 root 密码。

我们现在必须创建一个基本的 MySQL 用户，并赋予其正确的权限，以便从本地主机以外的地址和网络访问数据库。如果没有这个设置，我们将无法从 web1 机器访问数据库，所以请运行以下命令：

CREATE USER 'external'@'localhost' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON *.* TO 'external'@'localhost' WITH GRANT OPTION;
CREATE USER 'external'@'%' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON *.* TO 'external'@'%' WITH GRANT OPTION;
FLUSH PRIVILEGES;

现在，我们可以创建一个表并插入一些测试数据，这些数据将通过 web1 机器上的 PHP 进行访问。运行以下命令来创建一个新数据库、新表，并插入一些数据：

CREATE DATABASE VagrantDatabase;
USE VagrantDatabase;
CREATE TABLE VagrantTable (VagrantId int, VagrantText varchar(255));
INSERT INTO VagrantTable (VagrantId, VagrantText) VALUES (1, "This text is from MySQL");

现在，您可以退出 MySQL CLI 工具。接下来，我们必须配置最后一个 MySQL 设置，以允许来自 web1 机器的连接。我们需要编辑 mysqld.cnf 配置文件，可以通过运行以下命令来完成：

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

查找以下行：

bind_address = 127.0.0.1 

将其更改为以下内容：

bind_address = 0.0.0.0

现在，您可以保存文件并运行以下命令。这将重新启动 MySQL，使其使用新的配置：

sudo service mysql restart

现在，我们可以退出 MySQL CLI，并访问 http://10.0.0.50/test.php 来访问我们的数据库，如下图所示：

恭喜！您已经成功设置了 Vagrant 多机环境，使用两台机器分别作为 Web 服务器和数据库架构。

总结

在本章中，我们了解了 Vagrant 的多机功能，并创建了两个使用案例：三个机器进行负载均衡和两台机器的 Web 服务器与数据库架构。

在第八章，探索 Vagrant 插件与文件同步，我们将学习 Vagrant 插件以及如何在主机和 Vagrant 客机之间同步文件。

第八章：探索 Vagrant 插件和同步文件

本章将介绍 Vagrant 中强大且额外的功能。我们将学习 Vagrant 插件以及如何在主机和客户机之间同步文件。到本章结束时，你将对以下内容有一个较好的理解：

• 了解 Vagrant 插件

• 管理 Vagrant 插件

• Vagrant 插件命令和子命令

• 查找、安装和使用 Vagrant 插件

• Vagrant 文件同步

• 文件同步 — 共享文件夹、Rsync 和 NFS

了解 Vagrant 插件

Vagrant 提供了许多选项和功能，但当你需要的功能不可用时，可以通过插件的形式扩展其功能。Vagrant 提供了一个强大且灵活的内部 API，易于使用且开发灵活。Vagrant 实际上为许多核心功能使用了自己的 API。

Vagrant 插件的构成

Vagrant 插件由多个部分组成。有些部分用于开发，其他部分则用于插件的常规使用。我们将重点关注两个核心部分：gem 和 bundler。

Gem

gem 是一个特定的 Ruby 文件，使用 .gem 文件扩展名。gem 由三部分组成：包括逻辑、测试和实用工具的代码；文档；以及包含作者信息和其他元数据的 gemspec。gem 文件是 Vagrant 插件的核心部分，并且是你在 Vagrant 虚拟机中使用插件时运行的代码。

bundler

bundler 是 Vagrant 使用并与之交互的应用程序，用于管理插件及其插件依赖。它通常用于 Ruby 项目中，用于管理 gem 以及 gem 的版本控制。你经常会在安装 Vagrant 插件失败时在控制台中看到 bundler 的输出。由于 Vagrant 插件是用 Ruby 编写并保存为 gem 文件，使用 bundler 是一个很好的选择。

管理 Vagrant 插件

在这一部分，我们将讨论插件的常规管理，包括安装和卸载。管理 Vagrant 插件时最常用的命令是 list 命令。运行以下命令可以查看你在系统上安装了哪些插件：

vagrant plugin list

有可能你没有安装任何插件，这时你会看到 No plugins installed 消息。如果你已经安装了插件，你会看到类似以下的插件列表：

Vagrant 插件安装方法

要开始使用 Vagrant 插件，你必须先在系统上安装它。目前有两种安装插件的方式：你可以使用本地文件或 gem 源。我们将探讨这两种方式。

从本地文件安装 Vagrant 插件

从本地源安装插件相当快捷且简单。你可能有本地文件，因为你自己开发了该插件，或者朋友或公司私下提供了此插件代码给你。

本地文件将使用 .gem 扩展名。要安装插件，你必须知道相对于你希望安装/使用插件的文件夹的位置。我将安装名为 testplugin.gem 的插件，它位于当前 Vagrant 项目目录中的 test-plugin 文件夹里。以下是要运行的示例命令：

vagrant plugin install /test-plugin/testplugin.gem

Vagrant 和 bundler 将尝试定位并安装插件。如果无法找到插件，将显示以下错误信息：

如果插件有问题，比如 gem 文件中的语法错误，你将看到类似以下的消息：

从已知的 gem 源安装 Vagrant 插件

安装插件的第二种方式是从已知的 gem 源安装。已知的 gem 源是一个远程仓库，bundler 系统将尝试从中定位并安装 gem。最流行的 gem 源是 RubyGems，这是一个 Ruby gem 托管服务。

让我们通过这种方法安装一个新插件。以下是要运行的示例命令：

vagrant plugin install vagrant-hostsupdater

你将在接下来的章节中学习更多关于安装和管理插件的内容。

Vagrant 插件命令和子命令

Vagrant 中的 plugin 命令提供了多个命令和子命令。我们在第七章《多机配置》中已经介绍过这些内容，多机配置，但我们将在这里作为基本参考和提醒。

你可以通过运行 vagrant plugin help 命令查看插件命令的列表。让我们深入了解每个可用插件子命令：

• 要删除所有用户安装的插件和插件数据，运行 vagrant plugin expunge 命令。

• 要安装插件，运行 vagrant plugin install 命令。需要额外的参数，可以通过运行 vagrant plugin install -h 命令查看。

• 要为专有的 Vagrant 插件安装许可证，运行 vagrant plugin license 命令。需要额外的参数，可以通过运行 vagrant plugin license -h 命令查看。

• 要查看已安装的 Vagrant 插件列表，运行 vagrant plugin list 命令。

• 要尝试修复插件损坏或安装过程中的问题，运行 vagrant plugin repair 命令。

• 要卸载 Vagrant 插件，运行 vagrant plugin uninstall 命令。需要额外的参数，可以通过运行 vagrant plugin uninstall -h 命令查看。

• 要更新 Vagrant 插件，运行 vagrant plugin update 命令。需要额外的参数，可以通过运行 vagrant plugin update -h 命令查看。

在后续章节中，我们将把这些命令应用到更真实的场景中，学习如何与 Vagrant 插件进行互动。

查找、安装和使用 Vagrant 插件

在本节中，我们将学习如何查找、安装和使用 Vagrant 插件。这将帮助你更好地理解 Vagrant 插件生态系统，并提供一些查找好插件的技巧。

Vagrant 插件没有官方的仓库或网站（像 Vagrant boxes 的 Vagrant cloud），但有一些网站可以帮助你找到完美的插件：

• RubyGems (rubygems.org/)

• GitHub (github.com/)

• 搜索引擎

• 社区更新的 GitHub，列出了流行的插件 (github.com/hashicorp/vagrant/wiki/Available-Vagrant-Plugins)

RubyGems 和 GitHub 都是基于代码托管的网站，并提供强大的搜索功能。当搜索插件时，我发现 Google 非常有用。尝试使用不同的搜索词来找到符合要求的插件。例如，如果我正在寻找一个用于管理或与 Vagrant 中的 DNS 交互的插件，可以尝试 vagrant plugin dns 或 vagrant dns plugins。

安装 Vagrant 插件

让我们从 RubyGems 网站安装一个插件。我搜索了 vagrant，找到了一个名为 vagrant-hostsupdater 的插件，它的当前版本是 1.1.1.160，并且已经有超过 50 万次下载。以下是插件在 RubyGems 搜索结果中的截图：

这个插件会尝试在 Vagrant 虚拟机创建和销毁时编辑你的 /etc/hosts 文件，添加或删除主机。这意味着你可以通过像 machine.dev 这样的域名而不是 192.168.10.10 来访问 Vagrant 虚拟机。

我们可以通过运行以下命令来安装这个插件：

vagrant plugin install vagrant-hostsupdater

你应该看到类似于以下内容的输出：

我们可以通过运行 vagrant plugin list 命令来验证该插件是否已安装，如下所示：

现在让我们使用并测试我们的 Vagrant 插件。这个特定的插件已在 Vagrantfile 中配置，所以我们先创建一个基本的 Vagrantfile 来开始使用：

1. 运行 vagrant init -m 命令。

2. 编辑你的 Vagrantfile，添加以下代码：

Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/xenial64"
  config.vm.network :private_network, ip: "192.168.100.23"
  config.vm.hostname = "vagrant.dev"
  config.vm.provision "shell", inline: <<-SHELL
    sudo apt-get update
    sudo apt-get install -y nginx
  SHELL
end

我们创建一个基本的 Vagrant 虚拟机来测试我们的插件。我们关注的主要行是 config.vm.network 和 config.vm.hostname，因为它们是插件所必需的。

我们创建了一个使用私有静态 IP 地址、主机名为 vagrant.dev 的 Ubuntu 虚拟机，并使用基本的 shell 提供者来更新系统，然后安装 nginx Web 服务器。这将使我们能够快速查看一切是否正常工作，因为 nginx 安装并启动后，默认页面可以通过 80 端口访问。

1. 运行 vagrant up --provision 命令来启动并运行 Vagrant。

现在你应该会看到来自 [vagrant-hostsupdater] 插件的消息，它会尝试将虚拟机的 IP 地址和主机名写入 /etc/hosts 文件。hosts 文件是一个重要的系统文件，需要 root 权限才能编辑。系统会提示你输入主机机器的 root 密码：

1. 为了测试插件是否正常工作，我们可以在启动 vagrant 机器之前检查 /etc/hosts 文件。以下是一个基本示例。如果你之前编辑过文件，可能会看到更多条目：

1. 一旦你输入了 root 密码并且插件成功写入了 /etc/hosts 文件，你应该在 vagrant up 过程的一部分中看到这个消息：

1. 一旦机器启动并运行，重新检查 /etc/hosts 文件，看看是否添加了新条目。所有新条目都会被添加到文件的底部。在下面的截图中，我们可以看到我们的条目已经添加，IP 地址是 192.168.100.23，主机名是 vagrant.dev。插件还使用 # 字符添加了注释：

1. 很棒！现在让我们测试主机名，看看会得到什么。在终端中，我们可以运行 curl vagrant.dev 命令，它将尝试加载该 URL 并返回内容。我们可以看到返回的是默认的 nginx 页面：

1. Ping 主机名以查看是否有活动连接、丢包情况以及我们得到的连接时间。由于机器是本地的，速度非常快（小于 1 毫秒），我们将看到返回的 IP 地址，这个例子中是 192.168.100.23：

1. vagrant halt 机器。你会在终端中看到插件开始起作用并从 /etc/hosts 文件中移除该条目。你需要再次输入 root 密码：

卸载 Vagrant 插件

现在让我们卸载 vagrant-hostsupdater 插件。我们可以通过运行 vagrant plugin uninstall vagrant-hostsupdater 命令来卸载它。如果你不确定插件的名称，可以运行 vagrant plugin list 命令查看系统中已安装的插件列表。插件现在应该已经被移除，你应该看到 Successfully uninstalled 消息：

我们还可以通过运行 vagrant plugin list 命令来验证插件是否已被移除。我们应该看到 No plugins installed 消息（前提是系统中没有其他插件）：

Vagrant 文件同步

文件同步是共享主机和在 Vagrant 中运行的虚拟机之间文件的方式。它允许你在主机上编辑文件，并能在虚拟机中看到这些变化，反之亦然。

Vagrant 称之为 同步文件夹，并提供了五种方式来实现：

• 基本同步

• SMB

• VirtualBox

• RSync

• NFS

在本节中，我们将介绍基本用法、RSync 和 NFS。

设置同步文件夹

要开始使用，先通过运行 vagrant init -m 命令创建一个 Vagrantfile。我们将从基本的同步用法开始，然后介绍 RSync，最后讲解 NFS。

我们将在宿主系统上创建一个文件，修改其内容，然后在 Vagrant 机器上查看该文件。接着，我们将在 Vagrant 机器上编辑文件，并查看它在宿主机上的变化。这将证明文件可以通过宿主机和 Vagrant 机器双向编辑。

我们需要在 Vagrantfile 中创建并编辑 config.vm.synced_folder 设置。

基本用法的同步文件夹

Vagrant 中同步文件夹的基本用法很容易设置。我们可以通过一个基本的 Vagrantfile 就开始：

Vagrant.configure("2") do |config|
    config.vm.box = "ubuntu/xenial64"
    config.vm.synced_folder ".", "/home/vagrant/files"
end

我们先关注第三行。synced_folder 配置接受两个参数。第一个参数是宿主机上的文件夹，第二个参数是 Vagrant 机器内的文件夹。

在这个示例中，我们将第一个参数设置为 "."，这是宿主机上 Vagrantfile 所在的当前目录。在第二个参数中，我们将文件夹设置为 Vagrant 机器上的"/home/vagrant/files"。

Vagrant 机器上的默认文件夹是"/home/vagrant"，但如果我们尝试将其设置为第二个参数，当该文件夹挂载到"/home/vagrant/.ssh/authorized_keys"时，会发生错误，导致无法通过 SSH 访问 Vagrant 机器，因为 SSH 密钥无法上传和检查。

现在我们来测试新的文件夹同步配置：

运行 vagrant up --provision 命令。你应该会看到 Vagrant 机器输出类似的内容：

现在我们可以通过 SSH 进入机器，查看 files 文件夹是否已经创建（如果尚未创建）。你可以运行 ls 命令来列出当前目录中的文件和文件夹。现在应该能看到 files 文件夹：

现在我们在 files 文件夹内创建一个文件：

1. 通过运行 cd files 命令进入该文件夹

2. 通过运行 touch test-file.txt 命令创建一个文本文件

3. 通过运行echo "Hello from Vagrant!" > test-file.txt命令添加一些内容

现在，我们可以通过运行exit命令退出 Vagrant 机器。现在，你可以在宿主机的目录中查找文件。你可以通过终端或文本编辑器来完成这项操作。我将使用 Atom 文本编辑器。

在以下截图中，我们可以看到我们在目录中创建的文件及其内容：

恭喜！你已经成功配置了同步文件夹，并在宿主机和 Vagrant 机器之间同步了文件。

使用 RSync 的同步文件夹

当在 Vagrant 中使用 RSync 作为 同步文件夹 选项时，它的设置稍微复杂一些。当其他文件同步选项不可用时（例如我们之前看过的基本用法，或下一个章节中的 NFS 选项），可以使用 RSync。

要开始使用 RSync，我们的 Vagrantfile 只需要在 config.vm.synced_folders 选项中添加一个额外的参数：

config.vm.synced_folder ".", "/home/vagrant/files", type: "rsync"

要使用此选项，主机和 Vagrant 虚拟机都必须安装 rsync。如果可能，Vagrant 会尝试在 Vagrant 虚拟机上安装 rsync，如果不能，它会显示错误信息。

有一些额外的参数可以与 RSync 选项一起使用。请查看官方文档，获取最新的参数列表。这些包括排除某些文件的功能。

RSync 通常会执行一次性从主机到虚拟机的同步，除非在 Vagrantfile 中将 rsync_auto 选项设置为 true。这是 Vagrant 的默认值，但可以通过将 rsync_auto 选项设置为 false 来更改。

使用 NFS 同步文件夹

使用 NFS 作为同步主机和 Vagrant 虚拟机之间文件夹的解决方案，通常可以提供性能优势或更好地适应所需的环境。

使用 NFS 与 Vagrant 中的 basic usage 版本的同步文件夹非常相似。我们的 Vagrant 文件只需要在 config.vm.synced_folders 选项中添加一个额外的参数：

config.vm.synced_folder ".", "/home/vagrant/files", type: "nfs"

我们添加了 type 选项，值为 nfs。要使其生效，Vagrant 虚拟机中的操作系统必须支持 NFS。

主机也必须支持 NFS，通过运行 NFS 服务器守护进程 nfsd 软件包。macOS X 默认预装此包，但如果主机使用 Linux，你可能需要自行安装它。

Vagrant 的 NFS 同步文件夹在 Windows 主机上无法使用。如果你尝试在 Vagrantfile 中配置此选项，Vagrant 会忽略它。如果你使用 VirtualBox 作为提供程序，在使用 NFS 时，还需要配置私有网络。如果你使用 VMWare，则无需担心。

总结

在本节中，我们学习了 Vagrant 的两个主要功能。我们了解了 Vagrant 中的插件，学习了它们是什么、如何工作，以及如何安装/卸载和使用它们。我们还了解了 Vagrant 中的文件同步，明白了如何使用多种不同的方法在主机系统和 Vagrant 虚拟机之间同步文件。

在第九章，Shell 脚本 - 配置，我们将开始配置系列章节的第一部分。我们将学习 Vagrant 中的配置，并了解如何使用 Shell 脚本来配置 Vagrant 虚拟机。接下来的章节将深入介绍如何使用配置管理工具（如 Chef）进行配置。

第九章：Shell 脚本 - 配置

在本章中，我们将研究 Vagrant 配置。我们将重点介绍基本概念以及 Shell 脚本配置。到本章结束时，你将对以下内容有一个很好的理解：

• Vagrant 配置

• 理解配置管理

• 使用文件进行 Vagrant 配置

• Vagrant shell 配置

• Vagrant 内联脚本、外部脚本和脚本参数

Vagrant 配置介绍

在 Vagrant 中配置的思想是创建一个脚本，准备并安装软件到 Vagrant 机器上。配置可以通过在 Vagrantfile 中使用 shell 配置器或外部文件进行内联。配置会在 vagrant up 过程中发生，机器正在创建时。

在配置 Vagrant 机器时，有许多选项：

• 安装软件

• 修改配置

• 操作系统级别的更改

• 系统设置

理解配置管理

在后续章节中，我们将进一步了解如何在 Vagrant 中使用配置管理工具进行配置。在讨论 Vagrant 配置时，这将是一个良好的配置管理入门。

配置管理工具包括 Chef、Ansible 和 Salt。我们将专注于这三种工具。配置管理本质上是另一个表示配置的词汇，用于将机器设置为所需状态——这可以是安装软件或配置某些设置。

配置管理工具通常具有专门的文件类型或语法。我们将重点关注以下软件：

• Ansible（使用剧本）

• Chef（使用食谱）

• Docker（使用镜像）

• Puppet（使用清单）

• Salt（使用状态）

配置管理通常在开发和部署过程中需要更强大和灵活的选项时使用。使用配置管理工具的一个好处是关注点的分离。本质上，你不会依赖 Vagrant 处理太多操作，以防你遇到问题，或者你希望具备能够更换配置管理工具的灵活性。这可能是由于公司决策，考虑到预算或安全性等因素。

Vagrant 配置的基础用法

为了开始配置我们的 Vagrant 机器，我们可以创建一个新的 Vagrantfile。我们可以通过运行 vagrant init -m 命令来实现。

在我们的 Vagrantfile 中，我们可以使用 config.vm.provision 代码定义配置块，并传递一个值声明我们将使用哪种类型的配置器。在下面的示例中，我们将使用 shell 类型：

config.vm.provision "shell"

使用 shell 配置器时，可以在内联中定义额外的值：

config.vm.provision "shell", inline "sudo apt-get update -y"

或者使用配置块，在其中我们可以在管道字符内定义我们的 shell 值：

config.vm.provision "shell" do |shell|
     shell.inline = "sudo apt-get update -y"
 end

在这个例子中，两种选项都会更新系统包。使用配置块方法更容易阅读，因为每个值可以单独占一行。

Vagrant 配置命令

一旦你创建了配置值，就该将这些更改应用到 Vagrant 虚拟机了。你有几个选项：

• 当你第一次运行vagrant up命令时，系统会读取 Vagrantfile 并运行配置脚本。

• 如果你的机器已被停止，或者你希望强制配置，可以运行vagrant up --provision来启用配置。

• 你也可以使用--no-provision标志来禁用配置。

• 在配置块中，你可以设置run键并指定always值，这将强制配置脚本在每次启动机器时运行。例如，config.vm.provision "shell", inline: "sudo apt-get update -y", run: "always"。

最后一种选择仅在没有设置--no-provision标志时有效。

使用文件进行 Vagrant 配置

Vagrant 文件选项提供了一种简便的方法，在启动过程中将文件从主机复制到 Vagrant 虚拟机。

这是一种上传配置文件的绝佳方式，这些文件通常需要由软件创建，或者在软件开始工作之前可能是必需的。例如，.env文件用于存储环境变量，如数据库连接信息或特殊密钥。

有两个可用的选项——你可以从主机复制/上传一个单独的文件或整个目录到虚拟机中。

使用这个选项时，我们在 Vagrantfile 中将配置选项设置为file，例如：

config.vm.provision "file"

单个文件

从主机上传文件到虚拟机既快速又简单。我们只需要将配置类型设置为file，源文件设置为主机上的文件，目标文件夹设置为：

Vagrant.configure("2") do |config|
     config.vm.provision "file", source: "secret.env", destination: "secret.env"
 end

这将把我们的secret.env文件复制到 Vagrant 虚拟机的主目录中。

如果secret.env文件不存在，Vagrant 将在启动过程中抛出错误：

如果文件确实存在，你将在启动过程中看到类似以下内容的输出：

在运行vagrant ssh命令并连接到虚拟机后，我们可以运行ls命令列出目录中的文件。现在我们将看到secret.env文件：

目录

另一种选择是将文件和文件夹的目录从主机上传到虚拟机。如果你需要多个资源文件，如图像或配置文件，并且希望它们在一个独立且可管理的方式中，这将非常有用。

将这个选项添加到 Vagrantfile 中时，它与文件选项非常相似：

Vagrant.configure("2") do |config|
     config.vm.provision "file", source: "secretfolder", destination: "$HOME/newsecretfolder"
 end

我们将源值设置为当前 Vagrant 目录中的一个文件夹。如果文件夹位于主机系统的其他位置，你也可以指定绝对路径。

目标文件夹可以使用$HOME变量，在我们的来宾机器的主文件夹中创建新文件夹。此文件夹可以与来宾机器上的现有文件夹同名，或使用一个新名称，这取决于你的需求。

我们可以运行vagrant up --provision命令来启动 Vagrant 机器。在此过程中，我们将在输出中再次看到该消息：

一旦机器启动并运行，我们可以运行vagrant ssh命令连接到机器并运行ls命令。然后我们将在主目录中看到该文件夹。如果我们运行ls newsecretfolder/命令查看新文件夹的内容，将看到secret.env文件：

请注意：与同步文件夹功能相比，使用此选项时，主机/本地机器上的任何更改将不会反映到来宾机器上。

Vagrant Shell 配置器

我们已经看到如何使用基本的 shell 配置器，但根据你的设置和所需的环境，你可能会有一个非常大且复杂的配置器脚本。这个脚本可能需要参数或环境变量，或者可能链接到其他地方托管的外部资源。

在本节中，我们将查看使用 shell 作为 Vagrant 配置器时提供的众多选项。这通常是初学者使用的，但它非常强大且灵活，尤其是当你不想设置像 Chef 和 Ansible 这样的配置管理工具时。

使用 shell 配置器时，有一些可选的配置设置：

• args：这些是你为配置脚本指定的参数。可以是一个字符串或一个值的数组。

• env：这是传递给脚本的键值对（哈希）列表，作为环境变量。

• binary：默认情况下，Vagrant 会将 Windows 的行结束符替换为 Unix 的行结束符，除非你将此值更改为 true。

• 特权：这允许你更改脚本是否由特权用户运行，例如sudo。默认值为 true。

• upload_path：这是脚本将上传到的来宾机器上的路径。SSH 用户帐户必须有权限写入该文件夹/文件位置，否则会失败。

• 保持颜色：Vagrant 当前将成功消息输出为绿色，错误消息输出为红色。如果将此值更改为 false，则会停止此行为。

• name：这可以用于标识多个不同配置器在该过程中运行时的输出。

• powershell_args：这些是如果在 Windows 上使用 PowerShell 时可以传递给配置器的参数。

• powershell_elevated_interactive：当在 Windows 上尝试以交互模式提升脚本时使用。你必须启用 Windows 自动登录，并且用户必须已登录才能使其生效。

• md5：MD5 值（校验和）用于验证已下载的 shell 文件。

• sha1：SHA1 值（校验和）用于验证已下载的 shell 文件。

• 敏感：如果你在env选项中指定值，它将把这些值标记为敏感并且不会在输出中显示。

我们将重点讨论内联脚本、外部脚本和脚本参数。

内联脚本

我们简要提到了内联脚本，但还有更多可添加到配置中的选项，用于配置安装。

你可以使用以下语法来运行内联脚本：

config.vm.provision "shell", inline: "sudo apt-get update -y && echo updating finished"

或者，你可以在块外创建一个变量，并使用该变量来获得更简洁、更易读的格式：

$shellscript = <<-SCRIPT
 sudo apt-get update -y
 echo updating finished
 SCRIPT

config.vm.provision "shell", inline: $shellscript

你可以尝试这两种选项，看看哪种最适合你。在开发团队中工作时，你可能会发现他们已经有了你必须遵循的语法，用于创建和编辑 Vagrantfile。

外部脚本

使用 shell 配置的另一个选项是使用外部脚本。这是一种很好的方法，可以将脚本与其他内容分开，这样更容易管理，并有助于保持 Vagrantfile 的整洁。

要使用外部脚本，我们可以使用以下语法：

config.vm.provision "shell", path: "[FILELOCATION]"

在上面的例子中，"[FILELOCATION]"占位符可以是两种不同的选项之一：

• 本地脚本，位于你的机器上；例如值为script.sh

• 一个托管在外部的远程脚本；例如值为https://example.com/dev/script.sh

使用远程脚本的一个好处是，任何使用该 Vagrantfile 运行特定机器配置的人都将始终获得最新版本。如果你在一个开发团队中，当对配置脚本进行更改时，其他开发人员只需要运行vagrant up --provision命令，然后就可以使用相同的机器配置。

脚本参数

shell 配置的另一个好处是可以使用参数。这些是可以作为变量传入的值，当数据是动态时，它们可以更容易地管理。

脚本参数可以作为字符串或数组传入。字符串在仅需一个参数时很有用，而数组在需要多个参数时很有用。

脚本参数 – 字符串

下面是在 Vagrantfile 中使用字符串脚本参数时的语法示例：

config.vm.provision :shell do |shell|
     shell.inline = "echo $1"
     shell.args = "'this is a test'"
 end

当vagrant up进程进入配置阶段时，我们将看到一个值为this is a test的输出回显到屏幕上：

请注意：你必须记得正确转义字符串。在这种情况下，我们将字符串包裹在单引号中。系统会看到'this is a test'回显，这不会抛出任何错误。

脚本参数 – 数组

下面是使用数组脚本参数时在 Vagrantfile 中的语法示例：

config.vm.provision :shell do |shell|
     shell.inline = "echo $1 $2"
     shell.args = ["this is", "a test"]
 end

与字符串参数选项类似，当在vagrant up进程中启动此配置器时，我们将在屏幕上看到值为this is a test的输出：

请注意：不必为数组中的单个值加引号，但建议你转义任何特殊字符，以减少错误。

总结

在本章中，我们学习了 Vagrant 的配置与管理。我们通过基本用法类型、文件类型和 shell 类型，使用内联和外部脚本带参数来配置 Vagrant 虚拟机。

在第十章，Ansible - 使用 Ansible 配置 Vagrant Box，我们将深入了解 Ansible 配置管理工具，并使用它来配置 Vagrant 虚拟机。我们将学习如何使用 Ansible 和 Ansible playbooks，包括其语法。

第十章：Ansible - 使用 Ansible 配置 Vagrant Box

在我们的配置系列的第二部分中，我们将学习关于 Ansible 的知识，如何使用它来配置 Vagrant 机器。本章将覆盖以下主题：

• 理解 Ansible

• 在 macOS 上安装 Ansible

• 使用 Ansible 在主机机器上提供 Vagrant

• 在来宾机器上使用 Ansible 配置 Vagrant

• Ansible Playbooks

到本章结束时，你将能够自信地使用 Ansible 来配置 Vagrant 机器。你将对 Ansible 的工作原理有一个很好的理解，并且能通过 Playbooks 配置你所需的内容，能够在主机和 Vagrant 机器上使用 Ansible。

理解 Ansible

Ansible 是一个开源软件，用于使IT 自动化更简单，并为每个人提供自动化。Ansible 是一个用于配置管理、软件供应和应用程序部署的工具。它是一个功能强大的工具，提供了许多功能。这些功能包括以下内容：

• 它可以在主机或来宾机器上本地运行

• 它拥有丰富的插件生态系统

• 它可以使用许多云提供商来协调基础设施

• 它可以安装在许多不同的操作系统上

• 它具有简单的库存管理

• 它拥有简单而强大的自动化功能，通过 Playbooks 来实现

• 编写良好的详细文档

Ansible 提供了一种简单的方式来配置软件，拥有易于学习的语法，并且构建可靠、安全。我们将在本章中通过安装 Ansible、创建和测试 Playbooks、以及配置 Vagrant 机器来进一步了解 Ansible。

关于 Ansible 还有一些有趣的事实：它是 Red Hat 的一部分，使用 Python 和 PowerShell 编写，首次发布是在 2012 年 2 月，并且有一个基于 Web 的界面，叫做 Ansible Tower，可以用来简化 Ansible 的管理。

安装 Ansible

在第一部分中，我们将学习如何在主机机器上安装 Ansible，本例中为 macOS。稍后在本章中，我们将学习如何在 Ubuntu 上安装 Ansible，而 Ubuntu 将运行在我们的来宾 Vagrant 机器中。

在 macOS High Sierra (版本 10.13) 上安装 Ansible

在我们开始使用 Ansible 配置 Vagrant 机器之前，我们首先需要在主机上安装它。我们不会讨论任何高级安装方法——仅仅是安装 Ansible 并使其运行的基础内容。如果你使用的是其他操作系统，请随时参考Ansible 的官方文档。

1. 我们首先需要访问安装指南页面。

2. 这里列出了支持的操作系统，但我们需要点击 macOS 部分的最新版本。

3. 在这里，我们会看到首选的选项是通过 pip 安装 Ansible。

4. 你可以通过运行 pip -v 命令来检查是否已安装 pip：

1. 如果你没有安装，可以运行 sudo easy_install pip 命令：

你需要输入系统密码，因为该命令需要 sudo 权限。

1. 现在你可以通过运行 sudo pip install ansible 命令来安装 Ansible：

再次提示，你需要输入系统密码，因为该命令需要 sudo 权限。

1. 最后，我们可以通过运行 ansible --version 命令来检查 Ansible 是否已成功安装：

你可以看到我安装的是最新版本：2.6.3。

恭喜——你已经成功安装了 Ansible！现在我们可以开始配置和配置我们的 Vagrant 机器。

使用 Ansible 配置 Vagrant

在本节中，我们将研究两种不同的通过 Ansible 配置 Vagrant 的方式。第一种是通过在我们的主机（macOS）机器上运行 Ansible，第二种是在 Vagrant 内运行的客机（Ubuntu）上运行 Ansible。

请注意：我们将使用 ubuntu/xenial64 盒子，版本号为 virtualbox, 20180510.0.0。

在主机上使用 Ansible 配置 Vagrant

让我们设置一个基本的 Vagrant 环境，并通过 Ansible 从主机配置它。我们将学习如何在 Vagrantfile 中配置 Ansible，并安装软件到我们运行 Ubuntu 的 Vagrant 客户机中：

1. 让我们在一个新目录中创建一个新的 Vagrantfile，从头开始。我们可以运行 vagrant init -m 命令来做到这一点。

2. 在我们的 Vagrant 文件中，我们通过添加 config.vm.box = "ubuntu/xenial64" 这一行来设置盒子为 Ubuntu，还要添加网络配置行：

config.vm.network "private_network", ip: "10.10.10.10"

1. 现在我们可以创建一个 provision 块：

  config.vm.provision "shell", inline: "sudo apt-get update; sudo ln -sf /usr/bin/python3 /usr/bin/python"   
  config.vm.provision "ansible" do |ans|    ans.playbook = "vagrant_playbook.yml"
 end

1. 保存 Vagrant 文件并退出文本编辑器。

如果现在运行 vagrant up --provision 命令，在最后的配置阶段你会看到一个错误：

这是因为 Ansible 和 Vagrant 无法找到 playbook vagrant_playbook.yml。在与你的 Vagrantfile 相同的目录下，我们现在来创建 playbook 文件。

添加以下代码（我们稍后会详细讲解，以便你清楚它的作用）：

---
 -
  hosts: all
  sudo: true
  tasks:
   -
    apt: "name=nginx state=latest"
    name: "ensure nginx is at the latest version"
   -
    name: "start nginx"
    service:
     name: nginx
     state: started

请注意：Playbook 文件在格式和语法上非常严格。在 YAML 文件中只能使用空格，不能使用制表符（Tab）。如果遇到问题，尝试去除所有空格，并添加适当的缩进（顶级使用 1 个空格，子级使用 2 个空格，以此类推）。你可以使用在线 YAML 代码/语法验证工具（这是我使用的网站/工具：www.yamllint.com）。

这个标记会将最新版本的 Nginx 安装到 Vagrant 机器上。然后它会启动 Nginx 服务，使其运行并准备好使用。如果你已经有运行中的机器，可能需要先运行 vagrant destroy -f 命令。

运行 vagrant up --provision 命令以开始启动过程并启动 Ansible。你将在配置阶段看到大量新的彩色输出，这些输出表示 Ansible 正在安装和配置 Nginx。

配置器将开始运行我们在 Vagrantfile 中指定的 ansible_local：

然后它将运行 ansible-playbook 处理程序：

最后，你将看到 Ansible 所做工作的概览（或者有时没有做工作，这会导致红色的失败）。我们可以看到绿色的 ok=3 值表示有 3 项已成功运行，而黄色的 changed=1 值表示有一项已成功更改：

我们现在应该能够使用 10.10.10.10 的 IP 地址访问我们的 Vagrant 机器，因为我们在 Vagrantfile 中设置了网络配置。

打开浏览器并访问该 IP 地址，你应该能看到默认的 Nginx 欢迎页面：

恭喜！你已经成功使用 Ansible 从宿主机配置 Vagrant 安装了 Nginx。我们在这里讲解了很多内容，但在下一节中，我们将学习更多关于 Playbook 的知识。

在客户机上使用 Ansible 配置 Vagrant

现在我们已经成功配置了 Vagrant 机器并使用宿主机方法安装了 Nginx 服务，接下来我们可以学习如何在客户机（Vagrant 机器）上使用 Ansible 配置 Vagrant。

这种方法更简单，因为它允许在客户机内完成所有操作。你不需要在宿主机上安装任何额外的软件。如果找不到或无法访问 Ansible，Vagrant 会智能地尝试在客户机上安装它。

接下来的步骤与之前的步骤相似，但我们将向 Vagrantfile 中添加一些额外的配置：

1. 运行 vagrant init -m 命令以创建一个新的 Vagrantfile（如果你按照之前的步骤操作，可能需要清空当前目录或使用一个新的空目录）。

2. 在我们的 Vagrantfile 中，我们将通过添加 config.vm.box = "ubuntu/xenial64" 行来设置盒子为 Ubuntu，并且还需要添加网络配置行：

 config.vm.network "private_network", ip: "10.10.10.10"

1. 现在我们可以创建一个 provision 块：

 config.vm.provision "ansible_local" do |ans|
       ans.playbook = "vagrant_playbook.yml"
       ans.install = true
       ans.install_mode = "pip"
 end

1. 保存 Vagrantfile 并运行 vagrant up --provision 命令，以启动并运行 Vagrant 机器。

我们会看到类似的过程，直到 Vagrant 进入配置阶段。我们的客户机没有安装 Ansible，因此它将开始安装它。我们可以看到这里使用了 ansible_local 配置器：

由于我们在 Vagrantfile 中指定了安装模式为 pip，因此 pip 包管理器将被安装到我们的客户机上：

Vagrant 配置器将找到并运行 Ansible Playbook：

Ansible 现在将在客户机内运行，以安装 Playbook 中的内容。我们可以在以下截图中看到，Nginx 已成功安装并启动，并且没有失败的元素：

现在我们可以在浏览器中访问 10.10.10.10，并看到 Nginx 的默认页面。这将确认 Nginx 已成功安装并且服务正在运行：

现在让我们通过运行 vagrant ssh 命令 SSH 进入 Vagrant 客户机。连接后，我们可以运行 ansible --version 命令来确认 Ansible 是否已安装在目标系统上：

我们可以看到已安装的 Ansible 版本是 2.6.3。在我们的 Vagrantfile 中，我们使用了一些额外的 Ansible 值，我们将在下一部分深入了解。

额外的 Ansible 选项

Vagrant 在使用 Ansible 和 Ansible local 作为配置器时支持额外的选项。这些选项允许您向配置过程添加额外的功能和自定义设置。

配置器 – Ansible

在本节中，我们将探讨可以与 Ansible 配置器一起使用的其他选项：

• ask_become_pass：当设置为 true（布尔值）时，它会在使用 Ansible 中的 sudo 提升权限时提示输入密码。

• ask_sudo_pass：这基本上是 ask_become_pass，但将在 Vagrant 的未来版本中被淘汰。它用于向后兼容性。

• ask_vault_pass：当设置为 true（布尔值）时，它会强制 Ansible 提示输入密码。Ansible Vault 用于将敏感数据和密码加密存储，以便您不必担心它们在 Playbook 中以明文形式暴露。

• force_remote_user：此选项将要求 Vagrant 在清单中设置 ansible_ssh_user。Ansible 将使用 Vagrantfile 中的 config.ssh.username 值，而不是使用 Ansible Playbook 中的 remote_user 参数。

• host_key_checking：此选项将要求 Ansible 启用 SSH 主机密钥检查。

• raw_ssh_args：此选项可用于应用一组 OpenSSH 客户端选项。该值通常是一个字符串数组。

请注意：建议查看官方的 Vagrant 和 Ansible 文档，获取这些选项的更深入解释，并了解是否有任何您可能需要的内容，但不确定其名称或如何应用。

配置器 – Ansible local

在本节中，我们将探讨可以与 Ansible local 配置器一起使用的其他选项：

• install：此选项默认启用，如果目标系统未安装或无法运行 Ansible，则会尝试在目标系统上安装 Ansible。

• install_mode：此选项允许您选择如何在目标系统上安装 Ansible。您可以选择默认选项、pip 或 pip_args_only。默认选项将尝试使用目标操作系统的包管理器。pip 选项将使用 Python 包管理器。pip_args_only 选项与 pip 选项类似，但不允许 Vagrant 自动设置 pip 选项。

• pip_args：当install_mode设置为使用 pip 时，此选项会使用。它允许你将 pip 参数传递到命令行。

• provisioning_path：这是 Ansible 文件存储的目录路径。诸如ansible-playbook之类的命令都从此位置运行。

• tmp_path：这是在客户机上的绝对路径，用于 Ansible 本地提供者临时存储文件。

请注意：值得查看官方的 Vagrant 和 Ansible 文档，以便获得更深入的解释，并了解是否有你需要的内容，但不太确定其名称或如何应用。

Ansible Playbooks

Ansible Playbook 是 Ansible 使用的配置文件。你可以把它看作是 Vagrant 的 Vagrantfile。它使用 YAML（Yet Another Markup Language）标记语言作为语法，并且易于阅读：

---
 - hosts: all
     sudo: yes
     tasks:
         - name: ensure nginx is at the latest version
             apt: name=nginx state=latest
         - name: start nginx
             service:
                 name: nginx
                 state: started

让我们来看一下我们在上一节中创建的示例 Playbook，如上面代码块所示，并对其进行剖析，以便更好地理解它的含义：

• 第一行始终是三个短横线，用于标志文件的开始。

• 然后我们必须定义这些配置适用于哪些主机。通常可以在 Ansible 的库存文件中定义这些主机，通过设置类似[db]的值，并为该节点提供 IP 地址。

• 然后我们将sudo值设置为yes，因为我们需要 sudo/root 权限来在 Vagrant 客户机上安装 Nginx。

• 然后我们进入任务部分，这就是我们希望 Ansible 执行的操作——配置阶段。我们将通过名称部分分隔每个任务。它描述了我们希望任务做什么，例如，start nginx。

• 在一个任务中，我们可以定义操作。在我们第一个名为apt的任务中，我们调用包管理器（apt-get）来安装最新版本的 Nginx 包。

• 然后我们进入最后一个任务，确保 Nginx 服务已经启动。

我希望你能从这个例子中看到，Ansible Playbooks 非常易于阅读，并且按逻辑流程工作。你会遇到比这个例子更复杂的 Playbooks，以及一些相似的 Playbooks，但始终遵循每个块中的缩进，以更好地理解每个部分的功能。

总结

在本章中，我们学习了如何在主机和客户机上使用 Ansible 来配置 Vagrant。我们还学习了 Ansible 是什么，以及 Ansible Playbooks。如果你在公司中使用 Ansible，那么我建议你尝试将其与 Vagrant 结合使用，以帮助你的开发工作流。

在第十二章，Docker - 在 Vagrant 中使用 Docker，我们将继续我们的配置系列，学习 Chef 以及如何使用该配置管理工具来配置 Vagrant。我们将研究多个 Chef 选项（solo 和 client），并了解 Chef cookbooks。

第十一章：Chef - 使用 Chef 配置 Vagrant Box

在本章中，我们将继续使用流行的 DevOps 配置管理工具来配置 Vagrant 的系列教程。我们将重点介绍 Chef，并涵盖以下主题：

• 理解 Chef

• Chef Cookbook

• 在 macOS 上安装 Chef

• 使用 Chef Solo 配置 Vagrant 机器

• 使用 Chef Client 配置 Vagrant 机器

本章结束时，你将对 Chef 的概念以及其工作组件有一个清晰的了解。你将能够自信地使用 Chef 来配置 Vagrant 机器，无论是在宿主机上还是在 Vagrant 机器本身。你将明白如何创建一个 Cookbook，这可以是一个非常强大且灵活的工具，用于管理机器的状态。

理解 Chef

Chef 是一个流行的配置管理工具，用于配置和维护服务器。它由名为 Chef 的公司创建，使用 Ruby 和 Erlang 编写。它最初于 2009 年 1 月发布，并提供了两个不同的版本——免费（开源）和付费（企业版）。

Chef 支持并与许多云平台集成，如 Amazon EC2、OpenStack、Rackspace 和 Microsoft Azure。Chef 可以在独立模式下运行（无依赖），也可以在客户端/服务器模式下运行，客户端与服务器通信并发送有关安装节点的信息。

Chef 使用 Cookbook 和配方作为其配置的一部分，我们将在下一部分中详细讨论这一点。

Chef Cookbook

Chef 使用 Cookbook 作为其过程中的核心元素，Cookbook 用于描述节点/服务器的期望状态。

Chef Cookbook 是使用 Chef 配置机器时的重要组成部分。它描述了机器的期望状态。这类似于在 Ansible 中使用 Playbooks。Chef Cookbook 包含五个关键元素，每个元素都有其特定的作用：

• 配方

• 模板

• 属性值

• 扩展

• 文件分发器

这些元素通常是一些元数据，它们协同工作，创建机器的概览。让我们深入了解这五个元素，进一步学习它们。

当我们提到节点时，我们指的是一台机器——无论是物理机器还是虚拟机。节点可以是计算机、服务器、网络设备或其他机器。

配方

配方是 Cookbook 的关键部分。它用于详细描述应该在节点上发生什么。这类似于设置 Vagrant 虚拟机状态时使用的 Vagrantfile。

配方是用 Ruby 编写的，必须添加到节点的运行列表中，节点将根据该列表运行相应的配方。一个 Cookbook 可以使用一个或多个配方，或依赖外部的配方。

配方的主要目的是管理资源。资源可以是软件包、服务、用户、组、文件、目录、定时任务等。

模板

模板是一种特定类型的文件，包含嵌入式 Ruby。这些文件使用 .erb 扩展名，可以用来创建动态配置文件。

这些文件可以访问属性值（您将在下一部分中学习）。这就像是在文件中使用变量，而不必硬编码设置。您可以有多个模板引用相同的属性，当其中一个发生变化时，它会在所有模板文件中更改该值。

属性值

Chef 中的属性值本质上是设置。它们通常以键值对的形式显示。这些设置可以在 Cookbook 中使用。

属性设置在 Cookbook 的 attributes 子目录中，然后可以在 Cookbook 的其他部分中引用。属性可以在顶部（Cookbook）级别设置，但也可以通过任何特定于节点的设置/属性在节点级别进行覆盖。

扩展

这些只是 Chef 的扩展，如库和自定义资源。这些也可以被称为 工具，您可以在 Chef 超市 部分了解更多内容。

文件分发器

静态文件用于包含简单的配置。它们放置在文件的子目录中，通常通过配方移到节点上。这些文件通常不会更改，可以视为简单的、非动态的模板。

Chef 超市

如果您正在寻找特定的 Cookbook/软件，那么您可以使用 Chef 超市。您可以将 Chef 超市视为 HashiCorp 的 Vagrant Cloud。它托管了您可以查看和下载的 Cookbooks。超市界面简单易用，提供了一个快速的用户界面。其主要特点是易于使用的搜索功能。

搜索

如果您在寻找特定的 Cookbook 或只是想看看有哪些可用的内容，您可以使用强大的搜索功能。它提供了全文搜索和筛选功能，帮助缩小结果范围。您可以通过访问 Chef 超市主页来使用搜索，链接如下：supermarket.chef.io/：

在前面的截图中，您可以看到 搜索 功能。您可以搜索特定的软件包，例如 nginx，或者搜索更一般的内容，看看有哪些可用的，如 web server。

在缩小搜索范围时，有两个选项。第一个选项是您可以使用“高级选项”搜索功能，位于搜索栏下方，右侧：

在前面的截图中，您可以看到“高级选项”展开菜单，它允许您按 Badge 和/或选定的支持平台过滤搜索。如果平台不在列表中，您还可以使用底部的文本搜索栏搜索特定的平台。

目前只有一个 Badge 选项可用，即 partner。这个选项用于搜索 Chef 合作伙伴 Cookbooks，这些是由 Chef 工程团队精心挑选或他们创建的 Cookbooks。我们将在这里查看其他筛选选项：

在搜索栏的左侧，您可以选择您希望搜索的类型。目前有两个选项——Cookbooks 和 Tools。默认选项是 Cookbooks，这将搜索可用的 Cookbooks。Tools 选项将搜索可用的 Chef 工具。Tools 是可以与 Chef 一起使用的软件——这些不是插件，而是附加组件：

在前面的截图中，我们正在搜索 nginx，这是一个 Web 服务器。您可以看到它找到了 43 个 Cookbooks，您可以选择按“Most Followed”和“Recently Updated”排序。您将看到一些重要信息，如 Cookbook 版本、最后更新的日期/时间、支持的平台、安装代码和关注者数量。

您可以点击 Cookbook 的名称（此例中为 nginx）以获取有关该 Cookbook 的更多信息：

在前面的截图中，您可以看到 Cookbook 页面。它包含更多信息，包括 Cookbook 的创建者/维护者，并提供了详细的 README 文件。还有其他信息，如依赖项、更新日志、安装说明/选项等。

使用 Chef 配置 Vagrant

有四种不同的方式可以使用 Chef 来配置 Vagrant 支持的虚拟机。这意味着 Chef 在 Vagrant 中配置时有最多的选项。四种选项如下：

• Chef Solo

• Chef Zero

• Chef Client

• Chef Apply

在本章中，我们将重点关注 Chef Solo 和 Chef Client。这将为您提供在主机和 Vagrant 虚拟机上进行配置的良好组合。

在 macOS 上安装 Chef

在我们开始使用 Chef 之前，首先需要安装它。我们将学习如何在 macOS 操作系统（High Sierra 10.13 版本）上安装 Chef。

我们将安装 Chef DK（开发工具包），它包含所有依赖项、实用程序和主要的 Chef 软件。安装的软件列表包括以下内容：

• Chef 客户端

• OpenSSL

• 嵌入式 Ruby

• RubyGems

• 命令行实用程序

• 键值存储

• 解析器

• 实用工具

• 库

• 如 Kitchen 和 ChefSpec 等社区工具

请注意：在安装 Chef 之前，必须先安装 Apple XCode 软件包。

现在，让我们在系统上安装并测试 Chef：

1. 访问 Chef DK 下载页面（以下是 macOS 部分的链接：downloads.chef.io/chefdk#mac_os_x）。

2. 找到您当前在系统上运行的版本，然后点击橙色的下载按钮，如下所示：

1. 运行 .dmg 文件安装程序。您需要先运行安装文件。点击 .pkg 文件以运行它。

2. 安装程序将运行，您将被提示通过六个步骤。请按照这些步骤操作。在此安装过程中我们不会更改任何值：

1. 完成后，您应该看到绿色勾选的成功界面。点击关闭按钮关闭此窗口。接着，您可以将安装包移动到垃圾桶中。

2. 为了确认 Chef 是否已经安装，打开终端窗口并运行chef -v命令，它应该列出 Chef 的版本和其他依赖项：

如您所见，Chef 运行时有许多软件组成部分。包括 DK 版本、chef-client 版本、kitchen 版本等。了解这些版本会很有帮助，尤其是当您将来需要调试某些软件问题时。

恭喜！您现在已经在系统上安装了 Chef。接下来，让我们看看如何使用 Chef 来配置 Vagrant 虚拟机。

使用 Chef Solo 来配置 Vagrant 虚拟机

与前几章类似，我们将继续使用安装 nginx 网页服务器的示例。虽然这是一个简单的示例，但它让我们能够使用一款流行的软件，配置网络，并且是验证成功与否的一种简单方法。

使用 Chef Solo 作为 Vagrant 的配置工具，是开始使用 Chef 的快捷简便方式。它没有依赖项（除了 Chef 本身），适合初学者或高级用户使用。

我们首先需要通过运行vagrant init -m命令来创建 Vagrantfile。

在我们的 Vagrantfile 中，让我们指定虚拟机盒子和网络设置，以便配置 IP 地址。我们还将指定配置工具，并在 Vagrantfile 中配置 chef-solo。您的完成文件应该如下所示：

Vagrant.configure("2") do |config|
     config.vm.box = "ubuntu/xenial64"
     config.vm.network "private_network", ip: "10.10.10.10"
     config.vm.provision "chef_solo" do |ch|
         ch.add_recipe "nginx"
     end
 end

我们将config.vm.provision设置为chef_solo，并且在这个块内我们将add_recipe值设置为nginx。这意味着我们告诉 Vagrant 专门使用nginx的 recipe。Vagrant 会在项目的根目录下（即 Vagrantfile 所在位置）的cookbooks文件夹内查找相应的文件。

在我们运行 Vagrant 虚拟机之前，我们需要做一些 Chef 的基础配置。这里，我们将创建nginx的 recipe。我们将使用 Chef 超市中的官方 nginx Cookbook，可以通过以下链接找到：supermarket.chef.io/cookbooks/nginx。

默认情况下，Vagrant 会在项目根目录（即 Vagrantfile 所在位置）寻找一个cookbooks目录。我们首先通过运行mkdir cookbooks命令在主机上创建该文件夹。然后，通过在终端运行cd cookbooks命令进入该目录。

为了满足超市命令，我们需要一个本地的 git 仓库。让我们创建一个基础仓库并提交以开始使用。运行以下命令来实现最低要求：

• git init

• touch null

• git add -A

• git commit -m 'null'

让我们使用之前安装的knife命令行工具来安装这个 recipe。在 Chef 超市页面，我们可以看到两个命令。我们运行install命令：

knife supermarket install nginx --cookbook-path .

这应该会将 nginx Cookbook（文件夹）安装到你的 Cookbook 目录 中。我们可以通过在项目目录中运行 ls 和 ls cookbooks 命令来确认这一点：

现在让我们运行 vagrant up --provision 命令（回到根目录，而不是 Cookbook 目录）来启动并配置 Vagrant 机器。在配置阶段，你应该会看到 Running chef-solo... 消息，这表示配置器已启动。你将看到大量绿色输出，这是 Chef 启动、安装依赖项并运行 nginx Cookbook 的过程。一旦安装完成，nginx 服务应该会自动启动：

如果你现在在浏览器中访问 http://10.10.10.10，你应该能看到 nginx 的默认页面：

恭喜！你已经成功通过 Chef Solo 配置器将 nginx 安装到 Vagrant 机器上。

这是一个使用 Chef Solo 配置 Vagrant 的简单示例。请不要被误导以为这种技术不强大，你可以使用它来实验更复杂的 Cookbook。

使用 Chef Client 配置 Vagrant 机器

虽然 Chef Client 配置器可以被看作是高级选项，但它实际上比我们在上一节中介绍的 Chef Solo 配置器更简单、更快捷。

Chef Client 配置器之所以更简单、更快速，是因为它只是一个客户端。它本质上是一个僵尸，不会自主思考。它通过 Chef 服务器获取指令和 Cookbook 文件。在管理大型基础设施时，使用这种客户端与服务器的方式比分别管理多个节点要容易得多。

本书中不会介绍如何设置 Chef 服务器，因为这超出了本书的范围，但你可以从官方 Chef 文档网站了解更多：docs.chef.io/install_server.html。

本节内容不多，因为 Chef 服务器处理了大部分工作，但我们可以在 Vagrantfile 中添加一些配置设置。以下是一个配置块的示例（位于 Vagrantfile 中）：

config.vm.provision "chef_client" do |ch|
     ch.chef_server_url = "https://www.examplechefserver.com"
     ch.validation_key_path = "cert.pem"
 end

我们在这里使用了两个新键：chef_server_url 和 validation_key_path —— 这两个键都需要连接 Vagrant 机器（在本例中是节点）到 Chef 服务器。

我们必须设置 Chef 服务器的 URL 和验证密钥的路径（一个 .pem 文件）。这将把 Vagrant 机器注册为一个节点，下载运行列表（配方），然后进行配置。

总结

在这一章中，我们学习了如何使用 Chef 配置 Vagrant 机器。我们通过使用 Chef Cookbook 创建一个配方来控制安装到 Vagrant 机器上的软件，使用的是 Chef Solo 或 Chef Client。

在第十二章，Docker - 使用 Docker 配合 Vagrant中，我们将学习如何使用 Docker 来配置一个 Vagrant 虚拟机。我们将了解 Docker 镜像、容器和 Docker Hub。接着，我们将探索在配置 Vagrant 虚拟机时可用的多种 Docker 选项。

第十二章：Docker - 使用 Docker 与 Vagrant

在本章中，我们将学习如何使用 Docker 配置 Vagrant 虚拟机。这与 Docker 提供者不同，Docker 提供者用于支持和管理 Vagrant 虚拟机。目前，我们使用的是 VirtualBox 提供者。

我们将深入探讨 Docker 提供者，了解在使用 Docker 时 Vagrant 中有哪些可用的功能。具体来说，你将学习以下内容：

• 理解 Docker

• Docker 的关键组件（Docker Hub、容器和镜像）

• 如何从 Docker Hub 查找并拉取镜像

• 基本用法，如运行容器

• Vagrant 中的 Docker 特定配置

到本章结束时，你应该能够很好地理解 Docker 是什么，以及它如何作为 Vagrant 的配置工具使用。

理解 Docker

你可能听说过 Docker——即使你从未使用过。它目前非常流行，并且被许多公司采用。Docker 是一个工具，允许你使用一种称为容器化的虚拟化方式来管理应用程序。应用程序被打包到容器中，可以托管在云端或使用你自己的硬件。管理 Docker 容器有多种工具，比如 Docker Swarm 和 Kubernetes。

Docker 由 Solomon Hykes 于 2015 年 3 月发布。当前版本为 18.06.1，使用 Go 编程语言编写。它可以在 Windows、Linux 和 macOS 上运行。

Docker 属于与 Vagrant、VMWare 和 VirtualBox 相同的虚拟化家族。它也属于与 Chef、Puppet 和 Ansible 相同的配置和基础设施家族。

使用 Docker 相对于其他虚拟化软件有很多好处。它主要是一种更轻量、更快速的替代方案，因为它的运行方式不同于传统的虚拟机。

Docker 使用 Docker 引擎，该引擎位于操作系统之上，并共享主机操作系统的内核、库和二进制文件（这些是只读的）。这意味着容器可以快速启动，并且体积小巧。传统的虚拟化使用位于操作系统之上的虚拟机管理程序（Hypervisor）；这会创建出具有自己库和二进制文件的完整新操作系统。这种方式的优点是可以打包整个系统，但也意味着它的启动较慢，并且文件体积较大。当然，这两种方法各有优缺点，具体取决于你的需求。

Docker 的关键组件

在谈论 Docker 时，有一些主要组件是你会听到的。接下来，我们将详细了解每个组件。

容器

容器是便携、轻量的，它是一个包含运行应用程序所需所有内容的软件包。容器运行在 Docker 引擎上，并与其他容器共享主机操作系统的内核。容器本质上是 Docker 镜像的一个运行实例。

镜像

Docker 镜像是由不同层次组成的文件。这些层包括工具、依赖项和系统库，然后用来创建容器。通常有一些可以使用的基础镜像，比如 Ubuntu 镜像。你可以使用多个镜像来分离你的应用程序，例如，为你的 Web 服务器（Nginx）使用一个镜像，为你的数据库（MySQL）使用另一个镜像。

注册表

Docker 提供了一个托管注册表，称为 Docker Hub。它允许你浏览、拉取和存储 Docker 镜像。你可以将其视为 Vagrant Cloud，它提供 Vagrant box 的托管以及其他功能，比如下载和搜索 box。在接下来的部分中，我们将深入了解 Docker Hub。

服务

在 Docker 中，服务可以被看作是特定应用逻辑的组合。服务通常是生产环境中的容器，帮助管理你的 Docker 设置。有一些特定的工具被用来管理和编排 Docker，比如 Docker Swarm 和 Kubernetes。当你达到一定规模或需要更多控制时，这些工具就非常有用。

使用 Docker Hub 查找 Docker 镜像

Docker Hub 是 Docker 的在线托管注册表，用于 Docker 镜像。它允许你搜索、拉取和存储云中的镜像。它类似于 Hashicorp 的 Vagrant Cloud 或 Chef 超市。你可以通过访问其网站 hub.docker.com/ 来访问 Hub。

Docker Hub 还提供了一些非常有趣的功能，包括以下内容：

• 构建和测试你的镜像

• 它链接到 Docker Cloud，允许你将镜像部署到主机上

• 工作流/流水线自动化

• 用于容器发现的集中资源

• 用户账户

• 公共和私有注册表

让我们来看一下 Docker Hub，并使用搜索功能查找一个镜像：

1. 访问网站 hub.docker.com/。

2. 点击右上角菜单中的“探索”链接。

3. 你现在会看到“探索”页面，它列出了最受欢迎的官方仓库。

4. 在左上角，有一个搜索框。我们来搜索 memcached 并查看结果：

我们可以看到它找到了 1169 个仓库，排名第一的是官方仓库，拥有超过一千颗星和 1000 万次拉取。

1. 你现在可以通过点击下拉菜单来过滤搜索结果，选择了“All”选项：

1. 让我们点击第一个结果，了解更多关于官方 memcached 仓库的信息：

在这里，你可以看到与该镜像相关的很多信息。包括简短描述和完整描述。完整描述中有关于如何使用镜像、许可信息和不同版本的详细内容。在右侧，你可以看到 Docker 拉取命令 docker pull memcached。这是你可以运行的命令，用来拉取镜像，以便在你的 Docker 安装中使用。

基本用法 – 运行一个容器

我们不会深入探讨如何将 Docker 作为独立工具使用。本章的重点是使用 Docker 来配置 Vagrant 虚拟机，这一过程在 Vagrant 启动时进行。我们将学习一些基本的 Docker 命令——主要是那些在配置过程中使用的命令——以帮助你更好地理解发生了什么。

如果你不确定需要什么特定命令，或者想了解更多信息，可以运行docker命令，这将列出所有可用的命令。它会显示使用方法、命令选项、管理命令和常规命令。

请注意：你必须安装 Docker 才能运行这些命令，否则会收到错误提示。

pull

要从 Docker Hub 拉取镜像，可以使用docker pull命令。该命令的一个示例是通过运行以下命令来拉取nginx镜像：

docker pull nginx

这将生成一个与以下截图类似的输出：

然后我们可以通过运行docker images命令来检查该镜像是否可用：

run

要启动一个新的容器，可以使用docker run命令。该命令的一个示例是运行nginx镜像：

docker run nginx

这将启动 Nginx 容器。你不会在屏幕上看到除命令外的任何内容：

如果你在终端中打开另一个标签页并运行docker ps -a命令，你将看到所有正在运行的容器。在以下截图中，你将看到我们的 Docker 容器：

stop

要停止 Docker 容器，可以使用docker stop命令。该命令的一个示例是运行以下命令：

docker stop sleepy_dijkstra

我们从前面的示例中传入了sleepy_dijkstra容器名称。通过运行docker ps -a我们找到了镜像名称。如果我们现在再次运行docker ps -a命令，我们会看到状态为Exited (0) 3 seconds ago。在下图中，你将看到这两个命令及其输出：

start

此命令用于启动一个之前停止的 Docker 容器。为此，你可以使用docker start命令。该命令的一个示例是运行以下命令：

docker start sleepy_dijkstra

我们从前面的示例中传入了sleepy_dijkstra容器名称。通过运行docker ps -a我们找到了镜像名称。如果我们现在再次运行docker ps -a命令，我们会看到状态为Up 4 seconds。在下图中，你将看到这两个命令及其输出：

search

你可以通过命令行使用docker search命令来搜索 Docker Hub。该命令的一个示例是使用以下命令搜索ubuntu：

docker search ubuntu

这将生成一个与以下截图类似的输出：

类似于在 Docker Hub 网站上搜索，你将看到一个搜索结果列表。结果按从高到低排序。你会看到镜像名称、描述、星级评分以及是否为官方镜像。然后，你可以使用docker pull [imagename]命令拉取一个镜像。

使用 Docker 来配置 Vagrant 机器

现在我们已经了解了 Docker 的一些基本知识，接下来是有趣的部分！在本节中，我们将通过一个示例来演示如何使用 Docker 配置 Vagrant 机器。需要注意的是，Vagrant 会尝试安装 Docker，这样你就不需要手动安装了。有趣的是，Docker 是在 Vagrant 机器内运行的，而不是在宿主机上运行。你将会看到，当你 SSH 进入 Vagrant 机器时，可以运行 Docker 命令。

让我们开始并使用 Docker 来配置我们的 Vagrant 机器：

1. 首先，运行vagrant init -m命令来创建一个最小化的 Vagrantfile。

2. 在我们的 Vagrantfile 中，添加一个配置块：

 Vagrant.configure("2") do |config|
     config.vm.box = "ubuntu/xenial64"
     config.vm.network "forwarded_port", guest: 80, host: 8081
     config.vm.provision "docker" do |doc|
         doc.run "nginx", args: "-p 80:80"
     end
 end

我们设置了一些默认值来开始。我们使用"ubuntu/xenial64"盒子，并指定网络配置使用从宿主机（8081端口）到来宾机（80端口）的端口转发。

在配置块中，我们将docker设置为我们的配置工具。我们使用run选项并传入"nginx"镜像。同时，在run选项的基础上，我们传入了args选项并将其值设置为"-p 80:80"，这告诉 Docker 将容器的端口映射到宿主机。这就是为什么我们将端口转发设置为来宾的port 80。因此，我们可以访问 Docker 容器：

1. 现在，让我们运行vagrant up命令以启动机器。在配置阶段，你应该会看到类似以下截图的内容：

这里有几个步骤。首先，它会运行docker配置工具，然后将 Docker 安装到机器上。安装完成后，它会启动 Docker 容器（这是我们在 Vagrantfile 中通过run选项指定的），你会看到容器的输出为-- 容器：nginx。

1. 为了测试是否一切成功，我们可以打开浏览器并访问以下链接：http://localhost:8081。这应该会通过 Vagrant 的端口转发将我们连接到容器：

在前面的截图中，我们可以看到 Nginx 的默认欢迎页面。这是个好消息，意味着一切都在正常运行。

1. 我们还可以 SSH 进入 Vagrant 机器，通过终端访问 Docker。运行vagrant ssh命令即可访问。

2. 进入机器后，运行docker ps -a命令列出所有正在运行的容器：

在前面的截图中，我们可以看到nginx容器正在运行。

恭喜！您已成功使用 Docker 配置 Vagrant 虚拟机。这是一个相当简单的过程，但非常强大。如果您在应用的其他部分使用 Docker，那么现在可以尝试在开发中使用它。

Vagrant 中 Docker 的特定配置

关于 Vagrantfile 中与 Docker 相关的选项，没有必须的选项。如果不输入任何选项，那么 Vagrant 将简单地尝试安装 Docker —— 除非您已经安装了它。

Images

如果要 Docker 使用特定的镜像，则可以在 Vagrantfile 中传递一个镜像名称数组。例如，您的 Vagrantfile 如下所示：

Vagrant.configure("2") do |config|
     config.vm.provision "docker", images: ["nginx"]
 end

这将尝试拉取 nginx 镜像。还有其他可以用来处理镜像的选项：build_image 和 pull_images；我们将在接下来的部分中讨论这些选项。

build_image

除了运行和拉取镜像之外，您实际上可以在作为其过程一部分使用之前构建镜像。构建是在 Vagrant 客户机上完成的，并且必须对 Docker 可用。它运行 docker build 命令，所以您只需传递 Dockerfile 的位置。

在 Vagrantfile 中使用此选项的示例如下：

Vagrant.configure("2") do |config|
     config.vm.provision "docker" do |dock|
         dock.build_image "/vagrant/provision"
     end
 end

在此示例中，我们在 provision 块中使用 dock.build_image 键来设置目录（我们的 Dockerfile 所在的位置）。

args

使用 build_images 键时，还有一个名为 args 的额外参数。这允许您传递作为 docker build 命令的一部分运行的参数。该值将作为字符串传递。

要在构建过程中添加 --pull 标志（始终尝试拉取镜像的最新版本），Vagrantfile 可能如下所示：

Vagrant.configure("2") do |config|
     config.vm.provision "docker" do |dock|
         dock.build_image "/vagrant/provision", args: "--pull"
     end
 end

要传递多个参数/标志，只需将它们添加到字符串中即可。无需使用数组。

pull_images

在配置过程中处理镜像的另一种方法是在 Vagrantfile 中使用 pull_images 选项。此选项将尝试从 Docker 注册表中拉取镜像并使用这些镜像。

一个示例 Vagrantfile 如下所示：

Vagrant.configure("2") do |config|
     config.vm.provision "docker" do |dock|
         dock.pull_images "nginx"
         dock.pull_images "mysql"
     end
 end

此代码尝试拉取 nginx 和 mysql 镜像。pull_images 选项可以多次使用，并将它们附加在一起，而 images 选项只能使用一次。

run

run 选项用于在 Vagrantfile 中启动和运行特定的 Docker 容器。这在 vagrant up 过程中完成。它运行 docker run 命令来实现此目的。

在 Vagrantfile 中如何使用它：

Vagrant.configure("2") do |config|
     config.vm.provision "docker" do |dock|
         dock.run "nginx"
     end
 end

在上述示例中，我们正在指示 Docker 配置程序运行 nginx 容器。您可以多次使用 run 选项，但如果使用相同的镜像，则必须为它们定义不同的名称/标识符。以下是使用 nginx 镜像两次并使用不同名称的示例：

Vagrant.configure("2") do |config|
     config.vm.provision "docker" do |dock|
         dock.run "load-balancer", image: "nginx"
         dock.run "web-server", image: "nginx"
     end
 end

一个可以被识别为负载均衡器，另一个作为 Web 服务器。你可以在这里选择名称，但我发现描述性名称通常是最好的，最容易理解的。

镜像

这实际上是使用run选项时的默认值，它是你传递的第一个参数，例如镜像名称。然而，当你希望运行两个相同的镜像时，可以将其作为选项传递，就像前面的示例一样。

在你的 Vagrantfile 的配置块中，示例如下：

dock.run "lb1", image: "nginx"

在前面的示例中，我们引用了run选项和image选项。我们选择的镜像是nginx。

命令

这个cmd选项允许你传递一个将在容器内运行的命令。如果省略此值，则会使用容器的默认值。这可能是 Dockerfile 中提供的cmd值。

在你的 Vagrantfile 的配置块中，示例如下：

dock.run "ubuntu", cmd: "echo $HOME"

在前面的示例中，我们引用了run选项和cmd选项。cmd选项将简单地在容器内运行该命令。它仅访问$HOME环境变量，这是用户的主目录路径。

参数

使用args选项允许你将参数传递给docker run命令。这类似于在build_image部分使用的额外args选项。如果你需要比一般命令更细粒度的设置，这将非常有用。

在你的 Vagrantfile 的配置块中，示例如下：

dock.run "ubuntu", args: "--name ubuntumain"

在前面的示例中，我们引用了run命令和args选项。args选项将在需要时传递参数给docker run命令。在我们的示例中，它传递了--name标志，并将其值设置为ubuntumain。这将是容器的名称。

自动分配名称

使用auto_assign_name选项允许你自动为 Docker 容器命名。它的工作原理是通过传递--name标志和一个值来实现的。默认情况下启用此功能，且值为 true。需要注意的一点是，镜像名称中的任何斜杠（例如，base/archlinux）都将被替换为短横线，因此镜像将变为base-archlinux。名称由 run 的第一个参数选择。

在以下示例中，我们将run选项的值设置为nginx，以便容器会自动命名为nginx。唯一可以覆盖此设置的方式是将auto_assign_name值设置为false，我们将在下面执行此操作：

dock.run "nginx", auto_assign_name: false

守护进程化

这个选项允许你将容器守护进程化。此选项的默认值为 true，它将-d标志传递给docker run命令。如果你不希望守护进程化容器，可以将该值设置为 false。

在你的 Vagrantfile 的配置块中，示例如下：

dock.run "nginx", deamonize: false

在前面的示例中，我们使用了 run 选项和 deamonize 选项。deamonize 选项传递了 false 值，让 Docker 知道我们不希望它作为守护进程运行，因此 -d 标志不会传递给 Docker。

restart

这个选项允许你设置容器的重启策略。默认值为 always，但它也支持 no、unless-stopped 和 on-failure。如果你有特定的需求，并且需要控制一个或多个容器的重启策略，这个选项可能会很有用。

你 Vagrantfile 配置块中的一个示例如下：

dock.run "nginx", restart: "no"

在前面的示例中，我们使用了 run 选项和 restart 选项。restart 选项传递了 no 值，告诉 Docker 在容器退出时不要重启。

post_install_provisioner

使用 post_install_provisioner 选项为你提供了一种在原始配置器运行后运行一个新的配置器的简单方法。这听起来有点混乱，但它本质上允许你在 Docker 配置块内创建一个新的配置块。你可以将 Docker 作为主要配置器，然后在其中使用一个 shell 配置器，当 Docker 配置器完成时，shell 配置器将运行。

一个示例 Vagrantfile 看起来是这样的：

Vagrant.configure("2") do |config|
    config.vm.box = "ubuntu/xenial64"
    config.vm.network "forwarded_port", guest: 80, host: 8081
    config.vm.provision "docker" do |dock|
        dock.post_install_provision "shell", inline:"touch /vagrant/index.html && echo '<h1>Hello World!</h1>' > /vagrant/index.html"
        dock.run "nginx",
            args: "-p 80:80 -v '/vagrant:/usr/share/nginx/html'"
    end
end

上述代码将运行 nginx Docker 镜像，然后使用 shell 配置器。Shell 配置器将在 Vagrant 虚拟机内部运行一个脚本，简单地修改 Nginx 默认登录页面的内容。

当你运行前面的示例时，你应该能够在宿主机上访问 http://localhost:8081（当配置完成后），并看到一个大的 Hello World! 消息。

总结

在本章中，我们学习了 Docker 以及如何使用它来配置 Vagrant 虚拟机。我们还学习了 Docker 的工作原理、如何使用 Docker Hub，以及可用的各种 Docker 特定的 Vagrantfile 选项。现在你应该能够将 Docker 作为提供者进行实验。

在第十三章，Puppet – 使用 Puppet 来配置 Vagrant Box，你将学习如何使用 Puppet 来配置 Vagrant 虚拟机。我们将重点介绍两种主要的支持类型——Puppet Apply 和 Puppet Agent。

第十三章：Puppet - 使用 Puppet 配置 Vagrant Box

在本章中，我们将继续学习配置过程，并了解如何使用 Puppet 软件配置 Vagrant 机器。本章中，你将学习以下主题：

• 了解 Puppet

• Puppet apply 和 Puppet agent 是什么

• Puppet 清单是什么

• 如何使用 Puppet 配置 Vagrant 机器

在本章结束时，你将对 Puppet 如何与 Vagrant 一起工作来配置机器有一个很好的理解。

了解 Puppet

Puppet 是一种配置管理工具，用于部署、配置和管理节点（服务器）。

Puppet 由 Luke Kanies 于 2005 年发布，采用 C++ 和 Clojure 编写，并运行在 Linux、Unix 和 Windows 上。当前版本是 5.5.3，于 2018 年 7 月发布。作为一款软件，Puppet 属于基础设施即代码（Infrastructure as Code）类别，这意味着你通过代码和配置文件来进行配置和修改。Puppet 使用清单文件来帮助配置节点/服务器（我们将在后面的章节中深入学习）。

Puppet 使用拉取配置（主从）架构，其中节点（Puppet 代理）从主服务器拉取配置文件和更改。在这个主从过程中，有一个四步生命周期：

1. 节点将有关自身的事实发送给主服务器。

2. 主服务器使用这些事实来编译一个目录，描述节点应如何配置。然后，它将目录发送回节点。

3. 节点使用目录根据清单文件中描述的内容配置自身至预期状态。

4. 节点现在将向主服务器发送报告，包含任何更改或错误。这些报告随后可以在 Puppet 仪表板中查看。

Puppet 还支持多主架构，以减少停机时间并提供高可用性。当主服务器故障或遇到任何问题时，另一个主服务器可以替代它。Puppet 代理随后将轮询这个新的主服务器，查看是否有任何配置更改。

作为配置过程的一部分，Puppet 执行多个步骤，将配置文件中的代码转换并将节点配置到预期状态。

资源

Puppet 配置通常从资源开始。你可以把资源看作是描述节点某部分预期状态的代码。这可能是一个需要安装的特定包，例如 nginx。

清单

Puppet 程序被称为清单。清单包含 Puppet 配置代码，并以 .pp 文件扩展名结尾。这些代码块就是我们在前一节中提到的资源。

编译

编译过程是当 Puppet 主服务器将清单文件编译成目录时进行的。该目录随后被节点用于配置和达到预期状态。

目录

Puppet 目录是由主服务器创建的文档。它是通过编译 Puppet 清单文件生成的。它也可以处理多个清单文件。然后，目录由节点使用来设置所需的系统状态。

Apply

如果一个节点/服务器有一个目录，那么它必须将该配置应用到自己。这是安装必要的文件、服务和软件的过程。它允许节点达到期望的状态。

期望状态

当谈论 Puppet 和配置时，你会听到期望状态。就 Puppet 而言，它仅仅意味着节点/服务器已经完全配置，并且现在处于正确的状态。软件和服务已经安装并正常运行。

Puppet apply 和 Puppet agent

在本节中，我们将了解 Vagrant 中提供的两种 Puppet 配置选项——puppet apply和puppet agent。在接下来的部分，我们将使用这两种选项来配置我们自己的 Vagrant 机器。

Puppet apply

使用 Puppet apply 选项为 Vagrant 机器提供服务，可以让你在不需要 Puppet 主机的情况下使用 Puppet。它通过在客户机上调用puppet apply命令来工作。如果你没有 Puppet 主机，或者只是需要快速启动并运行，这将对测试 Puppet 配置很有帮助。

选项

使用 Puppet apply 时，有 14 个不同的选项可用。这些选项可以在你的 Vagrantfile 中应用，并帮助你对 Puppet 提供程序进行更多的控制：

• binary_path:

类型: string

描述: 这是客机上 Puppet 的 bin 目录的路径。

• facter:

类型: hash

描述: 这是一个包含可用 facter 变量（也称为 facts）的 hash。

• hiera_config_path:

类型: string

描述: 这是（位于主机上的）hiera 配置文件的路径。

• manifest_file:

类型: string

描述: 这是 Puppet 将使用的清单文件的名称。默认值是default.pp。

• manifests_path:

类型: string

描述: 这是包含清单文件的目录路径。默认值是manifests。

• module_path:

类型: string/array of strings

描述: 这可以是包含任何 Puppet 模块的目录路径（位于主机上）。

• environment:

类型: string

描述: 这是 Puppet 环境的名称。

• environment_path:

类型: string

描述: 这是包含环境文件的目录路径（位于主机上）。

• environment_variables:

类型: hash

描述: 这是一个环境变量集（以键/值对的字符串形式），将在 Puppet apply 运行之前使用。

• options:

类型: array of strings

描述: 这些是 Puppet 执行时可以传递给 Puppet 可执行文件的选项。

• synced_folder_type:

类型: string

描述：此选项允许您指定要使用的同步文件夹类型。默认情况下将使用同步文件夹类型。

• synced_folder_args:

类型：array

描述：这是一个传递给文件夹同步的参数数组（值）。您可以根据所选择的同步文件夹类型发送特定的参数（参见前面的选项）。

• temp_dir:

类型：string

描述：这是 Puppet 运行数据将存储的目录（在客户端机器上），例如清单文件。

• working_directory:

类型：string

描述：这是 Puppet 运行时的工作目录（在客户端机器上）。

Puppet 代理

在使用 Puppet 代理来配置 Vagrant 虚拟机时，您需要连接到一个 Puppet 主服务器。主服务器将提供模块和清单供节点使用。该配置程序通过使用 puppet agent 命令来工作，该命令由 Puppet 提供。

选项

在 Vagrant 中使用 Puppet apply 时，有七个不同的选项。这些选项将应用到您的 Vagrantfile 中，可以帮助您更好地控制 Puppet 配置程序：

• binary_path:

类型：string

描述：这是 Puppet 的 bin 目录在客户端机器上的路径。

• client_cert_path:

类型：string

描述：这是节点的客户端证书的路径。默认值为空，表示不会上传客户端证书。

• client_private_key_path:

类型：string

描述：这是节点的客户端密钥的路径。默认值为空，表示不会上传客户端密钥。

• facter:

类型：hash

描述：这是可用的 facter 变量（也称为事实）的哈希值。

• options:

类型：string/array

描述：这些是运行 puppet agent 命令时可以传递给 Puppet 的选项。

• puppet_node:

类型：string

描述：这是您希望为节点指定的名称。如果未设置值，则 Vagrant 将尝试使用主机名（如果在 Vagrantfile 中设置）或回退到使用的 box 名称。

• puppet_server:

类型：string

描述：这是 Puppet 服务器的主机名。如果未设置值，则默认值将设置为 puppet。

Puppet 清单示例和语法

清单是一个 Puppet 程序。它由告诉 Puppet 执行操作的代码组成，如执行命令、安装软件和运行服务。清单文件或多个清单文件是模块的主要部分之一。清单文件使用 .pp 文件扩展名，并可以在 manifests 文件夹中找到。

在清单文件中可以找到各种部分，如 exec、package、service 和 file。让我们深入了解清单文件的语法。

语法

清单文件包含声明的资源，这些资源可以分组到类中。清单文件使用一种称为 Puppet 的领域特定语言，这种语言类似于 YAML 或 Ruby（在编写 Vagrantfile 时）。

这是一个示例清单，它安装并运行 nginx web 服务器。让我们创建一个新的清单并将其命名为 nginx.pp：

package { "nginx":
     ensure => installed
 }

 service { "nginx":
     require => Package["nginx"],
     ensure => running,
     enable => true
 }

在上述示例中，有几点需要注意。每个资源（部分）从类别开始。我们使用了两种类别——包和服务。在资源块中，我们将值放在大括号 {} 中，然后引用名称（nginx）并设置所需的值。

在资源块中，我们使用了几个关键字——ensure、require 和 enable。这些关键字有助于描述节点达到期望状态时应该发生的事情。ensure 关键字用于确保包或服务执行你想要的操作，例如安装或运行。require 关键字用于当某个特定资源依赖另一个资源时。在服务资源中，我们使用了 enable 关键字，它允许我们指定服务是否启用。如果你需要在测试时临时禁用某个服务，它会很有用。

你可以通过使用井号/井号符号将注释添加到清单文件中。以下是一个示例：

# This comment wont be parsed by Puppet but it will be useful for other developers/DevOps

使用 Puppet 进行配置

现在进入令人兴奋的部分！我们将使用 Puppet apply 和 Puppet agent 来配置 Vagrant 机器。我们将查看这两种选项，并安装 nginx web 服务器。我们将使用 Vagrantfile 作为基础进行配置，同时还会添加 Puppet 特定的配置，如清单。

使用 Puppet apply 进行配置

Vagrant 中的 Puppet apply 配置选项允许你快速启动和运行 Puppet。使用此选项时，你无需独立的 Puppet 主服务器。让我们开始吧：

1. 为这个项目创建一个新目录，并进入该目录。

2. 创建一个目录，并命名为 manifests。

3. 在 manifests 文件夹中，创建一个名为 nginx.pp 的清单文件。在此文件中，我们将插入以下指令：

 package { "nginx":
     ensure => installed
 }
 service { "nginx":
     require => Package["nginx"],
     ensure => running,
     enable => true
 }

让我们逐步解析这个清单文件。首先，我们执行 apt-get update 命令以更新 Ubuntu 中的包。然后我们安装 nginx 包，并将其作为服务启动。我们确保它正在运行并已启用。

1. 回到 Vagrant。让我们运行 vagrant init -m 命令来创建一个最小化的 Vagrantfile。

2. 让我们在 Vagrantfile 中添加一些配置：

 Vagrant.configure("2") do |config|
     config.vm.box = "ubuntu/xenial64"
     config.vm.network "private_network", ip: "11.11.11.11"
     config.vm.provision "shell", :inline => <<-SHELL
         apt-get update
         apt-get install -y puppet
     SHELL
     config.vm.provision "puppet" do |pup|
         pup.manifest_file = "nginx.pp"
     end
 end

我们来逐步解析 Vagrantfile。首先，我们设置盒子使用 Ubuntu Xenial 64 位，然后将网络设置为使用私有网络和静态 IP 地址 11.11.11.11。我们需要在来宾机器上安装 Puppet，否则你将收到以下错误：

为了绕过这个错误，我们使用 shell 供应商首先更新包，并在我们的 Ubuntu 箱上安装 Puppet 软件。完成后，Puppet 供应商将开始运行。它将安装并启动 nginx：

前面的截图显示了 shell 供应商。在下面的截图中，您可以看到 Puppet 供应商：

1. 完成后，在浏览器中访问 http://11.11.11.11，您应该看到 nginx 的默认页面：

我们还可以通过使用 vagrant ssh 命令 SSH 进入 Vagrant 机器来检查 Puppet 是否正在运行。进入后，运行 puppet help 命令。我们应该看到类似下面截图的输出：

恭喜！您已成功使用 Puppet apply 配置了 Vagrant 机器。您已创建了一个 Vagrantfile 和一个 Puppet 清单文件，安装了 nginx，并测试了服务是否正确运行。

这是一个相当简单的例子，但 Puppet 实际上是一个非常灵活和强大的供应商。使用 Puppet 和 Vagrant 你可以做很多事情。我建议你通过测试一些可用的选项来进行实验和学习更多。

使用 Puppet agent 供应商

在使用 Puppet 作为供应商的第二个选项是 Puppet agent。尽管这个选项增加了复杂性（需要 Puppet 主服务器），但在涉及 Vagrant 时本地需要的配置较少。我们不会在主机上创建清单文件或任何与 Puppet 相关的配置。所有这些都将由 Puppet 主服务器处理。

Puppet agent 只是作为从服务器接收命令的客户端。在下面的示例中，我们将创建一个多机设置，用于提供 Puppet 主和 Puppet agent 机器：

1. 让我们首先创建一个新目录并进入其中。我将称其为 vagrant-puppet-agent 并使用以下注释来创建和移动它：

 mkdir vagrant-puppet-agent && cd vagrant-puppet-agent

1. 在我们的新目录中，通过运行 vagrant init -m 命令可以创建一个 Vagrantfile。

2. 现在我们需要编辑我们的 Vagrantfile，这需要相当多的配置。对于使用 puppet_server / Puppet agent 供应选项，不是所有这些都是必需的，但我们还在创建一个 Puppet 主服务器：

Vagrant.configure("2") do |config|
     config.vm.box = "ubuntu/xenial64"
         # Puppet master configuration
         config.vm.define "puppetmaster" do |pm|

                 pm.vm.provider "virtualbox" do |v|
                         v.memory = 2048
                         v.cpus = 2
                 end

                 pm.vm.network "private_network", ip: "10.10.10.11"

                 pm.vm.provision "shell", :inline => <<-SHELL
                         sudo echo "10.10.10.11 master.example.com" | sudo tee -a /etc/hosts
                         sudo echo "10.10.10.12 node.example.com" | sudo tee -a /etc/hosts
                         wget https://apt.puppetlabs.com/puppetlabs-release-pc1-xenial.deb
                         sudo dpkg -i puppetlabs-release-pc1-xenial.deb
                         sudo apt-get update -y
                         sudo apt-get install -y puppetserver
                         sudo awk '{sub(/-Xms2g -Xmx2g -XX:MaxPermSize=256m/,"-Xms512m -Xmx512m")}1'                   /etc/default/puppetserver > tmp.txt && mv tmp.txt /etc/default/puppetserver
                         sudo echo "*" | sudo tee -a /etc/puppetlabs/puppet/autosign.conf
                         sudo echo "autosign = true" | sudo tee -a /etc/puppetlabs/puppet/puppet.conf
                         sudo echo "certname=master.example.com" | sudo tee -a /etc/puppetlabs/puppet/puppet.conf
                         sudo echo "[agent]" | sudo tee -a /etc/puppetlabs/puppet/puppet.conf
                         sudo echo "certname=node.example.com" | sudo tee -a /etc/puppetlabs/puppet/puppet.conf
                         sudo echo "exec { 'apt-get update': path => '/usr/bin' } package { "nginx": ensure => installed } service { "nginx": require => Package["nginx"], ensure => running, enable => true }" | sudo tee -a /etc/puppetlabs/code/environments/production/manifests/default.pp
                         sudo systemctl enable puppetserver
                         sudo systemctl start puppetserver
                 SHELL
         end

         # Puppet Node configuration
         config.vm.define "pnode" do |pn|

                 pn.vm.network "private_network", ip: "10.10.10.12"

                 pn.vm.provision "shell", :inline => <<-SHELL
                 sudo echo "10.10.10.11 master.example.com" | sudo tee -a /etc/hosts
                 sudo echo "10.10.10.12 node.example.com" | sudo tee -a /etc/hosts
                 apt-get update
                 apt-get install -y puppet
                 sudo puppet agent --enable
                 sudo echo "autosign = true" | sudo tee -a /etc/puppet/puppet.conf
                 sudo echo "certname=master.example.com" | sudo tee -a /etc/puppet/puppet.conf
                 sudo echo "[agent]" | sudo tee -a /etc/puppet/puppet.conf
                 sudo echo "certname=node.example.com" | sudo tee -a /etc/puppet/puppet.conf
         SHELL

         pn.vm.provision "puppet_server" do |pup|
                 pup.puppet_node = "nginxplease"
                 pup.puppet_server = "master.example.com"
                 pup.options = "--verbose --waitforcert 10"
         end

     end
 end

这是我们迄今为止创建的最大的 Vagrantfile，但它涵盖了很多配置，并创建了多个 Vagrant 机器。让我们逐步分解它：

1. 我们首先将箱子设置为使用 Ubuntu Xenial 64 位（这将适用于两台机器，因为它在它们的配置块之外）。

2. 其次，我们定义了一个puppetmaster块，用于配置 Puppet 主机。在此块中，有大量自定义配置。其中一些部分用于帮助抑制错误，并不总是必需的。我们需要一台强大的机器以满足最低要求，因此我们将设置 RAM 内存和 CPU 数量。然后我们创建一个 shell 提供器，安装 Puppet 服务器软件并对多个文件进行各种配置更改。

3. 第三步，我们定义了一个pnode配置块，用于配置 Puppet 节点/代理机。我们使用 shell 提供器安装 Puppet 并对多个文件进行配置更改。我们还设置了提供器使用puppet_server，也就是 Puppet 代理。我们设置节点名称、服务器主机和一些附加选项，这些选项将在 Puppet 执行时传递给命令。

4. 现在我们运行vagrant up --provision命令。这将需要一些时间，因为它必须先配置 Puppet 主机，然后再配置 Puppet 代理机。

在 up 过程中，你将看到大量输出——主要是绿色的，也有一些红色的。不要太担心红色输出，因为在我们的场景中它不是错误，而是另一层输出。绿色是来自 Vagrant 虚拟机的输出，而红色可能是来自运行在 Vagrant 虚拟机中的 Puppet 主机的输出。

1. 我们将首先看到 Puppet 主机提供器开始工作。在此过程中，我们还会看到来自 echo 语句的输出，该语句将两个记录添加到/etc/hosts文件中：

在配置 Puppet 主机接近尾声时，我们会看到更多输出信息，同时我们会将额外的信息添加到puppet.conf文件中。在红色部分，我们可以看到 Puppet 主机的输出，表示它正在启动服务：

1. 现在我们开始配置第二台 Vagrant 虚拟机，它在本例中充当客户端/节点，并使用 Vagrant 提供选项puppet_server。我们将看到节点创建并缓存一个 SSL 证书：

在节点配置完成后，我们将看到它正在retrieving pluginfacts（检索插件信息），然后是applying configuration（应用配置）。它将创建一个 YAML 文件来存储状态，然后使用清单来达到desired state（期望状态）。在以下截图中，我们可以看到这一步骤在 7.14 秒内迅速完成：

现在，让我们检查确保我们的 Puppet 配置已正确工作，并且我们的节点已处于所需状态（正在运行 nginx）。在浏览器中访问 http://10.10.10.12，你应该能看到 nginx 的默认页面：

我们也可以单独通过 SSH 登录到各台机器，查看它们的状态。运行 vagrant status 命令查看每台机器的状态及其名称（因为我们需要这些信息来执行 SSH 命令）：

首先，我们通过运行vagrant ssh puppetmaster命令 SSH 进入 Puppet 主机。进入后，运行puppetserver --version命令确认一切正常运行，并查看当前版本：

现在，让我们通过运行vagrant ssh pnode命令 SSH 进入 Puppet 节点/代理。进入后，运行puppet --version命令确认一切正常运行，并查看当前版本：

如果你希望停止两个机器，可以运行vagrant halt命令。通过这样做，你可以运行vagrant destroy命令删除机器状态和任何相关文件。

恭喜！你已经成功地使用 Puppet agent 选项配置了一个 Vagrant 机器。我们通过在 Vagrant 中使用多机器选项以及各种配置和网络选项，创建了一个传统的 Puppet 服务器和客户端设置。

总结

在本章中，我们了解了所有关于 Puppet 的内容，以及如何将其作为 Vagrant 机器的配置工具。我们还学习了 Puppet 的两种支持的配置方法：Puppet apply 和 Puppet agent。

在第十四章，Salt - 使用 Salt 配置 Vagrant Box，我们将专注于 Vagrant 支持的另一种配置工具。我们将学习 Salt 及其如何用于配置 Vagrant 机器。你将深入了解 Salt 以及 Salt 状态。

第十四章：Salt - 使用 Salt 配置 Vagrant Box

你已经到达了本书的最后一章，以及我们的配置迷你系列。在本章中，我们将更深入地了解可以与 Vagrant 一起使用的 Salt 配置工具。在本章结束时，你将对如何使用 Salt 配置 Vagrant 有一个清晰的理解，并进一步了解 Salt 作为一款独立的配置管理软件。我们将学习 Salt 及其工作原理。

具体来说，我们将涵盖以下主题：

• 了解 Salt

• Salt 状态

• Salt 状态的语法

• 使用 Salt 配置 Vagrant 机器

• 使用 Salt 时 Vagrantfile 的可选项

了解 Salt

Salt 是配置和基础设施作为代码家族的另一员。它可以直接与 Chef、Ansible 和 Puppet 进行比较。Salt 是用 Python 语言编写的，首次发布于 2011 年 3 月。

Salt 有时被称为 SaltStack 平台。这是因为该软件采用了模块化的方法设计和构建。其可扩展、灵活的方式使你可以添加和移除模块。

Salt 有一个主要的设置——客户端和服务器。你可以将其视为 Puppet 主控和 Minion 设置。Salt 使用服务器（Master）和客户端（Minion）进行配置管理。Salt 支持的另一种设置选项称为Masterless（无主模式）。

Salt Master

Salt Master 用于管理基础设施及其中的服务器。它可以向 Minion 服务器发送远程执行命令并管理它们的状态。它还可以在主控层级设置中运行，其中命令可以通过更低层级的 Master 服务器传递。Salt Master 管理 Salt Minion，并用来捕捉从 Minion 发送的grain数据。然后它可以使用这些数据来决定如何管理特定的 Minion。它运行一个名为salt-master的守护进程。

Salt Minion

Salt Minion 是一个通常由 Salt Master 控制的服务器/机器。Minion 也可以在masterless（无主模式）设置中运行。Salt Minion 运行一个名为salt-minion的守护进程，其主要目的是执行从 Master 发送的命令，报告数据并以grain的形式发送有关自身的信息。

模块

Salt 提供了六种不同的模块。每种模块都提供不同的操作或功能。我们将在这里深入了解每个模块。

执行

你可以将执行模块视为ad hoc命令。这些命令在 Minion（命令行）机器/节点上运行。它们是使用 Python/Cython 编写的。

状态

状态是 Salt 配置管理的核心部分。状态是一个文件，用来配置和描述机器应处于的状态。这与 Puppet 清单类似，后者描述了机器的期望状态。

Grains（粒度）

Grains 是关于 Minion 的静态信息。这些信息包括有关 Minion 的核心细节，例如操作系统、型号、内存等，这些数据会在初次连接时收集并发送到 Master。这可以帮助 Master 针对不同的 Minion 群组进行目标设定，例如指定操作系统类型。

渲染器

在 Salt 中，渲染器用于将 Salt 状态文件（SLS）中描述的数据类型转换为 Python，以便 Salt 进行处理和使用。一个常见的例子是将一个 SLS 文件渲染为 Jinja 模板，然后解析为 YAML 文档。目前支持几种不同的组合：

• Jinja 和 YAML

• Mako 和 YAML

• Wempy 和 YAML

• Jinja 和 JSON

• Mako 和 JSON

• Wempy 和 JSON

返回器

在 Salt 中，返回器用于处理和输出在 Minion 机器上运行命令的结果。输出/结果数据总是返回到 Master，但使用返回器允许你决定数据的去向。你可以选择任何可以接收数据的服务，例如 Redis 或 MySQL。这些数据可以用于分析或存档，帮助你更好地了解 Minions 上发生的情况，以及哪些命令执行得最好。

执行器

Salt 执行器与执行模块非常相似。唯一的区别是执行器是一个在 Master 服务器上执行的命令。执行器可以简单也可以复杂。可以使用 salt-run 命令运行它们。

Salt 状态

Salt 状态也被称为状态模块。它们构成了 Salt 中状态系统的重要部分。Salt 状态用于描述应该在 Minion 上安装哪些软件包，以及其他选项，如用户帐户、正在运行的服务和文件夹权限。接下来我们将看一下 Salt 状态语法。

语法和示例

Salt 状态文件通常位于 roots 目录下。它采用 .sls 文件扩展名，并使用 另一种标记语言（YAML）格式存储内容。Salt 状态文件内部有一定的层级结构，根据需求和配置，这个层级结构可能相当深。

让我们分解一个示例 Salt 状态文件：

lampstack:
     pkg.installed:
         - pkgs:
         - mysql-server
         - php5
         - php-pear
         - php5-mysql

我们首先为本节设置一个名称，在这个示例中它被称为 lampstack。然后我们调用 pkg.installed，它验证某些软件包是否已安装。我们使用 - pkgs 选项并设置 - mysql-server、- php5、- php-pear 和 - php5-mysql 等值。

使用 Salt 配置 Vagrant

让我们进入本章的主要部分：使用 Salt 配置 Vagrant 虚拟机。在本节中，我们将研究 masterless 配置设置。我们将学习如何将 Nginx Web 服务器安装到我们的 Vagrant 虚拟机上：

1. 为此示例创建一个新的文件夹/目录。我将我的命名为 vagrant-salt。

2. 进入新文件夹并运行 vagrant init -m 命令以创建一个新的 Vagrantfile。

3. 我们需要为 Salt 创建一些文件夹和文件。创建一个 roots 文件夹和一个 minionfiles 文件夹。在 roots 文件夹内，创建一个名为 top.sls 的文件并输入以下内容：

 base:
     '*':
         - base

在同一文件夹（roots）内，创建另一个名为 base.sls 的文件并输入以下内容：

 nginx:
     pkg.installed:
         - name: nginx

顶部文件决定了要目标的主机。我们可以在这里使用 * 图标来表示我们将目标定位到所有主机。虽然这并不总是最佳选择，但在这种情况下是可行的。它还决定了使用哪个 Salt 文件。- base 值表示我们创建的 base.sls 文件。

base.sls 文件非常简洁。它规定应该安装 nginx 包（pkg）。现在，让我们进入 minionfile 文件夹并创建我们的基础 Minion 文件。创建 minion.yml 文件并输入以下内容：

 master: localhost
 file_client: local

在这里，我们将 master 值设置为 localhost（因为我们使用的是无主设置），并将 file_client 也设置为 local。保存这些文件并返回到 Vagrantfile 所在的 roots 文件夹。

1. 设置 Vagrantfile。编辑文件以包含以下内容：

 Vagrant.configure("2") do |config|
     config.vm.box = "ubuntu/xenial64"
     config.vm.network "private_network", ip: "10.10.10.20"
     config.vm.synced_folder "roots/", "/srv/salt"
     config.vm.provision :salt do |sa|
         sa.masterless = true
         sa.minion_config = "minionfiles/minion.yml"
         sa.run_highstate = true
     end
 end

Vagrantfile 文件相当简洁，但有许多可供配置 Salt 的选项。在接下来的章节中，你将了解更多这些选项。

在这个 Vagrantfile 中，我们首先设置了使用 Ubuntu Xenial 64 位的 box，并设置了私有网络 IP 地址为 10.10.10.20。然后，我们设置了 Vagrant 的 synced_folder 选项，将我们的 roots 文件夹与 Salt 共享，以便它可以访问我们的 top.sls 和 base.sls 文件。在接下来的部分，我们设置了 provision 块来使用 Salt 并设置一些基本值。我们将 Masterless 选项设置为 true，并将 minion_config 设置为使用我们在 minionfiles 文件夹内创建的 minion.yml 文件。我们还将 run_highstate 选项设置为 true，以抑制任何错误并运行文件。

1. 保存 Vagrantfile 文件并运行 vagrant up --provision 来启动 Vagrant 机器。

2. 在 vagrant up 过程中，我们将看到一些新输出，这些输出是由 Vagrantfile 和 Salt 配置选项定义的。我们将首先看到文件夹同步的设置。在以下截图中，我们可以看到 Vagrant 的 /srv/salt 文件夹链接到主机上的 /roots 文件夹：

然后我们将看到 Running provisioner: salt... 部分，这里会显示来自 Salt 提供程序的输出。我们可以看到 Salt 检查了许多内容，例如是否安装了 salt-minion，或者输出 Salt successfully configured and installed!。

Salt 已经安装，并且 Salt 状态文件和 minion 文件已经解析并执行：

一旦完成并且 Vagrant 机器运行起来，打开网页浏览器并访问我们在 Vagrantfile 中设置的私有网络 IP 地址。打开 http://10.10.10.20，你应该能看到默认的 Nginx 欢迎页面：

恭喜！您已成功使用 Salt 配置了一个 Vagrant 虚拟机。我们使用了sls文件来指定安装 Nginx 包。这里有许多不同的选项可以实验，特别是在使用主节点和 minion 配置时。

Vagrant 中的 Salt 选项

由于 Salt 本质上已内置于 Vagrant 中，因此有许多选项可供选择。目前，有六种不同类型的选项可以在 Vagrantfile 中进行管理。这些选项类型包括：

• 安装

• Minion

• 主节点

• 执行状态

• 执行运行器

• 输出控制

让我们逐一分析这些选项组，看看有哪些可用的特定选项可以配置。

安装选项

这些是相当通用的选项，用于管理 Salt 的安装。以下是可用的选项：

• install_master：如果此选项设置为true，将安装salt-master守护进程

• no_minion：如果设置为 true，则此选项将不安装 minion

• install_syndic：指定是否安装salt-syndic

• install_type：指定通过包管理器安装时的安装渠道，如稳定版、每日版或测试版

• install_args：使用 Git 时，可以指定附加参数，如分支或标签

• always_install：指定是否安装二进制文件，即使已经检测到这些文件

• bootstrap_script：这是您的自定义引导sh脚本的路径

• bootstrap_options：传递给自定义引导sh脚本的附加选项

• version：指定要安装的 Minion 版本

• python_version：指定要在 Minion 上安装的主要 Python 版本

Minion 选项

这些是仅适用于 minion 的选项。只有当no_minion选项设置为 true（默认值）时，这些选项才会被使用。以下是可用的选项：

• minion_config：自定义 minion 配置文件的路径

• minion_key：这是您 minion 密钥的路径

• minion_id：Minion 的唯一标识符

• minion_pub：这是您 minion 公钥的路径

• grains_config：自定义 grains 文件的路径

• masterless：在本地模式下调用state.highstate

• minion_json_config：这是用于配置 salt minion 的有效 JSON

• salt_call_args：如果使用无主配置进行预配，则传递给salt-call命令的附加参数

主节点选项

这些是仅适用于主节点的选项。只有当install_master选项设置为 true 时，这些选项才会被使用。以下是可用的选项：

• master_config：这是主节点配置文件的路径

• master_key：这是您主节点密钥的路径

• master_pub：这是您公钥的路径

• seed_master：用于将密钥上传到主节点

• master_json_config：这是用于配置主节点 minion 的有效 JSON

• salt_args：如果使用无主配置进行预配，则传递给salt命令的附加参数

执行状态

这里只有一个选项，用于控制在预配过程中执行状态：

• run_highstate：在vagrant up时执行state.highstate

执行运行器

这些选项控制在配置过程中运行器的执行。以下是可用的选项：

• run_overstate： 决定是否在vagrant up过程中运行state.over

• orchestrations：决定在vagrant up过程中是否运行state.orchestrate

输出控制

这些选项用于控制状态执行的输出：

• colorize：决定是否将输出进行颜色化

• log_level：输出的级别，默认值为debug

• verbose：决定是否显示 salt 命令的输出

Vagrant 备忘单

通过本章内容，我向你展示了使用 Vagrant 时的一些技巧和窍门。学习正确的做事方法总是有帮助的，当你熟练后，采用你自己学习到的更快速的方法也会非常有效。在本节中，我们将重点介绍一些我常用的 Vagrant 快捷方式，希望对你有所帮助。

测试 Vagrantfile

在处理 Vagrantfile 时，无论是大还是小，测试它的过程是非常有用的。如果编写一个复杂的 Vagrantfile，边写边测试某些部分会比写完整个文件再测试要方便许多，避免出错。

运行vagrant validate命令以测试你的 Vagrantfile，而无需运行vagrant up或经过整个过程。

保存快照

你可以快速轻松地保存 Vagrant 机器的快照，并在以后某个时间点回滚到该快照。这对于测试、版本控制以及一般用途都很有用。

运行vagrant snapshot save [options] [vm-name] [snapshot-save-name]命令。最后一个参数用于为快照命名，以便你可以回滚到该快照。

状态

Vagrant 提供了两个状态命令。一个是查看当前工作目录中机器的状态（如果有的话），另一个是查看系统中所有机器的状态。

使用vagrant status或vagrant global-status命令。

盒子

盒子是 Vagrant 生态系统中的重要组成部分，有时可能会很难管理。以下是一些有用的命令：

• 使用vagrant box list查看系统上安装的所有盒子

• 使用vagrant box outdated --global检查已安装的盒子的更新

• 使用vagrant box prune删除旧的盒子版本

硬件规格

如果你需要更强大的 Vagrant 机器，你可以在 Vagrantfile 中使用特定于提供商的代码来增强硬件规格。在以下示例中，我们将使用memory值来设置更高的内存（RAM），并且还设置cpus值来提高处理器数量。最后，我们设置gui值，以便通过图形用户界面访问机器：

config.vm.provider "virtualbox" do |vb|
     vb.memory = 4096
     vb.cpus = 2
     vb.gui = true
 end

这是特定于 VirtualBox 的代码。

请注意：你不能指定比主机机器更高的硬件规格。

代码部署

你可以通过运行 vagrant push 命令来从 Vagrant 部署代码。你需要先做一些配置，但这可以是同时管理代码和机器的好方法。你需要在 Vagrantfile 中指定一个远程服务器（例如 FTP），然后才能运行该命令。以下是一个示例块：

config.push.define "ftp" do |push|
     push.host = "ftp.yourdeploymentexample.com"
     push.username = "yourftpusername"
     push.password = "yourftppassword"
 end

你可以使用 FTP、SFTP（通过在 FTP 版本中将安全选项设置为 true）、Heroku，或者执行你为推送代码所创建的命令。

多机器

使用 Vagrant 的多机器功能是创建基础设施的一种强大且简便的方式。这可以用于测试或紧密地复制生产环境。你可以在一个 Vagrantfile 中设置多个 Vagrant 机器，然后分别管理它们。

每台机器在 Vagrantfile 中都有自己的块，因此任何选项都仅适用于该台机器。你可以在每个块中使用不同的配置器、硬件规格和其他选项。

一般设置

我们已经讨论了一些具体的部分，但当尝试解决问题或了解特定功能时，回顾基础知识通常是值得的。

你可以运行 vagrant help 命令列出系统中的所有命令，显示每个命令的描述和用法。要获取关于特定命令的更多信息，你可以运行 vagrant [命令名称] -h 命令。

官方的 Vagrant 网站和文档写得很好，容易理解且易于使用。我在使用新的工具或长时间未使用的工具时，经常参考它。

Vagrant 中的错误信息通常很有帮助，并且以一种相对容易理解的方式描述错误。如果遇到问题，尝试根据错误信息进行排查。我经常使用搜索引擎查找如何修复错误的方法。

总结

在本章中，我们学习了如何使用 Salt 软件来配置 Vagrant 机器。我们了解了在将 Salt 与 Vagrant 配置时可用的选项，并了解了 Salt 状态及其语法。

本章的结束标志着我们为期一段时间的配置小系列的结束，同时也意味着本书的结束。我鼓励你继续探索 Vagrant 及其众多不同的功能。本书主要集中在配置方面，但你也可以查看 Vagrant 中的提供者选项。这让你可以管理实际上驱动虚拟机的软件。我们在本书中使用了 VirtualBox，但也有其他选项，例如 VMWare 和 Docker。一切都取决于你的环境和可用软件，但 Vagrant 是灵活的，通常能够满足你的需求。