- SaltStack 教程
- SaltStack - 首页
- SaltStack - 概述
- SaltStack - 架构
- SaltStack - 竞争对手
- SaltStack - 安装
- 创建简单的环境
- SaltStack - 访问控制系统
- SaltStack - 作业管理
- SaltStack - Salt 文件服务器
- SaltStack - Git 作为文件服务器
- 使用 MinionFS 作为文件服务器
- SaltStack - 使用 Cron 与 Salt
- SaltStack - 远程执行
- 配置管理
- SaltStack - 日志记录
- SaltStack - 通过 SSH 使用 Salt
- Salt 用于云基础设施
- SaltStack - Salt 代理 Minion
- SaltStack - 事件系统
- SaltStack - 编排
- SaltStack - Salt 包管理器
- SaltStack - Python API
- SaltStack - 工作示例
- SaltStack 有用资源
- SaltStack 快速指南
- SaltStack - 有用资源
- SaltStack - 讨论
SaltStack 快速指南
SaltStack - 概述
在本章中，我们将学习 SaltStack 的基础知识。SaltStack 的远程执行功能允许管理员使用灵活的目标系统在各种机器上并行运行命令。Salt 配置管理建立了一个主从模型，可以快速、非常轻松、灵活且安全地使基础设施组件符合给定的策略。
什么是 SaltStack？
Salt 是一个非常强大的自动化框架。Salt 架构基于远程执行命令的想法。所有网络都围绕远程执行的某些方面设计。这可能很简单，例如要求**远程 Web 服务器**显示静态 Web 页面，也可能很复杂，例如使用 shell 会话来交互地对远程服务器发出命令。Salt 是更复杂类型的远程执行之一的示例。
Salt 旨在允许用户显式地定位并直接向多台机器发出命令。Salt 基于一个主控节点（Master）控制一个或多个**Minion**（从节点）的想法。命令通常从主控节点发出到目标 Minion 组，然后 Minion 执行命令中指定的任务，然后将结果数据返回给主控节点。主控节点和从节点之间的通信通过**ZeroMQ 消息总线**进行。
SaltStack 模块与支持的 Minion 操作系统通信。**Salt Master**（主控节点）默认在 Linux 上运行，但任何操作系统都可以作为 Minion，目前 Windows、VMware vSphere 和 BSD Unix 变体都得到了很好的支持。Salt Master 和 Minion 使用密钥进行通信。当 Minion 第一次连接到 Master 时，它会自动在 Master 上存储密钥。SaltStack 还提供**Salt SSH**，它提供了一种“无代理”系统管理。
SaltStack 的需求
SaltStack 构建于速度和可扩展性。这就是为什么它被用于管理 LinkedIn、WikiMedia 和 Google 数万台服务器的大型基础设施。
假设您有多台服务器，并且想要对这些服务器执行某些操作。您需要登录到每个服务器并逐个对每个服务器执行这些操作，然后您可能想要执行一些复杂的操作，例如安装软件，然后根据某些特定条件配置该软件。
让我们假设您有十台甚至 100 台服务器。想象一下，一次登录到每台服务器，在这些 100 台机器上发出相同的命令，然后编辑所有 100 台机器上的配置文件，这将变得非常繁琐。为了克服这些问题，您希望通过键入一个命令就能立即更新所有服务器。SaltStack 为所有此类问题提供了完美的解决方案。
SaltStack 的特性
SaltStack 是一种开源配置管理软件和远程执行引擎。Salt 是一个命令行工具。虽然是用 Python 编写的，但 SaltStack 配置管理与语言无关且简单。Salt 平台使用推送模型通过 SSH 协议执行命令。默认配置系统为**YAML**和**Jinja 模板**。Salt 主要与**Puppet**、**Chef**和**Ansible**竞争。
与其他竞争工具相比，Salt 提供了许多功能。下面列出了一些重要的功能。
**容错性** - Salt Minion 可以通过将 Master 配置参数配置为所有可用 Master 的 YAML 列表，一次连接到多个 Master。任何 Master 都可以将命令发送到 Salt 基础设施。
**灵活** - Salt 的整个管理方法非常灵活。它可以实现为遵循最流行的系统管理模型，例如代理和服务器、仅代理、仅服务器或以上所有模型在同一环境中。
**可扩展的配置管理** - SaltStack 旨在处理每个 Master 的一万个 Minion。
**并行执行模型** - Salt 可以使命令以并行方式执行远程系统。
**Python API** - Salt 提供了一个简单的编程接口，并且它被设计为模块化且易于扩展，以便轻松地适应各种应用程序。
**易于设置** - Salt 易于设置，并提供了一个单一的远程执行架构，可以管理任意数量服务器的不同需求。
**与语言无关** - Salt 状态配置文件、模板引擎或文件类型支持任何类型的语言。
SaltStack 的优势
Salt 作为一个简单且功能丰富的系统，提供了许多优势，可以概括如下：
**健壮** - Salt 是一个强大且健壮的配置管理框架，适用于数万个系统。
**身份验证** - Salt 管理简单的 SSH 密钥对进行身份验证。
**安全** - Salt 使用加密协议管理安全数据。
**快速** - Salt 非常快速，轻量级的通信总线为远程执行引擎提供了基础。
**虚拟机自动化** - Salt Virt Cloud Controller 功能用于自动化。
**基础设施作为数据，而不是代码** - Salt 提供了一个简单的部署、模型驱动的配置管理和命令执行框架。
ZeroMQ 简介
**Salt**基于**ZeroMQ**库，它是一个可嵌入的网络库。它轻量级且快速的消息库。基本实现是用**C/C++**，并且提供了包括**Java**和**.Net**在内的多种语言的原生实现。
ZeroMQ 是一个无代理的点对点消息处理。ZeroMQ 允许您轻松地设计复杂的通信系统。
ZeroMQ 带有以下五种基本模式：
**同步请求/响应** - 用于发送请求并接收每个发送请求的后续回复。
**异步请求/响应** - 请求者通过发送请求消息启动对话并等待响应消息。提供者等待传入的请求消息并用响应消息进行回复。
**发布/订阅** - 用于将数据从单个进程（例如发布者）分发到多个接收者（例如订阅者）。
**推送/拉取** - 用于将数据分发到连接的节点。
**独占对** - 用于将两个对等体连接在一起，形成一对。
ZeroMQ 是一种高度灵活的网络工具，用于在集群、云和其他多系统环境之间交换消息。ZeroMQ 是 SaltStack 中提供的**默认传输库**。
SaltStack - 架构
SaltStack 的架构设计用于处理任意数量的服务器，从本地网络系统到跨不同数据中心的其他部署。架构是一个简单的服务器/客户端模型，所需的功能内置在一组守护进程中。
查看下图。它显示了 SaltStack 架构的不同组件。
**SaltMaster** - SaltMaster 是主守护进程。SaltMaster 用于将命令和配置发送到 Salt 从节点。单个 Master 可以管理多个从节点。
**SaltMinions** - SaltMinion 是从守护进程。Salt Minion 从 SaltMaster 接收命令和配置。
**执行** - 从命令行针对一个或多个 Minion 执行模块和临时命令。它执行实时监控。
**公式** - 公式是预先编写的 Salt 状态。它们与 Salt 状态本身一样开放，可用于安装软件包、配置和启动服务、设置用户或权限以及许多其他常见任务等任务。
**Grains** - Grains 是一个接口，提供特定于 Minion 的信息。通过 Grains 接口提供的信息是静态的。Grains 在 Salt Minion 启动时加载。这意味着 Grains 中的信息是不变的。因此，Grains 信息可能是关于正在运行的内核或操作系统的。它不区分大小写。
**Pillar** - Pillar 是一个接口，用于生成和存储特定于特定 Minion 的高度敏感数据，例如加密密钥和密码。它以键值对的形式存储数据，并且数据以与 Salt 状态树类似的方式管理。
**顶部文件** - 将 Salt 状态和 Pillar 数据与 Salt Minion 匹配。
**Runners** - 它位于 SaltMaster 内部的一个模块，执行诸如作业状态、连接状态、读取外部 API 的数据、查询连接的 Salt Minion 等任务。
**Returners** - 将数据从 Salt Minion 返回到另一个系统。
**Reactor** - 它负责在 SaltStack 环境中发生事件时触发反应。
**SaltCloud** - Salt Cloud 提供了一个强大的接口来与云主机交互。
**SaltSSH** - 在不使用 Salt Minion 的情况下通过 SSH 运行 Salt 命令。
在下一章中，我们将详细了解 SaltStack 的各种竞争对手及其功能。
SaltStack - 竞争对手
Salt、Puppet、Chef 和 Ansible 是领先的配置管理和编排工具，每个工具都采用不同的路径进行服务器自动化。它们旨在简化数十、数百甚至数千台服务器的配置和维护。
让我们了解 SaltStack 如何主要与 Puppet、Chef 和 Ansible 竞争。
平台和支持
以下是所有支持 SaltStack 及其竞争对手的平台列表。
**SaltStack** - SaltStack 软件在 Linux、Windows、Mac OS X 和 UNIX 的多个版本上运行并管理它们。
**Puppet** - Red Hat Enterprise Linux、CentOS、Oracle Linux、Scientific Linux、SUSE Linux Enterprise Server 和 Ubuntu。
**Chef** - Chef 在多个平台上受支持，例如 AIX、RHEL/CentOS、FreeBSD、OS X、Solaris、Microsoft Windows 和 Ubuntu。
**Ansible** - Fedora Linux 发行版、CentOS 和 Scientific Linux 通过企业 Linux 附加软件包 (EPEL) 以及其他操作系统。
源语言
**SaltStack** - Python
**Puppet** - Ruby
**Chef** - Ruby 及其 CLI 使用基于 Ruby 的 DSL
**Ansible** - Python
支持的语言
**SaltStack** - 任何语言
**Puppet** - Ruby
**Chef** - Ruby 及其 CLI 使用基于 Ruby 的 DSL
**Ansible** - 任何语言
Web UI
**SaltStack** - Web UI 提供运行作业、Minion 状态和事件日志的视图。
**Puppet** - Web UI 处理报告、清单和实时节点管理。
**Chef** - Web UI 允许您搜索和查看节点清单、查看节点活动以及分配 Cookbook、角色和节点。
**Ansible** - Web UI 允许您配置用户、团队和清单，并将 Playbook 应用于清单。
管理工具
**SaltStack** - SaltStack Enterprise 被定位为管理云和 IT 操作以及**DevOps**编排的主要工具。
**Puppet** - Puppet 有两种形式，Puppet Enterprise 和开源 Puppet。除了提供开源 Puppet 的功能外，Puppet Enterprise 还提供 GUI、API 和命令行工具来管理节点。
**Chef** - CFEngine 是配置管理工具。
**Ansible** - Ansible 1.3 是管理的主要工具。
性能
**SaltStack** - Salt 旨在实现高性能和可扩展性。Salt 的通信系统使用 ZeroMQ 在 Salt Master 和 Minion 之间建立持久数据管道。
**Puppet** - 安全且高性能，无需代理。
Chef − Chef Server 最明显的挑战是搜索；搜索速度慢且不会并发地从客户端接收请求。
Ansible − 安全、高性能且无需代理。
价格和价值
SaltStack − 免费开源版本。SaltStack Enterprise 每年每台机器 150 美元。
Puppet − 免费开源版本。Puppet Enterprise 每年每台机器 100 美元。
Chef − 免费开源版本；企业版 Chef 5 台机器免费，20 台机器每月 120 美元，50 台机器每月 300 美元。
Ansible − 免费开源版本；Ansible 10 台机器免费，然后根据您需要的支持，每年每台机器 100 美元或 250 美元。
使用情况
SaltStack − SaltStack 被思科和 Rackspace 使用。它可以与任何基于云的平台集成。
Puppet − Puppet 被 Zynga、Twitter、纽约证券交易所、PayPal、迪士尼、谷歌等公司使用。
Chef − Chef 可以与基于云的平台集成，例如 Internap、Amazon EC2、Google Cloud Platform、OpenStack、Microsoft Azure 和 Rackspace。
Ansible − Ansible 可以部署到虚拟化环境、云环境，包括 Amazon Web Services、Cloud Stack、DigitalOcean 和 Google Cloud Platform 等。
SaltStack - 安装
在开始安装之前，您需要满足以下要求：−
一台 Linux 服务器（最新的 Ubuntu 服务器）。
此服务器的 sudo 或 root 权限。
使用以下命令安装所有更新：−
sudo apt-get update
安装 SaltMaster
使用以下 apt-get 命令从存储库安装 SaltMaster。
sudo apt-get install salt-master
安装 Salt Minion
使用以下 apt-get 命令从存储库安装 Salt minion。
sudo apt-get install salt-minion
安装 Salt syndic
使用以下 apt-get 命令从存储库安装 Salt syndic。
sudo apt-get install salt-syndic
Master 配置
Salt 配置非常简单。master 的默认配置适用于大多数安装。配置文件安装在“/etc/salt”目录中，并以其各自的组件命名，例如：− /etc/salt/master 和 /etc/salt/minion。
#interface: 0.0.0.0 interface: <local ip address>
更新配置文件后，使用以下命令重新启动 Salt master。
sudo service salt-master restart
Minion 配置
配置 Salt Minion 非常简单。默认情况下，Salt Minion 会尝试连接到 DNS 名称“salt”；如果 Minion 能够正确解析该名称，则无需进行任何配置。重新定义 minion 配置文件中的“master”指令，该文件通常为 /etc/salt/minion，如下面的代码所示：−
#master: salt master: <local ip address>
更新配置文件后，使用以下命令重新启动 Salt minion。
sudo service salt-minion restart
密钥管理
Salt 使用 AES 加密进行 Master 和 Minion 之间的所有通信。Master 和 Minion 之间的通信通过受信任的、已接受的密钥进行身份验证。
salt-key -L
它将生成以下 输出：−
Accepted Keys: Denied Keys: Unaccepted Keys: <local system name> Rejected Keys:
通过发出以下命令接受所有密钥。
sudo salt-key -A
它将生成以下 输出：−
The following keys are going to be accepted: Unaccepted Keys: <local system name> Proceed? [n/Y] y Key for minion bala-Inspiron-N4010 accepted.
现在再次发出 salt key listing 命令，
salt-key -L
它将生成以下 输出：−
Accepted Keys: <local system name> Denied Keys: Unaccepted Keys: Rejected Keys:
发送命令
Master 和 Minion 之间的通信必须通过运行 test.ping 命令进行验证。
sudo salt '*' test.ping
它将生成以下 输出：−
<local system name> True
这里，“*” 指的是所有 minion。由于我们只有一个 minion – test.ping，它执行 ping 命令并返回 ping 是否成功。
SaltStack - 创建简单的环境
在本章中，我们将创建一个简单的 SaltStack 环境，一个 salt master 和两个 salt minion。此环境将帮助我们在接下来的章节中学习 salt 概念。
让我们按照以下步骤创建 SaltStack 环境。
安装 VirtualBox 环境
VirtualBox 是一款跨平台的虚拟化应用程序。VirtualBox 允许您同时运行多个操作系统。VirtualBox 运行在 Windows、Linux、Macintosh 和 Solaris 上。它托管并支持大量 客户操作系统。
您可以访问以下链接下载并安装 VirtualBox：https://www.virtualbox.org/wiki/Downloads
我们将创建三个虚拟机并使用 VirtualBox 运行它。
安装 Vagrant
Vagrant 提供易于配置、可重现且可移植的工作环境。
您可以访问以下链接下载并安装 Vagrant：https://www.vagrantup.com
成功安装 Vagrant 后，您需要对其进行配置。在文件夹中创建一个名为 Vagrantfile 的单个文件，并描述机器的类型及其属性。
运行 Vagrant − 要运行 Vagrant，请发出以下命令：−
vagrant up
运行 vagrant up 后，Vagrant 会创建并启动这些机器，这些机器是在后台使用 VirtualBox 在 Vagrantfile 中定义的。这些机器将一直运行，直到您关闭它们为止。
停止 Vagrant − 要停止 VirtualBox 中所有正在运行的机器，请键入以下命令：−
vagrant halt
下载演示环境
SaltStack 提供了一个简单的演示环境作为 Vagrant 设置，它托管在 github 上。让我们使用以下命令下载设置：−
cd /cd/to/path git clone https://github.com/UtahDave/salt-vagrant-demo
启动环境
现在，使用以下命令启动演示环境：−
cd /cd/to/path/salt-vagrant-demo vagrant up
执行此命令后，您将看到以下响应：−
result
现在，三个服务器正在运行，一个配置了 salt master，两个配置了 salt minion。
运行 Salt master
使用以下命令登录到 Salt master：−
vagrant ssh master
现在，使用以下命令切换到 root 用户：−
sudo su
现在我们已成功连接到 Salt master。
现在让我们浏览 SaltStack 中的一些基本命令。
列出所有密钥
以下命令用于验证 Salt minion 连接并查看连接是已接受、已拒绝还是正在等待。
salt-key —list-all
它将生成以下 输出：−
Accepted Keys: minion1 minion2 Denied Keys: Unaccepted Keys: Rejected Keys:
验证 Salt Minions
现在，我们已接受所有密钥，您可以从 Salt master 发送命令以检查 Salt minion 是否正在侦听，
salt '*' test.ping
它将生成以下 输出：−
minion1: True minion2: True
从以上结果中，列出 minion 1 和 minion 2，这意味着 minion 正在正常侦听，否则 minion 可能无法正常响应。
SaltStack - 访问控制系统
访问控制系统为用户或组提供执行任务的权限选项。Salt 访问控制系统用于配置对非管理控制接口的访问。您可以将此过程应用于所有系统。此控制帮助非管理用户执行 Salt 命令。
Salt 接口有以下三种类型：−
- 发布者 ACL 系统
- 外部身份验证系统
- 对等系统
让我们详细了解这些接口。
发布者 ACL 系统
发布者 ACL 系统允许除 root 以外的用户从 master 上执行 Salt 命令以操作 minion。发布者 ACL 系统通过 publisher_acl 配置选项在 master 配置文件中进行配置。其定义如下：−
publisher_acl:
user1:
- .*
user2:
- web*:
- test.*
- pkg.*
这里，
user1 允许执行任何操作。
user2 允许使用 test 和 pkg，但仅限于“web*” minion。
外部身份验证系统
外部身份验证系统用于通过外部授权系统（如 PAM、LDAP 等）提供执行 salt 命令以操作特定 minion 的权限。此配置文件在 master 文件中定义，如下所述。
external_auth:
pam:
user1:
- 'web*':
- test.*
- network.*
user2:
- .*
这里，
user1 允许在与 web* 目标匹配的 minion 上执行 test 和 network 模块中的函数。
user2 允许执行所有函数。
在命令中启用外部身份验证系统
Salt 服务器提供“–a”选项来启用外部身份验证。
salt -a pam web\* test.ping
这里，-a pam 选项用于启用 PAM 外部身份验证。每当我们执行命令时，Salt 服务器都会要求提供身份验证详细信息。为了限制 Salt 服务器仅在第一次询问身份验证详细信息，我们可以使用 T 选项。此 -T 选项会缓存身份验证详细信息 12 小时（默认设置），并将其用于对用户进行身份验证。
salt -T -a pam web\* test.ping
对等系统
Salt minion 可以使用对等接口传递命令。对等接口通过 master 配置文件进行配置，要么允许 minion 使用 peer 配置部分从 master 发送命令，要么允许 minion 使用 peer_run 配置从 master 执行运行程序。
让我们详细了解这两种配置。
对等配置
要在 master 文件中定义的简单配置如下：−
peer:
.*:
- .*
这里，它为所有 minion 启用了通信，但仅推荐用于非常安全的环境。
要将 minion 分配给特定的 ID，需要按如下所示定义配置：peer −
.*domain.com: - test.*
peer_run 配置
此配置允许 minion 使用 master 文件上的 peer_run 选项从 master 执行运行程序。以下示例允许访问所有 minion 和所有运行程序。
peer_run:
.*:
- .*
要将 minion 分配给特定的 ID，需要按如下所示定义配置：−
peer_run:
.*domain.com:
- test.*
如何执行命令
要在所有 minion 上执行 test.ping，请使用 salt-call 命令以及 publish.publish 模块。
salt-call publish.publish \* test.ping
要执行 runner，请使用 salt-call 命令以及 publish.runner 模块。
salt-call publish.runner manage.up
SaltStack - 作业管理
Salt 能够与大量系统进行高速通信。这种方法有助于 Salt 创建一个强大的多任务系统。Salt 可以在多个系统上运行作业，因此 Salt 使用作业管理技术来管理在所有系统上运行的每个作业。本章详细介绍了作业管理。
什么是作业 ID？
Salt 有一个缓存目录，cachedir。在此目录中，minion 保持的目录称为 proc 目录。它位于以下目录中 /var/cache/salt/proc。
proc 目录用于维护所有文件。当这些文件被执行时，它们会分配一个唯一的作业 ID。此作业 ID 有助于识别 minion 上当前正在运行的作业，并允许查找作业。
SALTUTIL 模块
Salt 引入了一个称为 Saltutil 作业管理过程的新模块。此模块包含用于管理作业的不同函数。这些函数用于在 minion 级别管理作业。这些函数简要描述如下：−
running − 返回在 proc 目录中找到的所有正在运行的作业数据。
find_job − 根据作业 ID 返回有关特定作业的特定数据。
signal_job − 允许将信号发送到给定的作业 ID(jid)。
term_job − 为指定的作业发送终止信号。
kill_job − 为指定的作业发送终止信号。
作业运行程序
作业运行程序包含用于使查看数据更容易和更清晰的函数。它具有不同的函数。让我们详细讨论每个函数。
ACTIVE 函数
Active 函数用于识别哪些作业仍在运行，并检查哪些系统已完成作业以及哪些系统仍在等待。它使用以下命令执行，
salt-run jobs.active
LOOKUP_JID 函数
lookup_jid 运行程序将显示当前正在查找的作业的数据。这些作业通过 master 配置中的 keep_jobs 选项进行配置。它使用以下命令执行。
salt-run jobs.lookup_jid <job id number>
LIST_JOBS 函数
List_jobs 函数用于列出作业的作业数据。它由以下命令表示：−
salt-run jobs.list_jobs
作业调度
调度系统公开了在 minion 上执行任何执行函数或在 master 上执行任何运行程序。
它通过以下方法执行：−
Schedule − master 或 minion config 文件中的 schedule 选项。
Minion pillar 数据 − 它使用 saltutil.refresh_pillar 命令刷新 minion pillar 数据。
schedule 状态或 schedule 模块。
Salt 状态会在 minion 上执行。您可以传递位置参数，并在配置文件中提供命名参数的YAML 字典，如下所示。
schedule:
job1:
function: saltstate.sls
seconds: 3600
args:
- httpd
kwargs:
test: True
这里，job1 将每小时执行函数saltstate.sls，并使用指定的参数httpd。test: True 是httpd 命令的附加参数，该参数在saltstate.sls 中定义。
SaltStack - Salt 文件服务器
Salt 文件服务器是一个无状态的 ZeroMQ 服务器。它内置于 Salt master 中。Salt 文件服务器用于将文件从 master 分发到 minion。它包含不同的模块。在本章中，我们将了解 Salt 文件服务器、其配置、与 Salt 文件服务器相关的模块、如何在 Python 中访问 Salt 文件服务器等。
文件服务器后端
文件服务器后端允许 Salt 文件服务器充当其他文件服务器（如本地文件系统、Git 版本控制系统等）的透明接口。
可以通过在 master 文件中使用以下配置启用 Git 文件服务器后端。
fileserver_backend: - git
要启用多个后端文件系统，我们可以使用以下配置。
fileserver_backend: - roots - git
我们还可以使用相应后端服务器的特定部分为不同的后端服务器指定其他选项。
本地文件系统
要使用此系统，我们必须使用以下代码。
file_roots:
base:
- /srv/salt/prod
Git 文件系统
要使用此系统，我们必须使用以下代码。
gitfs_remotes: - https://github.com/sample/sample1.git
请求文件
Salt 具有为特定环境请求文件的选项。
salt://path/to/file?saltenv = base
这里，环境使用 roots 选项定义。
文件服务器配置
Salt 文件可以分配到多个根目录中，并通过指定文件路径和要搜索的环境来访问。各个环境可以跨越多个目录根。
环境
默认环境是 base。此环境已定义，并在未指定其他环境时用于下载文件。
file_roots:
base:
- /srv/salt/base
您也可以使用多个环境，如下面的代码所示。
file_roots:
base:
- /srv/salt/base
dev:
- /srv/salt/dev
- /srv/salt/base
CP 模块
CP 模块是操作Salt 文件服务器的主要模块。salt-cp 命令也可用于分发 Salt 文件服务器提供的文件。
GET_FILE
cp.get_file 函数可以在 minion 上使用，用于从 master 下载文件。其定义如下面的代码块所示。
salt '*' cp.get_file salt://vimrc /etc/vimrc
以上命令指示所有 Salt minion 下载vimrc 文件并将其复制到/etc/vimrc。
启用模板
您可以如下所示在 get_file 中启用模板选项：
salt '*' cp.get_file "salt://vimrc" /etc/vimrc template = jinja
应用压缩
要使用压缩，请使用gzip 命名参数。有效值为 1 到 9 之间的整数，其中 1 是最小压缩，9 是最大值。
命令定义如下：
salt '*' cp.get_file salt://vimrc /etc/vimrc gzip = 5
GET_DIR
cp.get_dir 函数可以在 minion 上使用，用于从 master 下载整个目录。其定义如下面的代码块所示。
salt '*' cp.get_dir salt://etc/mysql /etc
cp.get_dir 支持模板渲染和 gzip 压缩参数。如果需要，您也可以分配。
FILECLIENT 模块
Salt 提供了一个 Python 模块，用于访问 Salt 文件服务器。salt/fileclient.py 模块用于设置 minion 与 master 之间的通信。
获取文件的示例代码如下：
import salt.minion import salt.fileclient def get_file(path, dest, saltenv = ‘base'): client = salt.fileclient.get_file_client(__opts__) return client.get_file(path, dest, true, saltenv)
这里，
当模块在 Salt 环境中运行时，opts 可用。否则，我们应该提供配置文件路径 – /etc/salt/minion。
path 指的是 Salt 文件服务器中源文件的路径。
dest 指的是文件的目标路径。
saltenv 指的是环境
在下一章中，我们将了解如何使用Git 作为文件服务器。
SaltStack - Git 作为文件服务器
Git 是一个开源的分布式版本控制系统。它可以用来跟踪任何文件的更改。Salt 使用 Git 文件服务器从 Git 存储库发送文件。您可以将 Git 配置到fileserver_backend 列表选项中，如果需要配置一个或多个存储库，则可以使用gitfs_remotes 选项。
本章介绍如何安装和配置 Git 文件服务器。在开始安装之前，您必须满足以下先决条件。
使用 Git 的 Salt 服务器先决条件
Salt 服务器将 Git 用作文件服务器的最低要求如下：
- pygit2
- Dulwich
Pygit2 和 Dulwich 是使用 master 配置文件中的gitfs_provider 参数配置的。如果 master 文件中未配置gitfs_provider，则 Salt 将优先使用 pygit2（如果可用合适的版本），然后是GitPython 和Dulwich。
安装 pygit2
以下命令用于在基于 Fedora 和 Ubuntu 的系统上安装 pygit2：
基于 Fedora 的系统
yum install python-pygit2
基于 Ubuntu 的系统
apt-get install python-pygit2
这里，pygit2 的最低支持版本是 0.20.3。
安装 GitPYTHON
可以使用yum/apt 命令轻松地在 master 上安装 GitPython，如下所示。
基于 Fedora 的系统
yum install GitPython
基于 Ubuntu 的系统
apt-get install python-git
安装 DULWICH
可以使用 yum 命令轻松地在 master 上安装 Dulwich。
基于 Fedora 的系统
yum install python-dulwich
基于 Ubuntu 的系统
apt-get install python-dulwich
现在，我们已经安装了 Git 文件服务器的所有依赖项。现在让我们使用 master 配置文件中的fileserver_backend 部分配置此 Git 文件服务器。
后端配置
为了使用 Git 文件服务器，您需要在 master 配置文件中的 fileserver_backend 列表中添加 Git。其描述如下：
fileserver_backend: - git
让我们进一步了解如何在远程配置中配置 Git 文件服务器。
gitfs_remotes 配置
您可以为 master 文件中的 gitfs_remotes 配置指定任何一个或所有 URL，例如 git://、https://、file:// 或 ssh://。这用于搜索请求的文件。
简单的 https URL 规范定义如下。
gitfs_remotes: - https://github.com
ssh 配置可以如下所示完成。
gitfs_remotes: - [email protected]:user1/sample.git - ssh://[email protected]/path/to/sample.git
现在，我们已经使用两个选项fileserver_backend 和gitfs_remotes 配置了 Git 文件服务器。
重新启动 Master
在 master 文件中进行所有更改后，现在重新启动 master 以加载 Git 文件服务器中的所有配置。
多个远程配置
以下命令用于在 master 文件中的gitfs_remotes 中进行多配置。
gitfs_remotes: - git://github.com/sample/sample1.git - https://github.com/sample/sample2.git - file:///root/user/sample
这里，存储库sample1.git、sample2.git 和sample.doc 可能包含以下文件。
sample1.git: top.sls sample2.git edit/vimrc sample.doc edit/vimrc
SaltStack - 使用 MinionFS 作为文件服务器
MinionFS 是 Salt 为 minion 提供的一个特殊文件服务器，用于在它们之间交换文件。MinionFS 提供的文件是由 minion 故意共享的文件。要共享文件，Minion 必须按照以下步骤操作。
源 minion 必须使用cp.push 函数将文件推送到 Salt master。
源 minion 推送文件后，任何其他 minion 都可以使用 MinionFS 文件服务器访问已部署的文件。
启用推送
默认情况下，minion 向 master 推送文件是被禁用的。要接受来自 minion 的文件，master 需要在配置文件中具有“file_recv”选项，并且其值必须设置为True。默认情况下，“file_recv”的值为false。
file_recv: True
启用该选项后，重新启动 master 服务。
推送文件
Minion 可以将文件推送到 master。这是通过cp.push 函数执行的。此 cp.push 函数提供了一种简单的机制，可以使用 minion ID 由 minion 推送文件。
salt 'minion-id' cp.push /path/to/the/file
这里，minion-id 用于识别哪个 minion 正在推送文件。此命令会将文件存储在 master 的 cachedir 下名为minions 的子目录中。通常，路径为 – /var/cache/salt/master/minions。
对于 minion m1 和文件 – /var/log/mylog.txt，文件将存储在 – /var/cache/salt/master/minions/m1/var/log/mylog.txt 中。
启用 MinionFS
要启用 MinionFS，只需在 fileserver 后端设置中添加minion，如下面的代码块所示。
fileserver_backend: - roots - minion
启用 MinionFS 后，minion 推送的文件如下所示：
salt://<minion-id>/path/to/pushed/file
对于 minion m1 和推送的文件 – /var/log/mylog.txt，推送的文件将从 salt://m1/var/log/mylog.txt 提供。
此 minionFS 可以使用以下配置安装到一个特殊目录中。它会将 minionFS 文件与其他文件分开，并有助于组织 minion 文件。
minionfs_mountpoint: salt://minionfs
对于上述配置，文件将在minionfs 目录下可用，如 – salt://minionfs/m1/var/log/mylog.txt
MinionFS 高级选项
MinionFS 还提供了一个选项，用于启用/禁用来自特定 minion 的推送文件的可用性。这些选项是minionfs_whitelist（启用 minion）和minionfs_blacklist（禁用 minion）。
minionfs_whitelist: - webserver - develop* - ‘mail\d+.mysite.com' minionfs_blacklist: - testing
在上述配置中，除testing 之外的所有 minion 都允许使用 minionFS 共享文件。
Webserver1
其 ID 与正则表达式develop * 匹配的 minion
其 ID 与正则表达式mail\d+.mysite.com 匹配的 minion。
测试
在下一章中，我们将学习如何在 Salt 中使用 Cron。
SaltStack - 使用 Cron 与 Salt
Salt 可以与Cron 应用程序一起使用。将这两个应用程序结合使用，可以为 Salt 自动化提供极好的机会。虽然 Salt 提供了远程执行命令的选项，但 Cron 使其能够以预定的或自动的方式运行。让我们在本节中了解如何将 Cron 和 Salt 结合使用。
什么是 Cron？
Cron 是 Linux 环境中非常有用的应用程序。它可以预设命令或脚本在特定日期和时间运行。它还可以使应用程序以规则的间隔运行，例如每天、每周或每月的第一天。
系统启动时 Cron 会启动，并检查/etc/crontab 文件以获取配置详细信息。/etc/crontab 中的每一行都包含一个应用程序及其计划，如下所示。
15 * * * * root echo "This command runs at 15 minutes past every hour" 15 10 * * * root echo "This command is run daily at 10:15 am"
每行都有以下七个入口点，它们用空格分隔，如下所示：
minute - 小时内的分钟，介于“0”和“59”之间。
hour - 小时，以 24 小时制表示。
day_of_month - 月份中的日期，介于 1 和 31 之间。例如，每月的第 10 天是 10。
month - 指定的月份，用数字（0-12）或月份名称表示（例如 May）。
day_of_week - 星期几，用数字（0-7）或星期名称表示（例如 Sun）。
user - 运行命令的用户帐户。
cmd - 实际命令及其参数。
这里，* 替换未分配的内容。
Salt Caller (salt-call)
Salt 提供了一个 CLI（命令行接口），**salt-call**，用于在本地 minion 系统本身运行模块，而不是使用 salt 命令从主服务器运行。salt call CLI 支持 salt 命令支持的所有选项，但在本地运行。
Salt Caller 最初设计用于支持调试，但现在，它可以用作独立应用程序。
salt-call test.ping
在 cron 中使用 salt-call
salt-call CLI 可用于使用 Cron 计划 Salt 操作。例如，要每天午夜检查 minion 的状态，我们可以使用 salt-call 以及 –state.apply 选项，如下所示。
/etc/crontab
PATH = /bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:/opt/bin 0 0 * * * salt-call state.apply
这里，
**state.apply** 函数将检查 minion 的 Salt 配置文件，并检查为 minion 定义的所有操作是否已正确配置。
设置路径是一个好的实践，因为有时 salt 命令可能在系统路径中不可用。
在下一章中，我们将学习远程执行，这是 Salt 的核心概念。
SaltStack - 远程执行
Salt 的核心概念之一是远程执行。Salt 可以在几秒钟内跨数千个系统执行命令。Salt 使用自己的命令来实现此功能。让我们在本章中了解用于远程执行的不同 Salt 命令。
Salt 命令
Salt 命令使 Salt master 能够与一个或多个 **Salt minion** 通信。基本语法如下所示：
salt '<target>' <module.function> [arguments]
上述命令语法包含以下三个主要组件。
**target** - 它确定命令应用于哪些系统。
**module.function** - 它是一个命令。命令由模块和函数组成。
**arguments** - 调用函数所需的其他数据。
让我们详细了解每个组件。
什么是 Target 组件？
Target 是一个组件，它允许您过滤 minion（受管系统）以运行函数。下面定义了一个使用 Target 组件的简单命令。
salt '*' test.ping
它将生成以下 输出：−
minion2: True minion1: True
这里，Target **'***'** 表示所有受管系统。这里的 '**test**' 是一个模块，**ping** 是一个函数。这用于测试远程系统中的 ping 服务。我们将在后续章节中学习有关不同模块及其功能的信息。
使用 ID（minion）作为 Target
您可以使用 minion 在 Target 中的 **id** 向特定 minion 发送命令。您可以使用 **minion id** 替换 **'*'**。定义如下。
salt 'minion1’ test.ping
它将生成以下 输出：−
minion1: True
使用正则表达式作为 Target
可以使用特定正则表达式过滤 Target。定义如下。
salt -E 'minion[0-9]' test.ping
它将生成以下 输出：−
minion2: True minion1: True
使用列表作为 Target
可以在列表中显式指定 Target。在以下代码块中定义。
salt -L 'minion1,minion2' test.ping
它将生成以下 输出：−
minion2: True minion1: True
根据条件设置 Target
Target 可以组合在一个命令中，如下面的代码块所示。
salt -C 'G@os:Ubuntu and minion* or [email protected].*' test.ping
它将生成以下 输出：−
minion1: True minion2: True
模块和函数 (module.function)
Salt 可以同时在其所有受管系统中执行 shell 命令、更新软件包和分发文件等。Salt 使用模块执行这些操作。Salt 为所有可用的功能提供了特殊的模块。让我们在本节中使用一些简单的示例来了解不同的 Salt 模块。
Shell 命令
Salt 使用 **cmd.run** 命令远程跨多个系统执行 shell 命令。**cmd** 是主模块，**run** 是 **cmd** 模块中可用的函数之一。**run** 函数允许在远程系统中执行任何 shell 命令，如下面的代码块所示。
salt '*' cmd.run 'ls -l /etc'
它将生成以下 输出：−
minion2: total 868 drwxr-xr-x 7 root root 4096 Jan 26 22:10 X11 drwxr-xr-x 3 root root 4096 Jan 26 21:02 acpi -rw-r--r-- 1 root root 2981 Jan 26 20:48 adduser.conf -rw-r--r-- 1 root root 10 Jan 26 21:04 adjtime drwxr-xr-x 2 root root 4096 Jan 26 22:10 alternatives drwxr-xr-x 3 root root 4096 Jan 26 20:53 apm drwxr-xr-x 3 root root 4096 Jan 26 21:02 apparmor drwxr-xr-x 9 root root 4096 Jan 26 21:02 apparmor.d drwxr-xr-x 3 root root 4096 Jan 26 21:02 apport drwxr-xr-x 6 root root 4096 Jan 29 07:14 apt drwxr-xr-x 2 root root 4096 Jan 26 22:10 at-spi2 …………… …………… minion1: total 868 drwxr-xr-x 7 root root 4096 Jan 26 22:10 X11 drwxr-xr-x 3 root root 4096 Jan 26 21:02 acpi -rw-r--r-- 1 root root 2981 Jan 26 20:48 adduser.conf -rw-r--r-- 1 root root 10 Jan 26 21:04 adjtime drwxr-xr-x 2 root root 4096 Jan 26 22:10 alternatives drwxr-xr-x 3 root root 4096 Jan 26 20:53 apm drwxr-xr-x 3 root root 4096 Jan 26 21:02 apparmor drwxr-xr-x 9 root root 4096 Jan 26 21:02 apparmor.d drwxr-xr-x 3 root root 4096 Jan 26 21:02 apport drwxr-xr-x 6 root root 4096 Jan 29 07:09 apt drwxr-xr-x 2 root root 4096 Jan 26 22:10 at-spi2 -rw-r----- 1 root daemon 144 Oct 21 2013 at.deny -rw-r--r-- 1 root root 2177 Apr 9 2014 bash.bashrc -rw-r--r-- 1 root root 45 Mar 22 2014 bash_completion …………… ……………
显示磁盘使用情况
Salt 提供了一个特殊的模块 **disk**，用于获取受管系统的完整磁盘详细信息。**disk** 模块有一个 **usage** 函数来查询详细信息。
salt '*' disk.usage
它将生成以下 输出：−
minion1:
----------
/:
----------
1K-blocks:
41251136
available:
37852804
capacity:
5%
filesystem:
/dev/sda1
used:
1662420
/dev:
----------
1K-blocks:
503908
available:
503896
capacity:
1%
filesystem:
udev
used:
12
/run:
----------
1K-blocks:
101780
available:
101412
capacity:
1%
filesystem:
tmpfs
used:
368
/run/lock:
----------
1K-blocks:
5120
available:
5120
capacity:
0%
filesystem:
none
used:
0
/run/shm:
----------
1K-blocks:
508884
available:
508872
capacity:
1%
filesystem:
none
used:
12
/run/user:
----------
1K-blocks:
102400
available:
102400
capacity:
0%
filesystem:
none
used:
0
/sys/fs/cgroup:
----------
1K-blocks:
4
available:
4
capacity:
0%
filesystem:
none
used:
0
/vagrant:
----------
1K-blocks:
303114632
available:
252331440
capacity:
17%
filesystem:
none
used:
50783192
minion2:
----------
/:
----------
1K-blocks:
41251136
available:
37852804
capacity:
5%
filesystem:
/dev/sda1
used:
1662420
/dev:
----------
1K-blocks:
503908
available:
503896
capacity:
1%
filesystem:
udev
used:
12
/run:
----------
1K-blocks:
101780
available:
101412
capacity:
1%
filesystem:
tmpfs
used:
368
/run/lock:
----------
1K-blocks:
5120
available:
5120
capacity:
0%
filesystem:
none
used:
0
/run/shm:
----------
1K-blocks:
508884
available:
508872
capacity:
1%
filesystem:
none
used:
12
/run/user:
----------
1K-blocks:
102400
available:
102400
capacity:
0%
filesystem:
none
used:
0
/sys/fs/cgroup:
----------
1K-blocks:
4
available:
4
capacity:
0%
filesystem:
none
used:
0
/vagrant:
----------
1K-blocks:
303114632
available:
252331440
capacity:
17%
filesystem:
none
used:
50783192
网络接口
Salt 提供了一个单独的模块 **network** 和函数 **interfaces**，该函数位于模块内部，用于查询有关受管系统的网络接口信息。
salt '*' network.interfaces
它将生成以下 输出：−
minion1:
----------
eth0:
----------
hwaddr:
08:00:27:04:3e:28
inet:
|_
----------
address:
10.0.2.15
broadcast:
10.0.2.255
label:
eth0
netmask:
255.255.255.0
inet6:
|_
----------
address:
fe80::a00:27ff:fe04:3e28
prefixlen:
64
scope:
link
up:
True
eth1:
----------
hwaddr:
08:00:27:34:10:52
inet:
|_
----------
address:
192.168.50.11
broadcast:
192.168.50.255
label:
eth1
netmask:
255.255.255.0
inet6:
|_
----------
address:
fe80::a00:27ff:fe34:1052
prefixlen:
64
scope:
link
up:
True
lo:
----------
hwaddr:
00:00:00:00:00:00
inet:
|_
----------
address:
127.0.0.1
broadcast:
None
label:
lo
netmask:
255.0.0.0
inet6:
|_
----------
address:
::1
prefixlen:
128
scope:
host
up:
True
minion2:
----------
eth0:
----------
hwaddr:
08:00:27:04:3e:28
inet:
|_
----------
address:
10.0.2.15
broadcast:
10.0.2.255
label:
eth0
netmask:
255.255.255.0
inet6:
|_
----------
address:
fe80::a00:27ff:fe04:3e28
prefixlen:
64
scope:
link
up:
True
eth1:
----------
hwaddr:
08:00:27:a7:31:8e
inet:
|_
----------
address:
192.168.50.12
broadcast:
192.168.50.255
label:
eth1
netmask:
255.255.255.0
inet6:
|_
----------
address:
fe80::a00:27ff:fea7:318e
prefixlen:
64
scope:
link
up:
True
lo:
----------
hwaddr:
00:00:00:00:00:00
inet:
|_
----------
address:
127.0.0.1
broadcast:
None
label:
lo
netmask:
255.0.0.0
inet6:
|_
----------
address:
::1
prefixlen:
128
scope:
host
up:
True
sys.doc 执行模块
Salt 函数可以发送到 **sys.doc** 执行模块。这用于直接从命令行获取有关任何模块的详细信息。Salt 函数是自文档化的。所有函数文档都可以通过 minion 通过 sys.doc() 函数检索，该函数定义如下。
salt '*' sys.doc
函数调用的参数
参数用于为函数调用提供其他数据。下面给出了一个简单的参数示例。
salt '*' sys.doc pkg.install
这里，参数 **pkg.install** 是一个用于安装特定软件包的模块。
Python 函数
参数是函数的空格分隔参数。它允许将 python 代码作为参数传递，如下所示。
salt '*' cmd.exec_code python 'import sys;print sys.version'
它将生成以下 输出：−
minion2: 2.7.6 (default, Oct 26 2016, 20:30:19) [GCC 4.8.4] minion1: 2.7.6 (default, Oct 26 2016, 20:30:19) [GCC 4.8.4]
同样，您也可以使用可选关键字和 **YAML** 格式。
SaltStack - 配置管理
配置管理是 SaltStack 中最重要的概念之一。它用于创建可重用的配置模板，称为 **状态**。状态描述了将系统组件或应用程序置于已知配置所需的全部内容。
Salt 状态
Salt 状态是系统特定部分的可重用配置。状态更易于理解，并使用简单的 YAML 进行描述。
创建 Salt 状态
Salt 状态易于创建。让我们在本节中创建一个简单的状态。移动到目录“salt-vagrant-demo/saltstack/salt/”并创建一个名为 **samples.sls** 的文件，并在其中添加以下行。
samples.sls
install_network_packages:
pkg.installed:
- pkgs:
- rsync
- lftp
- curl
现在，保存文件并在 Salt master 上运行以下命令。
root@saltmaster:/home/vagrant# salt 'minion1’ state.apply samples
在这里，我们通过 **pkg.installed** 模块使用 Salt 状态在 Salt minion **minion1** 中安装了 **rsync、lftp** 和 **curl**。如果正常工作，您将看到如下所示的响应。
它将生成以下 输出：−
minion1: ---------- ID: install_network_packages Function: pkg.installed Result: True Comment: All specified packages are already installed Started: 08:08:48.612336 Duration: 545.385 ms Changes: Summary for minion1 ------------ Succeeded: 1 Failed: 0 ------------ Total states run: 1 Total run time: 545.385 ms
应用 Salt 状态
现在，我们已经使用 '.sls' 文件创建了一个状态，并通过专门调用它来应用它。Salt 有一个默认状态文件，称为 **top.sls** 文件。顶级文件用于将多个状态文件应用于 Salt minion。顶级文件描述了应在何处应用状态。好吧，**状态** 和 **顶级文件** 协同工作以创建 SaltStack 配置管理功能的核心。
现在，让我们在目录 **saltstack/salt** 中创建一个简单的 top.sls 文件，并添加以下内容。
top.sls
base:
'*':
- common
'minion1':
- samples
这里，**状态** 通常 **应用于所有系统** 状态，**samples** 应用于 **minion1**。
接下来，运行 Salt master 并应用状态，如下所示。
root@saltmaster:/home/vagrant# salt '*' state.apply
它将生成以下 输出：−
minion1: ---------- ID: common_packages Function: pkg.installed Result: True Comment: All specified packages are already installed Started: 09:33:35.642355 Duration: 588.21 ms Changes: Summary for minion1 ------------ Succeeded: 1 Failed: 0 ------------ Total states run: 1 Total run time: 588.210 ms minion2: ---------- ID: common_packages Function: pkg.installed Result: True Comment: All specified packages are already installed Started: 09:33:35.890331 Duration: 602.79 ms Changes: Summary for minion2 ------------ Succeeded: 1 Failed: 0 ------------ Total states run: 1 Total run time: 602.790 ms
应用批处理大小
如果您有大量连接的 minion，那么您可以限制一次更新多少个系统。这是通过使用 **–batch-size** 选项执行的，该选项定义如下。
root@saltmaster:/home/vagrant# salt --batch-size 5 '*' state.apply
它将生成以下 输出：−
Executing run on ['minion2', 'minion1'] jid: 20170314094638482664 minion1: ---------- ID: common_packages Function: pkg.installed Result: True Comment: All specified packages are already installed Started: 09:46:41.228519 Duration: 582.24 ms Changes: Summary for minion1 ------------ Succeeded: 1 Failed: 0 ------------ Total states run: 1 Total run time: 582.240 ms retcode: 0 jid: 20170314094638482664 minion2: ---------- ID: common_packages Function: pkg.installed Result: True Comment: All specified packages are already installed Started: 09:46:41.153609 Duration: 605.235 ms Changes: Summary for minion2 ------------ Succeeded: 1 Failed: 0 ------------ Total states run: 1 Total run time: 605.235 ms retcode: 0
Salt 状态函数
Salt 状态函数用于在远程系统上安装和配置应用程序。让我们使用 Salt 状态函数安装“Vim”软件包。
创建和应用状态函数
在目录“salt-vagrant-demo/saltstack/salt/sample.sls”下创建一个名为“sample.sls”的文件，并添加以下内容 -
sample.sls
install vim:
pkg.installed:
- name: vim
Vagrant 环境启动后，运行 Salt master 并通过运行以下命令应用 sample.sls。
root@saltmaster:/home/vagrant# sudo salt 'minion2’ state.apply sample
它将生成以下 输出：−
minion2: ---------- ID: install vim Function: pkg.installed Name: vim Result: True Comment: Package vim is installed Started: 15:07:45.752764 Duration: 553.506 ms Changes: Summary for minion2 ------------ Succeeded: 1 Failed: 0 ------------ Total states run: 1 Total run time: 553.506 ms
现在，我们添加了一个软件包“Vim”。现在让我们使用 Salt 测试方法测试该软件包。
Salt 状态测试
测试运行需要通过向状态添加“test = True”选项来强制执行。返回信息将以黄色显示将应用的状态，结果报告为“None”。
以下命令用于测试状态 -
root@saltmaster:/home/vagrant# sudo salt 'minion2’ state.apply sample test = True
它将生成以下 输出：−
minion2: ---------- ID: install vim Function: pkg.installed Name: vim Result: True Comment: Package vim is already installed Started: 15:07:45.752764 Duration: 553.506 ms Changes: Summary for minion2 ------------ Succeeded: 1 Failed: 0 ------------ Total states run: 1 Total run time: 553.506 ms
SaltStack ─ Pillar 组件
Pillar 是使 Salt 状态可重用的一个重要组件。它用于为使用 Target 分配的 minion 定义安全数据。Salt pillar 数据存储诸如端口、文件路径、配置参数和密码等值。
Pillar 配置文件
主配置文件中 **pillar_roots** 的配置如下所示 -
pillar_roots:
base:
- /srv/pillar
这里，文件位于“/srv/pillar”目录中。
假设位于 /srv/pillar/top.sls 的顶级文件具有以下结构 -
base:
'*':
- default
现在，移动到位于 /srv/pillar/default.sls 的 default.sls 文件，并添加以下代码。
# Default pillar values apache git
保存文件后，刷新 pillar 以更新所有更改。
刷新 Pillar
您可以使用以下命令刷新 pillar。
root@saltmaster:/home/vagrant# salt '*' saltutil.refresh_pillar
上述命令用于刷新所有 minion 上的 Salt pillar 数据。
列出 Pillar 数据
要列出 pillar 数据，您可以使用以下命令。
root@saltmaster:/home/vagrant# salt '*' pillar.ls
它将生成以下 输出：−
minion2: - apache - git minion1: - apache - git
Pillar 项目
设置 pillar 后，可以通过 pillar 模块在 minion 上查看数据。可以通过函数 **pillar.items** 访问它，该函数定义如下。
root@saltmaster:/home/vagrant# salt '*' pillar.items
它将生成以下 输出：−
minion2:
----------
apache:
httpd
git:
git
minion1:
----------
apache:
httpd
git:
git
SaltStack – Include 组件
‘Include’ 组件用于在多个位置定义相同的配置任务。这很容易执行。在状态文件的顶部，使用以下格式添加 include -
include: - state file 1 - state file 2
这里，**状态文件 1** 和 **状态文件 2** 是您要包含的 SLS 文件的名称。无需包含 **.sls** 扩展名。包含的 Salt 状态将插入当前文件的顶部。
子目录中的状态文件
您可以使用点 (.) 包含子目录状态文件。它充当目录分隔符。
include: - dir.sls1
Grains 接口
Grains 是一个用于获取有关底层系统信息的接口。Grains 会针对操作系统、域名、IP 地址、内核、操作系统类型、内存以及许多其他系统属性进行收集。
Grains 定位
在定位 minion 时可以使用 Grain 数据，这在以下代码块中定义。
root@saltmaster:/home/vagrant# salt -G 'os:Ubuntu' test.ping
它将生成以下 输出：−
minion1: True minion2: True
列出 Grains
可以使用 'grains.ls' 模块列出 Grains，该模块定义如下。
root@saltmaster:/home/vagrant# salt '*' grains.ls
列出项目
与 Pillar 一样，也可以使用 'grains.items' 列出 Grains 数据。
root@saltmaster:/home/vagrant# salt '*' grains.items
SaltStack - 日志记录
日志记录用于跟踪正在运行的软件事件。事件由描述性消息描述，该消息可以选择包含可变数据。Salt 日志记录方法用于解决您可能遇到的任何问题。您可以查看特定的日志级别。
配置设置
让我们详细了解日志记录的不同配置设置。
LOG_FILE
Salt 日志记录通过包含本地路径名或网络位置以进行标识的文件传递。此文件被视为日志文件。
log_file: /var/log/salt/master
这里，文件依赖于在 master 中执行的二进制文件。类似地，您也可以在 minion 中执行，如下所示。
log_file: /var/log/salt/minion
您还可以使用远程地址。使用远程地址的语法为 - <file|udp|tcp>://<host|socketpath>:<port-if-required>/<log-facility>。
log_file: udp://loghost:port
这里，Log-facility 默认为 LOG_USER。
LOG_LEVEL
日志级别按数字分配的值排序。Python 库默认定义了大多数日志级别。除此之外，Salt 还使用了一些其他级别。下面解释了一些级别。
**log_level: error; level value is 40** - 表示记录错误时的日志语句。
**log_level: quiet; level value is 1000** - 表示在此级别不应记录任何内容。
**log_level: info; level value is 20** - 表示正常的日志信息。
**log_level: warn; level value is 30** - 表示记录警告时的日志语句。
**log_level: debug; level value is 10** - 有助于调试 Salt 实现和 Salt 代码的信息。
**log_level: trace; level value is 5** - 更详细的代码调试信息。
LOG_LEVEL_LOGFILE
它定义要发送到日志文件的邮件级别。
log_level_logfile: info
LOG_DATEFMT
它定义了日志日期格式。默认情况下，它表示为 %Y-%m-%d %H:%M:%S。
log_datefmt_logfile: '%Y-%m-%d %H:%M:%S'
LOG_FMT_CONSOLE
它定义了控制台日志消息的格式。Salt 使用自定义的LogRecord属性来为控制台日志输出着色。它遵循以下语法 -
'%(colorlevel)s' # log level name colorized by level '%(colorname)s' # colorized module name '%(colorprocess)s' # colorized process number '%(colormsg)s' # colorized messages name
LOG_FMT_LOGFILE
它定义了日志文件记录消息的格式。基本语法如下 -
%(asctime)s,%(msecs)03d [%(name)-17s][%(levelname)-8s] %(message)s
LOG_GRANULAR_LEVELS
此级别用于更具体地控制日志记录级别。
log_granular_levels: 'salt': 'info' 'salt.modules': ‘trace'
这里，主 Salt 库在“info”级别将salt.modules设置为在跟踪级别记录日志。
外部日志处理程序
Salt 使用 LogStash 和 Sentry 外部日志处理程序进行日志记录。让我们在本节中详细了解它。
LOGSTASH 处理程序
LogStash 是一个开源的服务器端安全数据处理管道。让我们考虑 Salt 中一个简单的 UDP 日志处理程序，它使用 LogStash。
在 Salt master 文件中指定以下更改 -
logstash_udp_handler: host: 127.0.0.1 port: 9999 version: 1 msg_type: logstash
然后在 Logstash 配置文件中添加更改 -
input {
udp {
port ⇒ 9999
codec ⇒ json
}
}
这里，UDP – 是输入，需要具有json_event格式，这是我们通过网络发送的内容。
SENTRY 日志处理程序
Sentry 是生产部署中的实时错误跟踪和用于重现和修复崩溃的信息。master 文件中的默认配置如下所示。
sentry_handler: dsn: https://pub-key:[email protected]/app-id log_level: debug
这里，sentry 处理程序的默认日志级别为 ERROR，但我们在 sentry_handler 配置键下定义了调试log_level。
SaltStack - 通过 SSH 使用 Salt
Salt 通过使用salt-minion在远程系统中执行命令。这是正常行为。在某些情况下，只能通过 SSH 协议访问远程系统。对于这些情况，Salt 提供了一个选项，仅使用 SSH 协议连接远程系统，并通过 SSH 层执行命令。
Salt SSH非常易于配置。唯一需要的配置是在一个名为Roster 文件的特殊文件中指定远程系统详细信息。此清单文件通常位于/etc/salt/roster中。清单文件将包含有关远程系统的所有信息以及我们如何连接到它。配置清单文件后，所有 Salt 命令都将使用salt-ssh而不是 salt 命令执行。
Roster 文件
Roster 系统专为 Salt SSH 设计。它被设计为一个可插拔系统。Roster 系统的唯一目的是收集有关远程系统的信息。Roster 文件是一个基于 YAML 的配置文件，其中包含远程系统信息作为目标。这些目标是具有预定义属性集的特殊数据结构。Roster 文件包含一个或多个目标，每个目标由Salt ID标识。
Roster 文件的基本结构如下 -
<Salt ID>: host: <host name> user: <user name> passwd: <password of the user>
Roster 文件支持的所有其他属性都是可选的。它们如下 -
port – SSH 端口号。
sudo – 是否通过 sudo 运行命令。
sudo_user – sudo 用户名。
tty – 如果启用了 sudo 则为 true。
priv – 私钥。
timeout – SSH 连接的超时时间。
minion_opts – minion 选项的字典。
thin_dir – 目标系统用于 Salt 组件的存储目录。
cmd_umask – 强制用于 salt-call 命令的 umask。
示例清单文件如下 -
web: host: 192.168.2.1 user: webuser passwd: secret sudo: True db: host: 192.168.2.2
部署 SSH 密钥
Salt SSH 将为 SSH 登录生成默认的公钥/私钥对。默认路径将为 /etc/salt/pki/master/ssh/salt-ssh.rsa。可以使用ssh-copy-id命令将此密钥部署到远程系统，如下所示。
ssh-copy-id -i /etc/salt/pki/master/ssh/salt-ssh.rsa.pub [email protected]
执行命令
执行 salt 命令就像将salt cli命令更改为salt-ssh一样简单，如下所示。
salt-ssh '*' test.ping
原始 Shell 命令
Salt SSH 提供了一个选项 (-r) 用于在远程系统中执行原始命令，绕过 salt 模块和函数。
salt-ssh '*' -r 'ls'
使用 Salt SSH 定位
Salt SSH 中的远程系统定位仅支持 glob 和 regex 目标。由于 Salt SSH 是一个单独的模块，因此目前它仅提供有限的选项，并且将在不久的将来提供更多功能。
SaltStack - 用于云基础设施的 Salt
Salt 提供了一个单独的模块Salt Cloud，用于提供各种云提供商（如 Amazon AWS、Google Compute 等）的虚拟机。Salt Cloud 是一个通用接口，用于配置和管理各种云提供商的 VM。
Cloud Config – Salt Cloud 的主要配置文件为 /etc/salt/cloud，它适用于所有 VM。主要配置文件称为Cloud Config。
Cloud Providers – 要定位特定云提供商，我们可以使用特定的配置文件，它们位于 /etc/salt/cloud.providers.d/*.conf 中，这些称为Cloud Providers。
Cloud Profiles – 要定位特定的 VM，我们还可以使用一个特殊的配置文件，该文件仅适用于该特定 VM，它们位于 /etc/salt/cloud.profiles.d/*.conf 中，这些称为Cloud Profiles。
对于虚拟机，首先应用Cloud Config中的设置，然后应用Cloud Providers中的设置，最后由Cloud Profiles覆盖。
Salt Cloud 的安装
默认情况下，Salt Cloud 内置于 Salt 中，并且随时可用。如果它不可用，我们可以使用以下命令安装它。
pip install salt-cloud
由于 Salt Cloud 是一个单独的模块，并且在其自己的进程中运行，因此它也可以安装在 Salt Minion 系统中，而不是 Salt Master 中。
配置虚拟机
要配置虚拟机，我们需要定义一个云提供商和一个云配置文件。创建两者后，我们可以配置一个新的虚拟机以供使用。
云提供商
云主机信息配置在云提供商配置文件中。通常，需要配置的基本信息包括云驱动程序、用户名、密码、私钥等。让我们创建一个名为my-amazon-cloud的新云提供商。
在 /etc/salt/cloud.providers.d/ 下创建一个文件 my-amazon-cloud.conf。
使用ec2驱动程序添加一个新的提供商。
my-amazon-cloud:
driver: ec2
id: '<AWS_ID>'
key: '<AWS_KEY>'
private_key: /path/to/privatekey.pem
keyname: <name of the key>
securitygroup: default
minion:
master: <master server>
Salt 提供了各种云主机的驱动程序，例如 GoGrid、HP Cloud、Google Compute Engine (GCE)、Amazon AWS、Joyent、Linode、OpenNebula、ProfitBricks、Proxmox、Saltify、VexxHost、VMWare 等。
配置云提供商后，我们可以查询提供商的可用位置、可用的机器映像及其各种大小。
salt-cloud --list-location my-amazon-cloud salt-cloud --list-images my-amazon-cloud salt-cloud --list-sizes my-amazon-cloud
云配置文件
云配置文件指定虚拟机映像和大小。它可以在 – /etc/salt/cloud.profiles.d/ 下配置。让我们创建一个简单的配置文件simple.conf。
aws_micro: provider: my-amazon-cloud image: <image_id> size: <machine_id e.g. t1.micro>
虚拟机
配置提供商和配置文件后，我们可以使用 salt-cloud 轻松地提供虚拟机，如下所示。
salt-cloud -p aws_micro master minion1 minion2
其中，p – 配置文件名称 master、minion1 和 minion2 是新的虚拟机。
可以使用以下命令获取新创建的虚拟机的详细信息。
salt-cloud --query
可以使用以下命令销毁虚拟机 -
slat-cloud -d master minion1
云映射
云映射是一种特殊格式，用于一次创建多个虚拟机。映射文件格式是指定配置文件，然后在其下添加虚拟机的列表。
示例映射文件如下 -
micro: - web1 - web2 large: - db1 - db2
映射文件可以作为参数传递给 salt-cloud 命令以创建虚拟机，如下所示 -
salt-cloud -m /path/to/mapfile
SaltStack - Salt 代理 Minion
有很多设备，如路由器、网络设备等，具有自定义操作系统、有限的内存和高度的安全考虑因素。在这些设备中，我们无法安装标准的salt-minion，因此无法管理这些系统。但是，Salt 提供了一种创新的技术来克服此限制。
Salt 有一个单独的模块 salt proxy minion，它使用远程系统中运行的 REST 服务控制远程系统。此 REST 服务是一个基于 HTTP 的 Web 服务，使用表述性状态转移 (REST)概念编写，它们易于实现且易于使用。
每个设备都有自己的 SDK 和开发环境来编写复杂的应用程序。Salt 期望根据 Salt 接口规范在设备中开发 REST 服务。Salt 还提供了一个 python 模块来编写 REST Web 服务。如果设备支持 python，那么开发 REST Web 服务将很容易。
开发并在远程系统中部署 REST Web 服务后，可以将 Salt 配置为使用 REST Web 服务而不是 salt minion 来控制远程设备。
工作示例
让我们使用实时工作环境学习salt proxy minion的概念。对于实时环境，我们为 master 和 proxy minion 选择了一个 Linux 系统。我们将使用 REST Web 服务而不是 salt-minion 来控制系统。
安装和配置 REST Web 服务
Salt 提供了 REST Web 服务实现的示例，名为 proxyminion_rest_example，位于其 contrib 模块中。让我们安装示例 Web 服务。
使用 pip 安装'bottle'。bottle命令是一个 python web 框架，用于开发 web 应用程序。
pip install bottle = 0.12.8
从 github 下载saltstack/salt-contrib项目。或者，使用以下命令克隆项目。
git clone https://github.com/saltstack/salt-contrib
打开终端并转到salt-contrib目录。
此 salt-contrib 目录将有一个文件夹proxyminion_rest_example。此文件夹包含 REST Web 服务的示例实现。转到 proxyminion_rest_example 文件夹。
运行以下命令启动 REST Web 服务。
python rest.py --address <your ip address> --port 8000
打开浏览器并加载 http://«您的 IP 地址»:8000。这将显示默认页面，其中包含服务和程序包，如以下屏幕截图所示。
现在，我们已经配置了 REST Web 服务，它将检查如何配置 salt proxy 以查询 REST Web 服务并控制系统。
配置 Salt-Proxy
要配置 Salt-Proxy，我们必须按照以下步骤操作。
我们必须为 salt-proxy 指定 master 节点。编辑代理配置文件位置，位于 /etc/salt /proxy 中，并输入以下代码。
master: <your ip address>
修改 / 创建基本 pillar 文件，位于/srv/pillar/top.sls中，如以下代码块所示。
base:
'p8000':
- p8000
添加一个新的 pillar 文件p8000.sls，位于/srv/pillar中，如以下代码块所示。
proxy: proxytype: rest_sample url: http://<your ip address>:8000
使用以下命令在调试模式下启动 salt-proxy。
salt-proxy --proxyid = p8000 -l debug
与 salt-minion 类似，接受salt-proxy 密钥，如下所示。
salt-key -y -a p8000 The following keys are going to be accepted: Unaccepted Keys: p8000 Key for minion p8000 accepted.
运行 Salt
现在，运行salt命令并调用ping.test函数，如下所示。
salt p8000 test.ping
我们可以通过使用salt运行 REST Web 服务支持的任何函数，这类似于salt-minion。
例如，可以使用以下命令获取 grain 信息。
salt p8000 grains.items
SaltStack - 事件系统
Salt 中的事件系统是一个本地 ZeroMQ PUB 接口，它触发 salt 事件。它由以下组件执行。
事件套接字 – 用于发布事件。
事件库 – 用于侦听事件并将事件发送到 salt 系统。
Salt Master 事件
Salt master 提供不同类型的事件，下面将详细介绍 -
- 身份验证事件
- 启动事件
- 密钥事件
- 作业事件
- Runner 事件
- 存在事件
- 云事件
让我们详细了解每种事件类型。
身份验证事件
当 minion 对 master 执行身份验证检查时，这些身份验证事件会触发。它由 salt/auth 表示。
启动事件
每当 minion 连接到 Salt master 时，启动事件都会触发，它由 salt/minion//start 表示。
密钥事件
当 salt master 接受和拒绝 Salt minion 上的密钥时，会触发密钥事件。您可以使用 salt-key 命令访问此事件。
作业事件
每当新作业即将开始时，就会触发作业事件。它由salt/job//new表示。这里，JID - 作业 ID new - 新作业
Runner 事件
当 runner 开始执行时，会触发 runner 事件。它由 salt/run//new 表示。
存在事件
当Minion连接、新连接或断开连接时，此事件会以定期间隔触发。它由 – **salt/presence/present** 和 **salt/presence/change** 表示。其中，
**Present** – 表示 Salt Master 当前已连接到 Minion 列表。
**Change** – 用于检测新的 Minion 连接或断开连接。
云事件
Salt-cloud 事件在虚拟机上触发。除非其他事件，否则它不会在 Minion 上执行。您可以使用 – **salt/cloud//creating** 访问它。当 Salt Cloud 启动虚拟机执行过程时，它会被触发。
事件工具
现在，让我们了解一下事件工具和脚本。您可以使用 CLI 访问事件总线。可以通过以下命令访问。
salt-run state.event pretty = True
这里，runner 被设计为从外部工具和 shell 脚本与事件总线交互。Salt 的事件总线可以通过 **REST API** 远程访问。它由 –（示例 URL）表示。
curl -SsNk https://salt-api.example.com:8000/events?token = 05A3.
类似地，您也可以从 Python 脚本访问事件。
SaltStack - 编排
一般来说，**编排** 是系统自动协调和安排的过程。Orchestrate Runner 用于在 SaltStack 中执行编排。
Orchestrate Runner
Orchestrate Runner 提供了 **OverState**（先前系统）的所有功能。它最初被称为 **state.sls** runner。此 Orchestrate Runner 用于将 Salt 状态系统泛化到 Salt Master 上下文。
**state.sls** 和 **state.highstate** 函数在每个 Salt Minion 上执行，但 **state.orchestrate** runner 在 Master 上执行。**state.orchestrate** runner 允许您完全以状态的形式管理整个基础设施。让我们了解如何执行一个简单的执行过程。
简单执行
Orchestrate Runner 命令与 **state.sls** 函数相同，但您可以使用“salt-run”而不是 salt 来执行它。
假设您有一个位于 ** /srv/salt/orch/samples.sls** 的 **sample.sls** 文件。在该文件中添加以下代码。
sample.sls
install_nginx:
salt.state:
- tgt: 'web*'
- sls:
- nginx
以下命令用于在 Master 上运行，它将应用该文件中定义的状态。
salt-run state.orchestrate orch.sample
它将生成以下 输出：−
saltmaster.local_master: ---------- ID: install_nginx Function: salt.state Result: True Comment: States ran successfully. Started: 11:54:56.308078 Duration: 63.401 ms Changes: Summary for saltmaster.local_master ------------ Succeeded: 1 Failed: 0 ------------ Total states run: 1 Total run time: 63.401 ms root@saltmaster:/home/vagrant#
这里，根据当前版本，runner 函数已重命名为 **state.orchestrate**。这将有助于避免与 state.sls 执行函数混淆，但必须使用先前版本的 **state.sls**。
执行函数
要执行函数，应使用 **salt.function**。考虑一个位于 ** /srv/salt/orch/data.sls** 的文件 **data.sls**。现在，在该文件中添加以下更改。
data.sls
cmd.run:
salt.function:
- tgt: '*'
- arg:
- rm -rf /tmp/data
以下命令用于执行 Salt 函数。
root@saltmaster:/home/vagrant# salt-run state.orchestrate orch.data
它将生成以下 输出：−
saltmaster.local_master:
----------
ID: cmd.run
Function: salt.function
Result: True
Comment: Function ran successfully. Function cmd.run ran on minion1, minion2.
Started: 12:14:54.791635
Duration: 234.615 ms
Changes:
minion1:
minion2:
Summary for saltmaster.local_master
------------
Succeeded: 1 (changed = 1)
Failed: 0
------------
Total states run: 1
Total run time: 234.615 ms
SaltStack - Salt 包管理器
Salt 公式通过包管理器打包并分发到 Salt Master。这个概念受到 **RPM**、**Yum** 和 **Pacman** 打包系统的启发。Salt 状态、pillar、文件模板和其他文件由公式使用，然后打包到单个文件中。
创建公式包后，将其复制到存储库系统，以便 Salt Master 使用。在转到包管理器之前，让我们看看如何使用 Salt 基本命令安装“nginx”包。
以下语法用于安装“nginx”包。
root@saltmaster:/home/vagrant# salt '*' pkg.install nginx
这里，**pkg.install nginx** 命令用于安装包。执行后，您将看到以下响应。
它将生成以下 输出：−
minion2:
----------
httpd:
----------
new:
1
old:
httpd-cgi:
----------
new:
1
old:
libxslt1.1:
----------
new:
1.1.28-2build1
old:
nginx:
----------
new:
1.4.6-1ubuntu3.7
old:
nginx-common:
----------
new:
1.4.6-1ubuntu3.7
old:
nginx-core:
----------
new:
1.4.6-1ubuntu3.7
old:
minion1:
----------
httpd:
----------
new:
1
old:
httpd-cgi:
----------
new:
1
old:
libxslt1.1:
----------
new:
1.1.28-2build1
old:
nginx:
----------
new:
1.4.6-1ubuntu3.7
old:
nginx-common:
----------
new:
1.4.6-1ubuntu3.7
old:
nginx-core:
----------
new:
1.4.6-1ubuntu3.7
old:
现在，您已安装了一个包。要启动该包的服务，请使用以下命令。
root@saltmaster:/home/vagrant# salt '*' service.start nginx
运行此命令后，结果如下面的代码块所示。
minion1: True minion2: True
因此，我们已经使用基本命令安装并启动了“nginx”包的服务。现在让我们讨论如何在 Salt 包管理器中构建和安装包。
构建包
可以在任何可以安装 Salt 的系统上构建包。有三种类型的包，如下所示。
- Formula
- Reactor
- Conf
现在让我们了解如何使用 **Formula** 文件构建包。
Formula 文件
包中的大多数文件默认位于 – /srv/spm/salt/ 目录下，但 pillar 文件可以放在 – /srv/spm/pillar/ 目录中。Formula 文件描述了包。
示例
name: apache os: RedHat os_family: RedHat version: 201607 release: 2 summary: Formula for installing Apache description: Formula for installing Apache
这里，
**Name** – 包的名称。这里，包名为 **apache**。
**os** – 用于了解哪些操作系统可以支持此包。
**os_family** – 用于了解哪些操作系统系列可以支持此包。
**Version** – 包的版本。它以 YYYYMM 格式指定。
**Release** – 此字段主要指版本的发布。
**Summary** – 包的简短描述。
**Description** – 包的详细描述。
REACTOR
reactor 文件位于 ** /srv/spm/reactor/** 目录中。
CONF
此类型包中的文件是 Salt 的配置文件，通常位于 ** /etc/salt/** 目录中。除 Salt 之外的其他包的配置文件可以使用 Salt 状态（使用 formula 类型的包）进行处理。
让我们继续执行以下步骤来构建包。
创建一个 FORMULA 文件并将其放在包文件夹的根目录中。
在构建系统上的文件夹中组装 formula 文件。
运行 **spm build**。包已构建并放置在 /srv/spm_build 文件夹中。以下命令用于构建包。
spm build /path/to/salt-packages-source/formula
现在，将 **.spm** 文件复制到存储库系统上的文件夹中。
您可以共享网络上的 **srv/spm_build** 文件夹，或将文件复制到您的 FTP 或 Web 服务器上。
使用以下命令生成 repo 元数据。
spm create_repo /srv/spm_build
安装包
本节介绍如何安装 Salt 包管理器包。
配置远程存储库
要配置远程存储库，Salt Master 需要通过配置过程知道存储库的位置。
文件位于 ** /etc/salt/spm.repos.d/spm.repo** 目录中。
示例
file_repository: url: https://spm.example.com/
这里，文件包含存储库的名称和存储库的链接。您还可以使用 http、https、ftp 或文件路径。要使用文件路径，您可以使用 URL 访问它：file:///srv/spm_build。
更新元数据
在 Salt Master 上配置存储库后，将使用以下命令下载存储库元数据。
spm update_repo
更新文件根目录
SPM 包位于 srv/spm/salt 目录中。将以下路径添加到 Salt Master 上的文件根目录中，
file_roots:
base:
1. /srv/salt
2. /srv/spm/salt
现在，重新启动 Salt Master。
安装 Apache 包
要安装 apache 包，请使用以下命令。
spm install apache
您也可以直接从 SPM 文件使用以下命令安装。
spm local install /srv/spm/apache-201607-1.spm
删除包
要删除包，例如 – apache，请使用以下命令，
spm remove apache
请注意，如果任何文件已被修改，则不会删除它们。
SaltStack - Python API
Salt 提供对其所有命令的编程访问。Salt 为 Salt 系统的每个部分提供不同的模块。在本节中，让我们学习 Python API 的基础知识以及如何在其中运行基本的 Salt 命令。
配置
**salt.config** 模块用于访问 Salt 配置详细信息。
import salt.config
opts = salt.config.client_config('/etc/salt/master')
这里，**client_config** 读取 salt 配置文件并将配置详细信息作为字典返回。
加载器
**salt.loader** 模块用于加载 Salt 中的每个模块，例如 grains、minions 等。
import salt.loader
opts = salt.config.minion_config('/etc/salt/minion')
grains = salt.loader.grains(opts)
这里，**grains** 读取 Salt 系统中 grains 的详细信息并返回它。
客户端模块
**salt.client** 模块用于以编程方式执行 salt、salt-call 和 salt-SSH 命令。
最重要的 Python 类如下：
- salt.client.LocalClient
- salt.client.Caller
- salt.client.ssh.client.SSHClient
大多数客户端模块提供的主要功能是 **cmd**。此函数包装 CLI 选项并执行它，这类似于命令行，并将结果作为 Python 数据结构返回。
LocalClient
LocalClient 用于从 Master 发送命令到 Salt Minion 并将结果返回到 Master。
import salt.client
local = salt.client.LocalClient()
local.cmd('*', 'test.ping')
它将生成以下 输出：−
{'minion1': True, 'minion2': True }
Caller
Caller 用于以编程方式运行 **salt-call** 并返回结果。
import salt.client
caller = salt.client.Caller()
caller.cmd('test.ping')
它将生成以下 输出：−
True
SSHClient
SSHCient 用于以编程方式运行 **salt-ssh** 并返回结果。
import salt.client.ssh.client
ssh = salt.client.ssh.client.SSHClient()
ssh.cmd('*', 'test.ping')
它将生成以下 输出：−
{'minion1': True, 'minion2': True }
CloudClient
**salt.cloud** 模块用于以编程方式执行 salt-cloud 命令。
client = salt.cloud.CloudClient(path = '/etc/salt/cloud')
Cloud 模块提供创建 VM（create）、销毁 VM（destroy）、列出云提供商提供的镜像（list_images）、列出云提供商的位置（list_locations）、列出云提供商的机器大小（list_sizes）等功能。
SaltStack - 工作示例
在这个工作示例中，我们将创建一个 Salt 公式，它将配置 apache web 服务器以及 PHP 软件。Salt 是执行 ad-hoc 命令的好方法，但您不希望持续以这种方式配置您的基础设施。通过创建一组 Salt 公式，您可以可靠地复制任何配置。
Salt 公式是简单的 YAML 文本文件，默认情况下驻留在 Salt Master 上的 ** /srv/salt/*** 中。让我们从创建一个 Salt 公式开始，以同时安装 Apache web 服务器和 PHP。
在 ** /srv/salt/** 目录下创建一个名为“websetup.sls”的文件，并添加以下代码。
websetup.sls
websetup:
pkg:
- installed
- pkgs:
- apache2
- php5
- php5-mysql
在此示例中，请注意“- pkgs:” 参数。“- pkgs:” 下面的每个项目都将一起传递到操作系统的包管理器以一起安装。无论何时需要安装大量包，这都是最有效的安装方式。
使用以下命令将此公式应用于 Salt Master。
root@saltmaster:/home/vagrant# salt 'minion2' state.sls websetup
现在，您将看到以下 **输出**：
minion2:
----------
ID: websetup
Function: pkg.installed
Result: True
Comment: 3 targeted packages were installed/updated.
Started: 01:50:53.978396
Duration: 86738.132 ms
Changes:
----------
apache2:
----------
new:
2.4.7-1ubuntu4.13
old:
apache2-api-20120211:
----------
new:
1
old:
apache2-bin:
----------
new:
2.4.7-1ubuntu4.13
old:
apache2-data:
----------
new:
2.4.7-1ubuntu4.13
old:
libapache2-mod-php5:
----------
new:
5.5.9+dfsg-1ubuntu4.21
old:
libapr1:
----------
new:
1.5.0-1
old:
libaprutil1:
----------
new:
1.5.3-1
old:
libaprutil1-dbd-sqlite3:
----------
new:
1.5.3-1
old:
libaprutil1-ldap:
----------
new:
1.5.3-1
old:
php5:
----------
new:
5.5.9+dfsg-1ubuntu4.21
old:
php5-cli:
----------
new:
5.5.9+dfsg-1ubuntu4.21
old:
php5-common:
----------
new:
5.5.9+dfsg-1ubuntu4.21
old:
php5-json:
----------
new:
1.3.2-2build1
old:
php5-mhash:
----------
new:
1
old:
php5-mysql:
----------
new:
5.5.9+dfsg-1ubuntu4.21
old:
php5-readline:
----------
new:
5.5.9+dfsg-1ubuntu4.21
old:
phpapi-20121212:
----------
new:
1
old:
ssl-cert:
----------
new:
1.0.33
old:
Summary for minion2
------------
Succeeded: 1 (changed = 1)
Failed: 0
------------
Total states run: 1
Total run time: 86.738 s
现在，您已在 **minion2** 中安装了这些包。
Highstate
“highstate”是 Salt 用于确定应将哪些 Salt 公式应用于特定 Minion 的一种方法。使用以下命令执行“highstate”。
root@saltmaster:/home/vagrant# salt <targets> state.highstate
top.sls
当 Minion 请求执行 highstate 时，如前所述，Minion 会从 Salt Master 请求 top.sls 并搜索与其匹配的公式。默认情况下，此文件位于 /srv/salt/top.sls。让我们将我们的公式添加到 top.sls 文件中并将 minion2 设置为目标。
base:
'*':
- common
'minion2’:
- websetup
现在，执行目标为 minion2 的 **highstate**，如下所示。
root@saltmaster:/home/vagrant# salt 'minion2' state.highstate
应用此操作后，您将看到以下输出 -
minion2: ---------- ID: common_packages Function: pkg.installed Result: True Comment: All specified packages are already installed Started: 01:55:17.998824 Duration: 461.615 ms Changes: Summary for minion2 ------------ Succeeded: 1 Failed: 0 ------------ Total states run: 1 Total run time: 461.615 ms
现在，Apache web服务器和PHP已安装在minion2上。通过这种方式，我们必须使用top.sls和highstate来定位minion，并以最少的工作量和最大的灵活性安装所需的软件。