SaltStack - Guida rapida

In questo capitolo impareremo le basi di SaltStack. Le capacità di esecuzione remota di SaltStack consentono agli amministratori di eseguire comandi su varie macchine in parallelo con un sistema di targeting flessibile. La gestione della configurazione di Salt stabilisce un modello master-minion per allineare rapidamente, molto facilmente, in modo flessibile e sicuro i componenti dell'infrastruttura in linea con una determinata politica.

Cos'è SaltStack?

Salt è un framework di automazione molto potente. L'architettura Salt si basa sull'idea di eseguire comandi da remoto. Tutta la rete è progettata intorno ad alcuni aspetti dell'esecuzione remota. Questo potrebbe essere semplice come chiedere aRemote Web Serverper visualizzare una pagina Web statica o complessa come l'utilizzo di una sessione di shell per inviare comandi in modo interattivo su un server remoto. Salt è un esempio di uno dei tipi più complessi di esecuzione remota.

Salt è progettato per consentire agli utenti di indirizzare esplicitamente e inviare comandi direttamente a più macchine. Il sale si basa sull'idea di un Maestro, che ne controlla uno o piùMinions. I comandi vengono normalmente impartiti dal Master a un gruppo target di Minion, che quindi eseguono i compiti specificati nei comandi e quindi restituiscono i dati risultanti al Master. Le comunicazioni tra un maestro e i servitori avvengono nelZeroMQ message bus.

I moduli SaltStack comunicano con i sistemi operativi minion supportati. IlSalt Mastergira su Linux per impostazione predefinita, ma qualsiasi sistema operativo può essere un servitore e attualmente le varianti Windows, VMware vSphere e BSD Unix sono ben supportate. Il maestro del sale e i servi usano le chiavi per comunicare. Quando un servitore si connette a un maestro per la prima volta, memorizza automaticamente le chiavi sul maestro. SaltStack offre ancheSalt SSH, che fornisce una gestione dei sistemi "senza agente".

Necessità di SaltStack

SaltStack è progettato per velocità e scalabilità. Questo è il motivo per cui viene utilizzato per gestire grandi infrastrutture con decine di migliaia di server su LinkedIn, WikiMedia e Google.

Immagina di avere più server e di voler fare cose su quei server. Dovresti accedere a ciascuno di essi e fare quelle cose una alla volta su ciascuno, quindi potresti voler fare cose complicate come installare il software e quindi configurare quel software in base ad alcuni criteri specifici.

Supponiamo che tu abbia dieci o forse anche 100 server. Immagina di accedere uno alla volta a ciascun server individualmente, emettere gli stessi comandi su quelle 100 macchine e quindi modificare i file di configurazione su tutte le 100 macchine diventa un compito molto noioso. Per superare questi problemi, ti piacerebbe aggiornare tutti i tuoi server contemporaneamente, semplicemente digitando un singolo comando. SaltStack ti fornisce esattamente la soluzione per tutti questi problemi.

Caratteristiche di SaltStack

SaltStack è un software di gestione della configurazione open source e un motore di esecuzione remota. Salt è uno strumento da riga di comando. Sebbene scritto in Python, la gestione della configurazione di SaltStack è indipendente dal linguaggio e semplice. La piattaforma Salt utilizza il modello push per eseguire comandi tramite il protocollo SSH. Il sistema di configurazione predefinito èYAML e Jinja templates. Il sale è principalmente in competizione conPuppet, Chef e Ansible.

Salt offre molte funzionalità rispetto ad altri strumenti concorrenti. Alcune di queste importanti caratteristiche sono elencate di seguito.

• Fault tolerance- I salt minion possono connettersi a più master contemporaneamente configurando il parametro di configurazione master come un elenco YAML di tutti i master disponibili. Qualsiasi master può indirizzare i comandi all'infrastruttura Salt.

• Flexible- L'intero approccio gestionale di Salt è molto flessibile. Può essere implementato per seguire i modelli di gestione dei sistemi più diffusi come agente e server, solo agente, solo server o tutti i modelli precedenti nello stesso ambiente.

• Scalable Configuration Management - SaltStack è progettato per gestire diecimila minion per master.

• Parallel Execution model - Salt può abilitare comandi per eseguire sistemi remoti in modo parallelo.

• Python API - Salt fornisce una semplice interfaccia di programmazione ed è stato progettato per essere modulare e facilmente estensibile, per renderlo facile da modellare per diverse applicazioni.

• Easy to Setup - Salt è facile da configurare e fornisce un'unica architettura di esecuzione remota in grado di gestire i diversi requisiti di qualsiasi numero di server.

• Language Agnostic - I file di configurazione dello stato Salt, il motore di modelli o il tipo di file supportano qualsiasi tipo di linguaggio.

Vantaggi di SaltStack

Essendo un sistema semplice e ricco di funzionalità, Salt offre molti vantaggi e possono essere riassunti come di seguito:

• Robust - Salt è un framework di gestione della configurazione potente e robusto e funziona con decine di migliaia di sistemi.

• Authentication - Salt gestisce semplici coppie di chiavi SSH per l'autenticazione.

• Secure - Salt gestisce i dati protetti utilizzando un protocollo crittografato.

• Fast - Salt è un bus di comunicazione molto veloce e leggero che fornisce le basi per un motore di esecuzione remota.

• Virtual Machine Automation - La funzionalità Salt Virt Cloud Controller viene utilizzata per l'automazione.

• Infrastructure as data, not code - Salt fornisce una semplice distribuzione, gestione della configurazione basata su modello e framework di esecuzione dei comandi.

Introduzione a ZeroMQ

Salt è basato su ZeroMQlibreria ed è una libreria di rete incorporabile. È leggero e una libreria di messaggistica veloce. L'implementazione di base è inC/C++ e implementazioni native per diversi linguaggi tra cui Java e .Net è disponibile.

ZeroMQ è un'elaborazione di messaggi peer-peer senza broker. ZeroMQ ti consente di progettare facilmente un sistema di comunicazione complesso.

ZeroMQ viene fornito con i seguenti cinque modelli di base:

• Synchronous Request/Response - Utilizzato per inviare una richiesta e ricevere successive risposte per ciascuna inviata.

• Asynchronous Request/Response- Il richiedente avvia la conversazione inviando un messaggio di richiesta e attende un messaggio di risposta. Il provider attende i messaggi di richiesta in arrivo e risponde con i messaggi di risposta.

• Publish/Subscribe - Utilizzato per la distribuzione dei dati da un singolo processo (es. Editore) a più destinatari (es. Abbonati).

• Push/Pull - Utilizzato per la distribuzione dei dati ai nodi connessi.

• Exclusive Pair - Utilizzato per collegare due pari insieme, formando una coppia.

ZeroMQ è uno strumento di rete altamente flessibile per lo scambio di messaggi tra cluster, cloud e altri ambienti multi-sistema. ZeroMQ è ildefault transport library presentato in SaltStack.

L'architettura di SaltStack è progettata per funzionare con un numero qualsiasi di server, dai sistemi di rete locale ad altre implementazioni su diversi data center. L'architettura è un semplice modello server / client con le funzionalità necessarie incorporate in un unico set di daemon.

Dai un'occhiata alla seguente illustrazione. Mostra i diversi componenti dell'architettura SaltStack.

• SaltMaster- SaltMaster è il demone principale. Un SaltMaster viene utilizzato per inviare comandi e configurazioni agli slave Salt. Un unico master può gestire più master.

• SaltMinions- SaltMinion è il demone schiavo. Un minion del sale riceve comandi e configurazione dal SaltMaster.

• Execution- Moduli e comandi ad hoc eseguiti dalla riga di comando contro uno o più servitori. Esegue il monitoraggio in tempo reale.

• Formulas- Le formule sono stati del sale pre-scritti. Sono aperti come gli stessi Salt States e possono essere utilizzati per attività come l'installazione di un pacchetto, la configurazione e l'avvio di un servizio, l'impostazione di utenti o autorizzazioni e molte altre attività comuni.

• Grains- Grains è un'interfaccia che fornisce informazioni specifiche a un servitore. Le informazioni disponibili tramite l'interfaccia dei grani sono statiche. I cereali vengono caricati quando inizia il minion di sale. Ciò significa che le informazioni in grani sono immutate. Pertanto, le informazioni sui granuli potrebbero riguardare il kernel in esecuzione o il sistema operativo. Non fa distinzione tra maiuscole e minuscole.

• Pillar- Un pilastro è un'interfaccia che genera e archivia dati altamente sensibili specifici per un particolare servitore, come chiavi crittografiche e password. Memorizza i dati in una coppia chiave / valore e i dati vengono gestiti in modo simile a Salt State Tree.

• Top File - Abbina gli stati di Salt e i dati sui pilastri ai minion di Salt.

• Runners - È un modulo situato all'interno di SaltMaster ed esegue attività come lo stato del lavoro, lo stato della connessione, leggere i dati da API esterne, interrogare i minion del sale collegati e altro ancora.

• Returners - Restituisce i dati da Salt minion a un altro sistema.

• Reactor - È responsabile dell'attivazione di reazioni quando si verificano eventi nell'ambiente SaltStack.

• SaltCloud - Salt Cloud fornisce una potente interfaccia per interagire con gli host cloud.

• SaltSSH - Esegui i comandi Salt su SSH sui sistemi senza utilizzare Salt minion.

Nel prossimo capitolo impareremo in dettaglio i vari concorrenti di SaltStack e le loro caratteristiche.

Salt, Puppet, Chef e Ansible sono i principali strumenti di orchestrazione e gestione della configurazione, ognuno dei quali segue un percorso diverso verso l'automazione del server. Sono stati creati per semplificare la configurazione e la manutenzione di dozzine, centinaia o addirittura migliaia di server.

Facci capire come SaltStack compete principalmente con Puppet, Chef e Ansible.

Piattaforme e supporto

Di seguito è riportato un elenco di tutte le piattaforme che supportano SaltStack e i suoi concorrenti.

• SaltStack - Il software SaltStack funziona e gestisce molte versioni di Linux, Windows, Mac OS X e UNIX.

• Puppet - Red Hat Enterprise Linux, CentOS, Oracle Linux, Scientific Linux, SUSE Linux Enterprise Server e Ubuntu.

• Chef - Chef è supportato su più piattaforme come AIX, RHEL / CentOS, FreeBSD, OS X, Solaris, Microsoft Windows e Ubuntu.

