SaltStack - Kurzanleitung
In diesem Kapitel lernen wir die Grundlagen von SaltStack kennen. Mit den Remote-Ausführungsfunktionen von SaltStack können Administratoren Befehle auf verschiedenen Computern parallel zu einem flexiblen Zielsystem ausführen. Das Salt-Konfigurationsmanagement erstellt ein Master-Minion-Modell, mit dem Infrastrukturkomponenten schnell, sehr einfach, flexibel und sicher an eine bestimmte Richtlinie angepasst werden können.
Was ist SaltStack?
Salt ist ein sehr leistungsfähiges Automatisierungsframework. Die Salt-Architektur basiert auf der Idee, Befehle remote auszuführen. Alle Netzwerke basieren auf bestimmten Aspekten der Remote-Ausführung. Dies könnte so einfach sein wie das Fragen aRemote Web ServerAnzeigen einer statischen Webseite oder so komplex wie die Verwendung einer Shell-Sitzung zum interaktiven Ausgeben von Befehlen für einen Remoteserver. Salt ist ein Beispiel für eine der komplexeren Arten der Remote-Ausführung.
Salt wurde entwickelt, um Benutzern das explizite Targeting und direkte Ausgeben von Befehlen an mehrere Computer zu ermöglichen. Salz basiert auf der Idee eines Meisters, der einen oder mehrere kontrolliertMinions. Befehle werden normalerweise vom Master an eine Zielgruppe von Minions ausgegeben, die dann die in den Befehlen angegebenen Aufgaben ausführen und die resultierenden Daten an den Master zurückgeben. Die Kommunikation zwischen einem Meister und Schergen erfolgt über dieZeroMQ message bus.
SaltStack-Module kommunizieren mit den unterstützten Minion-Betriebssystemen. DasSalt MasterLäuft standardmäßig unter Linux, aber jedes Betriebssystem kann ein Minion sein, und derzeit werden Windows-, VMware vSphere- und BSD Unix-Varianten gut unterstützt. Der Salzmeister und die Schergen benutzen Schlüssel, um zu kommunizieren. Wenn ein Diener zum ersten Mal eine Verbindung zu einem Master herstellt, speichert er automatisch Schlüssel auf dem Master. SaltStack bietet auchSalt SSH, die ein Systemmanagement ohne Agenten bietet.
Notwendigkeit für SaltStack
SaltStack ist auf Geschwindigkeit und Skalierbarkeit ausgelegt. Aus diesem Grund wird es zur Verwaltung großer Infrastrukturen mit Zehntausenden von Servern bei LinkedIn, WikiMedia und Google verwendet.
Stellen Sie sich vor, Sie haben mehrere Server und möchten diesen Servern etwas antun. Sie müssten sich bei jedem anmelden und diese Dinge einzeln ausführen, und dann möchten Sie möglicherweise komplizierte Dinge tun, z. B. Software installieren und diese Software dann anhand bestimmter Kriterien konfigurieren.
Nehmen wir an, Sie haben zehn oder vielleicht sogar 100 Server. Stellen Sie sich vor, Sie melden sich einzeln bei jedem Server einzeln an, geben dieselben Befehle auf diesen 100 Computern aus und bearbeiten dann die Konfigurationsdateien auf allen 100 Computern. Dies wird zu einer sehr mühsamen Aufgabe. Um diese Probleme zu lösen, würden Sie gerne alle Ihre Server gleichzeitig aktualisieren, indem Sie nur einen einzigen Befehl eingeben. SaltStack bietet Ihnen genau die Lösung für all diese Probleme.
Funktionen von SaltStack
SaltStack ist eine Open-Source-Konfigurationsverwaltungssoftware und eine Remote-Ausführungs-Engine. Salt ist ein Befehlszeilenprogramm. Das in Python geschriebene SaltStack-Konfigurationsmanagement ist sprachunabhängig und einfach. Die Salt-Plattform verwendet das Push-Modell zum Ausführen von Befehlen über das SSH-Protokoll. Das Standardkonfigurationssystem istYAML und Jinja templates. Salz konkurriert hauptsächlich mitPuppet, Chef und Ansible.
Salt bietet im Vergleich zu anderen konkurrierenden Tools viele Funktionen. Einige dieser wichtigen Funktionen sind unten aufgeführt.
Fault tolerance- Salt Minions können gleichzeitig eine Verbindung zu mehreren Mastern herstellen, indem sie den Master-Konfigurationsparameter als YAML-Liste aller verfügbaren Master konfigurieren. Jeder Master kann Befehle an die Salt-Infrastruktur weiterleiten.
Flexible- Der gesamte Managementansatz von Salt ist sehr flexibel. Es kann implementiert werden, um den gängigsten Systemverwaltungsmodellen wie Agent und Server, Nur Agent, Nur Server oder allen oben genannten in derselben Umgebung zu folgen.
Scalable Configuration Management - SaltStack ist für zehntausend Schergen pro Meister ausgelegt.
Parallel Execution model - Salt kann es Befehlen ermöglichen, entfernte Systeme parallel auszuführen.
Python API - Salt bietet eine einfache Programmierschnittstelle und wurde modular und leicht erweiterbar konzipiert, um das Formen an verschiedene Anwendungen zu erleichtern.
Easy to Setup - Salt ist einfach einzurichten und bietet eine einzige Remote-Ausführungsarchitektur, mit der die unterschiedlichen Anforderungen einer beliebigen Anzahl von Servern verwaltet werden können.
Language Agnostic - Salt-State-Konfigurationsdateien, Template-Engine oder Dateityp unterstützen jede Art von Sprache.
Vorteile von SaltStack
Salt ist sowohl einfach als auch ein funktionsreiches System. Es bietet viele Vorteile und kann wie folgt zusammengefasst werden:
Robust - Salt ist ein leistungsstarkes und robustes Konfigurationsmanagement-Framework und funktioniert mit Zehntausenden von Systemen.
Authentication - Salt verwaltet einfache SSH-Schlüsselpaare zur Authentifizierung.
Secure - Salt verwaltet sichere Daten mithilfe eines verschlüsselten Protokolls.
Fast - Salt ist ein sehr schneller und leichter Kommunikationsbus, der die Grundlage für eine Remote Execution Engine bildet.
Virtual Machine Automation - Die Salt Virt Cloud Controller-Funktion wird für die Automatisierung verwendet.
Infrastructure as data, not code - Salt bietet eine einfache Bereitstellung, ein modellgesteuertes Konfigurationsmanagement und ein Framework für die Befehlsausführung.
Einführung in ZeroMQ
Salt basiert auf dem ZeroMQBibliothek und es ist eine einbettbare Netzwerkbibliothek. Es ist leicht und eine schnelle Messaging-Bibliothek. Die grundlegende Implementierung ist inC/C++ und native Implementierungen für mehrere Sprachen, einschließlich Java und .Net ist verfügbar.
ZeroMQ ist eine maklerlose Peer-Peer-Nachrichtenverarbeitung. Mit ZeroMQ können Sie einfach ein komplexes Kommunikationssystem entwerfen.
ZeroMQ enthält die folgenden fünf Grundmuster:
Synchronous Request/Response - Wird zum Senden einer Anfrage und zum Empfangen nachfolgender Antworten für jede gesendete Anfrage verwendet.
Asynchronous Request/Response- Der Anforderer initiiert die Konversation durch Senden einer Anforderungsnachricht und wartet auf eine Antwortnachricht. Der Anbieter wartet auf die eingehenden Anforderungsnachrichten und antwortet mit den Antwortnachrichten.
Publish/Subscribe - Wird zum Verteilen von Daten von einem einzelnen Prozess (z. B. Herausgeber) an mehrere Empfänger (z. B. Abonnenten) verwendet.
Push/Pull - Wird zum Verteilen von Daten an verbundene Knoten verwendet.
Exclusive Pair - Wird verwendet, um zwei Peers miteinander zu verbinden und ein Paar zu bilden.
ZeroMQ ist ein hochflexibles Netzwerkwerkzeug für den Nachrichtenaustausch zwischen Clustern, Clouds und anderen Umgebungen mit mehreren Systemen. ZeroMQ ist dasdefault transport library präsentiert in SaltStack.
Die Architektur von SaltStack funktioniert mit einer beliebigen Anzahl von Servern, von lokalen Netzwerksystemen bis hin zu anderen Bereitstellungen in verschiedenen Rechenzentren. Die Architektur ist ein einfaches Server / Client-Modell mit der erforderlichen Funktionalität, die in einem einzigen Satz von Daemons integriert ist.
Schauen Sie sich die folgende Abbildung an. Es zeigt die verschiedenen Komponenten der SaltStack-Architektur.
SaltMaster- SaltMaster ist der Master-Daemon. Ein SaltMaster wird verwendet, um Befehle und Konfigurationen an die Salt-Slaves zu senden. Ein einzelner Master kann mehrere Master verwalten.
SaltMinions- SaltMinion ist der Slave-Daemon. Ein Salt Minion erhält Befehle und Konfigurationen vom SaltMaster.
Execution- Module und Ad-hoc-Befehle, die über die Befehlszeile gegen einen oder mehrere Schergen ausgeführt werden. Es führt eine Echtzeitüberwachung durch.
Formulas- Formeln sind vorab geschriebene Salzzustände. Sie sind so offen wie Salt States selbst und können für Aufgaben wie das Installieren eines Pakets, das Konfigurieren und Starten eines Dienstes, das Einrichten von Benutzern oder Berechtigungen und viele andere allgemeine Aufgaben verwendet werden.
Grains- Grains ist eine Schnittstelle, die Informationen für einen Diener bereitstellt. Die über die Körnerschnittstelle verfügbaren Informationen sind statisch. Getreide wird geladen, wenn der Salz-Diener beginnt. Dies bedeutet, dass die Informationen in Körnern unverändert bleiben. Daher können sich die Informationen zu Körnern auf den laufenden Kernel oder das Betriebssystem beziehen. Es wird nicht zwischen Groß- und Kleinschreibung unterschieden.
Pillar- Eine Säule ist eine Schnittstelle, die hochsensible Daten generiert und speichert, die für einen bestimmten Diener spezifisch sind, z. B. kryptografische Schlüssel und Kennwörter. Es speichert Daten in einem Schlüssel / Wert-Paar und die Daten werden auf ähnliche Weise wie der Salt State Tree verwaltet.
Top File - Passt Salzzustände und Säulendaten an Salzschergen an.
Runners - Es ist ein Modul im SaltMaster und führt Aufgaben wie Jobstatus, Verbindungsstatus, Lesen von Daten von externen APIs, Abfragen verbundener Salt Minions und mehr aus.
Returners - Gibt Daten von Salt Minions an ein anderes System zurück.
Reactor - Es ist dafür verantwortlich, Reaktionen auszulösen, wenn Ereignisse in Ihrer SaltStack-Umgebung auftreten.
SaltCloud - Salt Cloud bietet eine leistungsstarke Schnittstelle für die Interaktion mit Cloud-Hosts.
SaltSSH - Führen Sie Salt-Befehle über SSH auf Systemen aus, ohne Salt Minion zu verwenden.
Im nächsten Kapitel erfahren Sie mehr über die verschiedenen Wettbewerber von SaltStack und ihre Funktionen.
Salt, Puppet, Chef und Ansible sind die führenden Tools für Konfigurationsmanagement und Orchestrierung, die jeweils einen anderen Weg zur Serverautomatisierung einschlagen. Sie wurden entwickelt, um die Konfiguration und Wartung von Dutzenden, Hunderten oder sogar Tausenden von Servern zu vereinfachen.
Lassen Sie uns verstehen, wie SaltStack hauptsächlich mit Puppet, Chef und Ansible konkurriert.
Plattformen und Support
Im Folgenden finden Sie eine Liste aller Plattformen, die SaltStack und seine Konkurrenten unterstützen.
SaltStack - Die SaltStack-Software läuft auf und verwaltet viele Versionen von Linux, Windows, Mac OS X und UNIX.
Puppet - Red Hat Enterprise Linux, CentOS, Oracle Linux, Scientific Linux, SUSE Linux Enterprise Server und Ubuntu.
Chef - Chef wird auf mehreren Plattformen wie AIX, RHEL / CentOS, FreeBSD, OS X, Solaris, Microsoft Windows und Ubuntu unterstützt.
Ansible - Fedora-Distribution von Linux, CentOS und Scientific Linux über Extra Packages für Enterprise Linux (EPEL) sowie für andere Betriebssysteme.
Herkunftssprache
SaltStack - Python
Puppet - Ruby
Chef - Ruby und seine CLI verwenden Ruby-basiertes DSL
Ansible - Python
Unterstützte Sprache
SaltStack - Jede Sprache
Puppet - Ruby
Chef - Ruby und seine CLI verwenden Ruby-basiertes DSL
Ansible - Jede Sprache
Web-Benutzeroberfläche
SaltStack - Die Web-Benutzeroberfläche bietet Ansichten zum Ausführen von Jobs, zum Minion-Status und zu Ereignisprotokollen.
Puppet - Die Web-Benutzeroberfläche übernimmt die Berichterstellung, Inventarisierung und Echtzeit-Knotenverwaltung.
Chef - Mit der Web-Benutzeroberfläche können Sie Knoten suchen und inventarisieren, Knotenaktivitäten anzeigen und Kochbücher, Rollen und Knoten zuweisen.
Ansible - Mit der Web-Benutzeroberfläche können Sie Benutzer, Teams und Inventare konfigurieren und Playbooks auf Inventare anwenden.
Management-Tools
SaltStack - SaltStack Enterprise ist das Hauptwerkzeug für die Verwaltung der Orchestrierung von Cloud- und IT-Vorgängen DevOps.
Puppet- Puppet gibt es in zwei Varianten: Puppet Enterprise und Open Source Puppet. Puppet Enterprise bietet nicht nur Funktionen für Open Source Puppet, sondern auch GUI-, API- und Befehlszeilentools für die Knotenverwaltung.
Chef - CFEngine ist das Konfigurationsmanagement-Tool.
Ansible - Ansible 1.3 ist das Hauptwerkzeug für die Verwaltung.
Performance
SaltStack- Salz ist auf hohe Leistung und Skalierbarkeit ausgelegt. Das Kommunikationssystem von Salt stellt mithilfe von ZeroMQ eine dauerhafte Datenleitung zwischen dem Salt-Master und den Minions her.
Puppet - Sicher sowie leistungsstark und keine Agenten erforderlich.
Chef- Der offensichtlichste Kampf für Chef Server ist die Suche. Die Suche ist langsam und wird nicht gleichzeitig von Clients angefordert.
Ansible - Sicher, leistungsstark und keine Agenten erforderlich.
Preis und Wert
SaltStack- Kostenlose Open Source Version. SaltStack Enterprise kostet 150 USD pro Maschine und Jahr.
Puppet- Kostenlose Open Source Version. Puppet Enterprise kostet 100 USD pro Maschine und Jahr.
Chef- Kostenlose Open Source Version; Enterprise Chef kostenlos für 5 Maschinen, 120 USD pro Monat für 20 Maschinen, 300 USD pro Monat für 50 Maschinen.
Ansible- Kostenlose Open Source Version; Ansible kostenlos für 10 Maschinen, dann 100 oder 250 US-Dollar pro Maschine und Jahr, je nachdem, welchen Support Sie benötigen.
Verwendung
SaltStack- SaltStack wird von Cisco und Rackspace verwendet. Es kann in jede Cloud-basierte Plattform integriert werden.
Puppet - Puppet wird von Zynga, Twitter, der New Yorker Börse, PayPal, Disney, Google usw. verwendet.
Chef - Chef kann in Cloud-basierte Plattformen wie Internap, Amazon EC2, Google Cloud Platform, OpenStack, Microsoft Azure und Rackspace integriert werden.
Ansible - Ansible kann in Virtualisierungsumgebungen, Cloud-Umgebungen wie Amazon Web Services, Cloud Stack, DigitalOcean und Google Cloud Platform usw. bereitgestellt werden.
Bevor Sie zur Installation übergehen, müssen Sie die folgenden Anforderungen erfüllen:
Ein Linux-Server (neuester Ubuntu-Server).
sudo oder root access zu diesem Server.
Installieren Sie alle Updates mit dem folgenden Befehl:
sudo apt-get update
Installieren Sie SaltMaster
Installieren Sie den SaltMaster aus dem Repository mit dem folgenden Befehl apt-get.
sudo apt-get install salt-master
Installieren Sie Salt Minion
Installieren Sie den Salt Minion aus dem Repository mit dem folgenden Befehl apt-get.
sudo apt-get install salt-minion
Installieren Sie Salt Syndic
Installieren Sie das Salt-Syndic mit dem folgenden Befehl apt-get aus dem Repository.
sudo apt-get install salt-syndic
Master-Konfiguration
Die Salzkonfiguration ist sehr einfach. Die Standardkonfiguration für den Master funktioniert für die meisten Installationen. Die Konfigurationsdateien werden im Verzeichnis '/ etc / salt' installiert und nach ihren jeweiligen Komponenten benannt, z. B. - / etc / salt / master und / etc / salt / minion.
#interface: 0.0.0.0
interface: <local ip address>
Starten Sie den Salt Master nach dem Aktualisieren der Konfigurationsdatei mit dem folgenden Befehl neu.
sudo service salt-master restart
Minion-Konfiguration
Das Konfigurieren eines Salt Minion ist sehr einfach. Standardmäßig versucht ein Salt Minion, eine Verbindung zum DNS-Namen "salt" herzustellen. Wenn der Minion diesen Namen korrekt auflösen kann, ist keine Konfiguration erforderlich. Definieren Sie die "Master" -Anweisung in der Minion-Konfigurationsdatei neu/etc/salt/minion, wie im folgenden Code gezeigt -
#master: salt
master: <local ip address>
Starten Sie den Salt Minion nach dem Aktualisieren der Konfigurationsdatei mit dem folgenden Befehl neu.
sudo service salt-minion restart
Schlüsselverwaltung
Salz verwendet AES Encryptionfür die gesamte Kommunikation zwischen dem Meister und dem Diener. Die Kommunikation zwischen Master und Minion wird über vertrauenswürdige, akzeptierte Schlüssel authentifiziert.
salt-key -L
Es wird Folgendes erzeugt output - -
Accepted Keys:
Denied Keys:
Unaccepted Keys:
<local system name>
Rejected Keys:
Akzeptieren Sie alle Schlüssel, indem Sie den folgenden Befehl eingeben.
sudo salt-key -A
Es wird Folgendes erzeugt output - -
The following keys are going to be accepted:
Unaccepted Keys:
<local system name>
Proceed? [n/Y] y
Key for minion bala-Inspiron-N4010 accepted.
Jetzt nochmal ausstellen salt key listing Befehl,
salt-key -L
Es wird Folgendes erzeugt output - -
Accepted Keys:
<local system name>
Denied Keys:
Unaccepted Keys:
Rejected Keys:
Befehle senden
Die Kommunikation zwischen dem Master und einem Minion muss durch Ausführen des Befehls test.ping überprüft werden.
sudo salt '*' test.ping
Es wird Folgendes erzeugt output - -
<local system name>
True
Hier bezieht sich '*' auf alle Schergen. Da wir nur einen Diener haben - test.ping, führt er das ausping Befehl und gibt zurück, ob der Ping erfolgreich ist oder nicht.
In diesem Kapitel erstellen wir eine einfache SaltStack-Umgebung, einen Salt Master und zwei Salt Minions. Diese Umgebung wird uns helfen, das Salzkonzept in den kommenden Kapiteln zu lernen.
Befolgen Sie die folgenden Schritte, um die SaltStack-Umgebung zu erstellen.
Installieren Sie die VirtualBox-Umgebung
VirtualBox ist eine plattformübergreifende Virtualisierungsanwendung. Mit VirtualBox können Sie mehrere Betriebssysteme gleichzeitig ausführen. VirtualBox läuft unter Windows, Linux, Macintosh und Solaris. Es hostet und unterstützt eine große Anzahl vonGuest Operating Systems.
Sie können VirtualBox herunterladen und installieren, indem Sie den folgenden Link besuchen: https://www.virtualbox.org/wiki/Downloads
Wir werden drei virtuelle Maschinen erstellen und diese mit der VirtualBox ausführen.
Installieren Sie Vagrant
Vagrant bietet einfach zu konfigurierende, reproduzierbare und tragbare Arbeitsumgebungen.
Sie können den Vagrant herunterladen und installieren, indem Sie den folgenden Link besuchen: https://www.vagrantup.com
Nach der erfolgreichen Installation von Vagrant müssen Sie es konfigurieren. Erstellen Sie eine einzelne Datei mit dem NamenVagrantfile in einem Ordner und beschreiben Sie den Maschinentyp und seine Eigenschaften.
Run Vagrant - Um den Vagrant auszuführen, geben Sie den folgenden Befehl ein:
vagrant up
Nachdem Sie vagrant gestartet haben, erstellt und startet Vagrant die Maschinen, die in der Liste definiert sind VagrantfileVerwenden der VirtualBox im Hintergrund. Diese Maschinen laufen, bis Sie sie schließen.
Stop Vagrant - Um alle laufenden Maschinen in der VirtualBox zu stoppen, geben Sie den folgenden Befehl ein:
vagrant halt
Laden Sie die Demo-Umgebung herunter
SaltStack bietet eine einfache Demo-Umgebung als Vagrant-Setup und wird in der gehostet github. Laden Sie das Setup mit dem folgenden Befehl herunter:
cd /cd/to/path
git clone https://github.com/UtahDave/salt-vagrant-demo
Umgebung starten
Starten Sie nun die Demo-Umgebung mit dem folgenden Befehl:
cd /cd/to/path/salt-vagrant-demo
vagrant up
Nach diesem Befehl wird die folgende Antwort angezeigt:
result
Jetzt werden drei Server ausgeführt, einer mit dem konfigurierten Salt Master und zwei mit dem konfigurierten Salt Minion.
Führen Sie Salt Master aus
Melden Sie sich mit dem folgenden Befehl beim Salt Master an:
vagrant ssh master
Wechseln Sie nun mit dem folgenden Befehl zum Root-Benutzer -
sudo su
Jetzt haben wir uns erfolgreich mit dem Salzmeister verbunden.
Lassen Sie uns nun einige der grundlegenden Befehle in SaltStack durchgehen.
Listen Sie alle Schlüssel auf
Der folgende Befehl dient zum Überprüfen der Salt Minion-Verbindungen und zum Anzeigen, ob die Verbindung akzeptiert, abgelehnt oder ausstehend ist.
salt-key —list-all
Es wird Folgendes erzeugt output - -
Accepted Keys:
minion1
minion2
Denied Keys:
Unaccepted Keys:
Rejected Keys:
Überprüfen Sie Salt Minions
Nachdem wir alle Schlüssel akzeptiert haben, können Sie einen Befehl vom Salt Master senden, um zu überprüfen, ob Salt Minions zuhören oder nicht.
salt '*' test.ping
Es wird Folgendes erzeugt output - -
minion1:
True
minion2:
True
Listen Sie aus dem obigen Ergebnis Minion 1 und Minion 2 auf, was bedeutet, dass Minions richtig zuhören, andernfalls könnten Minions jetzt richtig reagieren.
Ein Zugriffskontrollsystem bietet einem Benutzer Optionen für eine Gruppe, um eine Aufgabe mit Berechtigungen auszuführen. Ein Salt-Zugriffskontrollsystem wird verwendet, um den Zugriff auf nicht administrative Steuerungsschnittstellen zu konfigurieren. Sie können diesen Prozess auf alle Systeme anwenden. Dieses Steuerelement hilft den nicht administrativen Benutzern, die Salt-Befehle auszuführen.
Es gibt drei Arten von Salzgrenzflächen:
- Publisher-ACL-System
- Externes Auth-System
- Peer-System
Lassen Sie uns verstehen, gehen Sie jede dieser Schnittstellen im Detail durch.
Publisher-ACL-System
Ein Publisher-ACL-System ermöglicht den Zugriff auf andere Benutzer als root, um Salt-Befehle für Minions vom Master auszuführen. Das Publisher-ACL-System wird in der Master-Konfigurationsdatei über das konfiguriertpublisher_aclKonfigurationsoption. Es ist wie folgt definiert:
publisher_acl:
user1:
- .*
user2:
- web*:
- test.*
- pkg.*
Hier,
user1 darf alles ausführen.
user2 darf benutzen test und pkg, aber nur auf "Web *" - Schergen.
Externes Authentifizierungssystem
Das external auth system wird verwendet, um den Zugriff zum Ausführen von Salt-Befehlen für bestimmte Minions über ein externes Autorisierungssystem wie z PAM, LDAPusw. Diese Konfigurationsdatei wird in der Masterdatei wie unten beschrieben definiert.
external_auth:
pam:
user1:
- 'web*':
- test.*
- network.*
user2:
- .*
Hier,
user1 darf Funktionen in der ausführen test und network modules auf die Schergen, die dem entsprechen web* Ziel.
user2 darf alle Funktionen ausführen.
Aktivieren Sie das externe Authentifizierungssystem im Befehl
Salt Server bietet die Option '–a', um die externe Authentifizierung zu aktivieren.
salt -a pam web\* test.ping
Hier das -a pamMit dieser Option wird die externe PAM-Authentifizierung aktiviert. Salt Server fragt bei jeder Ausführung des Befehls nach Authentifizierungsdetails. Um zu verhindern, dass Salt Server nur zum ersten Mal nach den Authentifizierungsdetails fragt, können wir die Option T verwenden. Diese-T option speichert die Authentifizierungsdetails für die nächsten 12 Stunden zwischen (Standardeinstellung) und verwendet sie zur Authentifizierung der Benutzer.
salt -T -a pam web\* test.ping
Peer-System
Salt Minions können Befehle über die Peer-Schnittstelle übergeben. Die Peer-Schnittstelle wird entweder über die Master-Konfigurationsdatei konfiguriert, damit Minions Befehle vom Master über die senden könnenpeer Konfigurationsabschnitt oder um Minions zu ermöglichen, Läufer vom Master mit dem auszuführen peer_run Aufbau.
Lassen Sie uns diese beiden Konfigurationen im Detail verstehen.
Peer-Konfiguration
Die einfache Konfiguration, die in der Masterdatei definiert werden muss, lautet wie folgt:
peer:
.*:
- .*
Hier ermöglicht es die Kommunikation für alle Schergen, wird jedoch nur für sehr sichere Umgebungen empfohlen.
Um bestimmten IDs Minions zuzuweisen, muss die Konfiguration wie folgt definiert werden: peer -
.*domain.com:
- test.*
peer_run Konfiguration
Diese Konfiguration soll es Minions ermöglichen, Läufer vom Master mit der Option peer_run in der Masterdatei auszuführen. Das folgende Beispiel soll den Zugriff auf alle Schergen und auf alle Läufer ermöglichen.
peer_run:
.*:
- .*
Um einer bestimmten ID Schergen zuzuweisen, muss die Konfiguration wie folgt definiert werden:
peer_run:
.*domain.com:
- test.*
Ausführen von Befehlen
Ausführen test.ping Verwenden Sie für alle Schergen die salt-call Befehl zusammen mit dem publish.publish Modul.
salt-call publish.publish \* test.ping
Ausführen runnerVerwenden Sie den Befehl salt-call zusammen mit dem Befehl publish.runner Modul.
salt-call publish.runner manage.up
Salt kann mit einer Vielzahl von Systemen schnell kommunizieren. Dieser Ansatz hilft Salt, ein leistungsstarkes Multitasking-System zu entwickeln. Salt kann Jobs auf mehr als einem System ausführen. Daher verwendet Salt die Jobverwaltungstechnik, um jeden Job zu verwalten, der auf allen Systemen ausgeführt wird. In diesem Kapitel wird das Jobmanagement ausführlich erläutert.
Was ist eine Job ID?
Salt hat ein Cache-Verzeichnis, cachedir. In diesem Verzeichnis wird ein Verzeichnis, das von Minions verwaltet wird, als das bezeichnetprocVerzeichnis. Es befindet sich im folgenden Verzeichnis / var / cache / salt / proc.
Das proc-Verzeichnis wird verwendet, um alle Dateien zu verwalten. Wenn diese Dateien ausgeführt werden, werden sie mit einer eindeutigen Job-ID zugewiesen. Diese Job-ID hilft dabei, die aktuell ausgeführten Jobs auf dem Minion zu identifizieren und das Nachschlagen der Jobs zu ermöglichen.
SALTUTIL-Modul
Salt führt ein neues Modul ein, das als Saltutil-Jobverwaltungsprozess bezeichnet wird. Dieses Modul enthält verschiedene Funktionen zum Verwalten von Jobs. Diese Funktionen werden verwendet, um Jobs auf Minion-Ebene zu verwalten. Die Funktionen werden kurz wie folgt beschrieben:
running - Gibt alle laufenden Jobdaten zurück, die im proc-Verzeichnis gefunden wurden.
find_job - Gibt basierend auf der Job-ID bestimmte Daten zu einem bestimmten Job zurück.
signal_job - Ermöglicht das Senden eines Signals an eine bestimmte Job-ID (jid).
term_job - Sendet ein Beendigungssignal für den angegebenen Job.
kill_job - Sendet ein Kill-Signal für den angegebenen Job.
Jobs Runner
Der Job Runner enthält Funktionen, die das Anzeigen von Daten einfacher und übersichtlicher machen. Es hat verschiedene Funktionen. Lassen Sie uns jede dieser Funktionen im Detail diskutieren.
AKTIVE Funktion
Mit der Funktion Aktiv wird ermittelt, welche Jobs noch ausgeführt werden, und überprüft, auf welchen Systemen ein Job abgeschlossen wurde und auf welche Systeme noch gewartet wird. Es wird mit dem folgenden Befehl ausgeführt:
salt-run jobs.active
LOOKUP_JID Funktion
Der Läufer lookup_jid zeigt die Daten für den aktuell aussehenden Job an. Diese Jobs werden über das konfiguriertkeep_jobsOption in der Master-Konfiguration. Es wird mit dem folgenden Befehl ausgeführt.
salt-run jobs.lookup_jid <job id number>
LIST_JOBS-Funktion
Die Funktion List_jobs wird verwendet, um die Jobdaten für Jobs aufzulisten. Es wird durch den folgenden Befehl ausgedrückt:
salt-run jobs.list_jobs
Arbeit planen
Das Zeitplansystem macht die Ausführung einer Ausführungsfunktion für Schergen oder einen Läufer auf dem Master verfügbar.
Es wird mit den folgenden Methoden durchgeführt:
Schedule - Die Zeitplanoption entweder im Master oder im Minion config Dateien.
Minion pillar data - Die Daten der Minion-Säule werden mit dem Befehl saltutil.refresh_pillar aktualisiert.
Der Zeitplanstatus oder das Zeitplanmodul.
Salzzustände werden auf dem Diener ausgeführt. Sie können die Positionsargumente übergeben und a angebenYAML dict der genannten Argumente in der config file Wie nachfolgend dargestellt.
schedule:
job1:
function: saltstate.sls
seconds: 3600
args:
- httpd
kwargs:
test: True
Hier, job1 wird die Funktion ausführen saltstate.sls mit den angegebenen Argumenten, httpdfür jede Stunde. Dastest: True ist das zusätzliche Argument für die httpd Befehl, der in definiert ist saltstate.sls.
Der Salt-Dateiserver ist ein zustandsloser ZeroMQ-Server. Es ist in den Salzmeister eingebaut. Ein Salt-Dateiserver wird zum Verteilen von Dateien vom Master an Minions verwendet. Es enthält verschiedene Module. Lassen Sie uns in diesem Kapitel den Salt-Dateiserver, seine Konfiguration, Module im Zusammenhang mit dem Salt-Dateiserver, den Zugriff auf den Salt-Dateiserver in Python usw. verstehen.
Dateiserver-Backend
Das Dateiserver-Backend ermöglicht es dem Salt-Dateiserver, als transparente Schnittstelle zu anderen Dateiservern wie einem lokalen Dateisystem, einem Git-Versionskontrollsystem usw. zu fungieren.
Ein Git-Dateiserver-Backend kann mithilfe der folgenden Konfiguration in der Masterdatei aktiviert werden.
fileserver_backend:
- git
Um mehrere Backend-Dateisysteme zu aktivieren, können Sie die folgende Konfiguration verwenden.
fileserver_backend:
- roots
- git
Wir können die zusätzliche Option für einen anderen Backend-Server auch über den spezifischen Abschnitt des entsprechenden Backend-Servers angeben.
Lokales Dateisystem
Für die Verwendung dieses Systems müssen wir den folgenden Code verwenden.
file_roots:
base:
- /srv/salt/prod
Git-Dateisystem
Für die Verwendung dieses Systems müssen wir den folgenden Code verwenden.
gitfs_remotes:
- https://github.com/sample/sample1.git
Dateien anfordern
Salt bietet die Möglichkeit, Dateien für bestimmte Umgebungen anzufordern.
salt://path/to/file?saltenv = base
Hier wird die Umgebung mit der Option Roots definiert.
Dateiserverkonfiguration
Salt-Dateien können in vielen Stammverzeichnissen zugewiesen und aufgerufen werden, indem sowohl der Dateipfad als auch die zu durchsuchende Umgebung angegeben werden. Die einzelnen Umgebungen können sich über mehrere Verzeichniswurzeln erstrecken.
Umgebung
Die Standardumgebung ist base. Diese Umgebung ist definiert und wird zum Herunterladen von Dateien verwendet, wenn keine andere Umgebung angegeben ist.
file_roots:
base:
- /srv/salt/base
Sie können auch mehrere Umgebungen verwenden, wie im folgenden Code gezeigt.
file_roots:
base:
- /srv/salt/base
dev:
- /srv/salt/dev
- /srv/salt/base
CP-Modul
Das CP-Modul ist das Hauptmodul zur Manipulation des Salt file server. Dassalt-cp Der Befehl kann auch zum Verteilen von Dateien verwendet werden, die vom Salt-Dateiserver angezeigt werden.
EINE DATEI BEKOMMEN
Das cp.get_fileDie Funktion kann auf dem Minion verwendet werden, um eine Datei vom Master herunterzuladen. Es wird wie im folgenden Codeblock gezeigt definiert.
salt '*' cp.get_file salt://vimrc /etc/vimrc
Der obige Befehl weist alle Salt Minions an, das herunterzuladen vimrc Datei und kopieren Sie es in /etc/vimrc.
Vorlage aktivieren
Sie können die Vorlagenoption in get_file wie folgt aktivieren:
salt '*' cp.get_file "salt://vimrc" /etc/vimrc template = jinja
Komprimierung anwenden
Verwenden Sie die Komprimierung, um die Komprimierung zu verwenden gzipbenanntes Argument. Die gültigen Werte sind Ganzzahlen von 1 bis 9, wobei 1 die minimale Komprimierung und 9 der maximale Wert ist.
Der Befehl ist wie folgt definiert:
salt '*' cp.get_file salt://vimrc /etc/vimrc gzip = 5
GET_DIR
Das cp.get_dirDie Funktion kann auf dem Minion verwendet werden, um ein gesamtes Verzeichnis vom Master herunterzuladen. Es wird im folgenden Codeblock definiert.
salt '*' cp.get_dir salt://etc/mysql /etc
Das cp.get_dirunterstützt Template-Rendering und gzip-Komprimierungsargumente. Wenn Sie möchten, können Sie auch zuweisen.
FILECLIENT-Modul
Salt bietet ein Python-Modul, mit dem Sie auf den Salt-Dateiserver zugreifen können. Dassalt/fileclient.py Das Modul wird verwendet, um die Kommunikation vom Diener zum Meister einzurichten.
Der Beispielcode zum Abrufen von Dateien lautet wie folgt:
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)
Hier,
opts ist verfügbar, wenn das Modul in der Salt-Umgebung ausgeführt wird. Andernfalls sollten wir den Konfigurationspfad angeben -/etc/salt/minion.
path bezieht sich auf den Pfad der Quelldatei im Salt-Dateiserver.
dest verweist auf den Zielpfad der Datei.
saltenv bezieht sich auf die Umwelt
Im nächsten Kapitel werden wir verstehen, wie man es benutzt Git als Dateiserver.
Gitist ein verteiltes Open-Source-Versionskontrollsystem. Es kann verwendet werden, um Änderungen in beliebigen Dateien zu verfolgen. Salt sendet Dateien aus Git-Repositorys über den Git-Dateiserver. Sie können Git für das konfigurierenfileserver_backend Listenoption und wenn Sie ein oder mehrere Repositorys konfigurieren müssen, können Sie dies mit der Option tun gitfs_remotes Möglichkeit.
In diesem Kapitel wird erläutert, wie Sie den Git-Dateiserver installieren und konfigurieren. Bevor Sie zur Installation übergehen, müssen Sie die folgenden Voraussetzungen erfüllen.
Salt Server Voraussetzungen für die Verwendung von Git
Die Mindestanforderung für den Salt-Server, Git als Dateiserver zu verwenden, lautet wie folgt:
- pygit2
- Dulwich
Pygit2 und Dulwich werden mit dem konfiguriert gitfs_providerParameter in der Master-Konfigurationsdatei. Wenngitfs_provider ist in der Master-Datei nicht konfiguriert, bevorzugt Salt pygit2, wenn die geeignete Version verfügbar ist, gefolgt von GitPython und Dulwich.
Installieren Sie pygit2
Die folgenden Befehle werden verwendet, um pygit2 auf Fedora- und Ubuntu-basierten Systemen zu installieren:
Fedora-based system
yum install python-pygit2
Ubuntu-based system
apt-get install python-pygit2
Hier beträgt die minimal unterstützte Version von pygit2 0,20,3.
Installieren Sie GitPYTHON
GitPython kann einfach mit dem auf dem Master installiert werden yum / apt command Wie nachfolgend dargestellt.
Fedora-based system
yum install GitPython
Ubuntu-based system
apt-get install python-git
Installieren Sie DULWICH
Dulwich kann einfach mit dem Befehl yum auf dem Master installiert werden.
Fedora-based system
yum install python-dulwich
Ubuntu-based system
apt-get install python-dulwich
Jetzt haben wir alle Abhängigkeiten für den Git-Dateiserver installiert. Lassen Sie uns nun diesen Git-Dateiserver mit dem konfigurierenfileserver_backend Abschnitt in der master config Datei.
Backend-Konfiguration
Um den Git-Dateiserver verwenden zu können, müssen Sie Git in der Liste fileserver_backend in der Master-Konfigurationsdatei hinzufügen. Es wird wie folgt beschrieben -
fileserver_backend:
- git
Lassen Sie uns weiter verstehen, wie der Git-Dateiserver in einer Remote-Konfiguration konfiguriert wird.
gitfs_remotes Konfiguration
Sie können eine oder alle URLs wie git: //, https: //, file: // oder ssh: // für die Konfiguration von gitfs_remotes in der Masterdatei angeben. Dies wird verwendet, um nach den angeforderten Dateien zu suchen.
Die einfache https-URL-Spezifikation ist unten definiert.
gitfs_remotes:
- https://github.com
Das ssh Die Konfiguration kann wie unten gezeigt erfolgen.
gitfs_remotes:
- [email protected]:user1/sample.git
- ssh://[email protected]/path/to/sample.git
Jetzt haben wir den Git-Dateiserver mit den beiden Optionen konfiguriert fileserver_backend und gitfs_remotes.
Starten Sie den Master neu
Nachdem Sie alle Änderungen in der Master-Datei vorgenommen haben, starten Sie den Master neu, um alle Konfigurationen auf dem Git-Dateiserver zu laden.
Konfiguration mehrerer Fernbedienungen
Der folgende Befehl wird für die Mehrfachkonfiguration in verwendet gitfs_remotes in der Master-Datei.
gitfs_remotes:
- git://github.com/sample/sample1.git
- https://github.com/sample/sample2.git
- file:///root/user/sample
Hier die Repositories sample1.git, sample2.git, und sample.doc kann die folgenden Dateien haben.
sample1.git:
top.sls
sample2.git
edit/vimrc
sample.doc
edit/vimrc
Das MinionFSist ein spezieller Dateiserver, der von Salt bereitgestellt wird, damit die Minions die Dateien zwischen ihnen austauschen können. Die vom MinionFS bereitgestellten Dateien sind die Dateien, die absichtlich von Minions gemeinsam genutzt werden. Um die Dateien freizugeben, muss ein Minion die folgenden Schritte ausführen.
Source Minion muss die Datei mit dem an den Salt Master senden cp.push Funktion.
Sobald die Dateien vom Quell-Minion gepusht wurden, kann jeder andere Minion über den MinionFS-Dateiserver auf die bereitgestellten Dateien zugreifen.
Pushing aktivieren
Standardmäßig ist das Übertragen der Dateien durch Schergen an einen Master deaktiviert. Um die Dateien von Minions zu akzeptieren, muss der Master die Option "file_recv" in der Konfigurationsdatei haben und ihr Wert muss auf "gesetzt" seinTrue. Standardmäßig ist der Wert bei "file_recv"false.
file_recv: True
Sobald die Option aktiviert ist, starten Sie den Masterdienst neu.
Dateien pushen
Minions können die Dateien an den Master senden. Es wird von der durchgeführtcp.pushFunktion. Diese cp.push-Funktion bietet einen einfachen Mechanismus zum Übertragen der Dateien durch Minion mithilfe der Minion-ID.
salt 'minion-id' cp.push /path/to/the/file
Hier wird die Minion-ID verwendet, um zu identifizieren, welcher Minion die Datei pusht. Dieser Befehl speichert die Datei in einem Unterverzeichnis mit dem Namenminions unter dem master's cachedir. Normalerweise lautet der Pfad - / var / cache / salt / master / minions.
Für Diener, m1 und die Datei - /var/log/mylog.txt, die Datei wird in der Datei - /var/cache/salt/master/minions/m1/var/log/mylog.txt gespeichert.
Aktivieren Sie MinionFS
Um das MinionFS zu aktivieren, fügen Sie einfach hinzu minion in der Dateiserver-Backend-Einstellung, wie im folgenden Codeblock gezeigt.
fileserver_backend:
- roots
- minion
Sobald MinionFS aktiviert ist, sind die Minion-Push-Dateien verfügbar als -
salt://<minion-id>/path/to/pushed/file
Für Diener, m1 und die Push-Datei - /var/log/mylog.txt, die Push-Datei wird von salt: //m1/var/log/mylog.txt bereitgestellt.
Dieses minionFS kann mit der folgenden Konfiguration in einem speziellen Verzeichnis bereitgestellt werden. Es trennt die minionFS-Dateien von anderen Dateien und hilft bei der Organisation der minion-Dateien.
minionfs_mountpoint: salt://minionfs
Für die obige Konfiguration ist die Datei unter verfügbar minionfs Verzeichnis als - salt: //minionfs/m1/var/log/mylog.txt
Erweiterte MinionFS-Optionen
Das MinionFS bietet auch eine Option zum Aktivieren / Deaktivieren der Verfügbarkeit von Push-Dateien von einem bestimmten Minion. Die Optionen sindminionfs_whitelist, um Schergen und minionfs_blacklist, um die Schergen zu deaktivieren.
minionfs_whitelist:
- webserver
- develop*
- ‘mail\d+.mysite.com'
minionfs_blacklist:
- testing
In der obigen Konfiguration sind alle Schergen außer testing dürfen die Datei mit minionFS teilen.
Webserver1
Schergen, deren IDs dem regulären Ausdruck entsprechen, entwickeln sich *
Minions, deren IDs dem regulären Ausdruck entsprechen mail\d+.mysite.com.
Testing
Im nächsten Kapitel lernen wir, wie man Cron mit Salz verwendet.
Salz kann zusammen mit dem verwendet werden CronAnwendung. Die gleichzeitige Verwendung beider Anwendungen bietet eine hervorragende Möglichkeit, Salt zu automatisieren. Während Salt eine Option zum Remote-Ausführen von Befehlen bietet, ermöglicht Cron die Ausführung vorab geplant oder automatisiert. Lassen Sie uns in diesem Kapitel lernen, wie man Cron und Salt zusammen verwendet.
Was ist Cron?
Cron ist eine sehr nützliche Anwendung in der Linux-Umgebung. Es ermöglicht die Voreinstellung eines Befehls oder Skripts für die Ausführung zu einem bestimmten Datum und einer bestimmten Uhrzeit. Außerdem kann eine Anwendung in regelmäßigen Abständen ausgeführt werden, z. B. täglich, wöchentlich oder an jedem ersten Tag des Monats.
Cron startet beim Systemstart und überprüft die /etc/crontabDatei für Konfigurationsdetails. Die / etc / crontab hat jede Anwendung und ihren Zeitplan in einer separaten Zeile, wie unten gezeigt.
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"
Jede Linie hat die folgenden sieben Einstiegspunkte, die durch Leerzeichen getrennt sind und wie folgt lauten:
minute - Minute der Stunde und liegt zwischen '0' und '59'.
hour - Stunde und wird im 24-Stunden-Takt angegeben.
day_of_month- Tag des Monats und ist zwischen 1 und 31 zum Beispiel des 10 - te eines jeden Monats 10.
month - Ein Monat angegeben und numerisch angegeben (0-12) oder als Name des Monats (z. B. Mai).
day_of_week - Der Wochentag wird numerisch (0-7) oder als Name des Tages (z. B. Sonne) angegeben.
user - Benutzerkonto, unter dem der Befehl ausgeführt wird.
cmd - Der eigentliche Befehl und seine Argumente.
Hier ersetzt *, wenn nichts zugewiesen ist.
Salt Caller (Salzruf)
Salt bietet eine CLI (Command Line Interface), salt-callum die Module im lokalen Minion-System selbst anstatt vom Master-Server mit dem Befehl salt auszuführen. Die Salt Call-CLI unterstützt alle vom Salt-Befehl unterstützten Optionen, wird jedoch lokal ausgeführt.
Salt Caller wurde ursprünglich zur Unterstützung des Debuggens entwickelt, kann jetzt jedoch als eigenständige Anwendung verwendet werden.
salt-call test.ping
Mit Salt-Call in Cron
Die Salt-Call-CLI ist nützlich, um den Salt-Betrieb mit Cron zu planen. Um beispielsweise den Status des Minions jeden Tag um Mitternacht zu überprüfen, können wir Salt-Call zusammen mit der Option - state.apply verwenden, wie unten gezeigt.
/etc/crontab
PATH = /bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:/opt/bin
0 0 * * * salt-call state.apply
Hier,
Das state.apply Die Funktion überprüft die Salt-Konfigurationsdatei für den Minion und prüft, ob alle für den Minion definierten Aktionen ordnungsgemäß konfiguriert sind.
Das Festlegen des Pfads ist eine gute Vorgehensweise, da der Befehl salt manchmal nicht im Systempfad verfügbar ist.
Im nächsten Kapitel lernen wir Remote Execution kennen, ein Kernkonzept von Salt.
Eines der Kernkonzepte von Salt ist die Remote-Ausführung. Salt kann Befehle in Sekundenschnelle über Tausende von Systemen ausführen. Salt verwendet einen eigenen Befehl, um diese Funktionalität auszuführen. Lassen Sie uns nun die verschiedenen Salt-Befehle für die Remote-Ausführung in diesem Kapitel verstehen.
Salzbefehl
Mit dem Salt-Befehl kann der Salt-Master mit einem oder mehreren kommunizieren Salt minions. Die grundlegende Syntax lautet wie folgt:
salt '<target>' <module.function> [arguments]
Die obige Befehlssyntax besteht aus den folgenden drei Hauptkomponenten.
target - Legt fest, welche Systeme vom Befehl angewendet werden.
module.function- Es ist ein Befehl. Befehle bestehen aus einem Modul und einer Funktion.
arguments - Zusätzliche Daten zum Aufrufen der Funktion.
Lassen Sie uns jede der Komponenten im Detail verstehen.
Was ist die Zielkomponente?
Ziel ist eine Komponente, mit der Sie Schergen (verwaltetes System) filtern können, um die Funktion auszuführen. Ein einfacher Befehl unter Verwendung der Zielkomponente ist unten definiert.
salt '*' test.ping
Es wird Folgendes erzeugt output - -
minion2:
True
minion1:
True
Hier das Ziel ‘*’repräsentiert alle verwalteten Systeme. Das 'test'hier ist ein Modul und pingist eine Funktion. Dies wird verwendet, um den Ping-Dienst im Remote-System zu testen. In den folgenden Kapiteln lernen wir die verschiedenen Module und ihre Funktionen kennen.
Ziele mit ID (Diener)
Sie können einen Befehl an einen bestimmten Diener senden, indem Sie dessen idim Ziel. Anstatt zu verwenden'*'können Sie es mit ersetzen minion id. Es ist unten definiert.
salt 'minion1’ test.ping
Es wird Folgendes erzeugt output - -
minion1:
True
Ziele mit regulärem Ausdruck
Ziele können nach bestimmten regulären Ausdrücken gefiltert werden. Es ist unten definiert.
salt -E 'minion[0-9]' test.ping
Es wird Folgendes erzeugt output - -
minion2:
True
minion1:
True
Ziele mit Liste
Ziele können explizit in einer Liste angegeben werden. Es wird im folgenden Codeblock definiert.
salt -L 'minion1,minion2' test.ping
Es wird Folgendes erzeugt output - -
minion2:
True
minion1:
True
Ziele nach Zustand
Ziele können in einem Befehl kombiniert werden, wie im folgenden Codeblock gezeigt.
salt -C 'G@os:Ubuntu and minion* or [email protected].*' test.ping
Es wird Folgendes erzeugt output - -
minion1:
True
minion2:
True
Modul und Funktionen (Modul.Funktion)
Salt kann Shell-Befehle ausführen. Aktualisieren Sie Pakete und verteilen Sie Dateien usw. auf allen verwalteten Systemen gleichzeitig. Salt führt diese Operationen mit Modulen aus. Salt verfügt über spezielle Module für alle verfügbaren Funktionen. Lassen Sie uns die verschiedenen Salt-Module anhand eines einfachen Beispiels in diesem Kapitel verstehen.
Shell-Befehl
Salt führt Shell-Befehle mithilfe von cmd.runBefehl. Dascmd ist das Hauptmodul und run ist eine der Funktionen, die in der cmdModul. Dasrun Mit dieser Funktion kann jeder Shell-Befehl im Remote-System ausgeführt werden, wie im folgenden Codeblock gezeigt.
salt '*' cmd.run 'ls -l /etc'
Es wird Folgendes erzeugt output - -
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
……………
……………
Festplattennutzung anzeigen
Salz bietet ein spezielles Modul, diskum die vollständigen Datenträgerdetails des verwalteten Systems abzurufen. Dasdiskmodule hat ein usage Funktion zum Abfragen der Details.
salt '*' disk.usage
Es wird Folgendes erzeugt output - -
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
Netzwerk Schnittstellen
Salt bietet ein separates Modul, Netzwerk und Funktionsschnittstellen innerhalb des Moduls, um die Netzwerkschnittstelleninformationen zu den verwalteten Systemen abzufragen.
salt '*' network.interfaces
Es wird Folgendes erzeugt output - -
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
Ausführungsmodul sys.doc
Salzfunktionen können an die gesendet werden sys.docAusführungsmodul. Dies wird verwendet, um die Details zu jedem Modul direkt über die Befehlszeile abzurufen. Die Salt-Funktionen sind selbstdokumentierend. Die gesamte Funktionsdokumentation kann über die unten definierte Funktion sys.doc () von den Minions abgerufen werden.
salt '*' sys.doc
Argumente für einen Funktionsaufruf
Argumente werden verwendet, um zusätzliche Daten für den Funktionsaufruf bereitzustellen. Ein einfaches Argumentbeispiel ist unten angegeben.
salt '*' sys.doc pkg.install
Hier das Argument pkg.install ist ein Modul zum Installieren bestimmter Pakete.
Python-Funktion
Argumente sind durch Leerzeichen getrennte Parameter für die Funktion. Damit kann der Python-Code wie unten angegeben als Argumente übergeben werden.
salt '*' cmd.exec_code python 'import sys;print sys.version'
Es wird Folgendes erzeugt output - -
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]
Ebenso können Sie optionale Schlüsselwörter und die verwenden YAML Format auch.
Das Konfigurationsmanagement ist eines der wichtigsten Konzepte in SaltStack. Es wird verwendet, um eine wiederverwendbare Konfigurationsvorlage mit dem Namen a zu erstellenstate. Der Status beschreibt alles, was erforderlich ist, um eine Systemkomponente oder eine Anwendung in eine bekannte Konfiguration zu versetzen.
Salzzustand
Der Salzzustand ist eine wiederverwendbare Konfiguration für einen bestimmten Teil eines Systems. Zustände sind mit einer einfachen YAML leichter zu verstehen und zu beschreiben.
Erstellen Sie einen Salzzustand
Salzzustände sind einfach zu erstellen. Lassen Sie uns in diesem Kapitel einen einfachen Zustand erstellen. Wechseln Sie in das Verzeichnis "salt-vagrant-demo / saltstack / salt /" und erstellen Sie eine Datei mit dem Namensamples.sls und fügen Sie die folgenden Zeilen hinzu.
samples.sls
install_network_packages:
pkg.installed:
- pkgs:
- rsync
- lftp
- curl
Speichern Sie nun die Datei und führen Sie den folgenden Befehl im Salt Master aus.
root@saltmaster:/home/vagrant# salt 'minion1’ state.apply samples
Hier haben wir installiert rsync, lftp und curl durch die pkg.installed Modul unter Verwendung des Salzzustands in einem Salzschergen, minion1. Wenn es richtig funktioniert, können Sie die Antwort wie unten gezeigt sehen.
Es wird Folgendes erzeugt output - -
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 State auftragen
Jetzt haben wir einen Status mit der Datei '.sls' erstellt und ihn durch gezieltes Aufrufen angewendet. Salt hat eine Standardstatusdatei namenstop.slsDatei. Die oberste Datei wird verwendet, um mehrere Statusdateien auf Salt Minions anzuwenden. Die oberste Datei beschreibt, wo Zustände angewendet werden sollen. Gut,States und die Top file Arbeiten Sie zusammen, um den Kern der Konfigurationsverwaltungsfunktionen von SaltStack zu erstellen.
Lassen Sie uns nun eine einfache top.sls-Datei im Verzeichnis erstellen saltstack/salt und fügen Sie Folgendes hinzu.
top.sls
base:
'*':
- common
'minion1':
- samples
Hier das state, häufig applies zu all system Zustand, samples gilt für minion1.
Führen Sie als Nächstes den Salt Master aus und wenden Sie den Status wie unten gezeigt an.
root@saltmaster:/home/vagrant# salt '*' state.apply
Es wird Folgendes erzeugt output - -
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
Stapelgröße anwenden
Wenn Sie eine große Anzahl verbundener Schergen haben, können Sie die Anzahl der gleichzeitig aktualisierten Systeme begrenzen. Es wird mit dem ausgeführt–batch-size Option, die unten definiert ist.
root@saltmaster:/home/vagrant# salt --batch-size 5 '*' state.apply
Es wird Folgendes erzeugt output - -
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 State-Funktionen
Salt-State-Funktionen werden zum Installieren und Konfigurieren von Anwendungen auf Ihrem Remote-System verwendet. Lassen Sie uns ein "Vim" -Paket mit der Salt-Statusfunktion installieren.
Statusfunktion erstellen und anwenden
Erstellen Sie eine Datei mit dem Namen "sample.sls" im Verzeichnis "salt-vagrant-demo / saltstack / salt / sample.sls" und fügen Sie Folgendes hinzu:
sample.sls
install vim:
pkg.installed:
- name: vim
Sobald die Vagrant-Umgebung aktiv ist, führen Sie den Salt Master aus und wenden Sie die sample.sls an, indem Sie den folgenden Befehl ausführen.
root@saltmaster:/home/vagrant# sudo salt 'minion2’ state.apply sample
Es wird Folgendes erzeugt output - -
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
Jetzt haben wir ein Paket "Vim" hinzugefügt. Lassen Sie uns nun die Verpackung mit der Salzprüfmethode testen.
Salzzustandstest
Der Testlauf wird durch Hinzufügen der Option "test = True" zu den Status beauftragt. Die Rückgabeinformationen zeigen Zustände an, die gelb angewendet werden, und das Ergebnis wird als "Keine" gemeldet.
Der folgende Befehl wird verwendet, um den Status zu testen -
root@saltmaster:/home/vagrant# sudo salt 'minion2’ state.apply sample test = True
Es wird Folgendes erzeugt output - -
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 ─ Säulenkomponente
Die Säule ist ein wesentlicher Bestandteil, um Salzzustände wiederverwendbar zu machen. Es wird verwendet, um sichere Daten für Schergen zu definieren, die mithilfe von Zielen zugewiesen wurden. In Salt Pillar-Daten werden Werte wie Ports, Dateipfade, Konfigurationsparameter und Kennwörter gespeichert.
Säulenkonfigurationsdatei
Die Konfiguration für die pillar_roots in der Master-Konfigurationsdatei wird unten gezeigt -
pillar_roots:
base:
- /srv/pillar
Hier befindet sich die Datei im Verzeichnis „/ srv / pillar“.
Beachten Sie, dass die oberste Datei in /srv/pillar/top.sls die folgende Struktur aufweist:
base:
'*':
- default
Wechseln Sie nun zur Datei default.sls in /srv/pillar/default.sls und fügen Sie den folgenden Code hinzu.
# Default pillar values
apache
git
Aktualisieren Sie nach dem Speichern der Datei die Säule, um alle Änderungen zu aktualisieren.
Die Säule auffrischen
Sie können die Säule mit dem folgenden Befehl aktualisieren.
root@saltmaster:/home/vagrant# salt '*' saltutil.refresh_pillar
Der obige Befehl wird verwendet, um die Salzsäulendaten aller Schergen zu aktualisieren.
Säulendaten auflisten
Um die Säulendaten aufzulisten, können Sie den folgenden Befehl verwenden.
root@saltmaster:/home/vagrant# salt '*' pillar.ls
Es wird Folgendes erzeugt output - -
minion2:
- apache
- git
minion1:
- apache
- git
Säulenelemente
Sobald die Säule eingerichtet ist, können die Daten über das Säulenmodul auf dem Minion angezeigt werden. Es kann über die Funktion zugegriffen werdenpillar.items, die unten definiert ist.
root@saltmaster:/home/vagrant# salt '*' pillar.items
Es wird Folgendes erzeugt output - -
minion2:
----------
apache:
httpd
git:
git
minion1:
----------
apache:
httpd
git:
git
SaltStack - Komponente einschließen
Die Komponente 'Einschließen' wird verwendet, um dieselbe Konfigurationsaufgabe an mehreren Stellen zu definieren. Es ist einfach durchzuführen. Fügen Sie oben in Ihrer Statusdatei ein Include im folgenden Format hinzu:
include:
- state file 1
- state file 2
Hier, state file 1 und state file 2sind die Namen der SLS-Dateien, die Sie einschließen möchten. Keine Notwendigkeit, die einzuschließen.slsErweiterung. Die Status "Enthaltenes Salz" werden oben in die aktuelle Datei eingefügt.
Statusdatei im Unterverzeichnis
Sie können die Statusdatei des Unterverzeichnisses mit einem Punkt (.) Einfügen. Es fungiert als Verzeichnistrennzeichen.
include:
- dir.sls1
Körner-Schnittstelle
Grains ist eine Schnittstelle, über die Informationen über das zugrunde liegende System abgeleitet werden. Körner werden für das Betriebssystem, den Domänennamen, die IP-Adresse, den Kernel, den Betriebssystemtyp, den Speicher und viele andere Systemeigenschaften gesammelt.
Körner-Targeting
Korndaten können beim Zielen auf Schergen verwendet werden, was im folgenden Codeblock definiert ist.
root@saltmaster:/home/vagrant# salt -G 'os:Ubuntu' test.ping
Es wird Folgendes erzeugt output - -
minion1:
True
minion2:
True
Auflistung der Körner
Körner können mithilfe des unten definierten Moduls 'Körner.ls' aufgelistet werden.
root@saltmaster:/home/vagrant# salt '*' grains.ls
Elemente auflisten
Wie bei Pillar können auch bei Grains-Daten die Getreidesätze aufgelistet werden.
root@saltmaster:/home/vagrant# salt '*' grains.items
Die Protokollierung wird verwendet, um die laufenden Softwareereignisse zu verfolgen. Ein Ereignis wird durch eine beschreibende Nachricht beschrieben, die optional variable Daten enthalten kann. Der Salzprotokollierungsansatz wird verwendet, um eventuelle Probleme zu beheben. Sie können mit bestimmten Protokollebenen auschecken.
Konfigurationseinstellungen
Lassen Sie uns die verschiedenen Konfigurationseinstellungen für die Protokollierung im Detail verstehen.
LOGDATEI
Salt-Log-Datensätze werden durch die Datei geleitet, die den lokalen Pfadnamen oder den Netzwerkspeicherort zur Identifizierung enthält. Diese Datei wird als Protokolldatei betrachtet.
log_file: /var/log/salt/master
Hier wird die Datei abhängig von der Binärdatei im Master ausgeführt. In ähnlicher Weise können Sie auch im Minion ausführen, was unten gezeigt wird.
log_file: /var/log/salt/minion
Sie können auch die Remote-Adresse verwenden. Die Syntax für die Verwendung der Remote-Adresse lautet - <file | udp | tcp>: // <host | socketpath>: <port-if-required> / <log-facility>.
log_file: udp://loghost:port
Hier ist die Log-Funktion standardmäßig LOG_USER.
LOG_LEVEL
Die Protokollebenen sind in einem numerisch zugewiesenen Wert angeordnet. Die Python-Bibliothek hat standardmäßig die meisten Protokollierungsstufen definiert. Darüber hinaus verwendet Salt einige weitere Ebenen. Einige der Ebenen werden unten erläutert.
log_level: error; level value is 40 - Es zeigt den fehlerhaften Protokollanweisungsdatensatz an.
log_level: quiet; level value is 1000 - Es zeigt an, dass auf dieser Ebene nichts protokolliert werden soll.
log_level: info; level value is 20 - Es zeigt die normalen Protokollinformationen an.
log_level: warn; level value is 30 - Es zeigt den Protokollanweisungsdatensatz bei Warnung an.
log_level: debug; level value is 10 - Informationen, die zum Debuggen von Salt-Implementierungen und Salt-Code nützlich sind.
log_level: trace; level value is 5 - Detailliertere Informationen zum Code-Debugging.
LOG_LEVEL_LOGFILE
Es definiert die Ebene der Nachrichten, die an die Protokolldatei gesendet werden sollen.
log_level_logfile: info
LOG_DATEFMT
Es definiert das Protokolldatumformat. Standardmäßig wird es als% Y-% m-% d% H:% M:% S dargestellt.
log_datefmt_logfile: '%Y-%m-%d %H:%M:%S'
LOG_FMT_CONSOLE
Es definiert das Format der Konsole, die die Nachrichten protokolliert. Salz verwendet einen BrauchLogRecordAttribute zum Färben der Konsolenprotokollausgabe. Es folgt der folgenden Syntax:
'%(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
Es definiert das Format der Protokolldatei, in der die Nachrichten protokolliert werden. Die grundlegende Syntax lautet wie folgt:
%(asctime)s,%(msecs)03d [%(name)-17s][%(levelname)-8s] %(message)s
LOG_GRANULAR_LEVELS
Diese Ebene wird verwendet, um die Protokollierungsstufen genauer zu steuern.
log_granular_levels:
'salt': 'info'
'salt.modules': ‘trace'
Hier setzt die Hauptsalzbibliothek auf der Info-Ebene die salt.modules auf Trace-Ebene zu protokollieren.
Externer Protokollierungshandler
Salt verwendet für die Protokollierung den externen LogStash- und Sentry-Protokollhandler. Lassen Sie uns dies in diesem Kapitel im Detail verstehen.
LOGSTASH-Handler
LogStash ist Open Source. serverseitige sichere Datenverarbeitungspipeline. Betrachten wir einen einfachen UDP-Protokollierungshandler in Salt, der LogStash verwendet.
Geben Sie die folgenden Änderungen in der Salt-Masterdatei an:
logstash_udp_handler:
host: 127.0.0.1
port: 9999
version: 1
msg_type: logstash
Fügen Sie dann die Änderungen in die Logstash-Konfigurationsdatei ein -
input {
udp {
port ⇒ 9999
codec ⇒ json
}
}
Hier, UDP - ist die Eingabe, die ein Format als haben muss json_event, was wir über den Draht senden.
SENTRY Logging Handler
Sentry ist eine Echtzeit-Fehlerverfolgung in Produktionsbereitstellungen und Informationen zur Reproduktion und Behebung von Abstürzen. Die Standardkonfiguration in der Masterdatei ist unten definiert.
sentry_handler:
dsn: https://pub-key:[email protected]/app-id
log_level: debug
Hier ist die Standardprotokollierungsstufe für den Sentry-Handler ERROR, aber wir haben das Debug definiert log_level unter dem Konfigurationsschlüssel sentry_handler.
Salt führt Befehle in einem Remote-System mithilfe von aus salt-minion. Dies ist das normale Verhalten. In einigen Szenarien kann nur über das SSH-Protokoll auf das Remote-System zugegriffen werden. In diesen Szenarien bietet Salt die Option, das Remote-System nur über das SSH-Protokoll zu verbinden und den Befehl über die SSH-Schicht auszuführen.
Salt SSHist sehr einfach zu konfigurieren. Die einzige erforderliche Konfiguration besteht darin, die Details des Remote-Systems in einer speziellen Datei anzugeben, die alsRoster file. Diese Dienstplandatei befindet sich normalerweise in/etc/salt/roster. Die Dienstplandatei enthält alle Informationen zum Remote-System und wie können wir eine Verbindung herstellen. Sobald die Dienstplandateien konfiguriert sind, werden alle Salt-Befehle mit dem ausgeführtsalt-ssh anstelle des Salzbefehls.
Dienstplandatei
Das Dienstplansystem wurde speziell für Salt SSH entwickelt. Dies ist als steckbares System konzipiert. Der einzige Zweck des Dienstplansystems besteht darin, Informationen über das entfernte System zu sammeln. Die Dienstplandatei ist aYAML based configuration file mit Remote-Systeminformationen als targets. Diese Ziele sind eine spezielle Datenstruktur mit einem vordefinierten Satz von Attributen. Eine Dienstplandatei enthält ein oder mehrere Ziele und jedes Ziel wird durch a identifiziertSalt ID.
Die Grundstruktur der Dienstplandatei lautet wie folgt:
<Salt ID>:
host: <host name>
user: <user name>
passwd: <password of the user>
Alle anderen von der Dienstplandatei unterstützten Attribute sind optional. Sie sind wie folgt -
port - SSH-Portnummer.
sudo - ob der Befehl über sudo ausgeführt werden soll.
sudo_user - sudo Benutzername.
tty - true, wenn sudo aktiviert ist.
priv - privater Schlüssel.
timeout - Zeitüberschreitung für eine SSH-Verbindung.
minion_opts - Wörterbuch der Minion-Optionen.
thin_dir - Speicherverzeichnis des Zielsystems für Salzkomponenten.
cmd_umask - umask, um den Salt-Call-Befehl zu erzwingen.
Die Beispiel-Dienstplandatei lautet wie folgt:
web:
host: 192.168.2.1
user: webuser
passwd: secret
sudo: True
db:
host: 192.168.2.2
Stellen Sie SSH-Schlüssel bereit
Salt SSH generiert standardmäßig öffentliche / private Schlüsselpaare für SSH-Anmeldungen. Der Standardpfad lautet /etc/salt/pki/master/ssh/salt-ssh.rsa. Dieser Schlüssel kann mithilfe von auf dem Remote-System bereitgestellt werdenssh-copy-id Befehl wie unten gezeigt.
ssh-copy-id -i /etc/salt/pki/master/ssh/salt-ssh.rsa.pub [email protected]
Befehl ausführen
Das Ausführen eines Salt-Befehls ist so einfach wie das Ändern des salt cli Befehl in salt-ssh Wie nachfolgend dargestellt.
salt-ssh '*' test.ping
Raw Shell-Befehl
Salt SSH bietet eine Option (-r) zum Ausführen eines Raw-Befehls im Remote-System unter Umgehung des Salt-Moduls und der Funktionen.
salt-ssh '*' -r 'ls'
Targeting mit Salt SSH
Das Targeting des Remote-Systems in Salt SSH unterstützt nur Glob- und Regex-Ziele. Da Salt SSH ein separates Modul ist, bietet es derzeit nur begrenzte Optionen und wird in naher Zukunft weitere Funktionen bieten.
Salt bietet ein separates Modul, Salt Cloud Salt Cloud ist eine generische Schnittstelle zum Konfigurieren und Verwalten von VMs verschiedener Cloud-Anbieter, um virtuelle Maschinen verschiedener Cloud-Anbieter wie Amazon AWS, Google Compute usw. bereitzustellen.
Cloud Config- Die Hauptkonfigurationsdatei für Salt Cloud lautet / etc / salt / cloud und gilt für alle VMs. Die Hauptkonfigurationsdatei wird aufgerufenCloud Config.
Cloud Providers - Um bestimmte Cloud-Anbieter anzusprechen, können wir eine bestimmte Konfigurationsdatei verwenden, die sich in /etc/salt/cloud.providers.d/*.conf befindet. Diese werden als bezeichnet Cloud Providers.
Cloud Profiles - Um auf eine bestimmte VM abzuzielen, können wir auch eine spezielle Konfigurationsdatei verwenden, die nur für diese bestimmte VM gilt und sich unter /etc/salt/cloud.profiles.d/*.conf befindet. Diese werden als bezeichnet Cloud Profiles.
Für eine virtuelle Maschine Einstellungen in der Cloud Config wird zuerst angewendet und dann in der Cloud Providers und schließlich wird das Überschreiben von der durchgeführt Cloud Profiles.
Installation von Salt Cloud
Standardmäßig ist Salt Cloud in das Salt integriert und sofort verfügbar. Wenn es nicht verfügbar ist, können wir es mit dem folgenden Befehl installieren.
pip install salt-cloud
Da Salt Cloud ein separates Modul ist und in einem eigenen Prozess ausgeführt wird, kann es anstelle des Salt Master auch im Salt Minion-System installiert werden.
Bereitstellung einer virtuellen Maschine
Um eine virtuelle Maschine bereitzustellen, müssen wir einen Cloud-Anbieter und ein Cloud-Profil definieren. Sobald beide erstellt sind, können wir eine neue virtuelle Maschine für deren Verwendung bereitstellen.
Cloud-Anbieter
Cloud-Host-Informationen werden in der Konfigurationsdatei des Cloud-Anbieters konfiguriert. Normalerweise sind die grundlegenden Informationen, die konfiguriert werden müssen, Cloud-Treiber, Benutzername, Kennwort, privater Schlüssel usw. Erstellen wir einen neuen Cloud-Anbieter mit dem Namenmy-amazon-cloud.
Erstellen Sie eine Datei, my-amazon-cloud.conf unter /etc/salt/cloud.providers.d/
Fügen Sie einen neuen Anbieter hinzu, indem Sie die ec2 Treiber.
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 bietet sofort einsatzbereite Treiber für verschiedene Cloud-Hosts wie GoGrid, HP Cloud, Google Compute Engine (GCE), Amazon AWS, Joyent, Linode, OpenNebula, ProfitBricks, Proxmox, Saltify, VexxHost, VMWare usw.
Sobald die Cloud-Anbieter konfiguriert sind, können wir den verfügbaren Standort des Anbieters, die verfügbaren Maschinenabbilder und seine verschiedenen Größen abfragen.
salt-cloud --list-location my-amazon-cloud
salt-cloud --list-images my-amazon-cloud
salt-cloud --list-sizes my-amazon-cloud
Cloud-Profil
Ein Cloud-Profil gibt das Image und die Größe der virtuellen Maschine an. Es kann unter - /etc/salt/cloud.profiles.d/ konfiguriert werden. Lassen Sie uns ein einfaches Profil erstellen,simple.conf.
aws_micro:
provider: my-amazon-cloud
image: <image_id>
size: <machine_id e.g. t1.micro>
Virtuelle Maschine
Sobald der Anbieter und die Profile konfiguriert sind, können wir mithilfe der Salt-Cloud wie unten gezeigt problemlos eine virtuelle Maschine bereitstellen.
salt-cloud -p aws_micro master minion1 minion2
Wo, p - Profilname master, minion1 und minion2 sind die neuen virtuellen Maschinen.
Die Details der neu erstellten virtuellen Maschine können mit dem folgenden Befehl abgerufen werden.
salt-cloud --query
Die virtuellen Maschinen können mit dem folgenden Befehl zerstört werden:
slat-cloud -d master minion1
Wolkenkarte
Eine Cloud Map ist ein spezielles Format zum gleichzeitigen Erstellen mehrerer virtueller Maschinen. Das Format der Zuordnungsdatei besteht darin, das Profil anzugeben und anschließend eine Liste der virtuellen Maschinen darunter hinzuzufügen.
Eine Beispielkartendatei lautet wie folgt:
micro:
- web1
- web2
large:
- db1
- db2
Die Zuordnungsdatei kann als Argument an den Befehl salt-cloud übergeben werden, um die virtuelle Maschine wie folgt zu erstellen:
salt-cloud -m /path/to/mapfile
Es gibt viele Geräte wie Router, Netzwerkgeräte usw. mit benutzerdefiniertem Betriebssystem, begrenztem Speicher und hohen Sicherheitsaspekten. Auf diesen Geräten konnten wir den Standard nicht installierensalt-minionund waren anschließend nicht in der Lage, diese Systeme zu verwalten. Salt bietet jedoch eine innovative Technologie, um diese Einschränkung zu überwinden.
Salt verfügt über ein separates Modul, Salt Proxy Minion, das das Remote-System mithilfe des im Remote-System ausgeführten REST-Dienstes steuert. Dieser REST-Service ist ein HTTP-basierter Webdienst, der mit dem geschrieben wurdeRepresentational State Transfer (REST) Konzept und sie sind sowohl einfach zu implementieren als auch einfach zu konsumieren.
Jedes Gerät verfügt über ein eigenes SDK und eine eigene Entwicklungsumgebung zum Schreiben komplexer Anwendungen. Salt erwartet, dass im Gerät ein REST-Service gemäß der Salt-Schnittstellenspezifikation entwickelt wird. Salt bietet auch ein Python-Modul zum Schreiben des REST-Webdienstes. Wenn das Gerät Python unterstützt, ist es einfach, den REST-Webdienst zu entwickeln.
Sobald der REST-Webdienst entwickelt und im Remote-System bereitgestellt wurde, kann Salt so konfiguriert werden, dass das Remote-Gerät mithilfe des REST-Webdienstes anstelle des Salt Minion gesteuert wird.
Arbeitsbeispiel
Lassen Sie uns das Konzept von lernen salt proxy minionmit einer Live-Arbeitsumgebung. Für die Live-Umgebung haben wir ein Linux-System sowohl für den Master als auch für den Proxy-Minion ausgewählt. Wir werden das System mithilfe des REST-Webdienstes anstelle von Salt-Minion steuern.
Installieren und konfigurieren Sie den REST-Webdienst
Salt bietet ein Beispiel für die Implementierung des REST-Webdienstes, das in seinem Contrib-Modul als proxyminion_rest_example bezeichnet wird. Lassen Sie uns den Beispiel-Webdienst installieren.
Installieren ‘bottle’mit dem pip. Dasbottle Befehl ist ein Python-Webframework zum Entwickeln von Webanwendungen.
pip install bottle = 0.12.8
Laden Sie die saltstack/salt-contribProjekt von Github. Andernfalls klonen Sie das Projekt mit dem folgenden Befehl.
git clone https://github.com/saltstack/salt-contrib
Öffne ein Terminal und gehe zum salt-contrib Verzeichnis.
Dieses Salt-Contrib-Verzeichnis enthält einen Ordner: proxyminion_rest_example. Dieser Ordner enthält eine Beispielimplementierung für den REST-Webdienst. Wechseln Sie in den Ordner proxyminion_rest_example.
Führen Sie den folgenden Befehl aus, um den REST-Webdienst zu starten.
python rest.py --address <your ip address> --port 8000
Öffnen Sie einen Browser und laden Sie http: // «Ihre IP-Adresse»: 8000. Daraufhin wird die Standardseite mit Diensten und Paketen angezeigt (siehe Abbildung unten).
Jetzt haben wir den REST-Webdienst konfiguriert und es wird überprüft, wie der Salt-Proxy so konfiguriert wird, dass der REST-Webdienst abgefragt und das System gesteuert wird.
Konfigurieren Sie Salt-Proxy
Um den Salt-Proxy zu konfigurieren, müssen Sie die folgenden Schritte ausführen.
Wir müssen den Masterknoten für den Salt-Proxy angeben. Bearbeiten Sie den Speicherort der Proxy-Konfigurationsdatei in / etc / salt / proxy und geben Sie den folgenden Code ein.
master: <your ip address>
Ändern / Erstellen der Basissäulendatei in /srv/pillar/top.sls wie im folgenden Codeblock gezeigt.
base:
'p8000':
- p8000
Fügen Sie eine neue Säulendatei hinzu, p8000.sls in dem /srv/pillar wie im folgenden Codeblock gezeigt.
proxy:
proxytype: rest_sample
url: http://<your ip address>:8000
Starten Sie Salt-Proxy im Debug-Modus mit dem folgenden Befehl.
salt-proxy --proxyid = p8000 -l debug
Akzeptieren Sie ähnlich wie beim Salt-Minion die salt-proxy key Wie nachfolgend dargestellt.
salt-key -y -a p8000
The following keys are going to be accepted:
Unaccepted Keys:
p8000
Key for minion p8000 accepted.
Das Salz laufen lassen
Führen Sie nun die aus salt Befehl und rufen Sie die ping.test Funktion wie unten gezeigt.
salt p8000 test.ping
Wir können jede Funktion ausführen, die vom REST-Webdienst unterstützt wird salt, das ist ähnlich wie salt-minion.
Beispielsweise können die Korninformationen unter Verwendung des folgenden Befehls erhalten werden.
salt p8000 grains.items
Das Ereignissystem in Salt ist eine lokale ZeroMQ PUB-Schnittstelle, die Salt-Ereignisse auslöst. Es wird von den folgenden Komponenten ausgeführt.
Event Sockets - Es wird zum Veröffentlichen von Ereignissen verwendet.
Event library - Es wird verwendet, um Ereignisse abzuhören und die Ereignisse in das Salzsystem zu senden.
Salt Master Event
Ein Salzmeister bietet verschiedene Arten von Ereignissen an, die im Folgenden ausführlich erläutert werden:
- Authentifizierungsereignisse
- Ereignisse starten
- Schlüsselereignisse
- Jobereignisse
- Runner-Ereignisse
- Anwesenheitsereignisse
- Cloud-Ereignisse
Lassen Sie uns jeden Ereignistyp im Detail durchgehen.
Authentifizierungsereignisse
Diese Authentifizierungsereignisse werden ausgelöst, wenn ein Diener eine Authentifizierungsprüfung mit dem Master durchführt. Es wird durch salt / auth dargestellt.
Ereignisse starten
Die Startereignisse werden immer dann ausgelöst, wenn sich ein Diener mit dem Salzmeister verbindet und dies durch Salz / Diener // Start dargestellt wird.
Schlüsselereignisse
Die Schlüsselereignisse werden ausgelöst, wenn der Salzmeister Schlüssel für den Salz-Diener akzeptiert und ablehnt. Sie können mit dem Befehl salt-key auf dieses Ereignis zugreifen.
Jobereignisse
Ein Jobereignis wird ausgelöst, wenn ein neuer Job gestartet wird. Es wird vertreten durchsalt/job//new. Hier JID - Job ID neu - neuer Job
Runner-Ereignisse
Wenn ein Läufer mit der Ausführung beginnt, wird ein Läuferereignis ausgelöst. Es wird durch salt / run // new dargestellt.
Anwesenheitsereignisse
Wenn Schergen verbunden oder neu verbunden oder getrennt werden, wird dieses Ereignis in regelmäßigen Abständen ausgelöst. Es wird vertreten durch -salt/presence/present und salt/presence/change. Hier,
Present - bedeutet, dass der Salzmeister derzeit mit der Schergenliste verbunden ist.
Change - wird verwendet, um einen neuen Diener zu erkennen - verbunden oder getrennt.
Cloud-Ereignisse
Die Salt-Cloud-Ereignisse werden auf einer virtuellen Maschine ausgelöst. Sofern keine anderen Ereignisse vorliegen, wird es nicht am Diener durchgeführt. Sie können mit - darauf zugreifen.salt/cloud//creating. Es wird ausgelöst, wenn eine Salt Cloud den Ausführungsprozess der virtuellen Maschine startet.
Ereignistools
Lassen Sie uns nun die Ereignistools und -skripte durchgehen. Sie können über die CLI auf den Ereignisbus zugreifen. Der Zugriff erfolgt über den folgenden Befehl.
salt-run state.event pretty = True
Hier ist der Runner so konzipiert, dass er über externe Tools und Shell-Skripte mit dem Ereignisbus interagiert. Auf den Eventbus von Salt kann über die Fernzugriff zugegriffen werdenREST API. Es wird durch - (Beispiel-URL) dargestellt.
curl -SsNk https://salt-api.example.com:8000/events?token = 05A3.
Ebenso können Sie auch über die Python-Skripte auf Ereignisse zugreifen.
Im Allgemeinen, orchestrationist eine automatisierte Koordination und Anordnung von Systemen. Orchestrate Runner wird verwendet, um die Orchestrierung in SaltStack durchzuführen.
Runner orchestrieren
Der Orchestrate Runner bietet alle Funktionen des OverState(vorheriges System). Es wird ursprünglich als das bezeichnetstate.slsLäufer. Dieser Orchestrierungsläufer wird verwendet, um das Salt-State-System auf einen Salt-Master-Kontext zu verallgemeinern.
Das state.sls und die state.highstate Funktionen werden auf jedem Salt Minion ausgeführt, aber die state.orchestrateLäufer wird auf dem Master ausgeführt. Dasstate.orchestrateMit Runner können Sie Ihre gesamte Infrastruktur vollständig als Status verwalten. Lassen Sie uns verstehen, wie man einen einfachen Ausführungsprozess durchläuft.
Einfache Ausführung
Der Befehl Orchestrate Runner entspricht dem Befehl state.sls Funktion, aber Sie können es mit dem "Salt-Run" anstelle von Salt ausführen.
Angenommen, Sie haben eine sample.sls Datei befindet sich bei /srv/salt/orch/samples.sls. Fügen Sie den folgenden Code in diese Datei ein.
sample.sls
install_nginx:
salt.state:
- tgt: 'web*'
- sls:
- nginx
Der folgende Befehl wird zum Ausführen auf dem Master verwendet und wendet die in dieser Datei definierten Zustände an.
salt-run state.orchestrate orch.sample
Es wird Folgendes erzeugt output - -
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#
Hier wurde gemäß der aktuellen Version die Runner-Funktion in umbenannt state.orchestrate. Dies ist hilfreich, um Verwechslungen mit der Ausführungsfunktion state.sls, aber den vorherigen Versionen von zu vermeidenstate.sls muss benutzt werden.
Funktion ausführen
Um eine Funktion auszuführen, sollten Sie die verwenden salt.function. Betrachten Sie eine Dateidata.sls befindet sich /srv/salt/orch/data.sls. Fügen Sie nun die folgenden Änderungen in diese Datei ein.
data.sls
cmd.run:
salt.function:
- tgt: '*'
- arg:
- rm -rf /tmp/data
Der folgende Befehl wird verwendet, um die Salt-Funktion auszuführen.
root@saltmaster:/home/vagrant# salt-run state.orchestrate orch.data
Es wird Folgendes erzeugt output - -
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
Salzformeln werden verpackt und über den Paketmanager an Salzmeister verteilt. Dieses Konzept wurde von beeinflusstRPM, Yum und PacmanVerpackungssysteme. Salt State, Pillar, Dateivorlagen und andere Dateien werden von der Formel verwendet und dann in eine einzelne Datei gepackt.
Nachdem ein Formelpaket erstellt wurde, wird es in das Repository-System kopiert, damit es für Salt-Master verwendet werden kann. Bevor Sie zum Paketmanager wechseln, werfen wir einen Blick darauf, wie Sie ein „nginx“ -Paket mit dem Befehl Salt basic installieren.
Die folgende Syntax wird verwendet, um ein "nginx" -Paket zu installieren.
root@saltmaster:/home/vagrant# salt '*' pkg.install nginx
Hier das pkg.install nginxBefehl wird verwendet, um ein Paket zu installieren. Nach der Ausführung wird die folgende Antwort angezeigt.
Es wird Folgendes erzeugt output - -
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:
Jetzt haben Sie ein Paket installiert. Verwenden Sie den folgenden Befehl, um die Dienste für dieses Paket zu starten.
root@saltmaster:/home/vagrant# salt '*' service.start nginx
Nach dem Ausführen dieses Befehls sieht das Ergebnis wie im folgenden Codeblock gezeigt aus.
minion1:
True
minion2:
True
Aus diesem Grund haben wir die Dienste für das Paket „nginx“ mit dem Befehl basic installiert und gestartet. Lassen Sie uns nun diskutieren, wie Pakete im Salt-Paketmanager erstellt und installiert werden.
Pakete erstellen
Pakete können auf jedem System erstellt werden, auf dem Sie Salt installieren können. Es gibt drei Arten von Paketen, und sie sind folgende.
- Formula
- Reactor
- Conf
Lassen Sie uns nun verstehen, wie Pakete mit dem erstellt werden Fomula Datei.
Formeldatei
Die meisten Dateien aus dem Paket befinden sich standardmäßig im Verzeichnis - / srv / spm / salt /. Die Pillar-Datei kann jedoch im Verzeichnis - / srv / spm / pillar / abgelegt werden. Die Formeldatei beschreibt das Paket.
Example
name: apache
os: RedHat
os_family: RedHat
version: 201607
release: 2
summary: Formula for installing Apache
description: Formula for installing Apache
Hier,
Name- Der Name des Pakets. Hier lautet der Paketnameapache.
os - Es wird verwendet, um zu wissen, welche Betriebssysteme dieses Paket unterstützen können.
os_family - Es wird verwendet, um zu wissen, welche Betriebssystemfamilien dieses Paket unterstützen können.
Version- Die Version des Pakets. Es wird in einem JJJJMM-Format angegeben.
Release - Dieses Feld bezieht sich hauptsächlich auf eine Version einer Version.
Summary - Kurzbeschreibung des Pakets.
Description - Eine detailliertere Beschreibung des Pakets.
REAKTOR
Die Reaktordateien befinden sich in der /srv/spm/reactor/ Verzeichnis.
CONF
Die Dateien in diesem Pakettyp sind Konfigurationsdateien für Salt, die normalerweise in der Datei gespeichert sind /etc/salt/Verzeichnis. Konfigurationsdateien für andere Pakete als Salt können und sollten mit einem Salt-Status (unter Verwendung eines Pakettyps) behandelt werden.
Fahren wir mit den folgenden Schritten fort, um ein Paket zu erstellen.
Erstellen Sie eine FORMEL-Datei und legen Sie sie im Stammverzeichnis des Paketordners ab.
Stellen Sie die Formeldateien in einem Ordner auf dem Build-System zusammen.
Lauf spm build. Das Paket wird erstellt und im Ordner / srv / spm_build abgelegt. Der folgende Befehl wird zum Erstellen eines Pakets verwendet.
spm build /path/to/salt-packages-source/formula
Kopieren Sie nun die .spm Datei in einen Ordner im Repository-System.
Sie können die teilen srv/spm_build Ordner im Netzwerk oder kopieren Sie die Dateien auf Ihren FTP- oder Webserver.
Generieren Sie Repo-Metadaten mit dem folgenden Befehl.
spm create_repo /srv/spm_build
Pakete installieren
In diesem Abschnitt wird die Installation von Salt Package Manager-Paketen erläutert.
Konfigurieren Sie Remote-Repositorys
Um Remote-Repositorys zu konfigurieren, muss der Salt Master durch einen Konfigurationsprozess wissen, wo sich das Repository befindet.
Dateien sind in der /etc/salt/spm.repos.d/spm.repo Verzeichnis.
Example
file_repository:
url: https://spm.example.com/
Hier enthält die Datei den Namen des Repositorys und den Link zum Repository. Sie können auch http, https, ftp oder den Dateipfad verwenden. Um den Dateipfad zu verwenden, können Sie über die URL auf ihn zugreifen: file: /// srv / spm_build.
Metadaten aktualisieren
Nachdem das Repository auf dem Salt-Master konfiguriert wurde, werden die Repository-Metadaten mit dem folgenden Befehl heruntergeladen.
spm update_repo
Dateiroots aktualisieren
Die SPM-Pakete befinden sich im Verzeichnis srv / spm / salt. Fügen Sie den Dateistammwurzeln auf dem Salt-Master den folgenden Pfad hinzu:
file_roots:
base:
1. /srv/salt
2. /srv/spm/salt
Starten Sie nun den Salzmeister neu.
Installieren Sie das Apache-Paket
Verwenden Sie den folgenden Befehl, um das Paket Apache zu installieren.
spm install apache
Sie können die Installation auch direkt aus der SPM-Datei mit dem folgenden Befehl durchführen.
spm local install /srv/spm/apache-201607-1.spm
Paket entfernen
Verwenden Sie den folgenden Befehl, um ein Paket zu entfernen, z. B. Apache.
spm remove apache
Beachten Sie, dass Dateien, die geändert wurden, nicht entfernt werden.
Salt bietet programmgesteuerten Zugriff auf alle seine Befehle. Salt bietet verschiedene Module für jeden Abschnitt des Salt-Systems. Lassen Sie uns die Grundlagen der Python-API und die Ausführung der grundlegenden Salt-Befehle in diesem Kapitel lernen.
Aufbau
Das salt.config Modul wird verwendet, um auf Salt-Konfigurationsdetails zuzugreifen.
import salt.config
opts = salt.config.client_config('/etc/salt/master')
Hier das client_config Liest die Salt-Konfigurationsdatei und gibt die Konfigurationsdetails als Wörterbuch zurück.
Lader
Das salt.loader Modul wird verwendet, um jedes Modul in Salz wie Getreide, Schergen usw. zu laden.
import salt.loader
opts = salt.config.minion_config('/etc/salt/minion')
grains = salt.loader.grains(opts)
Hier, grains liest die Details der Körner im Salzsystem und gibt sie zurück.
Client-Modul
Das salt.client Das Modul wird verwendet, um die Befehle salt, salt-call und salt-SSH programmgesteuert auszuführen.
Die wichtigsten Python-Klassen sind wie folgt:
- salt.client.LocalClient
- salt.client.Caller
- salt.client.ssh.client.SSHClient
Die Hauptfunktion, die von den meisten Client-Modulen bereitgestellt wird, ist cmd. Diese Funktion umschließt die CLI-Optionen und führt sie aus. Dies ähnelt der Befehlszeile und gibt die Ergebnisse als Python-Datenstrukturen zurück.
LocalClient
Der LocalClient wird verwendet, um Befehle vom Master an die Salt Minions zu senden und die Ergebnisse an den Master zurückzugeben.
import salt.client
local = salt.client.LocalClient()
local.cmd('*', 'test.ping')
Es wird Folgendes erzeugt output - -
{'minion1': True, 'minion2': True }
Anrufer
Der Anrufer wird zum Ausführen verwendet salt-call programmgesteuert und geben Sie die Ergebnisse zurück.
import salt.client
caller = salt.client.Caller()
caller.cmd('test.ping')
Es wird Folgendes erzeugt output - -
True
SSHClient
Der SSHCient wird zum Ausführen des verwendet salt-ssh programmgesteuert und geben Sie die Ergebnisse zurück.
import salt.client.ssh.client
ssh = salt.client.ssh.client.SSHClient()
ssh.cmd('*', 'test.ping')
Es wird Folgendes erzeugt output - -
{'minion1': True, 'minion2': True }
CloudClient
Das Modul salt.cloud wird verwendet, um die Salt-Cloud-Befehle programmgesteuert auszuführen.
client = salt.cloud.CloudClient(path = '/etc/salt/cloud')
Das Cloud-Modul bietet Funktionen zum Erstellen von VMs (Erstellen), zum Zerstören von VMs (Zerstören), zum Auflisten von Images, die von einem Cloud-Anbieter bereitgestellt wurden (list_images), zum Auflisten von Standorten eines Cloud-Anbieters (list_locations) und zum Auflisten von Computergrößen eines Cloud-Anbieters (list_sizes). usw.
In diesem Arbeitsbeispiel erstellen wir eine Salt-Formel, mit der der Apache-Webserver zusammen mit der PHP-Software konfiguriert wird. Salt ist eine großartige Möglichkeit, Ad-hoc-Befehle auszuführen, aber Sie möchten Ihre Infrastruktur nicht wirklich kontinuierlich auf diese Weise konfigurieren. Durch Erstellen einer Reihe von Salt-Formeln können Sie jede Konfiguration zuverlässig reproduzieren.
Salt-Formeln sind einfache YAML-Textdateien und befinden sich standardmäßig auf Ihrem Salt Master in /srv/salt/*. Beginnen wir mit der Erstellung einer Salt Formula, um den Apache-Webserver und PHP gleichzeitig zu installieren.
Erstellen Sie eine Datei mit dem Namen "websetup.sls" unter /srv/salt/ Verzeichnis und fügen Sie den folgenden Code hinzu.
websetup.sls
websetup:
pkg:
- installed
- pkgs:
- apache2
- php5
- php5-mysql
Beachten Sie in diesem Beispiel das Argument "- pkgs:". Jedes Element in der Liste unter "- pkgs:" wird zusammen an den Paketmanager des Betriebssystems übergeben, um zusammen installiert zu werden. Wenn Sie eine große Liste von zu installierenden Paketen haben, ist dies der effizienteste Weg, diese zu installieren.
Wenden Sie diese Formel mit dem folgenden Befehl auf Salt Master an.
root@saltmaster:/home/vagrant# salt 'minion2' state.sls websetup
Nun sehen Sie Folgendes output - -
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
Jetzt haben Sie die Pakete in installiert minion2.
Highstate
Ein „Highstate“ ist eine Möglichkeit für Salt, zu bestimmen, welche der Salzformeln auf einen bestimmten Diener angewendet werden soll. Führen Sie einen "Highstate" mit dem folgenden Befehl aus.
root@saltmaster:/home/vagrant# salt <targets> state.highstate
top.sls
Wenn der Minion wie oben erwähnt die Ausführung eines Highstate anfordert, fordert der Minion die top.sls vom Salt-Master an und sucht nach übereinstimmenden Formeln. Standardmäßig befindet sich diese Datei unter /srv/salt/top.sls. Fügen wir unsere Formel zur Datei top.sls hinzu und legen minion2 als Ziel fest.
base:
'*':
- common
'minion2’:
- websetup
Führen Sie nun die aus highstate ziele auf minion2 wie unten gezeigt.
root@saltmaster:/home/vagrant# salt 'minion2' state.highstate
Nachdem Sie dies angewendet haben, können Sie Folgendes sehen output - -
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
Jetzt sind Apache-Webserver und PHP in minion2 installiert. Auf diese Weise müssen wir mit beiden auf Schergen zielentop.sls und highstate und installieren Sie die erforderliche Software mit minimalem Arbeitsaufwand und maximaler Flexibilität.