SaltStack – 快速指南
SaltStack – 快速指南
SaltStack – 概述
在本章中，我们将学习 SaltStack 的基础知识。SaltStack 的远程执行功能允许管理员在各种机器上并行运行命令以及灵活的目标系统。Salt 配置管理建立了一个 master-minion 模型，以快速、轻松、灵活和安全地使基础设施组件符合给定的策略。
什么是盐栈？
Salt 是一个非常强大的自动化框架。Salt 架构基于远程执行命令的思想。所有网络都是围绕远程执行的某些方面设计的。这可以像要求远程 Web 服务器显示静态网页一样简单，也可以像使用 shell 会话以交互方式向远程服务器发出命令一样复杂。Salt 是一种更复杂的远程执行类型的示例。
Salt 旨在允许用户明确地直接针对多台机器发出命令。Salt 是基于控制一个或多个Minion的 Master 的想法。命令通常从 Master 发送到目标组 Minion，然后执行命令中指定的任务，然后将结果数据返回给 Master。master 和 minions 之间的通信发生在ZeroMQ 消息总线上。
SaltStack 模块与支持的 minion 操作系统通信。该盐大师在Linux上默认运行，但任何操作系统可以是一个奴才，和目前的Windows，VMware vSphere和BSD Unix的变种很好的支持。Salt Master 和 Minions 使用密钥进行通信。当 Minion 首次连接到 master 时，它会自动将密钥存储在 master 上。SaltStack 还提供Salt SSH，它提供“无代理”系统管理。
需要 SaltStack
SaltStack 是为速度和规模而构建的。这就是为什么它被用于管理具有数万台服务器的大型基础设施，包括 LinkedIn、WikiMedia 和 Google。
想象一下，您有多个服务器并且想要对这些服务器执行操作。您需要登录到每一个并一次对每一个做这些事情，然后您可能想要做一些复杂的事情，例如安装软件，然后根据某些特定标准配置该软件。
让我们假设您有 10 台甚至 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 易于设置并提供单一的远程执行架构，可以管理任意数量服务器的不同需求。
-
Language Agnostic – Salt 状态配置文件、模板引擎或文件类型支持任何类型的语言。
SaltStack的好处
简单且功能丰富的系统，Salt 提供了许多好处，它们可以总结如下 –
-
Robust – Salt 是功能强大且健壮的配置管理框架，适用于数以万计的系统。
-
Authentication – Salt 管理用于身份验证的简单 SSH 密钥对。
-
安全– Salt 使用加密协议管理安全数据。
-
Fast – Salt 是非常快速、轻量级的通信总线，为远程执行引擎提供基础。
-
虚拟机自动化– Salt Virt 云控制器功能用于自动化。
-
基础设施即数据，而不是代码– Salt 提供了一个简单的部署、模型驱动的配置管理和命令执行框架。
ZeroMQ 简介
Salt基于ZeroMQ库，它是一个可嵌入的网络库。它是轻量级且快速的消息传递库。基本实现是在C/C++ 中，并且可以使用包括Java和.Net在内的多种语言的本机实现。
ZeroMQ 是一种无代理的对等消息处理。ZeroMQ 允许您轻松设计复杂的通信系统。
ZeroMQ 带有以下五种基本模式 –
-
同步请求/响应– 用于发送请求并接收每个发送的后续回复。
-
异步请求/响应– 请求者通过发送请求消息并等待响应消息来启动对话。Provider 等待传入的 Request 消息并回复 Response 消息。
-
发布/订阅– 用于将数据从单个进程（例如发布者）分发到多个接收者（例如订阅者）。
-
推/拉– 用于将数据分发到连接的节点。
-
Exclusive Pair – 用于将两个对等点连接在一起，形成一对。
ZeroMQ 是一种高度灵活的网络工具，用于在集群、云和其他多系统环境之间交换消息。ZeroMQ 是SaltStack 中提供的默认传输库。
SaltStack – 架构
SaltStack 的架构旨在与任意数量的服务器一起工作，从本地网络系统到跨不同数据中心的其他部署。架构是一个简单的服务器/客户端模型，将所需的功能内置到一组守护进程中。
请看下图。它展示了 SaltStack 架构的不同组件。
-
SaltMaster – SaltMaster 是主守护进程。SaltMaster 用于向 Salt slaves 发送命令和配置。一个master可以管理多个master。
-
SaltMinions – SaltMinion 是奴隶守护进程。Salt Minion 从 SaltMaster 接收命令和配置。
-
执行– 从命令行针对一个或多个 Minion执行的模块和 Adhoc 命令。它执行实时监控。
-
公式– 公式是预先编写的盐状态。它们与 Salt States 本身一样开放，可用于安装包、配置和启动服务、设置用户或权限以及许多其他常见任务等任务。
-
Grains – Grains 是一个界面，提供特定于 Minion 的信息。通过grains界面可用的信息是静态的。当 Salt Minion 启动时，Grains 会被加载。这意味着谷物中的信息是不变的。因此，grains 信息可能与正在运行的内核或操作系统有关。它不区分大小写。
-
Pillar – 支柱是一个接口，用于生成和存储特定于特定 minion 的高度敏感数据，例如加密密钥和密码。它将数据存储在键/值对中，并且数据的管理方式与 Salt State Tree 类似。
-
Top File – 将 Salt 状态和支柱数据与 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 – Linux、CentOS 和 Scientific Linux 通过 Extra Packages for Enterprise Linux (EPEL) 以及其他操作系统的 Fedora 发行版。
原始语言
-
SaltStack – Python
-
木偶 – 红宝石
-
Chef – Ruby 及其 CLI 使用基于 Ruby 的 DSL
-
Ansible – Python
支持的语言
-
SaltStack – 任何语言
-
木偶– 红宝石
-
Chef – Ruby 及其 CLI 使用基于 Ruby 的 DSL
-
Ansible – 任何语言
网页界面
-
SaltStack – Web UI 提供正在运行的作业、minion 状态和事件日志的视图。
-
Puppet – Web UI 处理报告、盘点和实时节点管理。
-
Chef – Web UI 可让您搜索和清点节点、查看节点活动并分配食谱、角色和节点。
-
Ansible – Web UI 可让您配置用户、团队和库存，并将 Playbooks 应用于库存。
管理工具
-
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 – 免费开源版本；Enterprise Chef 5 台机器免费，20 台机器每月 120 美元，50 台机器每月 300 美元。
-
Ansible – 免费开源版本；10 台机器免费使用 Ansible，然后每台机器每年 100 美元或 250 美元，具体取决于您需要的支持。
用法
-
SaltStack – 思科和 Rackspace 使用 SaltStack。它可以与任何基于云的平台集成。
-
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
主配置
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列表命令，
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 minions。这种环境将帮助我们在接下来的章节中学习盐的概念。
让我们按照以下步骤来创建 SaltStack 环境。
安装 VirtualBox 环境
VirtualBox 是一个跨平台的虚拟化应用程序。VirtualBox 允许您一次运行多个操作系统。VirtualBox 可在 Windows、Linux、Macintosh 和 Solaris 上运行。它承载并支持大量客户操作系统。
您可以通过访问以下链接下载并安装 VirtualBox – https://www.virtualbox.org/wiki/Downloads
我们将创建三个虚拟机并使用 VirtualBox 运行它。
安装流浪汉
Vagrant 提供易于配置、可复制和可移植的工作环境。
您可以通过访问以下链接下载并安装 Vagrant – https://www.vagrantup.com
Vagrant安装成功后，需要进行配置。在文件夹中创建一个名为Vagrantfile的文件，并描述机器的类型及其属性。
运行 Vagrant – 要运行 Vagrant，请发出以下命令 –
vagrant up
在你运行 vagrant up 之后，Vagrant 创建并启动这些机器，这些机器是在Vagrantfile中定义的，在后台使用 VirtualBox。这些机器将一直运行，直到您关闭它们。
停止 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 Minions 是否正在监听，
salt '*' test.ping
它将产生以下输出–
minion1: True minion2: True
从上面的结果中，列出 minion 1 和 minion 2，这意味着 minion 正在正常监听，否则 minion 现在可能会正确响应。
SaltStack – 访问控制系统
访问控制系统为用户组提供选项以执行具有权限的任务。Salt 访问控制系统用于配置对非管理控制界面的访问。您可以将此过程应用于所有系统。此控件可帮助非管理用户执行 Salt 命令。
Salt接口有以下三种类型 –
- 发布者 ACL 系统
- 外部认证系统
- 对等系统
让我们详细了解这些接口中的每一个。
发布者 ACL 系统
发布者 ACL 系统允许访问除 root 之外的用户以从 master 对 minions 执行 Salt 命令。通过publisher_acl配置选项在主配置文件中配置发布者ACL 系统。它的定义如下 –
publisher_acl:
user1:
- .*
user2:
- web*:
- test.*
- pkg.*
这里，
-
user1可以执行任何操作。
-
允许user2使用test和pkg，但只能在“web*”minions 上使用。
外部认证系统
的外部身份验证系统用于提供接入通过外部授权系统等执行特定的爪牙盐命令PAM，LDAP等如下所述该配置文件的主文件中定义的。
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 Server 都会询问身份验证详细信息。为了限制 Salt Server 仅在第一次询问身份验证详细信息，我们可以使用 T 选项。此-T 选项会缓存接下来 12 小时（默认设置）的身份验证详细信息并使用它来对用户进行身份验证。
salt -T -a pam web\* test.ping
对等系统
Salt Minion 可以使用对等接口传递命令。peer 接口通过 master 配置文件进行配置，以允许minions使用peer配置部分从 master 发送命令，或者允许minions使用peer_run配置从 master 执行运行程序。
让我们详细了解这两种配置。
对等配置
要在主文件中定义的简单配置如下 –
peer:
.*:
- .*
在这里，它可以为所有 Minion 启用通信，但仅推荐用于非常安全的环境。
要将 Minion 分配给特定 ID，需要如下定义配置： peer –
.*domain.com: - test.*
peer_run 配置
此配置是为了允许 minions 使用 master 文件上的 peer_run 选项从 master 执行运行程序。下面的例子是允许访问所有minion和所有runner。
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。在其中，minions 维护的目录称为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 功能用于识别哪些作业仍在运行，并检查哪些系统已完成作业以及哪些系统仍在等待。它使用以下命令执行，
salt-run jobs.active
LOOKUP_JID 函数
lookup_jid runner 将显示当前查找作业的数据。这些作业是通过主配置中的keep_jobs选项配置的。它是使用以下命令执行的。
salt-run jobs.lookup_jid <job id number>
LIST_JOBS 函数
List_jobs 函数用于列出作业的作业数据。它由以下命令表示 –
salt-run jobs.list_jobs
作业调度
调度系统公开了 Minion 上的任何执行函数或 master 上的任何 runner。
它通过以下方法执行 –
-
Schedule – master 或 minion配置文件中的计划选项。
-
Minion pillar data – 它使用 saltutil.refresh_pillar 命令刷新 minion 支柱数据。
-
调度状态或调度模块。
Salt 状态在 minion 上执行。您可以传递位置参数并在配置文件中提供命名参数的YAML 字典，如下所示。
schedule:
job1:
function: saltstate.sls
seconds: 3600
args:
- httpd
kwargs:
test: True
在这里，job1将每小时执行带有指定参数的函数saltstate.sls，httpd。的测试：真正是为附加参数的httpd是在定义的命令saltstate.sls。
SaltStack – 盐文件服务器
Salt 文件服务器是一个无状态的 ZeroMQ 服务器。它内置于 Salt Master 中。Salt 文件服务器用于将文件从 master 分发到 minions。它包含不同的模块。本章让我们了解salt文件服务器，它的配置，与salt文件服务器相关的模块，如何在python中访问salt文件服务器等。
文件服务器后端
文件服务器后端允许 Salt 文件服务器充当与本地文件系统、Git 版本控制系统等其他文件服务器的透明接口。
可以通过在主文件中使用以下配置来启用 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
在这里，环境是使用 root 选项定义的。
文件服务器配置
Salt 文件可以在许多根目录中分配，并通过指定文件路径和要搜索的环境来访问。单个环境可以跨越多个目录根。
环境
默认环境是 base。此环境已定义，用于在未指定其他环境时下载文件。
file_roots:
base:
- /srv/salt/base
您还可以使用多种环境，如下面的代码所示。
file_roots:
base:
- /srv/salt/base
dev:
- /srv/salt/dev
- /srv/salt/base
CP模块
CP 模块是操作Salt 文件服务器的主要模块。该盐的cp命令也可以用于分发由盐业文件服务器提供文件。
获取文件
该cp.get_file功能可以在仆从可以用来从主机下载文件。它的定义如下面的代码块所示。
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功能可以在仆从被用来从主下载整个目录。它在以下代码块中定义。
salt '*' cp.get_dir salt://etc/mysql /etc
该cp.get_dir支持模板渲染和gzip压缩参数。如果你愿意，你也可以分配。
文件客户端模块
Salt 提供了一个 python 模块来帮助访问 salt 文件服务器。的盐/ fileclient.py模块用于建立从仆从到主用的通信。
获取文件的示例代码如下 –
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 Server 先决条件
Salt 服务器使用 Git 作为文件服务器的最低要求如下 –
- pygit2
- 德威
Pygit2 和 Dulwich 使用主配置文件中的gitfs_provider参数进行配置。如果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
GitPython 可以使用yum / apt 命令轻松安装在 master 上，如下所示。
-
基于 Fedora 的系统
yum install GitPython
-
基于Ubuntu的系统
apt-get install python-git
安装德威
使用 yum 命令可以轻松地将 Dulwich 安装到主服务器上。
-
基于 Fedora 的系统
yum install python-dulwich
-
基于Ubuntu的系统
apt-get install python-dulwich
现在，我们已经安装了 Git 文件服务器的所有依赖项。现在让我们使用主配置文件中的fileserver_backend部分配置此 Git 文件服务器。
后端配置
为了使用 Git 文件服务器，您需要在主配置文件的 fileserver_backend 列表中添加 Git。描述如下 –
fileserver_backend: - git
让我们进一步了解如何在远程配置中配置 Git 文件服务器。
gitfs_remotes 配置
您可以为主文件中的 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 以加载 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是由盐提供一个特殊的文件服务器的爪牙在它们之间交换文件。MinionFS 提供的文件是 Minion 有意共享的文件。要共享文件，Minion 必须遵循以下步骤。
-
Source minion 必须使用cp.push函数将文件推送到 salt master 。
-
一旦文件被源 minion 推送，任何其他 minion 就可以使用 MinionFS 文件服务器访问部署的文件。
启用推送
默认情况下，minion 将文件推送到 master 是禁用的。要接受来自 minion 的文件，master 需要在配置文件中有“file_recv”选项，并且它的值必须设置为True。默认情况下，“file_recv”的值为false。
file_recv: True
启用该选项后，重新启动主服务。
推送文件
Minions 可以将文件推送到 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_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共享文件。
-
网络服务器1
-
id 与正则表达式匹配的 Minions develop *
-
id 与正则表达式mail\d+.mysite.com匹配的 Minions 。
-
测试
在下一章中，我们将学习如何将 Cron 与 Salt 结合使用。
SaltStack – 将 Cron 与盐一起使用
Salt 可以与Cron应用程序一起使用。一起使用这两个应用程序提供了自动化 Salt 的绝佳机会。虽然 Salt 提供了远程执行命令的选项，但 Cron 使其能够以预先安排或自动的方式运行。让我们在本章中学习如何一起使用 Cron 和 Salt。
什么是克朗？
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"
每行有以下七个入口点，以空格分隔，如下所示 –
-
分钟– 一小时的分钟，介于“0”和“59”之间。
-
小时– 小时，以 24 小时制指定。
-
day_of_month – 月份中的第几天，介于 1 到 31 之间。例如，10th 每个月是 10。
-
月– 指定的月份并以数字（0-12）或月份的名称（例如五月）指定。
-
day_of_week – 星期几以数字（0-7）或一天的名称（例如太阳）指定。
-
user – 命令运行的用户帐户。
-
cmd – 实际命令及其参数。
在这里，如果没有指定任何内容，则替换为 *。
盐调用者（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功能将检查盐配置文件仆从并检查仆从定义的所有动作是否被正确配置。
-
设置路径是一个很好的做法，因为有时系统路径中可能没有 salt 命令。
下一章我们将学习Remote Execution，它是Salt的一个核心概念。
SaltStack – 远程执行
Salt 的核心概念之一是远程执行。Salt 可以在几秒钟内跨数千个系统执行命令。Salt 使用自己的命令来执行此功能。现在让我们了解本章中用于远程执行的不同 Salt 命令。
盐命令
Salt 命令使 Salt Master 能够与一个或多个Salt Minion通信。基本语法如下，
salt '<target>' <module.function> [arguments]
上述命令语法由以下三个主要部分组成。
-
target – 它确定命令应用哪些系统。
-
module.function – 这是一个命令。命令由模块和函数组成。
-
arguments – 调用函数所需的额外数据。
让我们详细了解每个组件。
什么是目标组件？
Target 是一个组件，它允许您过滤 minion（托管系统）以运行该功能。下面定义了一个使用目标组件的简单命令。
salt '*' test.ping
它将产生以下输出–
minion2: True minion1: True
此处，目标“*”代表所有受管系统。这里的’ test ‘是一个模块，ping是一个函数。这用于测试远程系统中的 ping 服务。我们将在后续章节中了解不同的模块及其功能。
使用 ID 的目标（minion）
您可以使用目标中的id向特定 minion 发送命令。您可以使用minion id替换它，而不是使用‘*’。它定义如下。
salt 'minion1’ test.ping
它将产生以下输出–
minion1: True
使用正则表达式的目标
可以通过特定的正则表达式过滤目标。它定义如下。
salt -E 'minion[0-9]' test.ping
它将产生以下输出–
minion2: True minion1: True
使用列表的目标
可以在列表中明确指定目标。它在以下代码块中定义。
salt -L 'minion1,minion2' test.ping
它将产生以下输出–
minion2: True minion1: True
条件目标
目标可以组合在一个命令中，如下面的代码块所示。
salt -C 'G@os:Ubuntu and minion* or [email protected].*' test.ping
它将产生以下输出–
minion1: True minion2: True
模块和函数 (module.function)
Salt可以执行shell命令；同时在其所有托管系统中更新包和分发文件等。Salt 使用模块执行这些操作。Salt 具有用于所有可用功能的特殊模块。让我们通过本章中的一些简单示例来了解不同的 Salt 模块。
外壳命令
Salt 使用cmd.run命令跨多个系统远程执行 shell 命令。该CMD是主模块和运行是在现有的功能之一CMD模块。的运行功能使作为显示在下面的代码块被在远程系统执行的任何外壳命令。
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来获取托管系统的完整磁盘详细信息。该diskmodule具有使用功能来查询详细信息。
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提供了一个单独的模块，网络和功能，模块内部的接口来查询被管系统的网络接口信息。
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 函数是自记录的。所有函数文档都可以通过 sys.doc() 函数从 minions 中检索，该函数定义如下。
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 中最重要的概念之一。它用于创建一个可重用的配置模板，称为state。状态描述了将系统组件或应用程序置于已知配置中所需的一切。
盐州
Salt 状态是系统特定部分的可重用配置。使用简单的 YAML 更容易理解和描述状态。
创建盐状态
盐状态很容易创建。让我们在本章中创建一个简单的状态。移动到目录“salt-vagrant-demo/saltstack/salt/”并创建一个名为samples.sls的文件并在其中添加以下行。
样品.sls
install_network_packages:
pkg.installed:
- pkgs:
- rsync
- lftp
- curl
现在，保存文件并在 Salt Master 中运行以下命令。
root@saltmaster:/home/vagrant# salt 'minion1’ state.apply samples
在这里，我们安装的rsync，lftp的和卷曲通过pkg.installed模块使用盐状态盐奴才，minion1。如果它工作正常，您可以看到如下所示的响应。
它将产生以下输出–
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
应用盐态
现在我们已经使用“.sls”文件创建了一个状态，并通过专门调用它来应用它。Salt 有一个名为top.sls文件的默认状态文件。顶层文件用于将多个状态文件应用于 Salt Minion。顶部文件描述了应该在哪里应用状态。好吧，States和Top 文件共同创建了 SaltStack 配置管理功能的核心。
现在让我们在目录saltstack/salt 中创建一个简单的 top.sls 文件并添加以下内容。
顶.sls
base:
'*':
- common
'minion1':
- samples
这里，state，通常适用于所有系统状态，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 状态函数安装一个“Vim”包。
创建和应用状态函数
在“salt-vagrant-demo/saltstack/salt/sample.sls”目录下创建一个名为“sample.sls”的文件并添加以下内容 –
样本.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 测试方法测试包。
盐态测试
通过向状态添加“test = True”选项来强制执行测试运行。返回信息将显示将应用的状态为黄色，结果报告为“无”。
以下命令用于测试状态 –
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 是使 Salt 状态可重用的重要组件。它用于为使用目标分配的 Minion 定义安全数据。Salt 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
保存文件后，刷新支柱以更新所有更改。
刷新支柱
您可以使用以下命令刷新支柱。
root@saltmaster:/home/vagrant# salt '*' saltutil.refresh_pillar
上述命令用于刷新所有minion上的Salt pillar数据。
列出支柱数据
要列出支柱数据，您可以使用下面给出的命令。
root@saltmaster:/home/vagrant# salt '*' pillar.ls
它将产生以下输出–
minion2: - apache - git minion1: - apache - git
支柱项目
一旦设置了支柱，就可以通过支柱模块在 minion 上查看数据。可以通过函数pillar.items访问它，该函数定义如下。
root@saltmaster:/home/vagrant# salt '*' pillar.items
它将产生以下输出–
minion2:
----------
apache:
httpd
git:
git
minion1:
----------
apache:
httpd
git:
git
SaltStack – 包含组件
“包含”组件用于在多个位置定义相同的配置任务。它很容易执行。在状态文件的顶部，使用以下格式添加一个包含 –
include: - state file 1 - state file 2
此处，状态文件 1和状态文件 2是您要包含的 SLS 文件的名称。无需包含.sls扩展名。Included Salt 状态被插入到当前文件的顶部。
子目录中的状态文件
您可以使用点 (.) 包含子目录状态文件。它充当目录分隔符。
include: - dir.sls1
谷物界面
Grains 是一个接口，用于获取有关底层系统的信息。为操作系统、域名、IP 地址、内核、操作系统类型、内存和许多其他系统属性收集 Grain。
谷物瞄准
以小兵为目标时可以使用谷物数据，这在以下代码块中定义。
root@saltmaster:/home/vagrant# salt -G 'os:Ubuntu' test.ping
它将产生以下输出–
minion1: True minion2: True
列出谷物
可以使用“grains.ls”模块列出谷物，该模块定义如下。
root@saltmaster:/home/vagrant# salt '*' grains.ls
列出项目
与 Pillar 一样，Grains 数据也可以使用“grains.items”列出。
root@saltmaster:/home/vagrant# salt '*' grains.items
SaltStack – 日志记录
日志记录用于跟踪正在运行的软件事件。事件由描述性消息描述，该消息可以选择性地包含可变数据。盐日志记录方法用于解决您可能面临的任何问题。您可以查看特定的日志级别。
配置设置
让我们详细了解日志记录的不同配置设置。
日志文件
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_USER。
LOG_LEVEL
日志级别按数字分配的值排序。默认情况下，Python 库定义了大部分日志记录级别。除此之外，Salt 使用了更多级别。下面解释了一些级别。
-
log_level：错误；级别值为 40 – 它表示错误时的日志语句记录。
-
log_level：安静；级别值为 1000 – 表示在此级别不应记录任何内容。
-
日志级别：信息；level value is 20 – 它表示正常的日志信息。
-
日志级别：警告；级别值为 30 – 它表示警告时的日志语句记录。
-
log_level：调试；level value is 10 – 对调试salt实现和salt代码有用的信息。
-
log_level：跟踪；级别值为 5 – 更详细的代码调试信息。
LOG_LEVEL_LOGFILE
它定义了发送到日志文件的消息级别。
log_level_logfile: info
LOG_DATEFMT
它定义了日志日期格式。默认情况下，它表示为 &percntY-&percntm-&percntd &percntH:&percntM:&percntS。
log_datefmt_logfile: '&percntY-&percntm-&percntd &percntH:&percntM:&percntS'
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'
在这里，’info’ 级别的 Main salt 库将salt.modules设置为跟踪级别的日志。
外部日志处理程序
Salt 使用 LogStash 和 Sentry 外部日志处理程序进行日志记录。让我们在本章中详细了解它。
LOGSTASH 处理程序
LogStash 是一个开源软件；服务器端安全数据处理管道。让我们考虑在 Salt 中使用 LogStash 的简单 UDP 日志处理程序。
在 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 是生产部署和信息中的实时错误跟踪，用于重现和修复崩溃。主文件中的默认配置定义如下。
sentry_handler: dsn: https://pub-key:[email protected]/app-id log_level: debug
在这里，哨兵处理程序的默认日志级别是 ERROR，但我们在 sentry_handler 配置键下定义了调试log_level。
SaltStack – 通过 SSH 加盐
Salt 通过使用salt-minion在远程系统中执行命令。这是正常行为。在某些情况下，远程系统只能通过 SSH 协议访问。对于这些场景，Salt 提供了仅使用 SSH 协议连接远程系统并通过 SSH 层执行命令的选项。
Salt SSH很容易配置。唯一需要的配置是在称为名册文件的特殊文件中指定远程系统详细信息。该名册文件通常位于/etc/salt/roster 中。名册文件将包含有关远程系统的所有信息以及我们如何连接到它。一旦配置了名册文件，所有的 Salt 命令都将使用salt-ssh而不是 salt 命令来执行。
名册文件
名册系统专为 Salt SSH 设计。这被设计为可插拔系统。名册系统的唯一目的是收集有关远程系统的信息。名册文件是一个基于 YAML 的配置文件，其中包含作为目标的远程系统信息。这些目标是具有预定义属性集的特殊数据结构。一个名册文件包含一个或多个目标，每个目标都由一个Salt ID 标识。
名册文件的基本结构如下 –
<Salt ID>: host: <host name> user: <user name> passwd: <password of the user>
名册文件支持的所有其他属性都是可选的。它们如下 –
-
端口– SSH 端口号。
-
sudo – 是否通过 sudo 运行命令。
-
sudo_user – sudo 用户名。
-
tty – 如果启用了 sudo，则为真。
-
priv – 私钥。
-
timeout – SSH 连接超时。
-
minion_opts – minion opts 字典。
-
Thin_dir – 目标系统的盐组件存储目录。
-
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 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配置文件。
对于虚拟机，首先应用Cloud Config 中的设置，然后应用到Cloud Providers 中，最后覆盖由Cloud Profiles 完成。
盐云安装
默认情况下，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
云图
Cloud Map 是一种可以同时创建多个虚拟机的特殊格式。映射文件的格式是指定配置文件，然后在其下添加虚拟机列表。
示例地图文件如下 –
micro: - web1 - web2 large: - db1 - db2
映射文件可以作为参数传递给 salt-cloud 命令以创建虚拟机，如下所示 –
salt-cloud -m /path/to/mapfile
SaltStack – Salt 代理 Minions
有很多设备，如路由器、网络设备等，具有自定义操作系统、有限的内存和高安全性考虑。在这些设备中，我们无法安装标准的salt-minion，因此无法管理这些系统。然而，Salt 提供了一种创新技术来克服这种限制。
Salt 有一个单独的模块，即 salt proxy minion，它使用远程系统中运行的 REST 服务来控制远程系统。此 REST 服务是使用Representational State Transfer (REST)概念编写的基于 HTTP 的 Web 服务，它们既易于实现又易于使用。
每个设备都有自己的 SDK 和开发环境来编写复杂的应用程序。Salt 期望根据 Salt 接口规范在设备中开发 REST 服务。Salt 还提供了一个 python 模块来编写 REST web 服务。如果设备支持python，那么开发REST web服务就很容易了。
一旦在远程系统中开发并部署了 REST Web 服务，就可以将 Salt 配置为使用 REST Web 服务而不是 salt minion 来控制远程设备。
工作示例
让我们在现场工作环境中学习salt proxy minion的概念。对于 live 环境，我们为 master 和 proxy minion 选择了一个 Linux 系统。我们将使用 REST Web 服务而不是 salt-minion 来控制系统。
安装和配置 REST Web 服务
Salt 提供了 REST Web 服务实现的示例，在其 contrib 模块中将其命名为 proxyminion_rest_example。让我们安装示例 Web 服务。
-
使用 pip安装“瓶子”。该瓶命令是一个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 代理来查询 REST web 服务并控制系统。
配置盐代理
要配置 Salt-Proxy，我们必须遵循以下步骤。
-
我们必须为盐代理指定主节点。编辑 /etc/salt /proxy 中的代理配置文件位置，然后输入以下代码。
master: <your ip address>
-
修改/创建/srv/pillar/top.sls 中的基础支柱文件，如以下代码块所示。
base:
'p8000':
- p8000
-
在/srv/pillar 中添加一个新的 pillar 文件p8000.sls，如下面的代码块所示。
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命令并调用ping.test函数，如下所示。
salt p8000 test.ping
我们可以通过使用salt来运行 REST web 服务支持的任何函数，它类似于salt-minion。
例如，可以使用以下命令获取谷物信息。
salt p8000 grains.items
SaltStack – 事件系统
Salt 中的事件系统是一个本地 ZeroMQ PUB 接口，它会触发 salt 事件。它由以下组件执行。
-
事件套接字– 用于发布事件。
-
事件库– 用于侦听事件并将事件发送到盐系统。
盐大师活动
Salt master 提供不同类型的事件，下面详细解释 –
- 认证事件
- 开始活动
- 关键事件
- 工作事件
- 跑者活动
- 出席活动
- 云事件
让我们详细了解每种事件类型。
认证事件
当 minion 与 master 执行身份验证检查时，会触发这些身份验证事件。它由salt/auth 表示。
开始活动
每当一个 minion 连接到 Salt Master 时都会触发 start 事件，它由 salt/minion//start 表示。
关键事件
当 salt master 接受和拒绝 Salt minion 上的密钥时，会触发 Key 事件。您可以使用 salt-key 命令访问此事件。
工作事件
每当要开始新作业时都会触发 Job 事件。它由salt/job//new 表示。在这里，JID – 作业 ID 新 – 新作业
跑者活动
当跑步者开始执行时，会触发跑步者事件。它用 salt/run//new 表示。
出席活动
当 Minion 连接或新连接或断开连接时，此事件会定期触发。它由 – salt/presence/present和salt/presence/change 表示。这里，
-
Present – 表示 Salt Master 当前连接到 Minions 列表。
-
Change – 用于检测新的 minion – 已连接或已断开连接。
云事件
盐云事件在虚拟机上触发。除非发生其他事件，否则不会在 minion 上执行。您可以使用 – salt/cloud//creating访问它。当 Salt 云启动虚拟机执行过程时会触发它。
活动工具
现在，让我们来看看事件工具和脚本。您可以使用 CLI 访问事件总线。它通过以下命令访问。
salt-run state.event pretty = True
在这里，运行器旨在与来自外部工具和 shell 脚本的事件总线进行交互。Salt 的事件总线可以通过REST API远程访问。它由 –（示例 URL）表示。
curl -SsNk https://salt-api.example.com:8000/events?token = 05A3.
同样，您也可以从 Python 脚本访问事件。
SaltStack – 编排
一般来说，编排是系统的自动协调和安排。Orchestrate runner 用于在 SaltStack 中执行编排。
编排跑步者
Orchestrate Runner 提供OverState（以前的系统）的所有功能。它最初被称为state.sls runner。这个编排运行器用于将 Salt 状态系统推广到 Salt Master 上下文。
的state.sls和state.highstate功能在每个盐仆从执行，但state.orchestrate转轮上的主执行。该state.orchestrate亚军，让您充分管理整个基础架构的状态。让我们了解如何通过一个简单的执行过程。
简单执行
Orchestrate Runner 命令与state.sls函数相同，但您可以使用“salt-run”而不是 salt 来执行它。
假设你有一个sample.sls文件位于/srv/salt/orch/samples.sls。在该文件中添加以下代码。
样本.sls
install_nginx:
salt.state:
- tgt: 'web*'
- sls:
- nginx
以下命令用于在主服务器上运行，它将应用该文件中定义的状态。
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#
在这里，根据当前版本，运行器函数被重命名为state.orchestrate。这将有助于避免与 state.sls 执行函数混淆，但必须使用之前版本的state.sls。
执行函数
要执行一个函数，你应该使用salt.function。考虑一个文件data.sls位于/srv/salt/orch/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 Master。这个概念受到RPM、Yum和Pacman包装系统的影响。公式使用盐状态、支柱、文件模板等文件，然后打包成单个文件。
创建公式包后，将其复制到存储库系统以供 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 的系统上构建软件包。有三种类型的包，它们如下。
- 公式
- 反应堆
- 会议
现在让我们了解如何使用公式文件构建包。
公式文件
包中的大部分文件默认都在-/srv/spm/salt/目录下，但pillar文件可以放在-/srv/spm/pillar/目录下。公式文件描述了包。
例子
name: apache os: RedHat os_family: RedHat version: 201607 release: 2 summary: Formula for installing Apache description: Formula for installing Apache
这里，
-
名称– 包的名称。在这里，包名称是apache。
-
os – 用于了解哪些操作系统可以支持此包。
-
os_family – 用于了解哪些操作系统系列可以支持此包。
-
版本– 包的版本。它以 YYYYMM 格式指定。
-
Release – 此字段主要是指版本的发布。
-
摘要– 包的简短描述。
-
描述– 包的更详细描述。
反应堆
反应器文件位于/srv/spm/reactor/目录中。
配置文件
这种类型的包中的文件是 Salt 的配置文件，通常位于/etc/salt/目录中。Salt 以外的包的配置文件可以并且应该使用 Salt State（使用公式类型的包）进行处理。
让我们继续以下步骤来构建一个包。
-
创建一个 FORMULA 文件并将其放在包文件夹的根目录中。
-
将公式文件组装到构建系统上的文件夹中。
-
运行spm 构建。该包已构建并放置在 /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模块用于接入盐配置的详细信息。
import salt.config
opts = salt.config.client_config('/etc/salt/master')
在这里，client_config读取 salt 配置文件并将配置详细信息作为字典返回。
装载机
所述salt.loader模块用于加载在Salt每个模块，例如谷物，爪牙等
import salt.loader
opts = salt.config.minion_config('/etc/salt/minion')
grains = salt.loader.grains(opts)
在这里，grains读取 Salt 系统中的grains 的详细信息并返回。
客户端模块
所述salt.client模块用于执行盐，盐呼叫和编程方式将盐-SSH命令。
最重要的 Python 类如下 –
- salt.client.LocalClient
- salt.client.Caller
- salt.client.ssh.client.SSHClient
大多数客户端模块提供的主要功能是cmd。该函数包装了CLI选项并执行它，类似于命令行，将结果作为python数据结构返回。
本地客户端
LocalClient 用于从 master 向 salt minions 发送命令并将结果返回给 master。
import salt.client
local = salt.client.LocalClient()
local.cmd('*', 'test.ping')
它将产生以下输出–
{'minion1': True, 'minion2': True }
呼叫者
Caller 用于以编程方式运行salt-call并返回结果。
import salt.client
caller = salt.client.Caller()
caller.cmd('test.ping')
它将产生以下输出–
True
SSH客户端
SSHCient 用于以编程方式运行salt-ssh并返回结果。
import salt.client.ssh.client
ssh = salt.client.ssh.client.SSHClient()
ssh.cmd('*', 'test.ping')
它将产生以下输出–
{'minion1': True, 'minion2': True }
云客户端
salt.cloud 模块用于以编程方式执行 salt-cloud 命令。
client = salt.cloud.CloudClient(path = '/etc/salt/cloud')
Cloud 模块提供创建虚拟机（create）、销毁虚拟机（destroy）、列出云提供商提供的图像（list_images）、列出云提供商的位置（list_locations）、列出云提供商的机器大小（list_sizes）的功能，等等。
SaltStack – 工作示例
在这个工作示例中，我们将创建一个 Salt 公式，该公式将配置 apache Web 服务器以及 PHP 软件。Salt 是执行临时命令的好方法，但您不会真的希望以这种方式持续配置您的基础设施。通过创建一组 Salt 公式，您可以可靠地复制任何配置。
Salt Formulas 是简单的 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”是 Salt 确定应将哪个 Salt 公式应用于某个仆从的一种方式。使用以下命令执行“highstate”。
root@saltmaster:/home/vagrant# salt <targets> state.highstate
顶.sls
如前所述，当 minion 请求执行 highstate 时，minion 会从 Salt Master 请求 top.sls 并搜索它匹配的公式。默认情况下，此文件位于 /srv/salt/top.sls。让我们将公式添加到 top.sls 文件并将 minion2 设置为目标。
base:
'*':
- common
'minion2’:
- websetup
现在，执行highstate目标 minion2，如下所示。
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，并以最少的工作和最大的灵活性安装所需的软件。