• Ansible - Distribuzione Fedora di Linux, CentOS e Scientific Linux tramite pacchetti extra per Enterprise Linux (EPEL) e per altri sistemi operativi.

Lingua di origine

• SaltStack - Python

• Puppet - Ruby

• Chef - Ruby e la sua CLI utilizzano DSL basato su ruby

• Ansible - Python

Lingua supportata

• SaltStack - Qualsiasi lingua

• Puppet - Ruby

• Chef - Ruby e la sua CLI utilizzano DSL basato su ruby

• Ansible - Qualsiasi lingua

Interfaccia utente Web

• SaltStack - L'interfaccia utente Web offre viste dei lavori in esecuzione, dello stato dei minion e dei registri degli eventi.

• Puppet - L'interfaccia utente Web gestisce reportistica, inventario e gestione dei nodi in tempo reale.

• Chef - L'interfaccia utente Web ti consente di cercare e inventariare i nodi, visualizzare l'attività del nodo e assegnare libri di cucina, ruoli e nodi.

• Ansible - L'interfaccia utente Web ti consente di configurare utenti, team e inventari e applicare Playbook agli inventari.

Strumenti di gestione

• SaltStack - SaltStack Enterprise si posiziona come lo strumento principale per la gestione dell'orchestrazione delle operazioni cloud e IT, nonché DevOps.

• Puppet- Puppet è disponibile in due versioni, Puppet Enterprise e Open Source Puppet. Oltre a fornire le funzionalità dell'Open Source Puppet, Puppet Enterprise fornisce anche GUI, API e strumenti a riga di comando per la gestione dei nodi.

• Chef - CFEngine è lo strumento di gestione della configurazione.

• Ansible - Ansible 1.3 è lo strumento principale per la gestione.

Prestazione

• SaltStack- Salt è progettato per alte prestazioni e scalabilità. Il sistema di comunicazione di Salt stabilisce un canale dati persistente tra il maestro di sale e i servitori utilizzando ZeroMQ.

• Puppet - Sicuro e ad alte prestazioni e nessun agente richiesto.

• Chef- La difficoltà più evidente per Chef Server è la ricerca; La ricerca è lenta e non viene richiesta contemporaneamente dai client.

• Ansible - Sicuro, ad alte prestazioni e nessun agente richiesto.

Prezzo e valore

• SaltStack- Versione open source gratuita. SaltStack Enterprise costa $ 150 per macchina all'anno.

• Puppet- Versione open source gratuita. Puppet Enterprise costa $ 100 per macchina all'anno.

• Chef- Versione open source gratuita; Enterprise Chef gratuito per 5 macchine, $ 120 al mese per 20 macchine, $ 300 al mese per 50 macchine.

• Ansible- Versione open source gratuita; Ansible gratis per 10 macchine, quindi $ 100 o $ 250 per macchina all'anno a seconda del supporto necessario.

Utilizzo

• SaltStack- SaltStack è utilizzato da Cisco e Rackspace. Può integrarsi con qualsiasi piattaforma basata su cloud.

• Puppet - Puppet è utilizzato da Zynga, Twitter, Borsa di New York, PayPal, Disney, Google e così via.

• Chef - Chef può integrarsi con piattaforme basate su cloud come Internap, Amazon EC2, Google Cloud Platform, OpenStack, Microsoft Azure e Rackspace.

• Ansible - Ansible può distribuire in ambienti di virtualizzazione, ambienti cloud tra cui Amazon Web Services, Cloud Stack, DigitalOcean e Google Cloud Platform e così via.

Prima di passare all'installazione, è necessario disporre dei seguenti requisiti:

