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.