- 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: - git@github.com:user1/sample.git - ssh://user@domain.tld/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 S@192.168.50.*' 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:secret-key@app.getsentry.com/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 user@web.company.com
執行命令
執行 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，並以最少的工作量和最大的靈活性安裝所需的軟體。