• Un server Linux (l'ultimo server Ubuntu).

• sudo o root access a questo server.

Installa tutti gli aggiornamenti utilizzando il seguente comando:

sudo apt-get update

Installa SaltMaster

Installa SaltMaster dal repository con il seguente comando apt-get.

sudo apt-get install salt-master

Installa Salt Minion

Installa Salt minion dal repository con il seguente comando apt-get.

sudo apt-get install salt-minion

Installa Salt syndic

Installa Salt syndic dal repository con il seguente comando apt-get.

sudo apt-get install salt-syndic

Configurazione principale

La configurazione del sale è molto semplice. La configurazione predefinita per il master funzionerà per la maggior parte delle installazioni. I file di configurazione vengono installati nella directory '/ etc / salt' e prendono il nome dai rispettivi componenti, come - / etc / salt / master e / etc / salt / minion.

#interface: 0.0.0.0
interface: <local ip address>

Dopo aver aggiornato il file di configurazione, riavviare Salt master utilizzando il seguente comando.

sudo service salt-master restart

Configurazione Minion

Configurare un Salt Minion è molto semplice. Per impostazione predefinita, un Salt Minion proverà a connettersi al nome DNS "salt"; se il Minion è in grado di risolvere correttamente quel nome, non è richiesta alcuna configurazione. Ridefinisci la direttiva "master" nel file di configurazione minion, che è tipicamente/etc/salt/minion, come mostrato nel codice sottostante -

#master: salt
master: <local ip address>

Dopo aver aggiornato il file di configurazione, riavvia Salt minion utilizzando il comando seguente.

sudo service salt-minion restart

Gestione delle chiavi

Usi del sale AES Encryptionper tutta la comunicazione tra il Maestro e il Minion. La comunicazione tra Master e Minion viene autenticata tramite chiavi affidabili e accettate.

salt-key -L

Produrrà quanto segue output -

Accepted Keys:
Denied Keys:
Unaccepted Keys:
<local system name>
Rejected Keys:

Accetta tutte le chiavi immettendo il comando seguente.

sudo salt-key -A

Produrrà quanto segue 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.

Ora emetti di nuovo il file salt key listing comando,

salt-key -L

Produrrà quanto segue output -

Accepted Keys:
<local system name>
Denied Keys:
Unaccepted Keys:
Rejected Keys:

Invio di comandi

La comunicazione tra il Master e un Minion deve essere verificata eseguendo il comando test.ping.

sudo salt '*' test.ping

Produrrà quanto segue output -

<local system name>
   True

Qui, "*" si riferisce a tutti i servi. Poiché abbiamo solo un minion - test.ping, esegue il fileping comando e restituisce se il ping ha esito positivo o meno.

In questo capitolo creeremo un semplice ambiente SaltStack, un salt master e due salt minion. Questo ambiente ci aiuterà ad apprendere il concetto di sale nei prossimi capitoli.

Atteniamoci ai seguenti passaggi per creare l'ambiente SaltStack.

Installa l'ambiente VirtualBox

VirtualBox è un'applicazione di virtualizzazione multipiattaforma. VirtualBox ti consente di eseguire più di un sistema operativo alla volta. VirtualBox funziona su Windows, Linux, Macintosh e Solaris. Ospita e supporta un gran numero di fileGuest Operating Systems.

Puoi scaricare e installare VirtualBox visitando il seguente link - https://www.virtualbox.org/wiki/Downloads

Creeremo tre macchine virtuali e le eseguiremo utilizzando VirtualBox.

Installa Vagrant

Vagrant fornisce ambienti di lavoro facili da configurare, riproducibili e portatili.

Puoi scaricare e installare Vagrant visitando il seguente link - https://www.vagrantup.com

Dopo la corretta installazione di Vagrant, è necessario configurarlo. Crea un singolo file denominato comeVagrantfile in una cartella e descrivere il tipo di macchina e le sue proprietà.

Run Vagrant - Per eseguire il Vagrant, immetti il ​​seguente comando:

vagrant up

Dopo aver eseguito vagrant up, Vagrant crea e avvia quelle macchine, che sono definite nel file Vagrantfileutilizzando VirtualBox in background. Queste macchine funzioneranno fino a quando non le chiuderai.

Stop Vagrant - Per arrestare tutte le macchine in esecuzione in VirtualBox, digita il seguente comando -

vagrant halt

Scarica l'ambiente demo

SaltStack fornisce un semplice ambiente demo come configurazione Vagrant ed è ospitato in github. Cerchiamo di scaricare l'installazione utilizzando il seguente comando:

cd /cd/to/path

git clone https://github.com/UtahDave/salt-vagrant-demo

Avvia Ambiente

Ora avvia l'ambiente demo utilizzando il seguente comando:

cd /cd/to/path/salt-vagrant-demo
vagrant up

Dopo questo comando, vedrai la seguente risposta:

result

Ora sono in esecuzione tre server, uno con il salt master configurato e due con il salt minion configurato.

Esegui Salt master

Accedi a Salt master utilizzando il seguente comando:

vagrant ssh master

Ora, passa all'utente root utilizzando il comando seguente:

sudo su

Ora ci siamo collegati con successo al Salt master.

Esaminiamo ora alcuni dei comandi di base in SaltStack.

Elenca tutte le chiavi

Il comando seguente serve per verificare le connessioni di Salt minion e visualizzare se la connessione è accettata, rifiutata o in sospeso.

salt-key —list-all

Produrrà quanto segue output -

Accepted Keys:
minion1
minion2
Denied Keys:

Unaccepted Keys:
Rejected Keys:

Verifica i minion del sale

Ora, abbiamo accettato tutte le chiavi, puoi inviare un comando dal maestro del sale per verificare se i minion del sale stanno ascoltando o meno,

salt '*' test.ping

Produrrà quanto segue output -

minion1:
   True
minion2:
   True

Dal risultato sopra, elenca il servitore 1 e il servitore 2, il che significa che i servi stanno ascoltando correttamente, altrimenti i servi potrebbero ora rispondere correttamente.

Un sistema di controllo degli accessi fornisce a un utente le opzioni per consentire a un gruppo di eseguire un'attività con autorizzazioni. Un sistema di controllo degli accessi Salt viene utilizzato per configurare l'accesso alle interfacce di controllo non amministrative. È possibile applicare questo processo a tutti i sistemi. Questo controllo aiuta gli utenti non amministrativi a eseguire i comandi Salt.

Le interfacce Salt sono dei seguenti tre tipi:

• Sistema ACL del publisher
• Sistema di autenticazione esterno
• Sistema peer

Cerchiamo di capire in dettaglio ciascuna di queste interfacce.

Sistema ACL del publisher

Un sistema ACL di Publisher consente l'accesso agli utenti diversi da root per eseguire i comandi Salt sui minion dal master. Il sistema ACL dell'editore viene configurato nel file di configurazione principale tramitepublisher_aclopzione di configurazione. È definito come segue:

publisher_acl:
   user1:
      - .*

   user2:
      - web*:
         - test.*
         - pkg.*

Qui,

• user1 è autorizzato a eseguire qualsiasi cosa.

• user2 è consentito l'uso test e pkg, ma solo sui minion "web *".

Sistema di autenticazione esterno

Il external auth system viene utilizzato per fornire l'accesso per eseguire comandi salt su minion specifici attraverso un sistema di autorizzazione esterno come PAM, LDAP, ecc. Questo file di configurazione è definito nel file principale come descritto di seguito.

external_auth:
   pam:
      user1:
         - 'web*':
            - test.*
            - network.*
      user2:
         - .*

Qui,

• user1 è autorizzato a eseguire funzioni in test e network modules sui servitori che corrispondono a web* bersaglio.

• user2 è autorizzato a eseguire tutte le funzioni.

Abilita il sistema di autenticazione esterno in comando

Il server Salt fornisce un'opzione "–a" per abilitare l'autenticazione esterna.

salt -a pam web\* test.ping

Qui, il -a pamviene utilizzata per abilitare l'autenticazione esterna PAM. Salt Server chiederà i dettagli di autenticazione ogni volta che eseguiremo il comando. Per impedire a Salt Server di chiedere i dettagli di autenticazione solo per la prima volta, possiamo utilizzare l'opzione T. Questo-T option memorizza nella cache i dettagli di autenticazione per le successive 12 ore (impostazione predefinita) e li utilizza per autenticare gli utenti.

salt -T -a pam web\* test.ping

Sistema peer

I minion del sale possono passare comandi utilizzando l'interfaccia peer. L'interfaccia peer viene configurata tramite il file di configurazione principale per consentire ai servitori di inviare comandi dal master utilizzando il filepeer sezione di configurazione o per consentire ai servitori di eseguire i corridori dal maestro usando il peer_run configurazione.

Cerchiamo di capire entrambe queste configurazioni in dettaglio.

Configurazione peer

La semplice configurazione da definire nel file master è la seguente:

peer:
   .*:
      - .*

Qui, consente la comunicazione per tutti i minion, ma è consigliato solo per ambienti molto sicuri.

Per assegnare minion a ID specifici, la configurazione deve essere definita come mostrato di seguito: peer -

.*domain.com:
   - test.*

Configurazione peer_run

Questa configurazione consente ai minion di eseguire i corridori dal master utilizzando l'opzione peer_run sul file master. Il seguente esempio serve per consentire l'accesso a tutti i servitori ea tutti i corridori.

peer_run:
   .*:
      - .*

Per assegnare i minion a un ID specifico, la configurazione deve essere definita come indicato di seguito:

peer_run:
   .*domain.com:
      - test.*

Come eseguire i comandi

Eseguire test.ping su tutti i servitori, usa il salt-call comando insieme al publish.publish modulo.

salt-call publish.publish \* test.ping

Eseguire runner, usa il comando salt-call insieme a publish.runner modulo.

salt-call publish.runner manage.up

Salt ha la capacità di comunicazione ad alta velocità con un gran numero di sistemi. Questo approccio aiuta Salt a creare un potente sistema multitasking. Salt può eseguire lavori su più di un sistema, quindi Salt utilizza la tecnica di gestione dei lavori per gestire ogni lavoro in esecuzione su tutti i sistemi. Questo capitolo spiega in dettaglio la gestione dei lavori.

Cos'è un Job ID?

Salt ha una directory della cache, cachedir. All'interno di questo, una directory mantenuta dai servi è chiamataprocdirectory. Si trova nella seguente directory / var / cache / salt / proc.

La directory proc viene utilizzata per mantenere tutti i file. Quando questi file vengono eseguiti, vengono assegnati con un ID lavoro univoco. Questo ID lavoro aiuta a identificare i lavori in corso sul seguace e consente di cercare i lavori.

Modulo SALTUTIL

Salt introduce un nuovo modulo chiamato processo di gestione dei lavori Saltutil. Questo modulo contiene diverse funzioni per gestire i lavori. Queste funzioni vengono utilizzate per gestire i lavori a livello di minion. Le funzioni sono descritte brevemente come segue:

• running - Restituisce tutti i dati dei lavori in esecuzione che si trovano nella directory proc.

• find_job - Restituisce dati specifici su un determinato lavoro in base all'ID lavoro.

• signal_job - Consente a un determinato ID lavoro (jid) di ricevere un segnale.

• term_job - Invia un segnale di conclusione per il lavoro specificato.

• kill_job - Invia un segnale kill per il lavoro specificato.

Jobs Runner

Il runner dei lavori contiene funzioni per rendere la visualizzazione dei dati più semplice e pulita. Ha diverse funzioni. Cerchiamo di discutere ciascuna di queste funzioni in dettaglio.

Funzione ATTIVA

La funzione Attivo viene utilizzata per identificare quali lavori sono ancora in esecuzione e controllare quali sistemi hanno completato un lavoro e quali sistemi sono ancora in attesa. Viene eseguito utilizzando il seguente comando,

salt-run jobs.active

Funzione LOOKUP_JID

Il runner lookup_jid mostrerà i dati per il lavoro in cerca corrente. Questi lavori vengono configurati tramitekeep_jobsopzione nella configurazione master. Viene eseguito utilizzando il seguente comando.

salt-run jobs.lookup_jid <job id number>

Funzione LIST_JOBS

La funzione List_jobs viene utilizzata per elencare i dati del lavoro per i lavori. È espresso dal seguente comando:

salt-run jobs.list_jobs

Pianificazione del lavoro

Il sistema di pianificazione espone l'esecuzione di qualsiasi funzione di esecuzione su minion o qualsiasi corridore sul master.

Viene eseguito con i seguenti metodi:

• Schedule - L'opzione di pianificazione nel master o nel minion config File.

• Minion pillar data - Aggiorna i dati del pilastro minion utilizzando il comando saltutil.refresh_pillar.

• Lo stato di pianificazione o il modulo di pianificazione.

Gli stati del sale vengono eseguiti sul servitore. Puoi passare gli argomenti posizionali e fornire un fileYAML dict degli argomenti denominati in config file come mostrato di seguito.

schedule:
   job1:
      function: saltstate.sls
      seconds: 3600
      args:
         - httpd
      kwargs:
         test: True

Qui, job1 eseguirà la funzione saltstate.sls con gli argomenti specificati, httpdper ogni ora. Iltest: True è l'argomento aggiuntivo per il httpd comando definito in saltstate.sls.

Il file server Salt è un server ZeroMQ senza stato. È integrato nel Salt master. Un file server Salt viene utilizzato per distribuire file dal master ai minion. Contiene diversi moduli. In questo capitolo comprendiamo il file server salt, la sua configurazione, i moduli relativi al file server salt, come accedere al file server salt in Python, ecc.

Backend del file server

Il backend del file server consente al file server Salt di agire come un'interfaccia trasparente per altri file server come un file system locale, un sistema di controllo della versione Git, ecc.

Un back-end del file server Git può essere abilitato utilizzando la seguente configurazione nel file master.

fileserver_backend:
   - git

Per abilitare più file system di backend, possiamo utilizzare la seguente configurazione.

fileserver_backend:
   - roots
   - git

Possiamo anche specificare l'opzione aggiuntiva per un server backend diverso utilizzando la sezione specifica del server backend corrispondente.

File system locale

Per utilizzare questo sistema, dobbiamo utilizzare il seguente codice.

file_roots:
   base:
      - /srv/salt/prod

Git File System

Per utilizzare questo sistema, dobbiamo utilizzare il seguente codice.

gitfs_remotes:
   - https://github.com/sample/sample1.git

Richiesta di file

Salt ha la possibilità di richiedere file per ambienti specifici.

salt://path/to/file?saltenv = base

Qui, l'ambiente viene definito utilizzando l'opzione roots.

Configurazione del file server

I file salt possono essere allocati all'interno di molte directory principali e vi si può accedere specificando sia il percorso del file che l'ambiente in cui cercare. I singoli ambienti possono estendersi su più directory root.

Ambiente

L'ambiente predefinito è base. Questo ambiente è definito e viene utilizzato per scaricare i file quando non è specificato nessun altro ambiente.

file_roots:
   base:
      - /srv/salt/base

È inoltre possibile utilizzare più ambienti come mostrato nel codice seguente.

file_roots:
   base:
      - /srv/salt/base
   dev:
      - /srv/salt/dev
      - /srv/salt/base

Modulo CP

Il modulo CP è il modulo principale per manipolare il Salt file server. Ilsalt-cp può essere utilizzato anche per distribuire i file presentati dal file server Salt.

PRENDI IL FILE

Il cp.get_filela funzione può essere utilizzata sul minion per scaricare un file dal master. È definito come mostrato nel seguente blocco di codice.

salt '*' cp.get_file salt://vimrc /etc/vimrc

Il comando precedente indica a tutti i minion di Salt di scaricare il file vimrc file e copiarlo in /etc/vimrc.

Abilita modello

Puoi abilitare l'opzione del modello in get_file come segue:

salt '*' cp.get_file "salt://vimrc" /etc/vimrc template = jinja

Applica compressione

Per usare la compressione, usa il gzipargomento denominato. I valori validi sono numeri interi da 1 a 9, dove 1 è la compressione minima e 9 è il valore massimo.

Il comando è definito come segue:

salt '*' cp.get_file salt://vimrc /etc/vimrc gzip = 5

GET_DIR

Il cp.get_dirla funzione può essere utilizzata sul minion per scaricare un'intera directory dal master. È definito nel seguente blocco di codice.

salt '*' cp.get_dir salt://etc/mysql /etc

Il cp.get_dirsupporta il rendering dei modelli e gli argomenti di compressione gzip. Se vuoi, puoi anche assegnare.

Modulo FILECLIENT

Salt fornisce un modulo python che aiuta ad accedere al file server salt. Ilsalt/fileclient.py Il modulo è utilizzato per impostare la comunicazione dal servitore al padrone.

Il codice di esempio per ottenere i file è il seguente:

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)

Qui,

• opts è disponibile quando il modulo viene eseguito nell'ambiente salt. Altrimenti, dovremmo fornire il percorso di configurazione -/etc/salt/minion.

• path fa riferimento al percorso del file di origine nel file server salt.

• dest fa riferimento al percorso di destinazione del file.

• saltenv si riferisce all'ambiente

Nel prossimo capitolo capiremo come usare Git come file server.

Gitè un sistema di controllo della versione distribuito open source. Può essere utilizzato per tenere traccia delle modifiche in qualsiasi file. Salt invia file dai repository Git utilizzando il file server Git. Puoi configurare Git sufileserver_backend list e se hai bisogno di configurare uno o più repository, puoi farlo usando il gitfs_remotes opzione.

Questo capitolo spiega come installare e configurare il file server Git. Prima di procedere all'installazione, è necessario disporre dei seguenti prerequisiti.

Prerequisiti di Salt Server per l'utilizzo di Git

Il requisito minimo per il server salt per utilizzare Git come file server è il seguente:

• pygit2
• Dulwich

Pygit2 e Dulwich vengono configurati utilizzando il gitfs_providerparametro nel file di configurazione principale. Segitfs_provider non è configurato nel file master, Salt preferirà pygit2, se è disponibile la versione adatta, seguito da GitPython e Dulwich.

Installa pygit2

I seguenti comandi vengono utilizzati per installare pygit2 nei sistemi basati su Fedora e Ubuntu:

• Fedora-based system

yum install python-pygit2

• Ubuntu-based system

apt-get install python-pygit2

Qui, la versione minima supportata di pygit2 è la 0.20.3.

Installa GitPYTHON

GitPython può essere facilmente installato sul master utilizzando il yum / apt command come mostrato di seguito.

• Fedora-based system

yum install GitPython

• Ubuntu-based system

apt-get install python-git

Installa DULWICH

Dulwich può essere facilmente installato sul master utilizzando il comando yum.

• Fedora-based system

yum install python-dulwich

• Ubuntu-based system

apt-get install python-dulwich

Ora, abbiamo installato tutte le dipendenze per il file server Git. Cerchiamo ora di configurare questo file server Git utilizzando ilfileserver_backend sezione in master config file.

Configurazione backend

Per poter utilizzare il file server Git, è necessario aggiungere Git nell'elenco fileserver_backend nel file di configurazione principale. È descritto come segue:

fileserver_backend:
   - git

Cerchiamo di capire ulteriormente come configurare il file server Git in una configurazione remota.

Configurazione gitfs_remotes

Puoi specificare uno o tutti gli URL come git: //, https: //, file: // o ssh: // per la configurazione gitfs_remotes nel file master. Viene utilizzato per cercare i file richiesti.

La semplice specifica dell'URL https è definita di seguito.

gitfs_remotes:
   - https://github.com

Il ssh la configurazione può essere eseguita come mostrato di seguito.

gitfs_remotes:
   - [email protected]:user1/sample.git
   - ssh://[email protected]/path/to/sample.git

Ora, abbiamo configurato il file server Git utilizzando le due opzioni fileserver_backend e gitfs_remotes.

Riavvia Master

Dopo aver effettuato tutte le modifiche nel file master, riavvia ora il master per caricare tutte le configurazioni nel file server Git.

Configurazione di più telecomandi

Il comando seguente viene utilizzato per configurazioni multiple in gitfs_remotes nel file master.

gitfs_remotes:
   - git://github.com/sample/sample1.git
   - https://github.com/sample/sample2.git
   - file:///root/user/sample

Qui, i repository sample1.git, sample2.git, e sample.doc potrebbe avere i seguenti file.

sample1.git:
   top.sls
   
sample2.git
   edit/vimrc
   
sample.doc
   edit/vimrc

Il MinionFSè un file server speciale fornito da Salt per consentire ai servi di scambiare i file tra di loro. I file serviti da MinionFS sono i file condivisi intenzionalmente dai minion. Per condividere i file, un Minion deve seguire i passaggi indicati di seguito.

• Il seguace della fonte deve inviare il file al maestro del sale usando il cp.push funzione.

• Una volta che i file vengono inviati dal minion sorgente, i file distribuiti possono essere raggiunti da qualsiasi altro servitore utilizzando il file server MinionFS.

Abilita push

Per impostazione predefinita, l'invio dei file da minion a un master è disabilitato. Per accettare i file dai minion, il master deve avere l'opzione "file_recv" nel file di configurazione e il suo valore deve essere impostato suTrue. Per impostazione predefinita, il valore se "file_recv" èfalse.

file_recv: True

Una volta abilitata l'opzione, riavvia il servizio principale.

Push di file

I servitori possono inviare i file al master. Viene eseguito dacp.pushfunzione. Questa funzione cp.push fornisce un meccanismo semplice per spingere i file da minion usando l'id minion.

salt 'minion-id' cp.push /path/to/the/file

Qui, il minion-id viene utilizzato per identificare quale servitore sta spingendo il file. Questo comando memorizzerà il file in una sottodirectory denominataminions sotto il master's cachedir. Di solito, il percorso è - / var / cache / salt / master / minions.

Per minion, m1 e il file - /var/log/mylog.txt, il file verrà memorizzato in - /var/cache/salt/master/minions/m1/var/log/mylog.txt.

Abilita MinionFS

Per abilitare MinionFS, aggiungi semplicemente minion nell'impostazione del backend del fileserver come mostrato nel seguente blocco di codice.

fileserver_backend:
   - roots
   - minion

Una volta abilitato MinionFS, i file inviati dai minion sono disponibili come:

salt://<minion-id>/path/to/pushed/file

Per minion, m1 e il file inviato - /var/log/mylog.txt, il file inviato verrà servito da salt: //m1/var/log/mylog.txt.

Questo minionFS può essere montato in una directory speciale utilizzando la seguente configurazione. Separerà i file minionFS da altri file e aiuterà a organizzare i file minion.

minionfs_mountpoint: salt://minionfs

Per la configurazione di cui sopra, il file sarà disponibile sotto minionfs directory come - salt: //minionfs/m1/var/log/mylog.txt

Opzioni avanzate di MinionFS

MinionFS fornisce anche un'opzione per abilitare / disabilitare la disponibilità di file inviati da un determinato servitore. Le opzioni sonominionfs_whitelist, per abilitare i minion e minionfs_blacklist, per disabilitare i servi.

minionfs_whitelist:
   - webserver
   - develop*
   - ‘mail\d+.mysite.com'

minionfs_blacklist:
   - testing

Nella configurazione sopra, tutti i servitori tranne testing sono autorizzati a condividere il file utilizzando minionFS.

• Webserver1

• I servitori i cui ID corrispondono all'espressione regolare si sviluppano *

• Servitori i cui ID corrispondono all'espressione regolare mail\d+.mysite.com.

• Testing

Nel prossimo capitolo impareremo come usare Cron con Salt.

Il sale può essere usato insieme al Cronapplicazione. L'utilizzo di entrambe le applicazioni insieme offre una grande opportunità per automatizzare Salt. Mentre Salt fornisce un'opzione per eseguire comandi in remoto, Cron ne consente l'esecuzione in modo pre-programmato o automatizzato. Impariamo come usare Cron e Salt insieme in questo capitolo.

Cos'è Cron?

Cron è un'applicazione molto utile nell'ambiente Linux. Consente di preimpostare un comando o uno script da eseguire in una data e ora specifiche. Consente inoltre di eseguire un'applicazione a intervalli regolari, ad esempio ogni giorno, ogni settimana o ogni primo giorno del mese.

Cron si avvia all'avvio del sistema e controlla il file /etc/crontabfile per i dettagli di configurazione. Il file / etc / crontab ha tutte le applicazioni e la relativa pianificazione in una riga separata come mostrato di seguito.

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"

Ogni riga ha i seguenti sette punti di ingresso, separati da uno spazio e sono i seguenti:

• minute - minuto dell'ora ed è compreso tra "0" e "59".

• hour - ora ed è specificato nell'orologio a 24 ore.

• day_of_month- Giorno del mese ed è compreso tra 1 e 31. Ad esempio, il 10 ^° di ogni mese è 10.

• month - Un mese specificato ed è specificato numericamente (0-12) o come nome del mese (es. Maggio).

• day_of_week - Il giorno della settimana è specificato numericamente (0-7) o come nome del giorno (es. Sole).

• user - Account utente con cui viene eseguito il comando.

• cmd - Il comando effettivo e i suoi argomenti.

Qui, * sostituisce, se non viene assegnato nulla.

Salt Caller (salt-call)

Salt fornisce una CLI (Command Line Interface), salt-callper eseguire i moduli nel sistema minion locale stesso invece che dal server master usando il comando salt. La CLI salt call supporta tutte le opzioni supportate dal comando salt, ma viene eseguita localmente.

Salt Caller è stato inizialmente progettato per supportare il debug, ma ora può essere utilizzato come applicazione autonoma.

salt-call test.ping

Utilizzando salt-call in cron

La CLI salt-call è utile per programmare il funzionamento del sale utilizzando Cron. Ad esempio, per controllare lo stato del servitore ogni giorno a mezzanotte, possiamo usare salt-call insieme all'opzione - state.apply come mostrato di seguito.

/etc/crontab

PATH = /bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:/opt/bin
0 0 * * * salt-call state.apply

Qui,

• Il state.apply la funzione controllerà il file di configurazione del salt per il seguace e verificherà se tutte le azioni definite per il seguace sono configurate correttamente.

• L'impostazione del percorso è una buona pratica perché a volte il comando salt potrebbe non essere disponibile nel percorso di sistema.

Nel prossimo capitolo impareremo l'esecuzione remota, che è un concetto fondamentale di Salt.

Uno dei concetti fondamentali di Salt è l'esecuzione remota. Salt può eseguire comandi su migliaia di sistemi in pochi secondi. Salt utilizza il proprio comando per eseguire questa funzionalità. Vediamo ora di comprendere i diversi comandi Salt per l'esecuzione remota nel capitolo.

Comando di sale

Il comando Salt consente a Salt master di comunicare con uno o più Salt minions. La sintassi di base è la seguente,

salt '<target>' <module.function> [arguments]

La sintassi del comando precedente è costituita dai seguenti tre componenti principali.

• target - Determina quali sistemi vengono applicati dal comando.

• module.function- È un comando. I comandi sono costituiti da un modulo e da una funzione.

• arguments - Dati aggiuntivi necessari per chiamare la funzione.

Cerchiamo di capire in dettaglio ciascuno dei componenti.

Qual è il componente target?

Target è un componente che ti consente di filtrare i minion (sistema gestito) per eseguire la funzione. Di seguito viene definito un semplice comando che utilizza il componente di destinazione.

salt '*' test.ping

Produrrà quanto segue output -

minion2:
   True
minion1:
   True

Ecco l'obiettivo ‘*’rappresenta tutti i sistemi gestiti. Il 'test'ecco un modulo e pingè una funzione. Viene utilizzato per testare il servizio ping nel sistema remoto. Apprenderemo i diversi moduli e le sue funzioni nei capitoli successivi.

Obiettivi che utilizzano ID (minion)

Puoi inviare un comando a un servitore specifico usando il suo idnel bersaglio. Invece di usare'*', puoi sostituirlo usando minion id. È definito di seguito.

salt 'minion1’ test.ping

Produrrà quanto segue output -

minion1:
   True

Obiettivi che utilizzano l'espressione regolare

I target possono essere filtrati da un'espressione regolare specifica. È definito di seguito.

salt -E 'minion[0-9]' test.ping

Produrrà quanto segue output -

minion2:
   True
minion1:
   True

Obiettivi utilizzando List

I target possono essere specificati esplicitamente in un elenco. È definito nel seguente blocco di codice.

salt -L 'minion1,minion2' test.ping

Produrrà quanto segue output -

minion2:
   True
minion1:
   True

Obiettivi per condizione

I target possono essere combinati in un comando come mostrato nel blocco di codice seguente.

salt -C 'G@os:Ubuntu and minion* or [email protected].*' test.ping

Produrrà quanto segue output -

minion1:
   True
minion2:
   True

Modulo e funzioni (module.function)

Salt può eseguire comandi della shell; aggiornare i pacchetti e distribuire file, ecc. in tutti i suoi sistemi gestiti contemporaneamente. Salt esegue queste operazioni utilizzando i moduli. Salt ha moduli speciali per tutte le funzionalità disponibili. Cerchiamo di capire i diversi moduli Salt utilizzando alcuni semplici esempi in questo capitolo.

Comando Shell

Salt esegue i comandi della shell in remoto su più sistemi utilizzando l'estensione cmd.runcomando. Ilcmd è il modulo principale e run è una delle funzioni disponibili in cmdmodulo. Ilrun consente di eseguire qualsiasi comando della shell nel sistema remoto come mostrato nel blocco di codice seguente.

salt '*' cmd.run 'ls -l /etc'

Produrrà quanto segue 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
……………
……………

Mostra utilizzo disco

Salt fornisce un modulo speciale, diskper ottenere i dettagli completi del disco del sistema gestito. Ildiskmodule ha un usage funzione per interrogare i dettagli.

salt '*' disk.usage

Produrrà quanto segue 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

Interfacce di rete

Salt fornisce un modulo, una rete e una funzione separati, interfacce all'interno del modulo per interrogare le informazioni dell'interfaccia di rete sui sistemi gestiti.

salt '*' network.interfaces

Produrrà quanto segue 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

Modulo di esecuzione sys.doc

Le funzioni del sale possono essere inviate a sys.docmodulo di esecuzione. Viene utilizzato per ottenere i dettagli su qualsiasi modulo direttamente dalla riga di comando. Le funzioni Salt sono auto-documentanti. Tutta la documentazione della funzione può essere recuperata dai minion tramite la funzione sys.doc (), definita di seguito.

salt '*' sys.doc

Argomenti per una chiamata di funzione

Gli argomenti vengono utilizzati per fornire dati aggiuntivi per la chiamata di funzione. Di seguito viene fornito un semplice esempio di argomento.

salt '*' sys.doc pkg.install

Qui, l'argomento pkg.install è un modulo per installare pacchetti specifici.

Funzione Python

Gli argomenti sono parametri delimitati da spazi della funzione. Permette di passare il codice python come argomenti come indicato di seguito.

salt '*' cmd.exec_code python 'import sys;print sys.version'

Produrrà quanto segue 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]

Allo stesso modo, puoi utilizzare parole chiave facoltative e il file YAML formato pure.

La gestione della configurazione è uno dei concetti più significativi di SaltStack. Viene utilizzato per creare un modello di configurazione riutilizzabile, chiamato astate. Lo stato descrive tutto ciò che è necessario per inserire un componente di sistema o un'applicazione in una configurazione nota.

Stato del sale

Salt state è una configurazione riutilizzabile per una parte specifica di un sistema. Gli stati sono più facili da capire e descritti utilizzando un semplice YAML.

Crea uno stato del sale

Gli stati salini sono facili da creare. Creiamo uno stato semplice in questo capitolo. Spostati nella directory "salt-vagrant-demo / saltstack / salt /" e crea un file denominatosamples.sls e aggiungi le seguenti righe.

samples.sls

install_network_packages:
   pkg.installed:
      - pkgs:
         - rsync
         - lftp
         - curl

Ora salva il file ed esegui il seguente comando nel Salt master.

root@saltmaster:/home/vagrant# salt 'minion1’ state.apply samples

Qui, abbiamo installato rsync, lftp e curl tramite la pkg.installed modulo utilizzando lo stato di sale in un minion di sale, minion1. Se funziona correttamente, potresti vedere la risposta come mostrato di seguito.

Produrrà quanto segue 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

Applicare Salt State

Ora che abbiamo creato uno stato utilizzando il file ".sls" e lo abbiamo applicato chiamandolo specificamente. Salt ha un file di stato predefinito chiamato cometop.slsfile. Il file in alto viene utilizzato per applicare più file di stato ai minion di Salt. Il file in alto descrive dove dovrebbero essere applicati gli stati. Bene,States e il Top file collaborare per creare il nucleo della capacità di gestione della configurazione di SaltStack.

Creiamo ora un semplice file top.sls nella directory saltstack/salt e aggiungi quanto segue.

top.sls

base:
  '*':
      - common
   'minion1':
      - samples

Qui, il state, comunemente applies per all system stato, samples si applica a minion1.

Quindi, esegui Salt master e applica lo stato come mostrato di seguito.

root@saltmaster:/home/vagrant# salt '*' state.apply

Produrrà quanto segue 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

Applica dimensione batch

Se hai un numero elevato di servitori collegati, puoi limitare il numero di sistemi aggiornati contemporaneamente. Viene eseguito utilizzando il–batch-size opzione, che è definita di seguito.

root@saltmaster:/home/vagrant# salt --batch-size 5 '*' state.apply

Produrrà quanto segue 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

Funzioni di stato del sale

Le funzioni Salt State vengono utilizzate per installare e configurare le applicazioni sul sistema remoto. Installiamo un pacchetto "Vim" utilizzando la funzione Salt state.

Crea e applica la funzione di stato

Crea un file denominato "sample.sls" nella directory "salt-vagrant-demo / saltstack / salt / sample.sls" e aggiungi quanto segue:

sample.sls

install vim:
   pkg.installed:
      - name: vim

Una volta che l'ambiente Vagrant è attivo, esegui salt master e applica sample.sls eseguendo il comando seguente.

root@saltmaster:/home/vagrant# sudo salt 'minion2’ state.apply sample

Produrrà quanto segue 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

Ora, abbiamo aggiunto un pacchetto "Vim". Proviamo ora il pacchetto utilizzando il metodo di test del sale.

Salt State Testing

L'esecuzione del test è obbligatoria aggiungendo l'opzione "test = True" agli stati. Le informazioni sul reso mostreranno gli stati che verranno applicati in giallo e il risultato verrà segnalato come "Nessuno".

Il seguente comando viene utilizzato per testare lo stato:

root@saltmaster:/home/vagrant# sudo salt 'minion2’ state.apply sample test = True

Produrrà quanto segue 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 ─ Componente pilastro

Il pilastro è un componente essenziale per rendere riutilizzabili gli stati del sale. Viene utilizzato per definire dati protetti per i minion assegnati utilizzando obiettivi. I dati salt pillar memorizzano valori come porte, percorsi dei file, parametri di configurazione e password.

File di configurazione del pilastro

La configurazione per pillar_roots nel file di configurazione principale è mostrato di seguito -

pillar_roots:
   base:
      - /srv/pillar

Qui, il file si trova nella directory "/ srv / pillar".

Considera, il file in alto situato in /srv/pillar/top.sls ha la seguente struttura:

base:
   '*':
      - default

Ora passa al file default.sls che si trova in /srv/pillar/default.sls e aggiungi il codice seguente.

# Default pillar values
apache
git

Dopo aver salvato il file, aggiorna il pilastro per aggiornare tutte le modifiche.

Rinfrescare il pilastro

È possibile aggiornare il pilastro utilizzando il seguente comando.

root@saltmaster:/home/vagrant# salt '*' saltutil.refresh_pillar

Il comando precedente viene utilizzato per aggiornare i dati del pilastro di sale su tutti i servitori.

Elenca i dati del pilastro

Per elencare i dati del pilastro, puoi utilizzare il comando fornito di seguito.

root@saltmaster:/home/vagrant# salt '*' pillar.ls

Produrrà quanto segue output -

minion2:
   - apache
   - git
minion1:
   - apache
   - git

Elementi pilastro

Una volta impostato il pilastro, i dati possono essere visualizzati sul servitore tramite il modulo pilastro. Vi si può accedere tramite la funzionepillar.items, che è definito di seguito.

root@saltmaster:/home/vagrant# salt '*' pillar.items

Produrrà quanto segue output -

minion2:
   ----------
   apache:
      httpd
   git:
      git
minion1:
   ----------
   apache:
      httpd
   git:
      git

SaltStack - Includi componente

Il componente "Includi" viene utilizzato per definire la stessa attività di configurazione in più posizioni. È facile da eseguire. Nella parte superiore del file di stato, aggiungi un'inclusione utilizzando il seguente formato:

include:
   - state file 1 
   - state file 2

Qui, state file 1 e state file 2sono i nomi dei file SLS che desideri includere. Non è necessario includere il file.slsestensione. Gli stati Salt inclusi vengono inseriti all'inizio del file corrente.

File di stato nella sottodirectory

È possibile includere il file di stato della sottodirectory utilizzando un punto (.). Agisce come separatore di directory.

include:
   - dir.sls1

Interfaccia grani

Grains è un'interfaccia utilizzata per ricavare le informazioni sul sistema sottostante. Vengono raccolti i grani per il sistema operativo, il nome di dominio, l'indirizzo IP, il kernel, il tipo di sistema operativo, la memoria e molte altre proprietà di sistema.

Targeting dei cereali

I dati sul grano possono essere utilizzati quando si prendono di mira i minion, che è definito nel seguente blocco di codice.

root@saltmaster:/home/vagrant# salt -G 'os:Ubuntu' test.ping

Produrrà quanto segue output -

minion1:
   True
minion2:
   True

Elenco dei cereali

I grani possono essere elencati utilizzando il modulo 'grains.ls', definito di seguito.

root@saltmaster:/home/vagrant# salt '*' grains.ls

Elementi della lista

Come Pillar, anche i dati di Grains possono essere elencati utilizzando "grains.items".

root@saltmaster:/home/vagrant# salt '*' grains.items

La registrazione viene utilizzata per tenere traccia degli eventi del software in esecuzione. Un evento è descritto da un messaggio descrittivo, che può facoltativamente contenere dati variabili. L'approccio alla registrazione del sale viene utilizzato per ottenere eventuali problemi che potresti incontrare. Puoi effettuare il check-out con livelli di registro specifici.

Impostazioni di configurazione

Cerchiamo di capire in dettaglio le diverse impostazioni di configurazione per la registrazione.

LOG_FILE

I record di registro Salt vengono passati attraverso il file, che contiene il nome del percorso locale o il percorso di rete per l'identificazione. Questo file è considerato come il file di registro.

log_file: /var/log/salt/master

Qui, il file dipendente dal binario in esecuzione nel master. Allo stesso modo, puoi eseguire anche nel minion, come mostrato di seguito.

log_file: /var/log/salt/minion

Puoi anche utilizzare l'indirizzo remoto. La sintassi per l'utilizzo dell'indirizzo remoto è - <file | udp | tcp>: // <host | socketpath>: <port-if-required> / <log-facility>.

log_file: udp://loghost:port

Qui, la funzione di registro è impostata su LOG_USER.

LOG_LEVEL

I livelli di registro sono ordinati in un valore assegnato numericamente. La libreria Python ha definito la maggior parte dei livelli di registrazione per impostazione predefinita. Oltre a ciò, Salt utilizza alcuni livelli in più. Alcuni dei livelli sono spiegati di seguito.

• log_level: error; level value is 40 - Indica il record dell'istruzione di registro in errore.

• log_level: quiet; level value is 1000 - Indica che non deve essere registrato nulla a questo livello.

• log_level: info; level value is 20 - Indica le normali informazioni di registro.

• log_level: warn; level value is 30 - Indica il record dell'istruzione di registro in caso di avviso.

• log_level: debug; level value is 10 - Informazioni utili per il debug sia delle implementazioni salt che del salt code.

• log_level: trace; level value is 5 - Informazioni più dettagliate sul debug del codice.

LOG_LEVEL_LOGFILE

Definisce il livello di messaggi da inviare al file di registro.

log_level_logfile: info

LOG_DATEFMT

Definisce il formato della data di registro. Per impostazione predefinita, è rappresentato come% Y-% m-% d% H:% M:% S.

log_datefmt_logfile: '%Y-%m-%d %H:%M:%S'

LOG_FMT_CONSOLE

Definisce il formato della console che registra i messaggi. Salt usa un'usanzaLogRecordattributi per colorare l'output del log della console. Segue la seguente sintassi:

'%(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

Definisce il formato del file di registro che registra i messaggi. La sintassi di base è la seguente:

%(asctime)s,%(msecs)03d [%(name)-17s][%(levelname)-8s] %(message)s

LOG_GRANULAR_LEVELS

Questo livello viene utilizzato per controllare i livelli di registrazione in modo più specifico.

log_granular_levels:
   'salt': 'info'
   'salt.modules': ‘trace'

Qui, la libreria principale del sale al livello "info" imposta il file salt.modules per accedere a livello di traccia.

Gestore di registrazione esterno

Salt utilizza LogStash e il gestore di log esterno di Sentry per la registrazione. Cerchiamo di capirlo in dettaglio in questo capitolo.

Gestore LOGSTASH

LogStash è un open source; pipeline di elaborazione dati sicura lato server. Consideriamo un semplice gestore di registrazione UDP in Salt che utilizza LogStash.

Specificare le seguenti modifiche nel file principale di Salt:

logstash_udp_handler:
   host: 127.0.0.1
   port: 9999
   version: 1
   msg_type: logstash

Quindi aggiungi le modifiche nel file di configurazione Logstash -

input {
   udp {
      port ⇒ 9999
      codec ⇒ json
   }
}

Qui, UDP - è l'input che deve avere un formato come json_event, che è ciò che inviamo via cavo.

SENTRY Logging Handler

Sentry è il monitoraggio degli errori in tempo reale nelle distribuzioni di produzione e le informazioni per riprodurre e correggere i crash. La configurazione predefinita nel file master è definita di seguito.

sentry_handler:
   dsn: https://pub-key:[email protected]/app-id
   log_level: debug

Qui, il livello di registrazione predefinito per il gestore sentry è ERROR, ma abbiamo definito il debug log_level sotto la chiave di configurazione sentry_handler.

Salt esegue i comandi in un sistema remoto utilizzando salt-minion. Questo è il comportamento normale. In alcuni scenari, è possibile accedere al sistema remoto solo tramite il protocollo SSH. Per questi scenari, Salt fornisce un'opzione per connettere il sistema remoto utilizzando solo il protocollo SSH ed eseguire il comando tramite il livello SSH.

Salt SSHè molto facile da configurare. L'unica configurazione necessaria è specificare i dettagli del sistema remoto in un file speciale chiamato comeRoster file. Questo file di elenco si trova normalmente in/etc/salt/roster. Il file roster conterrà tutte le informazioni riguardanti il ​​sistema remoto e come possiamo collegarci ad esso. Una volta configurati i file roster, tutti i comandi Salt vengono eseguiti utilizzando il filesalt-ssh invece del comando del sale.

File di registro

Il sistema Roster è progettato specificamente per Salt SSH. Questo è progettato come un sistema collegabile. L'unico scopo del sistema di elenco è raccogliere informazioni sul sistema remoto. Il file roster è un fileYAML based configuration file contenente informazioni di sistema remoto come targets. Questi obiettivi sono una struttura dati speciale con un set predefinito di attributi. Un file roster contiene uno o più target e ogni target è identificato da un fileSalt ID.

La struttura di base del file elenco è la seguente:

<Salt ID>:
   host: <host name>
   user: <user name>
   passwd: <password of the user>

Tutti gli altri attributi supportati dal file elenco sono facoltativi. Sono i seguenti:

• port - Numero di porta SSH.

• sudo - se eseguire il comando tramite sudo.

• sudo_user - sudo nome utente.

• tty - true se sudo è abilitato.

• priv - chiave privata.

• timeout - timeout per una connessione SSH.

• minion_opts - dizionario di minion opts.

• thin_dir - directory di archiviazione del sistema di destinazione per i componenti del sale.

• cmd_umask - umask per forzare il comando salt-call.

Il file di elenco di esempio è il seguente:

web:
   host: 192.168.2.1
   user: webuser
   passwd: secret
   sudo: True   
db:
   host: 192.168.2.2

Distribuisci chiavi SSH

Salt SSH genererà una coppia di chiavi pubblica / privata predefinita per gli accessi SSH. Il percorso predefinito sarà /etc/salt/pki/master/ssh/salt-ssh.rsa. Questa chiave può essere distribuita al sistema remoto utilizzando ilssh-copy-id comando come mostrato di seguito.

ssh-copy-id -i /etc/salt/pki/master/ssh/salt-ssh.rsa.pub [email protected]

Esegui comando

L'esecuzione di un comando salt è semplice come cambiare il file salt cli comando in salt-ssh come mostrato di seguito.

salt-ssh '*' test.ping

Comando Raw Shell

Salt SSH fornisce un'opzione (-r) per eseguire un comando grezzo nel sistema remoto bypassando il modulo e le funzioni salt.

salt-ssh '*' -r 'ls'

Targeting con Salt SSH

Targeting del sistema remoto in Salt SSH supporta solo target glob e regex. Poiché Salt SSH è un modulo separato, fornisce solo opzioni limitate al momento e fornirà più funzionalità nel prossimo futuro.

Salt fornisce un modulo separato, Salt Cloud per fornire macchine virtuali di vari fornitori di cloud come Amazon AWS, Google Compute, ecc. Salt Cloud è un'interfaccia generica per configurare e gestire le VM di vari fornitori di cloud.

• Cloud Config- Il file di configurazione principale per Salt Cloud è / etc / salt / cloud e si applica a tutte le VM. Viene chiamato il file di configurazione principaleCloud Config.

• Cloud Providers - Per mirare a provider di cloud specifici, possiamo utilizzare file di configurazione specifici e si trovano in /etc/salt/cloud.providers.d/*.conf, questi sono chiamati come Cloud Providers.

• Cloud Profiles - Per indirizzare una VM specifica, possiamo anche utilizzare un file di configurazione speciale, che si applica solo a quella determinata VM e si trovano in /etc/salt/cloud.profiles.d/*.conf, questi sono chiamati come Cloud Profiles.

Per una macchina virtuale, le impostazioni in Cloud Config viene applicato prima e poi nel file Cloud Providers e infine l'override viene eseguito da Cloud Profiles.

Installazione di Salt Cloud

Per impostazione predefinita, Salt Cloud è integrato in Salt ed è immediatamente disponibile. Se non è disponibile, possiamo installarlo utilizzando il comando sottostante.

pip install salt-cloud

Poiché Salt Cloud è un modulo separato e funziona secondo un proprio processo, può essere installato anche nel sistema Salt Minion al posto di Salt Master.

Provisioning di una macchina virtuale

Per eseguire il provisioning di una macchina virtuale, è necessario definire un provider di servizi cloud e un profilo di cloud. Una volta creati entrambi, possiamo eseguire il provisioning di una nuova macchina virtuale per utilizzarla.

Provider cloud

Le informazioni sull'host cloud vengono configurate nel file di configurazione del provider cloud. Normalmente, le informazioni di base, che devono essere configurate sono driver cloud, nome utente, password, chiave privata, ecc. Creiamo un nuovo provider cloud denominato comemy-amazon-cloud.

• Crea un file, my-amazon-cloud.conf in /etc/salt/cloud.providers.d/

• Aggiungi un nuovo provider utilizzando il ec2 conducente.

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 fornisce driver per vari host cloud pronti all'uso, come GoGrid, HP Cloud, Google Compute Engine (GCE), Amazon AWS, Joyent, Linode, OpenNebula, ProfitBricks, Proxmox, Saltify, VexxHost, VMWare, ecc.

Una volta configurati i fornitori di servizi cloud, possiamo interrogare la posizione disponibile del fornitore, le immagini della macchina disponibili e le sue varie dimensioni.

salt-cloud --list-location my-amazon-cloud
salt-cloud --list-images my-amazon-cloud
salt-cloud --list-sizes my-amazon-cloud

Profilo cloud

Un profilo Cloud specifica l'immagine e le dimensioni della macchina virtuale. Può essere configurato in - /etc/salt/cloud.profiles.d/. Creiamo un profilo semplice,simple.conf.

aws_micro:
   provider: my-amazon-cloud
   image: <image_id>
   size: <machine_id e.g. t1.micro>

Macchina virtuale

Una volta configurati il ​​provider e i profili, possiamo fornire facilmente una macchina virtuale utilizzando il salt-cloud come mostrato di seguito.

salt-cloud -p aws_micro master minion1 minion2

Dove, p - Nome profilo master, minion1 e minion2 sono le nuove macchine virtuali.

I dettagli della macchina virtuale appena creata possono essere ottenuti utilizzando il seguente comando.

salt-cloud --query

Le macchine virtuali possono essere distrutte utilizzando il seguente comando:

slat-cloud -d master minion1

Cloud Map

Una Cloud Map è un formato speciale per creare più macchine virtuali contemporaneamente. Il formato del file di mappa consiste nello specificare il profilo e quindi aggiungere un elenco delle macchine virtuali sotto di esso.

Un file di mappa di esempio è il seguente:

micro:
   - web1
   - web2
large:
   - db1
   - db2

Il map file può essere passato come argomento al comando salt-cloud per creare la macchina virtuale come segue:

salt-cloud -m /path/to/mapfile

Ci sono molti dispositivi come router, dispositivi di rete, ecc., Con sistema operativo personalizzato, memoria limitata e considerazioni di alta sicurezza. In quei dispositivi, non siamo stati in grado di installare lo standardsalt-minione successivamente non sono stati in grado di gestire quei sistemi. Tuttavia, Salt fornisce una tecnologia innovativa per superare questo vincolo.

Salt ha un modulo separato, salt proxy minion che controlla il sistema remoto utilizzando il servizio REST in esecuzione nel sistema remoto. Questo servizio REST è un servizio Web basato su HTTP scritto utilizzando ilRepresentational State Transfer (REST) concetto e sono sia facili da implementare che facili da consumare.

Ogni dispositivo avrà il proprio SDK e l'ambiente di sviluppo per scrivere applicazioni complesse. Salt si aspetta che un servizio REST venga sviluppato nel dispositivo secondo le specifiche dell'interfaccia Salt. Salt fornisce anche un modulo python per scrivere il servizio web REST. Se il dispositivo supporta python, sarà facile sviluppare il servizio web REST.

Una volta che il servizio web REST è stato sviluppato e distribuito nel sistema remoto, Salt può essere configurato per controllare il dispositivo remoto utilizzando il servizio web REST invece del minion salt.

Esempio di lavoro

Impariamo il concetto di salt proxy minionutilizzando un ambiente di lavoro vivo. Per l'ambiente live, abbiamo scelto un sistema Linux sia per il master che per il proxy minion. Controlleremo il sistema utilizzando il servizio web REST invece di salt-minion.

Installa e configura il servizio Web REST

Salt fornisce un esempio dell'implementazione del servizio web REST, che è denominata proxyminion_rest_example nel suo modulo contrib. Cerchiamo di installare il servizio Web di esempio.

• Installare ‘bottle’usando il pip. Ilbottle command è un framework web Python per sviluppare applicazioni web.

pip install bottle = 0.12.8

• Scarica il file saltstack/salt-contribprogetto da GitHub. Altrimenti, clona il progetto utilizzando il seguente comando.

git clone https://github.com/saltstack/salt-contrib

• Apri un terminale e vai al salt-contrib directory.

• Questa directory salt-contrib avrà una cartella, proxyminion_rest_example. Questa cartella contiene l'implementazione di esempio per il servizio Web REST. Vai alla cartella proxyminion_rest_example.

• Eseguire il comando seguente per avviare il servizio Web REST.

python rest.py --address <your ip address> --port 8000

• Apri un browser e carica http: // «il tuo indirizzo ip»: 8000. Questo mostrerà la pagina predefinita con servizi e pacchetti come mostrato nello screenshot qui sotto.

Ora, abbiamo configurato il servizio web REST e controllerà come configurare il proxy salt per interrogare il servizio web REST e controllare il sistema.

Configurare Salt-Proxy

Per configurare Salt-Proxy, dobbiamo seguire i passaggi indicati di seguito.

• Dobbiamo specificare il nodo master per il salt-proxy. Modificare il percorso del file di configurazione del proxy, che si trova in / etc / salt / proxy, e immettere il codice seguente.

master: <your ip address>

• Modifica / crea il file del pilastro di base in formato /srv/pillar/top.sls come mostrato nel seguente blocco di codice.

base:
  'p8000':
      - p8000

• Aggiungi un nuovo file pilastro, p8000.sls nel /srv/pillar come mostrato nel blocco di codice di seguito.

proxy:
   proxytype: rest_sample
   url: http://<your ip address>:8000

• Avvia salt-proxy in modalità debug utilizzando il seguente comando.

salt-proxy --proxyid = p8000 -l debug

• Simile al salt-minion, accetta il salt-proxy key come mostrato di seguito.

salt-key -y -a p8000

The following keys are going to be accepted:
Unaccepted Keys:
p8000
Key for minion p8000 accepted.

Esecuzione del sale

Ora esegui il file salt comando e chiama il ping.test funzionare come mostrato di seguito.

salt p8000 test.ping

Possiamo eseguire qualsiasi funzione supportata dal servizio web REST utilizzando salt, che è simile a salt-minion.

Ad esempio, le informazioni sulla granulosità possono essere ottenute utilizzando il seguente comando.

salt p8000 grains.items

Il sistema degli eventi in Salt è un'interfaccia locale ZeroMQ PUB, che attiva gli eventi del sale. Viene eseguito dai seguenti componenti.

• Event Sockets - Viene utilizzato per pubblicare eventi.

• Event library - Viene utilizzato per ascoltare gli eventi e inviare gli eventi nel sistema del sale.

Evento Salt Master

Un Salt master fornisce diversi tipi di eventi, che sono spiegati in dettaglio di seguito:

• Eventi di autenticazione
• Inizia eventi
• Eventi chiave
• Eventi di lavoro
• Eventi per corridori
• Eventi di presenza
• Eventi cloud

Esaminiamo in dettaglio ciascuno dei tipi di evento.

Eventi di autenticazione

Questi eventi di autenticazione si attivano quando un minion esegue un controllo di autenticazione con il master. È rappresentato da salt / auth.

Avvia eventi

Gli eventi di inizio si attivano ogni volta che un servitore si connette al maestro di sale ed è rappresentato da salt / minion // start.

Eventi chiave

Gli eventi chiave vengono attivati ​​quando il maestro del sale accetta e rifiuta le chiavi del servitore del sale. È possibile accedere a questo evento utilizzando il comando salt-key.

Eventi di lavoro

Un evento Job viene generato ogni volta che inizia un nuovo lavoro. È rappresentato dasalt/job//new. Qui, JID - ID lavoro nuovo - nuovo lavoro

Eventi per corridori

Quando un corridore inizia l'esecuzione, viene attivato un evento corridore. È rappresentato da salt / run // new.

Eventi di presenza

Quando i minion sono connessi o appena connessi o disconnessi, questo evento viene attivato a intervalli regolari. È rappresentato da:salt/presence/present e salt/presence/change. Qui,

• Present - significa che il maestro di sale è attualmente connesso alla lista dei servitori.

• Change - utilizzato per rilevare un nuovo servitore: connesso o disconnesso.

Eventi cloud

Gli eventi salt-cloud vengono attivati ​​su una macchina virtuale. A meno che non si verifichino altri eventi, non viene eseguita sul servitore. Puoi accedervi utilizzando -salt/cloud//creating. Viene attivato quando una nuvola di Salt avvia il processo di esecuzione della macchina virtuale.

Strumenti per eventi

Ora esaminiamo gli strumenti e gli script dell'evento. È possibile accedere al bus degli eventi utilizzando la CLI. Vi si accede tramite il seguente comando.

salt-run state.event pretty = True

Qui, il runner è progettato per interagire con il bus degli eventi da strumenti esterni e script di shell. È possibile accedere all'autobus di Salt in remoto tramite ilREST API. È rappresentato da - (URL di esempio).

curl -SsNk https://salt-api.example.com:8000/events?token = 05A3.

Allo stesso modo, puoi accedere agli eventi anche dagli script Python.

In generale, orchestrationè un coordinamento e una disposizione automatizzati dei sistemi. Il runner Orchestrate viene utilizzato per eseguire l'orchestrazione in SaltStack.

Orchestrate Runner

a Orchestrate Runner offre tutte le funzionalità di OverState(sistema precedente). È originariamente chiamato comestate.slscorridore. Questo corridore orchestrato viene utilizzato per generalizzare il sistema di stato Salt a un contesto Salt master.

Il state.sls e il state.highstate le funzioni vengono eseguite su ogni minion di Salt, ma il state.orchestraterunner viene eseguito sul master. Ilstate.orchestraterunner ti consente di gestire l'intera infrastruttura come stato completamente. Cerchiamo di capire come eseguire un semplice processo di esecuzione.

Esecuzione semplice

Il comando Orchestrate Runner è lo stesso del state.sls funzione, ma puoi eseguirla con "salt-run" invece di salt.

Supponi di avere un file sample.sls file situato in /srv/salt/orch/samples.sls. Aggiungi il codice seguente in quel file.

sample.sls

install_nginx:
   salt.state:
      - tgt: 'web*'
      - sls:
         - nginx

Il seguente comando viene utilizzato per eseguire sul master e applicherà gli stati definiti in quel file.

salt-run state.orchestrate orch.sample

Produrrà quanto segue 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#

Qui, secondo la versione corrente, la funzione runner è stata rinominata state.orchestrate. Ciò sarà utile per evitare confusione con la funzione di esecuzione state.sls, ma le versioni precedenti distate.sls deve essere usato.

Esegui funzione

Per eseguire una funzione, dovresti usare il salt.function. Considera un filedata.sls situato in /srv/salt/orch/data.sls. Ora aggiungi le seguenti modifiche in quel file.

data.sls

cmd.run:
   salt.function:
      - tgt: '*'
      - arg:
         - rm -rf /tmp/data

Il seguente comando viene utilizzato per eseguire la funzione Salt.

root@saltmaster:/home/vagrant# salt-run state.orchestrate orch.data

Produrrà quanto segue 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

Le formule del sale vengono confezionate e distribuite ai maestri del sale utilizzando il gestore dei pacchetti. Questo concetto è stato influenzato daRPM, Yum e Pacmansistemi di confezionamento. Stato del sale, pilastro, modelli di file e altri file vengono utilizzati dalla formula e quindi confezionati in un unico file.

Dopo aver creato un pacchetto formula, viene copiato nel sistema di repository per utilizzarlo per i salt master. Prima di passare al gestore dei pacchetti, diamo un'occhiata a come installare un pacchetto "nginx" utilizzando il comando di base Salt.

La seguente sintassi viene utilizzata per installare un pacchetto "nginx".

root@saltmaster:/home/vagrant# salt '*' pkg.install nginx

Qui, il pkg.install nginxcomando viene utilizzato per installare un pacchetto. Dopo l'esecuzione, vedrai la seguente risposta.

Produrrà quanto segue 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:

Ora hai installato un pacchetto. Per avviare i servizi per quel pacchetto, utilizzare il comando fornito di seguito.

root@saltmaster:/home/vagrant# salt '*' service.start nginx

Dopo aver eseguito questo comando, il risultato appare come mostrato nel blocco di codice sottostante.

minion1:
   True
minion2:
   True

Pertanto, abbiamo installato e avviato i servizi per il pacchetto "nginx" utilizzando il comando di base. Parliamo ora di come creare e installare pacchetti nel gestore di pacchetti Salt.

Pacchetti di costruzione

I pacchetti possono essere creati su qualsiasi sistema in cui è possibile installare Salt. Ci sono tre tipi di pacchetti e sono i seguenti.

• Formula
• Reactor
• Conf

Vediamo ora come creare pacchetti utilizzando il Fomula File.

File formula

La maggior parte dei file del pacchetto si trova nella directory - / srv / spm / salt / per impostazione predefinita, ma il file pillar può essere posizionato nella directory - / srv / spm / pillar /. Il file Formula descrive il pacchetto.

Example

name: apache
os: RedHat
os_family: RedHat
version: 201607
release: 2
summary: Formula for installing Apache
description: Formula for installing Apache

Qui,

• Name- Il nome del pacchetto. Qui, il nome del pacchetto èapache.

• os - Viene utilizzato per sapere quali sistemi operativi possono supportare questo pacchetto.

• os_family - Viene utilizzato per sapere quali famiglie di sistemi operativi possono supportare questo pacchetto.

• Version- La versione del pacchetto. È specificato in un formato AAAAMM.

• Release - Questo campo si riferisce principalmente al rilascio di una versione.

• Summary - Breve descrizione del pacchetto.

• Description - Una descrizione più dettagliata del pacchetto.

REATTORE

I file del reattore risiedono in /srv/spm/reactor/ directory.

CONF

I file in questo tipo di pacchetto sono file di configurazione per Salt, che normalmente risiedono in /etc/salt/directory. I file di configurazione per pacchetti diversi da Salt possono e devono essere gestiti con Salt State (utilizzando un tipo di pacchetto formula).

Continuiamo con i seguenti passaggi per creare un pacchetto.

• Crea un file FORMULA e posizionalo nella radice della cartella del pacchetto.

• Assembla i file formula in una cartella nel sistema di compilazione.

• Correre spm build. Il pacchetto viene creato e posizionato nella cartella / srv / spm_build. Il comando seguente viene utilizzato per creare un pacchetto.

spm build /path/to/salt-packages-source/formula

• Ora copia il file .spm file in una cartella nel sistema di repository.

• Puoi condividere il file srv/spm_build cartella sulla rete o copia i file sul tuo FTP o sul server web.

• Genera metadati repo utilizzando il seguente comando.

spm create_repo /srv/spm_build

Installazione di pacchetti

Questa sezione spiega come installare i pacchetti del gestore di pacchetti Salt.

Configura repository remoti

Per configurare i repository remoti, Salt Master deve sapere dove si trova il repository attraverso un processo di configurazione.

I file sono in /etc/salt/spm.repos.d/spm.repo directory.

Example

file_repository:
   url: https://spm.example.com/

Qui, il file contiene il nome del repository e il collegamento al repository. Puoi anche utilizzare http, https, ftp o il percorso del file. Per utilizzare il percorso del file, è possibile accedervi utilizzando l'URL: file: /// srv / spm_build.

Aggiorna metadati

Dopo aver configurato il repository sul master Salt, i metadati del repository vengono scaricati utilizzando il comando seguente.

spm update_repo

Aggiorna file root

I pacchetti SPM si trovano nella directory srv / spm / salt. Aggiungi il seguente percorso alle radici dei file su Salt master,

file_roots:
   base:
      1. /srv/salt
      2. /srv/spm/salt

Ora riavvia il salt master.

Installa il pacchetto Apache

Per installare il pacchetto apache, utilizzare il seguente comando.

spm install apache

È inoltre possibile eseguire l'installazione direttamente dal file SPM utilizzando il comando seguente.

spm local install /srv/spm/apache-201607-1.spm

Rimozione di un pacchetto

Per rimuovere un pacchetto, ad esempio - apache, usa il seguente comando,

spm remove apache

Nota che, se qualche file è stato modificato, non verrà rimosso.

Salt fornisce l'accesso programmatico a tutti i suoi comandi. Salt fornisce diversi moduli per ogni sezione del sistema Salt. Impariamo le basi dell'API python e su come eseguire i comandi salt di base in questo capitolo.

Configurazione

Il salt.config viene utilizzato per accedere ai dettagli di configurazione di Salt.

import salt.config
opts = salt.config.client_config('/etc/salt/master')

Qui, il client_config legge il file di configurazione salt e restituisce i dettagli di configurazione come dizionario.

Caricatore

Il salt.loader modulo viene utilizzato per caricare ogni modulo in Salt come cereali, minion, ecc.

import salt.loader
opts = salt.config.minion_config('/etc/salt/minion')
grains = salt.loader.grains(opts)

Qui, grains legge i dettagli dei grani nel sistema del sale e li restituisce.

Modulo client

Il salt.client module viene utilizzato per eseguire i comandi salt, salt-call e salt-SSH a livello di codice.

Le classi python più importanti sono le seguenti:

• salt.client.LocalClient
• salt.client.Caller
• salt.client.ssh.client.SSHClient

La funzione principale fornita dalla maggior parte del modulo client è cmd. Questa funzione racchiude le opzioni CLI e le esegue, che è simile alla riga di comando e restituisce i risultati come strutture di dati Python.

LocalClient

Il LocalClient viene utilizzato per inviare comandi dal master ai minion del sale e restituire i risultati al master.

import salt.client

local = salt.client.LocalClient()
local.cmd('*', 'test.ping')

Produrrà quanto segue output -

{'minion1': True, 'minion2': True }

Caller

Il chiamante viene utilizzato per eseguire salt-call a livello di codice e restituire i risultati.

import salt.client
caller = salt.client.Caller()
caller.cmd('test.ping')

Produrrà quanto segue output -

True

SSHClient

Il SSHCient viene utilizzato per eseguire il salt-ssh a livello di codice e restituire i risultati.

import salt.client.ssh.client
ssh = salt.client.ssh.client.SSHClient()
ssh.cmd('*', 'test.ping')

Produrrà quanto segue output -

{'minion1': True, 'minion2': True }

CloudClient

Il modulo salt.cloud viene utilizzato per eseguire i comandi salt-cloud a livello di programmazione.

client = salt.cloud.CloudClient(path = '/etc/salt/cloud')

Il modulo cloud fornisce funzioni per creare VM (creare), distruggere VM (distruggere), elencare le immagini fornite da un fornitore di servizi cloud (list_images), elencare le posizioni di un fornitore di servizi cloud (list_locations), elencare le dimensioni della macchina di un fornitore di servizi cloud (list_sizes), eccetera.

In questo esempio funzionante, creeremo una formula Salt che configurerà il server Web Apache insieme al software PHP. Salt è un ottimo modo per eseguire comandi ad-hoc, ma in realtà non vorrai configurare continuamente la tua infrastruttura in questo modo. Creando un set di formule Salt, puoi riprodurre in modo affidabile qualsiasi configurazione.

Le Formule Salt sono semplici file di testo YAML e per impostazione predefinita risiedono sul tuo Salt Master in formato /srv/salt/*. Cominciamo creando una formula Salt per installare il server web Apache e PHP allo stesso tempo.

Crea un file denominato "websetup.sls" in /srv/salt/ directory e aggiungere il codice seguente.

websetup.sls

websetup:
   pkg:
      - installed
      - pkgs:
         - apache2
         - php5
         - php5-mysql

In questo esempio, notare l'argomento "- pkgs:". Ogni elemento nell'elenco sotto "- pkgs:" verrà passato insieme al gestore di pacchetti del sistema operativo per essere installato insieme. Ogni volta che hai un lungo elenco di pacchetti da installare, questo è il modo più efficiente per installarli.

Applica questa formula a Salt master usando il seguente comando.

root@saltmaster:/home/vagrant# salt 'minion2' state.sls websetup

Ora vedrai quanto segue 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

Ora hai installato i pacchetti in minion2.

Highstate

Uno "stato elevato" è un modo per Salt di determinare quale delle formule del sale dovrebbe essere applicata a un certo servitore. Eseguire un "highstate" utilizzando il seguente comando.

root@saltmaster:/home/vagrant# salt <targets> state.highstate

top.sls

Quando il servitore richiede di eseguire uno stato alto, come accennato in precedenza, il servitore richiede top.sls al maestro del sale e cerca le formule che corrispondono. Per impostazione predefinita, questo file si trova in /srv/salt/top.sls. Aggiungiamo la nostra formula al file top.sls e impostiamo minion2 come target.

base:
   '*':
      - common
   'minion2’:
      - websetup

Ora, esegui il file highstate mirando a minion2 come mostrato di seguito.

root@saltmaster:/home/vagrant# salt 'minion2' state.highstate

Dopo aver applicato questo, potresti vedere quanto segue 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

Ora, il server web Apache e PHP sono installati nel minion2. In questo modo, dobbiamo prendere di mira i minion usando entrambitop.sls e highstate e installare il software richiesto con il minimo lavoro e la massima flessibilità.