SaltStack - Guia rápido

Neste capítulo, aprenderemos os fundamentos do SaltStack. Os recursos de execução remota do SaltStack permitem que os administradores executem comandos em várias máquinas em paralelo com um sistema de direcionamento flexível. O gerenciamento da configuração do Salt estabelece um modelo mestre-subordinado para alinhar os componentes da infraestrutura de forma rápida, fácil, flexível e segura com uma determinada política.

O que é SaltStack?

Salt é uma estrutura de automação muito poderosa. A arquitetura do Salt é baseada na ideia de executar comandos remotamente. Toda a rede é projetada em torno de algum aspecto da execução remota. Isso pode ser tão simples quanto pedir umRemote Web Serverpara exibir uma página da Web estática ou tão complexo quanto usar uma sessão de shell para emitir comandos interativamente em um servidor remoto. O sal é um exemplo de um dos tipos mais complexos de execução remota.

O Salt foi projetado para permitir que os usuários direcionem explicitamente e emitam comandos para várias máquinas diretamente. O sal é baseado na ideia de um Mestre, que controla um ou maisMinions. Os comandos são normalmente emitidos do Mestre para um grupo alvo de Minions, que então executam as tarefas especificadas nos comandos e, em seguida, devolvem os dados resultantes ao Mestre. As comunicações entre um mestre e lacaios ocorrem durante oZeroMQ message bus.

Os módulos SaltStack comunicam-se com os sistemas operacionais minion suportados. oSalt Masterroda em Linux por padrão, mas qualquer sistema operacional pode ser um lacaio e, atualmente, Windows, VMware vSphere e variantes BSD Unix são bem suportadas. O Mestre de Sal e os lacaios usam chaves para se comunicar. Quando um lacaio se conecta a um mestre pela primeira vez, ele armazena automaticamente as chaves no mestre. SaltStack também ofereceSalt SSH, que fornece um gerenciamento de sistemas “sem agente”.

Necessidade de SaltStack

O SaltStack foi desenvolvido para velocidade e escala. É por isso que é usado para gerenciar grandes infraestruturas com dezenas de milhares de servidores no LinkedIn, WikiMedia e Google.

Imagine que você tem vários servidores e deseja fazer coisas com eles. Você precisaria fazer o login em cada um e fazer essas coisas um de cada vez em cada um e, em seguida, você pode querer fazer coisas complicadas como instalar software e, em seguida, configurar esse software com base em alguns critérios específicos.

Vamos supor que você tenha dez ou talvez até 100 servidores. Imagine fazer login um de cada vez em cada servidor individualmente, emitir os mesmos comandos nessas 100 máquinas e, em seguida, editar os arquivos de configuração em todas as 100 máquinas torna-se uma tarefa muito tediosa. Para superar esses problemas, você adoraria atualizar todos os seus servidores de uma vez, apenas digitando um único comando. O SaltStack oferece exatamente a solução para todos esses problemas.

Recursos do SaltStack

SaltStack é um software de gerenciamento de configuração de código aberto e mecanismo de execução remota. Salt é uma ferramenta de linha de comando. Embora escrito em Python, o gerenciamento de configuração do SaltStack é agnóstico de linguagem e simples. A plataforma Salt usa o modelo push para executar comandos por meio do protocolo SSH. O sistema de configuração padrão éYAML e Jinja templates. O sal está competindo principalmente comPuppet, Chef e Ansible.

O Salt oferece muitos recursos quando comparado a outras ferramentas concorrentes. Alguns desses recursos importantes estão listados abaixo.

• Fault tolerance- Os salt minions podem se conectar a vários mestres ao mesmo tempo, configurando o parâmetro de configuração principal como uma lista YAML de todos os mestres disponíveis. Qualquer mestre pode direcionar comandos para a infraestrutura do Salt.

• Flexible- Toda a abordagem de gestão do Salt é muito flexível. Ele pode ser implementado para seguir os modelos de gerenciamento de sistemas mais populares, como Agente e Servidor, Apenas Agente, Apenas Servidor ou todos os anteriores no mesmo ambiente.

• Scalable Configuration Management - SaltStack é projetado para lidar com dez mil lacaios por mestre.

• Parallel Execution model - O Salt pode permitir que comandos executem sistemas remotos de maneira paralela.

• Python API - O Salt fornece uma interface de programação simples e foi projetado para ser modular e facilmente extensível, para torná-lo fácil de ser moldado em diversas aplicações.

• Easy to Setup - O Salt é fácil de configurar e fornece uma única arquitetura de execução remota que pode gerenciar os diversos requisitos de qualquer número de servidores.

• Language Agnostic - Arquivos de configuração de estado de sal, mecanismo de modelagem ou tipo de arquivo suporta qualquer tipo de linguagem.

Benefícios do SaltStack

Por ser simples e também um sistema rico em recursos, o Salt oferece muitos benefícios e eles podem ser resumidos conforme abaixo -

• Robust - O Salt é uma estrutura de gerenciamento de configuração poderosa e robusta e funciona em dezenas de milhares de sistemas.

• Authentication - Salt gerencia pares de chaves SSH simples para autenticação.

• Secure - Salt gerencia dados seguros usando um protocolo criptografado.

• Fast - Salt é um barramento de comunicação muito rápido e leve para fornecer a base para um mecanismo de execução remota.

• Virtual Machine Automation - O recurso Salt Virt Cloud Controller é usado para automação.

• Infrastructure as data, not code - O Salt fornece uma implantação simples, gerenciamento de configuração orientado por modelo e estrutura de execução de comando.

Introdução ao ZeroMQ

Salt é baseado no ZeroMQbiblioteca e é uma biblioteca de rede embutida. É uma biblioteca de mensagens leve e rápida. A implementação básica está emC/C++ e implementações nativas para vários idiomas, incluindo Java e .Net está disponível.

ZeroMQ é um processamento de mensagens peer-peer sem corretor. ZeroMQ permite que você projete um sistema de comunicação complexo facilmente.

ZeroMQ vem com os seguintes cinco padrões básicos -

• Synchronous Request/Response - Usado para enviar um pedido e receber respostas subsequentes para cada um enviado.

• Asynchronous Request/Response- O solicitante inicia a conversa enviando uma mensagem de solicitação e aguarda uma mensagem de resposta. O provedor espera pelas mensagens de solicitação de entrada e responde com as mensagens de resposta.

• Publish/Subscribe - Usado para distribuir dados de um único processo (por exemplo, editor) para vários destinatários (por exemplo, assinantes).

• Push/Pull - Usado para distribuir dados para nós conectados.

• Exclusive Pair - Usado para conectar dois pares, formando um par.

ZeroMQ é uma ferramenta de rede altamente flexível para troca de mensagens entre clusters, nuvem e outros ambientes de vários sistemas. ZeroMQ é odefault transport library apresentado no SaltStack.

A arquitetura do SaltStack foi projetada para funcionar com qualquer número de servidores, de sistemas de rede local a outras implantações em diferentes data centers. A arquitetura é um modelo de servidor / cliente simples com a funcionalidade necessária integrada em um único conjunto de daemons.

Dê uma olhada na ilustração a seguir. Ele mostra os diferentes componentes da arquitetura SaltStack.

• SaltMaster- SaltMaster é o daemon mestre. Um SaltMaster é usado para enviar comandos e configurações para os escravos do Salt. Um único mestre pode gerenciar vários mestres.

• SaltMinions- SaltMinion é o daemon escravo. Um salt minion recebe comandos e configurações do SaltMaster.

• Execution- Módulos e comandos Adhoc executados na linha de comando contra um ou mais lacaios. Ele executa o monitoramento em tempo real.

• Formulas- As fórmulas são Salt States pré-escritos. Eles são tão abertos quanto os próprios Salt States e podem ser usados ​​para tarefas como instalar um pacote, configurar e iniciar um serviço, configurar usuários ou permissões e muitas outras tarefas comuns.

• Grains- Grãos é uma interface que fornece informações específicas para um lacaio. As informações disponíveis na interface de grãos são estáticas. Os grãos são carregados quando o Salt minion começa. Isso significa que as informações em grãos são imutáveis. Portanto, as informações de grãos podem ser sobre o kernel em execução ou o sistema operacional. Não faz distinção entre maiúsculas e minúsculas.

• Pillar- Um pilar é uma interface que gera e armazena dados altamente confidenciais específicos para um lacaio em particular, como chaves criptográficas e senhas. Ele armazena dados em um par chave / valor e os dados são gerenciados de maneira semelhante à Árvore de Estado do Salt.

• Top File - Corresponde estados de sal e dados de pilar para minions de sal.

• Runners - É um módulo localizado dentro do SaltMaster e executa tarefas como status do trabalho, status da conexão, ler dados de APIs externas, consultar minions de sal conectados e muito mais.

• Returners - Retorna dados de minions de sal para outro sistema.

• Reactor - É responsável por desencadear reações quando ocorrem eventos em seu ambiente SaltStack.

• SaltCloud - Salt Cloud fornece uma interface poderosa para interagir com hosts em nuvem.

• SaltSSH - Execute comandos Salt sobre SSH em sistemas sem usar Salt minion.

No próximo capítulo, aprenderemos em detalhes sobre os vários concorrentes do SaltStack e seus recursos.

Salt, Puppet, Chef e Ansible são as principais ferramentas de gerenciamento de configuração e orquestração, cada uma delas seguindo um caminho diferente para a automação do servidor. Eles foram construídos para tornar mais fácil configurar e manter dezenas, centenas ou mesmo milhares de servidores.

Vamos entender como o SaltStack compete principalmente com o Puppet, Chef e Ansible.

Plataformas e suporte

A seguir está uma lista de todas as plataformas que oferecem suporte ao SaltStack e seus concorrentes.

• SaltStack - O software SaltStack é executado e gerencia muitas versões do 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 é compatível com várias plataformas, como AIX, RHEL / CentOS, FreeBSD, OS X, Solaris, Microsoft Windows e Ubuntu.

• Ansible - Distribuição Fedora de Linux, CentOS e Scientific Linux via Pacotes Extra para Enterprise Linux (EPEL), bem como para outros sistemas operacionais.

Idioma de Origem

• SaltStack - Python

• Puppet - rubi

• Chef - Ruby e sua CLI usam DSL baseado em Ruby

• Ansible - Python

Idioma Suportado

• SaltStack - Qualquer idioma

• Puppet - rubi

• Chef - Ruby e sua CLI usam DSL baseado em Ruby

• Ansible - Qualquer idioma

IU da web

• SaltStack - A IU da Web oferece visualizações de trabalhos em execução, status de minion e logs de eventos.

• Puppet - A IU da Web lida com relatórios, inventário e gerenciamento de nós em tempo real.

• Chef - A IU da Web permite pesquisar e inventariar nós, visualizar a atividade dos nós e atribuir livros de receitas, funções e nós.

• Ansible - A IU da Web permite configurar usuários, equipes e inventários e aplicar Playbooks aos inventários.

Ferramentas de gerenciamento

• SaltStack - O SaltStack Enterprise está posicionado como a principal ferramenta para gerenciar a orquestração de operações em nuvem e TI, bem como DevOps.

• Puppet- O Puppet vem em dois sabores, Puppet Enterprise e Open Source Puppet. Além de fornecer funcionalidades do Open Source Puppet, o Puppet Enterprise também fornece GUI, API e ferramentas de linha de comando para gerenciamento de nós.

• Chef - CFEngine é a ferramenta de gerenciamento de configuração.

• Ansible - O Ansible 1.3 é a principal ferramenta de gerenciamento.

atuação

• SaltStack- O Salt foi projetado para alto desempenho e escalabilidade. O sistema de comunicação do Salt estabelece um canal de dados persistente entre o mestre do Salt e os lacaios usando ZeroMQ.

• Puppet - Seguro e de alto desempenho, sem a necessidade de agentes.

• Chef- A dificuldade mais aparente para o Chef Server é a pesquisa; A pesquisa é lenta e não é solicitada simultaneamente dos clientes.

• Ansible - Seguro, de alto desempenho e sem a necessidade de agentes.

Preço e valor

• SaltStack- Versão gratuita de código aberto. O SaltStack Enterprise custa US $ 150 por máquina por ano.

• Puppet- Versão gratuita de código aberto. A Puppet Enterprise custa US $ 100 por máquina por ano.

• Chef- Versão gratuita de código aberto; Enterprise Chef grátis para 5 máquinas,$120 per month for 20 machines, $300 por mês para 50 máquinas.

• Ansible- Versão gratuita de código aberto; Ansible grátis para 10 máquinas, então$100 or $250 por máquina por ano, dependendo do suporte necessário.

Uso

• SaltStack- SaltStack é usado pela Cisco e Rackspace. Ele pode se integrar a qualquer plataforma baseada em nuvem.

• Puppet - O Puppet é usado pela Zynga, Twitter, Bolsa de Valores de Nova York, PayPal, Disney, Google e assim por diante.

• Chef - Chef pode se integrar com plataformas baseadas em nuvem, como Internap, Amazon EC2, Google Cloud Platform, OpenStack, Microsoft Azure e Rackspace.

• Ansible - O Ansible pode implantar em ambientes de virtualização, ambientes em nuvem, incluindo Amazon Web Services, Cloud Stack, DigitalOcean e Google Cloud Platform e assim por diante.

Antes de passar para a instalação, você precisa ter os seguintes requisitos -

• Um servidor Linux (servidor Ubuntu mais recente).

• sudo ou root access para este servidor.

Instale todas as atualizações usando o seguinte comando -

sudo apt-get update

Instale o SaltMaster

Instale o SaltMaster do repositório com o seguinte comando apt-get.

sudo apt-get install salt-master

Instalar Salt Minion

Instale o Salt minion do repositório com o seguinte comando apt-get.

sudo apt-get install salt-minion

Instale o Salt syndic

Instale o Salt syndic do repositório com o seguinte comando apt-get.

sudo apt-get install salt-syndic

Configuração Mestre

A configuração do sal é muito simples. A configuração padrão do mestre funcionará na maioria das instalações. Os arquivos de configuração são instalados no diretório '/ etc / salt' e são nomeados de acordo com seus respectivos componentes, como - / etc / salt / master e / etc / salt / minion.

#interface: 0.0.0.0
interface: <local ip address>

Depois de atualizar o arquivo de configuração, reinicie o Salt master usando o seguinte comando.

sudo service salt-master restart

Configuração Minion

Configurar um Salt Minion é muito simples. Por padrão, um Salt Minion tentará se conectar ao nome DNS “salt”; se o Minion for capaz de resolver esse nome corretamente, nenhuma configuração será necessária. Redefina a diretiva "master" no arquivo de configuração do minion, que normalmente é/etc/salt/minion, conforme mostrado no código abaixo -

#master: salt
master: <local ip address>

Depois de atualizar o arquivo de configuração, reinicie o Salt minion usando o comando abaixo.

sudo service salt-minion restart

Gestão de Chaves

Sal usa AES Encryptionpara toda a comunicação entre o Mestre e o Minion. A comunicação entre o Mestre e o Minion é autenticada por meio de chaves aceitas e confiáveis.

salt-key -L

Irá produzir o seguinte output -

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

Aceite todas as chaves emitindo o comando abaixo.

sudo salt-key -A

Irá produzir o seguinte 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.

Agora, novamente emita o salt key listing comando,

salt-key -L

Irá produzir o seguinte output -

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

Envio de comandos

A comunicação entre o Mestre e um Lacaio deve ser verificada executando o comando test.ping.

sudo salt '*' test.ping

Irá produzir o seguinte output -

<local system name>
   True

Aqui, '*' refere-se a todos os lacaios. Uma vez que temos apenas um lacaio - test.ping, ele executa oping comando e retorna se o ping foi bem-sucedido ou não.

Neste capítulo, criaremos um ambiente SaltStack simples, um mestre de sal e dois minions de sal. Esse ambiente nos ajudará a aprender o conceito de sal nos próximos capítulos.

Vamos seguir as etapas a seguir para criar o ambiente SaltStack.

Instale o ambiente VirtualBox

VirtualBox é um aplicativo de virtualização de plataforma cruzada. O VirtualBox permite que você execute mais de um sistema operacional ao mesmo tempo. VirtualBox roda em Windows, Linux, Macintosh e Solaris. Ele hospeda e suporta um grande número deGuest Operating Systems.

Você pode baixar e instalar o VirtualBox visitando o seguinte link - https://www.virtualbox.org/wiki/Downloads

Vamos criar três máquinas virtuais e executá-las usando o VirtualBox.

Instale o Vagrant

O Vagrant oferece ambientes de trabalho fáceis de configurar, reproduzíveis e portáteis.

Você pode baixar e instalar o Vagrant visitando o seguinte link - https://www.vagrantup.com

Após a instalação bem-sucedida do Vagrant, você precisa configurá-lo. Crie um único arquivo chamadoVagrantfile em uma pasta e descreva o tipo de máquina e suas propriedades.

Run Vagrant - Para executar o Vagrant, emita o seguinte comando -

vagrant up

Depois de executar o vagrant up, o Vagrant cria e inicia essas máquinas, que são definidas no Vagrantfileusando o VirtualBox em segundo plano. Essas máquinas funcionarão até que você as feche.

Stop Vagrant - Para parar todas as máquinas em execução no VirtualBox, digite o seguinte comando -

vagrant halt

Baixe o ambiente de demonstração

O SaltStack oferece um ambiente de demonstração simples como configuração do Vagrant e está hospedado no github. Vamos baixar a configuração usando o seguinte comando -

cd /cd/to/path

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

Ambiente inicial

Agora, inicie o ambiente de demonstração usando o seguinte comando -

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

Após este comando, você verá a seguinte resposta -

result

Agora, três servidores estão em execução, um com o salt master configurado e dois com o salt minion configurado.

Executar Salt master

Faça login no Salt master usando o seguinte comando -

vagrant ssh master

Agora, vá para o usuário root usando o comando abaixo -

sudo su

Agora, conectamos com sucesso ao Salt master.

Vamos agora examinar alguns dos comandos básicos do SaltStack.

Liste todas as chaves

O comando a seguir é para verificar as conexões do Salt minion e ver se a conexão é aceita, rejeitada ou pendente.

salt-key —list-all

Irá produzir o seguinte output -

Accepted Keys:
minion1
minion2
Denied Keys:

Unaccepted Keys:
Rejected Keys:

Verifique Minions de Sal

Agora que aceitamos todas as chaves, você pode enviar um comando do mestre de sal para verificar se os minions de sal estão ouvindo ou não,

salt '*' test.ping

Irá produzir o seguinte output -

minion1:
   True
minion2:
   True

A partir do resultado acima, liste o minion 1 e o minion 2, o que significa que os lacaios estão ouvindo corretamente, caso contrário, os lacaios podem agora responder corretamente.

Um sistema de controle de acesso fornece opções para um usuário de um grupo executar uma tarefa com permissões. Um sistema de controle de acesso Salt é usado para configurar o acesso a interfaces de controle não administrativas. Você pode aplicar este processo a todos os sistemas. Este controle ajuda os usuários não administrativos a executar os comandos do Salt.

Interfaces de sal são dos seguintes três tipos -

• Sistema ACL do editor
• Sistema de autenticação externa
• Sistema par

Vamos entender cada uma dessas interfaces em detalhes.

Sistema ACL do editor

Um sistema Publisher ACL permite o acesso a outros usuários além do root para executar comandos Salt em lacaios do mestre. O sistema ACL do editor é configurado no arquivo de configuração principal por meio dopublisher_aclopção de configuração. É definido da seguinte forma -

publisher_acl:
   user1:
      - .*

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

Aqui,

• user1 tem permissão para executar qualquer coisa.

• user2 tem permissão para usar test e pkg, mas apenas em minions “web *”.

Sistema de autenticação externo

o external auth system é usado para fornecer acesso para executar comandos salt em lacaios específicos através de um sistema de autorização externo como PAM, LDAP, etc. Este arquivo de configuração é definido no arquivo mestre conforme descrito abaixo.

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

Aqui,

• user1 tem permissão para executar funções no test e network modules nos lacaios que combinam com o web* alvo.

• user2 tem permissão para executar todas as funções.

Habilite o Sistema de Autenticação Externa no Comando

O servidor Salt fornece uma opção '–a' para habilitar a autenticação externa.

salt -a pam web\* test.ping

Aqui o -a pamopção é usada para habilitar a autenticação externa PAM. O Salt Server pedirá detalhes de autenticação sempre que executarmos o comando. Para restringir o Salt Server de solicitar os detalhes de autenticação apenas pela primeira vez, podemos usar a opção T. este-T option armazena em cache os detalhes de autenticação pelas próximas 12 horas (configuração padrão) e usa-o para autenticar os usuários.

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

Sistema de Pares

Os salt minions podem passar comandos usando a interface de mesmo nível. A interface do par é configurada através do arquivo de configuração mestre para permitir que os lacaios enviem comandos do mestre usandopeer seção de configuração ou para permitir que lacaios executem runners do mestre usando o peer_run configuração.

Vamos entender essas duas configurações em detalhes.

Configuração de pares

A configuração simples a ser definida no arquivo mestre é a seguinte -

peer:
   .*:
      - .*

Aqui, ele permite a comunicação para todos os lacaios, mas só é recomendado para ambientes muito seguros.

Para atribuir lacaios a IDs específicos, a configuração precisa ser definida conforme mostrado abaixo: par -

.*domain.com:
   - test.*

Configuração peer_run

Esta configuração permite que os lacaios executem runners a partir do mestre usando a opção peer_run no arquivo mestre. O exemplo a seguir é para permitir o acesso a todos os lacaios e a todos os runners.

peer_run:
   .*:
      - .*

Para atribuir lacaios a um ID específico, a configuração precisa ser definida conforme abaixo -

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

Como executar comandos

Executar test.ping em todos os lacaios, use o salt-call comando junto com o publish.publish módulo.

salt-call publish.publish \* test.ping

Executar runner, use o comando salt-call junto com o publish.runner módulo.

salt-call publish.runner manage.up

O sal tem a capacidade de comunicação de alta velocidade com um grande número de sistemas. Essa abordagem ajuda o Salt a criar um sistema multitarefa poderoso. O Salt pode executar tarefas em mais de um sistema, portanto, o Salt usa a técnica de gerenciamento de tarefas para gerenciar cada tarefa em execução em todos os sistemas. Este capítulo explica detalhadamente o gerenciamento de tarefas.

O que é um ID de trabalho?

Salt tem diretório de cache, cachedir. Dentro dele, um diretório que os minions mantêm é chamado deprocdiretório. Ele está localizado no seguinte diretório / var / cache / salt / proc.

O diretório proc é usado para manter todos os arquivos. Quando esses arquivos são executados, eles são atribuídos a um ID de trabalho exclusivo. Este id de trabalho ajuda a identificar os trabalhos em execução no momento no minion e permite que os trabalhos sejam pesquisados.

Módulo SALTUTIL

O Salt apresenta um novo módulo denominado processo de gerenciamento de tarefas Saltutil. Este módulo contém diferentes funções para gerenciar trabalhos. Essas funções são usadas para gerenciar trabalhos no nível de servo. As funções são descritas resumidamente a seguir -

• running - Retorna todos os dados de trabalhos em execução encontrados no diretório proc.

• find_job - Retorna dados específicos sobre um determinado trabalho com base no ID do trabalho.

• signal_job - Permite que um determinado ID de trabalho (jid) seja enviado um sinal.

• term_job - Envia um sinal de encerramento para o trabalho especificado.

• kill_job - Envia um sinal de eliminação para o trabalho especificado.

Corredor de empregos

O executor de tarefas contém funções para tornar a visualização de dados mais fácil e limpa. Tem diferentes funções. Vamos discutir cada uma dessas funções em detalhes.

Função ATIVA

A função Active é usada para identificar quais trabalhos ainda estão em execução e verificar quais sistemas concluíram um trabalho e quais sistemas ainda estão sendo aguardados. Ele é executado usando o seguinte comando,

salt-run jobs.active

Função LOOKUP_JID

O executor lookup_jid exibirá os dados para o trabalho que está procurando no momento. Esses trabalhos são configurados por meio dokeep_jobsopção na configuração mestre. Ele é executado usando o seguinte comando.

salt-run jobs.lookup_jid <job id number>

Função LIST_JOBS

A função List_jobs é usada para listar os dados de trabalho para trabalhos. É expresso pelo seguinte comando -

salt-run jobs.list_jobs

Agendamento de Trabalho

O sistema de programação expõe a execução de qualquer função de execução em lacaios ou qualquer runner no mestre.

É realizado pelos seguintes métodos -

• Schedule - A opção de programação no mestre ou no lacaio config arquivos.

• Minion pillar data - Ele atualiza os dados do pilar do minion usando o comando saltutil.refresh_pillar.

• O estado da programação ou módulo de programação.

Os estados de sal são executados no lacaio. Você pode passar os argumentos posicionais e fornecer umYAML dict dos argumentos nomeados no config file como mostrado abaixo.

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

Aqui, job1 irá executar a função saltstate.sls com os argumentos especificados, httpdpara cada hora. otest: True é o argumento adicional para o httpd comando que é definido em saltstate.sls.

O servidor de arquivos Salt é um servidor ZeroMQ sem estado. Está embutido no Salt master. Um servidor de arquivos Salt é usado para distribuir arquivos do mestre para os lacaios. Ele contém diferentes módulos. Vamos entender o servidor de arquivos salt, sua configuração, módulos relacionados ao servidor de arquivos salt, como acessar o servidor de arquivos salt em python, etc., neste capítulo.

Backend do servidor de arquivos

O backend do servidor de arquivos permite que o servidor de arquivos Salt atue como uma interface transparente para outro servidor de arquivos, como um sistema de arquivos local, sistema de controle de versão Git, etc.

Um back-end do servidor de arquivos Git pode ser habilitado usando a seguinte configuração no arquivo mestre.

fileserver_backend:
   - git

Para habilitar vários sistemas de arquivos de backend, podemos usar a seguinte configuração.

fileserver_backend:
   - roots
   - git

Também podemos especificar a opção adicional para um servidor back-end diferente usando a seção específica do servidor back-end correspondente.

Sistema de arquivos local

Para usar este sistema, temos que usar o seguinte código.

file_roots:
   base:
      - /srv/salt/prod

Sistema de arquivos Git

Para usar este sistema, temos que usar o seguinte código.

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

Solicitando arquivos

O Salt tem a opção de solicitar arquivos para ambientes específicos.

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

Aqui, o ambiente é definido usando a opção raízes.

Configuração do servidor de arquivos

Os arquivos salt podem ser alocados em vários diretórios raiz e acessados ​​especificando o caminho do arquivo e o ambiente a ser pesquisado. Os ambientes individuais podem abranger várias raízes de diretório.

Meio Ambiente

O ambiente padrão é básico. Este ambiente é definido e é usado para baixar arquivos quando nenhum outro ambiente é especificado.

file_roots:
   base:
      - /srv/salt/base

Você também pode usar vários ambientes, conforme mostrado no código abaixo.

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

Módulo CP

O módulo CP é o módulo principal para manipular o Salt file server. osalt-cp O comando também pode ser usado para distribuir arquivos apresentados pelo servidor de arquivos Salt.

GET_FILE

o cp.get_fileA função pode ser usada no minion para baixar um arquivo do mestre. É definido conforme mostrado no seguinte bloco de código.

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

O comando acima instrui todos os lacaios de sal a baixar o vimrc arquivo e copie-o para /etc/vimrc.

Habilitar modelo

Você pode habilitar a opção de modelo em get_file da seguinte forma -

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

Aplicar compressão

Para usar a compressão, use o gzipargumento nomeado. Os valores válidos são inteiros de 1 a 9, onde 1 é a compactação mínima e 9 é o valor máximo.

O comando é definido da seguinte forma -

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

GET_DIR

o cp.get_dirA função pode ser usada no minion para baixar um diretório inteiro do mestre. É definido no seguinte bloco de código.

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

o cp.get_dirsuporta renderização de template e argumentos de compressão gzip. Se quiser, você também pode atribuir.

Módulo FILECLIENT

O Salt fornece um módulo python que ajuda a acessar o servidor de arquivos salt. osalt/fileclient.py módulo é usado para configurar a comunicação do lacaio com o mestre.

O código de amostra para obter arquivos é o seguinte -

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)

Aqui,

• opts está disponível quando o módulo é executado no ambiente salt. Caso contrário, devemos fornecer o caminho de configuração -/etc/salt/minion.

• path refere-se ao caminho do arquivo de origem no servidor de arquivos salt.

• dest refere-se ao caminho de destino do arquivo.

• saltenv refere-se ao meio ambiente

No próximo capítulo, vamos entender como usar Git como o servidor de arquivos.

Gité um sistema de controle de versão distribuído de código aberto. Ele pode ser usado para controlar as alterações em qualquer arquivo. Salt envia arquivos de repositórios Git usando o servidor de arquivos Git. Você pode configurar o Git para ofileserver_backend opção de lista e se você precisar configurar um ou mais repositórios, você pode fazer isso usando o gitfs_remotes opção.

Este capítulo explica como instalar e configurar o servidor de arquivos Git. Antes de avançar para a instalação, você deve ter os seguintes pré-requisitos.

Pré-requisitos do Salt Server para usar Git

O requisito mínimo para o servidor salt usar o Git como servidor de arquivos é o seguinte -

• pygit2
• Dulwich

Pygit2 e Dulwich são configurados usando o gitfs_providerparâmetro no arquivo de configuração principal. E segitfs_provider não está configurado no arquivo mestre, então o Salt irá preferir pygit2, se a versão adequada estiver disponível, seguido por GitPython e Dulwich.

Instale o pygit2

Os seguintes comandos são usados ​​para instalar o pygit2 nos sistemas baseados em Fedora e Ubuntu -

• Fedora-based system

yum install python-pygit2

• Ubuntu-based system

apt-get install python-pygit2

Aqui, a versão mínima suportada de pygit2 é 0,20.3.

Instale GitPYTHON

GitPython pode ser facilmente instalado no mestre usando o yum / apt command como mostrado abaixo.

• Fedora-based system

yum install GitPython

• Ubuntu-based system

apt-get install python-git

Instale DULWICH

O Dulwich pode ser facilmente instalado no master usando o comando yum.

• Fedora-based system

yum install python-dulwich

• Ubuntu-based system

apt-get install python-dulwich

Agora, instalamos todas as dependências do servidor de arquivos Git. Vamos agora configurar este servidor de arquivos Git usando ofileserver_backend seção no master config Arquivo.

Configuração de Backend

Para usar o servidor de arquivos Git, você precisa adicionar o Git na lista fileserver_backend no arquivo de configuração mestre. É descrito a seguir -

fileserver_backend:
   - git

Vamos entender melhor como configurar o servidor de arquivos Git em uma configuração remota.

Configuração gitfs_remotes

Você pode especificar qualquer um ou todos os URLs, como git: //, https: //, file: // ou ssh: // para a configuração gitfs_remotes no arquivo mestre. Isso é usado para pesquisar os arquivos solicitados.

A especificação de URL https simples é definida abaixo.

gitfs_remotes:
   - https://github.com

o ssh a configuração pode ser feita conforme mostrado abaixo.

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

Agora, configuramos o servidor de arquivos Git usando as duas opções fileserver_backend e gitfs_remotes.

Reiniciar mestre

Depois de fazer todas as alterações no arquivo mestre, reinicie agora o mestre para carregar todas as configurações no servidor de arquivos Git.

Configuração de vários controles remotos

O seguinte comando é usado para configuração múltipla em gitfs_remotes no arquivo mestre.

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

Aqui, os repositórios sample1.git, sample2.git, e sample.doc pode ter os seguintes arquivos.

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

o MinionFSé um servidor de arquivos especial fornecido pelo Salt para os lacaios trocarem os arquivos entre eles. Os arquivos servidos pelo MinionFS são os arquivos compartilhados intencionalmente por lacaios. Para compartilhar os arquivos, um Minion deve seguir as etapas abaixo.

• O lacaio de origem tem que enviar o arquivo para o mestre de sal usando o cp.push função.

• Uma vez que os arquivos são enviados pelo minion de origem, os arquivos implantados podem ser acessados ​​por qualquer outro minion usando o servidor de arquivos MinionFS.

Ativar push

Por padrão, enviar os arquivos por lacaios para um mestre está desabilitado. Para aceitar os arquivos dos lacaios, o mestre precisa ter a opção “file_recv” no arquivo de configuração e seu valor deve ser definido comoTrue. Por padrão, o valor se “file_recv” éfalse.

file_recv: True

Assim que a opção for ativada, reinicie o serviço mestre.

Empurrando arquivos

Os lacaios podem enviar os arquivos para o mestre. É realizado pelocp.pushfunção. Esta função cp.push fornece um mecanismo fácil para enviar os arquivos pelo minion usando o id do minion.

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

Aqui, o minion-id é usado para identificar qual minion está empurrando o arquivo. Este comando irá armazenar o arquivo em um subdiretório chamadominions debaixo de master's cachedir. Normalmente, o caminho é - / var / cache / salt / master / minions.

Para lacaio, m1 e o arquivo - /var/log/mylog.txt, o arquivo será armazenado em - /var/cache/salt/master/minions/m1/var/log/mylog.txt.

Habilitar MinionFS

Para habilitar o MinionFS, basta adicionar minion na configuração de back-end do servidor de arquivos, conforme mostrado no bloco de código a seguir.

fileserver_backend:
   - roots
   - minion

Uma vez que o MinionFS é habilitado, os arquivos enviados por minion ficam disponíveis como -

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

Para lacaio, m1 e o arquivo enviado - /var/log/mylog.txt, o arquivo enviado será servido a partir de salt: //m1/var/log/mylog.txt.

Este minionFS pode ser montado em um diretório especial usando a seguinte configuração. Isso separará os arquivos minionFS de outros arquivos e ajudará na organização dos arquivos minion.

minionfs_mountpoint: salt://minionfs

Para a configuração acima, o arquivo estará disponível no minionfs diretório como - salt: //minionfs/m1/var/log/mylog.txt

Opções avançadas do MinionFS

O MinionFS também oferece uma opção para habilitar / desabilitar a disponibilidade de arquivos enviados de um certo lacaio. As opções sãominionfs_whitelist, para habilitar lacaios e minionfs_blacklist, para desativar os lacaios.

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

minionfs_blacklist:
   - testing

Na configuração acima, todos os lacaios, exceto testing têm permissão para compartilhar o arquivo usando o minionFS.

• Webserver1

• Lacaios cujos ids correspondem à expressão regular desenvolvem *

• Lacaios cujos ids correspondem à expressão regular mail\d+.mysite.com.

• Testing

No próximo capítulo, aprenderemos como usar o Cron com Salt.

O sal pode ser usado junto com o Croninscrição. Usar os dois aplicativos juntos oferece uma grande oportunidade para automatizar o Salt. Enquanto o Salt oferece a opção de executar comandos remotamente, o Cron permite que ele seja executado de maneira pré-agendada ou automatizada. Vamos aprender como usar Cron e Salt juntos neste capítulo.

O que é Cron?

O Cron é um aplicativo muito útil no ambiente Linux. Ele permite predefinir um comando ou script para ser executado em uma data e hora específicas. Ele também permite executar um aplicativo em um intervalo regular, digamos diariamente, semanalmente ou todo primeiro dia do mês.

O cron começa quando o sistema é iniciado e verifica o /etc/crontabarquivo para detalhes de configuração. O / etc / crontab tem cada aplicativo e sua programação em uma linha separada, conforme mostrado abaixo.

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"

Cada linha tem os seguintes sete pontos de entrada, que são separados por espaço e são os seguintes -

• minute - minuto da hora e está entre '0' e '59'.

• hour - hora e é especificado no relógio de 24 horas.

• day_of_month- Dia do mês e está entre 1 e 31. Por exemplo, o 10 ^º de cada mês é 10.

• month - Um mês especificado e é especificado numericamente (0-12) ou como o nome do mês (por exemplo, maio).

• day_of_week - O dia da semana é especificado numericamente (0-7) ou como o nome do dia (por exemplo, Sol).

• user - Conta de usuário sob a qual o comando é executado.

• cmd - O comando real e seus argumentos.

Aqui, * substitui, se nada for atribuído.

Salt Caller (salmão)

Salt fornece uma CLI (Command Line Interface), salt-callpara executar os módulos no próprio sistema minion local em vez de no servidor mestre usando o comando salt. A CLI da chamada salt oferece suporte a todas as opções suportadas pelo comando salt, mas é executada localmente.

O Salt Caller foi inicialmente projetado para oferecer suporte à depuração, mas agora, ele pode ser usado como um aplicativo independente.

salt-call test.ping

Usando salt-call no cron

A CLI salt-call é útil para agendar a operação salt usando Cron. Por exemplo, para verificar o estado do lacaio todos os dias à meia-noite, podemos usar salt-call junto com a opção - state.apply conforme mostrado abaixo.

/etc/crontab

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

Aqui,

• o state.apply A função irá verificar o arquivo de configuração do salt para o minion e verificar se todas as ações definidas para o minion estão configuradas corretamente.

• Definir o caminho é uma boa prática porque às vezes o comando salt pode não estar disponível no caminho do sistema.

No próximo capítulo, aprenderemos a Execução Remota, que é um conceito central do Salt.

Um dos principais conceitos do Salt é a execução remota. O Salt pode executar comandos em milhares de sistemas em questão de segundos. O Salt usa seu próprio comando para fazer essa funcionalidade. Vamos agora entender os diferentes comandos Salt para execução remota neste capítulo.

Salt Command

O comando Salt permite que o mestre do Salt se comunique com um ou mais Salt minions. A sintaxe básica é a seguinte,

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

A sintaxe de comando acima consiste nos três componentes principais a seguir.

• target - Determina quais sistemas são aplicados pelo comando.

• module.function- É um comando. Os comandos consistem em um módulo e uma função.

• arguments - Dados adicionais necessários para chamar a função.

Vamos entender cada um dos componentes em detalhes.

Qual é o componente de destino?

Destino é um componente que permite filtrar lacaios (sistema gerenciado) para executar a função. Um comando simples usando o componente de destino é definido abaixo.

salt '*' test.ping

Irá produzir o seguinte output -

minion2:
   True
minion1:
   True

Aqui, o alvo ‘*’representa todos os sistemas gerenciados. O 'test'aqui está um módulo e pingé uma função. Isso é usado para testar o serviço de ping no sistema remoto. Aprenderemos sobre os diferentes módulos e suas funções nos capítulos subsequentes.

Alvos usando ID (minion)

Você pode enviar um comando para um lacaio específico usando seu idno alvo. Ao invés de usar'*', você pode substituí-lo usando minion id. É definido abaixo.

salt 'minion1’ test.ping

Irá produzir o seguinte output -

minion1:
   True

Alvos usando Expressão Regular

Os alvos podem ser filtrados por expressão regular específica. É definido abaixo.

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

Irá produzir o seguinte output -

minion2:
   True
minion1:
   True

Alvos usando lista

Os destinos podem ser especificados explicitamente em uma lista. É definido no seguinte bloco de código.

salt -L 'minion1,minion2' test.ping

Irá produzir o seguinte output -

minion2:
   True
minion1:
   True

Metas por condição

Os destinos podem ser combinados em um comando, conforme mostrado no bloco de código abaixo.

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

Irá produzir o seguinte output -

minion1:
   True
minion2:
   True

Módulo e funções (module.function)

Salt pode executar comandos de shell; atualizar pacotes e distribuir arquivos, etc., em todos os seus sistemas gerenciados simultaneamente. Salt faz essas operações usando módulos. O Salt possui módulos especiais para todas as funcionalidades disponíveis. Vamos entender os diferentes módulos do Salt usando alguns exemplos simples neste capítulo.

Comando Shell

O Salt executa comandos shell remotamente em vários sistemas usando o cmd.runcomando. ocmd é o módulo principal e run é uma das funções disponíveis no cmdmódulo. orun A função permite que qualquer comando do shell seja executado no sistema remoto, conforme mostrado no bloco de código abaixo.

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

Irá produzir o seguinte 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
……………
……………

Mostrar uso do disco

Salt fornece um módulo especial, diskpara obter os detalhes completos do disco do sistema gerenciado. odiskmodule tem um usage função para consultar os detalhes.

salt '*' disk.usage

Irá produzir o seguinte 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

Interfaces de rede

O Salt fornece um módulo separado, rede e função, interfaces dentro do módulo para consultar as informações da interface de rede sobre os sistemas gerenciados.

salt '*' network.interfaces

Irá produzir o seguinte 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

Módulo de Execução sys.doc

As funções de sal podem ser enviadas para o sys.docmódulo de execução. Isso é usado para obter os detalhes sobre qualquer módulo diretamente da linha de comando. As funções do Salt são autodocumentadas. Toda a documentação da função pode ser recuperada dos lacaios por meio da função sys.doc (), que é definida abaixo.

salt '*' sys.doc

Argumentos para uma chamada de função

Os argumentos são usados ​​para fornecer dados adicionais para a chamada de função. Um exemplo de argumento simples é fornecido abaixo.

salt '*' sys.doc pkg.install

Aqui, o argumento pkg.install é um módulo para instalar pacotes específicos.

Função Python

Os argumentos são parâmetros delimitados por espaço para a função. Ele permite que o código Python seja passado como argumentos conforme fornecido a seguir.

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

Irá produzir o seguinte 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]

Da mesma forma, você pode usar palavras-chave opcionais e o YAML formato também.

O gerenciamento de configuração é um dos conceitos mais significativos do SaltStack. É usado para criar um modelo de configuração reutilizável, chamado destate. O estado descreve tudo o que é necessário para colocar um componente do sistema ou um aplicativo em uma configuração conhecida.

Salt State

O estado de sal é uma configuração reutilizável para uma parte específica de um sistema. Os estados são mais fáceis de entender e descritos usando um YAML simples.

Crie um estado de sal

Os estados de sal são fáceis de criar. Vamos criar um estado simples neste capítulo. Mova para o diretório “salt-vagrant-demo / saltstack / salt /” e crie um arquivo chamadosamples.sls e adicione as seguintes linhas nele.

samples.sls

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

Agora, salve o arquivo e execute o seguinte comando no Salt master.

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

Aqui, nós instalamos rsync, lftp e curl através de pkg.installed módulo usando o estado de sal em um minion de sal, minion1. Se funcionar corretamente, você poderá ver a resposta conforme mostrado abaixo.

Irá produzir o seguinte 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

Aplicar estado de sal

Agora que criamos um estado usando o arquivo '.sls' e o aplicamos chamando-o especificamente. O Salt tem um arquivo de estado padrão chamado detop.slsArquivo. O arquivo principal é usado para aplicar vários arquivos de estado a salt minions. O arquivo superior descreve onde os estados devem ser aplicados. Bem,States e a Top file trabalham juntos para criar o núcleo da capacidade de gerenciamento de configuração do SaltStack.

Vamos agora criar um arquivo top.sls simples no diretório saltstack/salt e adicione o seguinte.

top.sls

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

Aqui o state, comumente applies para all system Estado, samples aplica-se a minion1.

Em seguida, execute o Salt master e aplique o estado conforme mostrado abaixo.

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

Irá produzir o seguinte 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

Aplicar tamanho de lote

Se você tiver um grande número de lacaios conectados, poderá limitar o número de sistemas atualizados de uma vez. É realizado usando o–batch-size opção, que é definida abaixo.

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

Irá produzir o seguinte 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

Funções de estado de sal

As funções de estado de sal são usadas para instalar e configurar aplicativos em seu sistema remoto. Vamos instalar um pacote “Vim” usando a função Salt state.

Criar e aplicar função de estado

Crie um arquivo chamado “sample.sls” no diretório “salt-vagrant-demo / saltstack / salt / sample.sls” e adicione o seguinte -

sample.sls

install vim:
   pkg.installed:
      - name: vim

Quando o ambiente Vagrant estiver ativo, execute o salt master e aplique o sample.sls executando o seguinte comando.

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

Irá produzir o seguinte 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

Agora, adicionamos um pacote “Vim”. Vamos agora testar o pacote usando o método de teste Salt.

Teste de estado de sal

A execução do teste é obrigatória adicionando a opção “test = True” aos estados. As informações de retorno mostrarão os estados que serão aplicados em amarelo e o resultado será relatado como 'Nenhum'.

O seguinte comando é usado para testar o estado -

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

Irá produzir o seguinte 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 Pilar

O pilar é um componente essencial para tornar os estados de sal reutilizáveis. É usado para definir dados seguros para lacaios atribuídos usando alvos. Os dados do Salt pilar armazena valores como portas, caminhos de arquivo, parâmetros de configuração e senhas.

Arquivo de configuração do pilar

A configuração para o pillar_roots no arquivo de configuração principal é mostrado abaixo -

pillar_roots:
   base:
      - /srv/pillar

Aqui, o arquivo está no diretório “/ srv / pillar”.

Considere que o arquivo principal localizado em /srv/pillar/top.sls tem a seguinte estrutura -

base:
   '*':
      - default

Agora, vá para o arquivo default.sls localizado em /srv/pillar/default.sls e adicione o código a seguir.

# Default pillar values
apache
git

Depois de salvar o arquivo, atualize o pilar para atualizar todas as alterações.

Atualizando o Pilar

Você pode atualizar o pilar usando o seguinte comando.

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

O comando acima é usado para atualizar os dados do pilar de Sal em todos os lacaios.

Listar dados do pilar

Para listar os dados do pilar, você pode usar o comando fornecido abaixo.

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

Irá produzir o seguinte output -

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

Itens do pilar

Uma vez que o pilar é configurado, os dados podem ser visualizados no lacaio através do módulo do pilar. Ele pode ser acessado através da funçãopillar.items, que é definido abaixo.

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

Irá produzir o seguinte output -

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

SaltStack - Incluir Componente

O componente 'Incluir' é usado para definir a mesma tarefa de configuração em vários locais. É fácil de executar. Na parte superior do seu arquivo de estado, adicione um include usando o seguinte formato -

include:
   - state file 1 
   - state file 2

Aqui, state file 1 e state file 2são os nomes dos arquivos SLS que você deseja incluir. Não há necessidade de incluir o.slsextensão. Os estados de Salt incluídos são inseridos na parte superior do arquivo atual.

Arquivo de estado no subdiretório

Você pode incluir o arquivo de estado do subdiretório usando um ponto (.). Ele atua como um separador de diretório.

include:
   - dir.sls1

Interface de grãos

Grãos é uma interface usada para derivar as informações sobre o sistema subjacente. Os grãos são coletados para o sistema operacional, nome de domínio, endereço IP, kernel, tipo de sistema operacional, memória e muitas outras propriedades do sistema.

Segmentação de grãos

Os dados de grãos podem ser usados ​​ao selecionar lacaios, o que é definido no bloco de código a seguir.

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

Irá produzir o seguinte output -

minion1:
   True
minion2:
   True

Listando grãos

Os grãos podem ser listados usando o módulo 'grains.ls', que é definido abaixo.

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

lista de itens

Como o Pillar, os dados de grãos também podem ser listados usando 'grains.items'.

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

O registro é usado para rastrear os eventos de software em execução. Um evento é descrito por uma mensagem descritiva, que pode conter opcionalmente dados variáveis. A abordagem de registro de sal é usada para obter quaisquer problemas que você possa enfrentar. Você pode verificar com níveis de log específicos.

Definições de configuração

Vamos entender as diferentes definições de configuração para registro em detalhes.

ARQUIVO DE LOG

Os registros de log do salt são passados ​​pelo arquivo, que contém o nome do caminho local ou o local da rede para identificação. Este arquivo é considerado o arquivo de log.

log_file: /var/log/salt/master

Aqui, o arquivo depende do binário sendo executado no mestre. Da mesma forma, você também pode executar no minion, que é mostrado abaixo.

log_file: /var/log/salt/minion

Você também pode usar o endereço remoto. A sintaxe para usar o endereço remoto é - <arquivo | udp | tcp>: // <host | socketpath>: <port-if-required> / <log-facility>.

log_file: udp://loghost:port

Aqui, o padrão do recurso de log é LOG_USER.

LOG_LEVEL

Os níveis de log são ordenados em um valor atribuído numericamente. A biblioteca Python definiu a maioria dos níveis de registro por padrão. Além disso, Salt usa mais alguns níveis. Alguns dos níveis são explicados abaixo.

• log_level: error; level value is 40 - Indica registro de declaração de log com erro.

• log_level: quiet; level value is 1000 - Indica que nada deve ser registrado neste nível.

• log_level: info; level value is 20 - Indica as informações de log normais.

• log_level: warn; level value is 30 - Indica registro de declaração de log no aviso.

• log_level: debug; level value is 10 - Informações úteis para depurar implementações salt e código salt.

• log_level: trace; level value is 5 - Informações de depuração de código mais detalhadas.

LOG_LEVEL_LOGFILE

Ele define o nível de mensagens a serem enviadas para o arquivo de log.

log_level_logfile: info

LOG_DATEFMT

Ele define o formato da data do log. Por padrão, é representado como% Y-% m-% d% H:% M:% S.

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

LOG_FMT_CONSOLE

Ele define o formato do console que registra as mensagens. Salt usa um costumeLogRecordatributos para colorir a saída do log do console. Segue a seguinte sintaxe -

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

Ele define o formato do arquivo de log que registra as mensagens. A sintaxe básica é a seguinte -

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

LOG_GRANULAR_LEVELS

Este nível é usado para controlar os níveis de registro mais especificamente.

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

Aqui, a biblioteca principal do salt no nível 'info' define o salt.modules para registrar no nível de rastreamento.

Manipulador de registro externo

Salt usa o manipulador de log externo LogStash e Sentry para registro. Vamos entender sobre isso em detalhes neste capítulo.

Manipulador LOGSTASH

LogStash é uma fonte aberta; pipeline de processamento de dados seguro do lado do servidor. Vamos considerar um manipulador de registro UDP simples no Salt que usa LogStash.

Especifique as seguintes alterações no arquivo mestre Salt -

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

Em seguida, adicione as mudanças no arquivo de configuração Logstash -

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

Aqui, UDP - é a entrada que precisa ter um formato como json_event, que é o que enviamos por transferência.

SENTRY Logging Handler

Sentry é o rastreamento de erros em tempo real em implantações de produção e informações para reproduzir e corrigir falhas. A configuração padrão no arquivo mestre é definida a seguir.

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

Aqui, o nível de registro padrão para o manipulador de sentinela é ERROR, mas definimos a depuração log_level sob a chave de configuração sentry_handler.

O Salt executa comandos em um sistema remoto usando salt-minion. Este é o comportamento normal. Em alguns cenários, o sistema remoto pode ser acessado apenas pelo protocolo SSH. Para esses cenários, o Salt oferece uma opção para conectar o sistema remoto usando apenas o protocolo SSH e executar o comando por meio da camada SSH.

Salt SSHé muito fácil de configurar. A única configuração necessária é especificar os detalhes do sistema remoto em um arquivo especial chamado deRoster file. Este arquivo de lista normalmente está localizado em/etc/salt/roster. O arquivo de lista terá todas as informações sobre o sistema remoto e como podemos nos conectar a ele. Uma vez que os arquivos de roster são configurados, todos os comandos Salt são executados usando osalt-ssh em vez do comando salt.

Arquivo de lista

O sistema Roster é projetado especificamente para Salt SSH. Ele foi projetado como um sistema conectável. O único objetivo do sistema de escala de serviço é reunir informações sobre o sistema remoto. O arquivo de lista é umYAML based configuration file contendo informações do sistema remoto como targets. Esses destinos são uma estrutura de dados especial com um conjunto predefinido de atributos. Um arquivo de lista contém um ou mais alvos e cada alvo é identificado por umSalt ID.

A estrutura básica do arquivo de roster é a seguinte -

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

Todos os outros atributos suportados pelo arquivo de lista são opcionais. Eles são os seguintes -

• port - Número da porta SSH.

• sudo - se deseja executar o comando via sudo.

• sudo_user - nome de usuário sudo.

• tty - verdadeiro se sudo estiver habilitado.

• priv - chave privada.

• timeout - tempo limite para uma conexão SSH.

• minion_opts - dicionário de opções de servos.

• thin_dir - diretório de armazenamento do sistema de destino para componentes salt.

• cmd_umask - umask para forçar o comando salt-call.

O arquivo de lista de amostra é o seguinte -

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

Implantar chaves SSH

Salt SSH irá gerar pares de chave pública / privada padrão para logins SSH. O caminho padrão será /etc/salt/pki/master/ssh/salt-ssh.rsa. Esta chave pode ser implantada no sistema remoto usando ossh-copy-id comando como mostrado abaixo.

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

Executar Comando

Executar um comando salt é tão simples quanto alterar o salt cli comando em salt-ssh como mostrado abaixo.

salt-ssh '*' test.ping

Comando Raw Shell

Salt SSH fornece uma opção (-r) para executar um comando bruto no sistema remoto, ignorando o módulo salt e funções.

salt-ssh '*' -r 'ls'

Segmentação com Salt SSH

O direcionamento do sistema remoto em Salt SSH suporta apenas destinos glob e regex. Como o Salt SSH é um módulo separado, ele fornece apenas opções limitadas a partir de agora e fornecerá mais recursos no futuro próximo.

Salt fornece um módulo separado, Salt Cloud para fornecer máquinas virtuais de vários provedores de nuvem, como Amazon AWS, Google Compute, etc. Salt Cloud é uma interface genérica para configurar e gerenciar VMs de vários provedores de nuvem.

• Cloud Config- O arquivo de configuração principal do Salt Cloud é / etc / salt / cloud e se aplica a todas as VMs. O arquivo de configuração principal é chamadoCloud Config.

• Cloud Providers - Para atingir provedores de nuvem específicos, podemos usar um arquivo de configuração específico e eles estão localizados em /etc/salt/cloud.providers.d/*.conf, são chamados de Cloud Providers.

• Cloud Profiles - Para direcionar uma VM específica, também podemos usar um arquivo de configuração especial, que se aplica a essa VM em particular e estão localizados em /etc/salt/cloud.profiles.d/*.conf, são chamados de Cloud Profiles.

Para uma máquina virtual, as configurações no Cloud Config é aplicado primeiro e depois no Cloud Providers e finalmente a substituição é feita pelo Cloud Profiles.

Instalação de Salt Cloud

Por padrão, o Salt Cloud é integrado ao Salt e está prontamente disponível. Se não estiver disponível, podemos instalá-lo usando o comando abaixo.

pip install salt-cloud

Como o Salt Cloud é um módulo separado e é executado em seu próprio processo, ele também pode ser instalado no sistema Salt Minion em vez do Salt Master.

Provisionando uma máquina virtual

Para provisionar uma máquina virtual, precisamos definir um provedor de nuvem e um perfil de nuvem. Depois que ambos forem criados, podemos provisionar uma nova máquina virtual para usá-los.

Provedor de nuvem

As informações do host da nuvem são configuradas no arquivo de configuração do provedor de nuvem. Normalmente, as informações básicas que precisam ser configuradas são driver de nuvem, nome de usuário, senha, chave privada, etc. Vamos criar um novo provedor de nuvem chamadomy-amazon-cloud.

• Crie um arquivo, my-amazon-cloud.conf em /etc/salt/cloud.providers.d/

• Adicione um novo provedor usando o ec2 motorista.

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 fornece drivers para vários hosts de nuvem prontos para uso, como GoGrid, HP Cloud, Google Compute Engine (GCE), Amazon AWS, Joyent, Linode, OpenNebula, ProfitBricks, Proxmox, Saltify, VexxHost, VMWare, etc.

Uma vez que os provedores de nuvem são configurados, podemos consultar a localização disponível do provedor, imagens de máquina disponíveis e seus vários tamanhos.

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

Perfil de Nuvem

Um perfil de nuvem especifica a imagem e o tamanho da máquina virtual. Ele pode ser configurado em - /etc/salt/cloud.profiles.d/. Vamos criar um perfil simples,simple.conf.

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

Máquina virtual

Depois que o provedor e os perfis estão configurados, podemos fornecer facilmente uma máquina virtual usando a nuvem-sal, conforme mostrado abaixo.

salt-cloud -p aws_micro master minion1 minion2

Onde, p - O nome do perfil master, minion1 e minion2 são as novas máquinas virtuais.

Os detalhes da máquina virtual recém-criada podem ser obtidos usando o seguinte comando.

salt-cloud --query

As máquinas virtuais podem ser destruídas usando o seguinte comando -

slat-cloud -d master minion1

Mapa de Nuvem

Um mapa de nuvem é um formato especial para criar várias máquinas virtuais ao mesmo tempo. O formato do arquivo de mapa é especificar o perfil e, em seguida, adicionar uma lista das máquinas virtuais sob ele.

Um arquivo de mapa de amostra é o seguinte -

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

O arquivo de mapa pode ser passado como um argumento para o comando salt-cloud para criar a máquina virtual da seguinte maneira -

salt-cloud -m /path/to/mapfile

Existem muitos dispositivos como roteador, equipamento de rede, etc., com sistema operacional personalizado, memória limitada e considerações de alta segurança. Nesses dispositivos, não foi possível instalar o padrãosalt-minione, posteriormente, foram incapazes de gerenciar esses sistemas. No entanto, Salt fornece uma tecnologia inovadora para superar essa limitação.

Salt tem um módulo separado, salt proxy minion que controla o sistema remoto usando o serviço REST em execução no sistema remoto. Este serviço REST é um serviço da web baseado em HTTP escrito usando oRepresentational State Transfer (REST) conceito e são fáceis de implementar e de consumir.

Cada dispositivo terá seu próprio SDK e ambiente de desenvolvimento para escrever aplicativos complexos. Salt espera que um serviço REST seja desenvolvido no dispositivo de acordo com a especificação da interface Salt. O Salt também fornece um módulo python para escrever o serviço da web REST. Se o dispositivo suportar python, será fácil desenvolver o serviço da web REST.

Depois que o serviço da Web REST é desenvolvido e implantado no sistema remoto, o Salt pode ser configurado para controlar o dispositivo remoto usando o serviço da Web REST em vez do minion de sal.

Exemplo de Trabalho

Vamos aprender o conceito de salt proxy minionusando um ambiente de trabalho ativo. Para o ambiente ao vivo, escolhemos um sistema Linux para o mestre e o proxy minion. Vamos controlar o sistema usando o serviço da web REST em vez do salt-minion.

Instalar e configurar o serviço da Web REST

Salt fornece uma amostra da implementação do serviço da web REST, que é nomeada como proxyminion_rest_example em seu módulo contrib. Vamos instalar o serviço da web de amostra.

• Instalar ‘bottle’usando o pip. obottle comando é uma estrutura da web python para desenvolver aplicativos da web.

pip install bottle = 0.12.8

• Faça o download do saltstack/salt-contribprojeto do github. Caso contrário, clone o projeto usando o seguinte comando.

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

• Abra um terminal e vá para o salt-contrib diretório.

• Este diretório salt-contrib terá uma pasta, proxyminion_rest_example. Esta pasta contém implementação de amostra para o serviço da web REST. Vá para a pasta proxyminion_rest_example.

• Execute o seguinte comando para iniciar o serviço da web REST.

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

• Abra um navegador e carregue http: // «seu endereço IP»: 8000. Isso mostrará a página padrão com serviços e pacotes, conforme mostrado na imagem abaixo.

Agora, configuramos o serviço da web REST e ele verificará como configurar o proxy salt para consultar o serviço da web REST e controlar o sistema.

Configurar Salt-Proxy

Para configurar o Salt-Proxy, temos que seguir os passos abaixo.

• Temos que especificar o nó mestre para o salt-proxy. Edite a localização do arquivo de configuração de proxy, que está em / etc / salt / proxy, e insira o código a seguir.

master: <your ip address>

• Modificar / criar arquivo de pilar de base em /srv/pillar/top.sls conforme mostrado no seguinte bloco de código.

base:
  'p8000':
      - p8000

• Adicione um novo arquivo pilar, p8000.sls no /srv/pillar conforme mostrado no bloco de código abaixo.

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

• Inicie o salt-proxy no modo de depuração usando o seguinte comando.

salt-proxy --proxyid = p8000 -l debug

• Semelhante ao minion de sal, aceite o salt-proxy key como mostrado abaixo.

salt-key -y -a p8000

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

Correndo o Sal

Agora, execute o salt comandar e chamar o ping.test função conforme mostrado abaixo.

salt p8000 test.ping

Podemos executar qualquer função compatível com o serviço da web REST usando salt, que é semelhante a salt-minion.

Por exemplo, as informações do grão podem ser obtidas usando o seguinte comando.

salt p8000 grains.items

O sistema de eventos no Salt é uma interface ZeroMQ PUB local, que dispara eventos salt. É executado pelos seguintes componentes.

• Event Sockets - É usado para publicar eventos.

• Event library - É usado para ouvir eventos e enviar os eventos para o sistema salt.

Evento Salt Master

Um mestre Salt fornece diferentes tipos de eventos, que são explicados em detalhes abaixo -

• Eventos de autenticação
• Iniciar eventos
• Principais eventos
• Eventos de trabalho
• Eventos de corredor
• Eventos de Presença
• Eventos na nuvem

Vamos examinar cada um dos tipos de evento em detalhes.

Eventos de autenticação

Esses eventos de autenticação são acionados quando um lacaio executa uma verificação de autenticação com o mestre. É representado por salt / auth.

Iniciar eventos

Os eventos de início disparam sempre que um lacaio se conecta ao mestre de Sal e é representado por salt / minion // start.

Eventos Chave

Os eventos de chave são disparados quando o mestre de sal está aceitando e rejeitando chaves no minion de sal. Você pode acessar este evento usando o comando salt-key.

Eventos de trabalho

Um evento de trabalho é disparado sempre que um novo trabalho vai começar. É representado porsalt/job//new. Aqui, JID - ID de trabalho novo - novo trabalho

Eventos de corredor

Quando um corredor começa a execução, um evento de corredor é disparado. É representado por salt / run // new.

Eventos de Presença

Quando lacaios são conectados ou recentemente conectados ou desconectados, este evento é disparado em um intervalo regular. É representado por -salt/presence/present e salt/presence/change. Aqui,

• Present - significa que o mestre de sal está conectado à lista de lacaios.

• Change - usado para detectar um novo lacaio - conectado ou desconectado.

Eventos na nuvem

Os eventos de nuvem salgada são disparados em uma máquina virtual. A menos que outros eventos, não é executado no lacaio. Você pode acessá-lo usando -salt/cloud//creating. Ele é disparado quando uma nuvem Salt inicia o processo de execução da máquina virtual.

Ferramentas de Evento

Agora, vamos examinar as ferramentas e scripts de eventos. Você pode acessar o barramento de eventos usando CLI. Ele é acessado pelo seguinte comando.

salt-run state.event pretty = True

Aqui, o runner é projetado para interagir com o barramento de eventos de ferramentas externas e scripts de shell. O ônibus de eventos do Salt pode ser acessado remotamente através doREST API. É representado por - (URL de amostra).

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

Da mesma forma, você também pode acessar eventos de scripts Python.

Em geral, orchestrationé uma coordenação e arranjo automatizado de sistemas. O orquestrar runner é usado para realizar a orquestração no SaltStack.

Orquestrar Corredor

O Orchestrate Runner oferece todas as funcionalidades do OverState(sistema anterior). É originalmente chamado destate.slscorredor. Este orquestrar runner é usado para generalizar o sistema de estado Salt para um contexto mestre Salt.

o state.sls e a state.highstate funções são executadas em cada salt minion, mas o state.orchestraterunner é executado no mestre. ostate.orchestraterunner permite que você gerencie toda a sua infraestrutura como estado totalmente. Vamos entender como passar por um processo de execução simples.

Execução Simples

O comando Orchestrate Runner é igual ao state.sls função, mas você pode executá-lo com o "salt-run" em vez de sal.

Suponha que você tenha um sample.sls arquivo localizado em /srv/salt/orch/samples.sls. Adicione o código a seguir nesse arquivo.

sample.sls

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

O seguinte comando é usado para rodar no master e irá aplicar os estados definidos naquele arquivo.

salt-run state.orchestrate orch.sample

Irá produzir o seguinte 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#

Aqui, de acordo com a versão atual, a função de execução foi renomeada para state.orchestrate. Isso será útil para evitar confusão com a função de execução state.sls, mas as versões anteriores dostate.sls deve ser usado.

Função de execução

Para executar uma função, você deve usar o salt.function. Considere um arquivodata.sls localizado em /srv/salt/orch/data.sls. Agora, adicione as seguintes alterações nesse arquivo.

data.sls

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

O seguinte comando é usado para executar a função Salt.

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

Irá produzir o seguinte 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

As fórmulas do Salt são empacotadas e distribuídas aos mestres do Salt usando o gerenciador de pacotes. Este conceito foi influenciado porRPM, Yum e Pacmansistemas de embalagem. Estado de sal, pilar, modelos de arquivo e outros arquivos são usados ​​pela fórmula e, em seguida, empacotados em um único arquivo.

Depois que um pacote de fórmula é criado, ele é copiado para o Sistema de Repositório para ser usado para mestres do Salt. Antes de passar para o gerenciador de pacotes, vamos dar uma olhada em como instalar um pacote “nginx” usando o comando básico do Salt.

A seguinte sintaxe é usada para instalar um pacote “nginx”.

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

Aqui o pkg.install nginxcomando é usado para instalar um pacote. Após a execução, você verá a seguinte resposta.

Irá produzir o seguinte 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:

Agora, você instalou um pacote. Para iniciar os serviços desse pacote, use o comando fornecido a seguir.

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

Depois de executar este comando, o resultado parece mostrado no bloco de código abaixo.

minion1:
   True
minion2:
   True

Portanto, instalamos e iniciamos os serviços para o pacote “nginx” usando o comando básico. Vamos agora discutir como construir e instalar pacotes no gerenciador de pacotes Salt.

Pacotes de construção

Os pacotes podem ser construídos em qualquer sistema onde você possa instalar o Salt. Existem três tipos de pacotes e são os seguintes.

• Formula
• Reactor
• Conf

Vamos agora entender como construir pacotes usando o Fomula Arquivo.

Arquivo de fórmula

A maioria dos arquivos do pacote estão localizados no diretório - / srv / spm / salt / por padrão, mas o arquivo pilar pode ser colocado no diretório - / srv / spm / pillar /. O arquivo de fórmula descreve o pacote.

Example

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

Aqui,

• Name- O nome do pacote. Aqui, o nome do pacote éapache.

• os - É usado para saber quais sistemas operacionais podem suportar este pacote.

• os_family - É usado para saber quais famílias de sistemas operacionais podem oferecer suporte a este pacote.

• Version- A versão do pacote. É especificado no formato AAAAMM.

• Release - Este campo se refere principalmente ao lançamento de uma versão.

• Summary - Descrição resumida do pacote.

• Description - Uma descrição mais detalhada do pacote.

REATOR

Os arquivos do reator residem no /srv/spm/reactor/ diretório.

CONF

Os arquivos neste tipo de pacote são arquivos de configuração do Salt, que normalmente residem no /etc/salt/diretório. Os arquivos de configuração para pacotes diferentes do Salt podem e devem ser tratados com um Salt State (usando um tipo de pacote de fórmula).

Vamos continuar com as etapas a seguir para construir um pacote.

• Crie um arquivo FORMULA e coloque-o na raiz da pasta do pacote.

• Monte os arquivos de fórmula em uma pasta no sistema de compilação.

• Corre spm build. O pacote é construído e colocado na pasta / srv / spm_build. O seguinte comando é usado para construir um pacote.

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

• Agora, copie o .spm arquivo para uma pasta no sistema de repositório.

• Você pode compartilhar o srv/spm_build pasta na rede ou copie os arquivos para o seu FTP ou servidor da Web.

• Gere metadados de repo usando o seguinte comando.

spm create_repo /srv/spm_build

Instalando Pacotes

Esta seção explica sobre como instalar os pacotes do gerenciador de pacotes Salt.

Configurar Repositórios Remotos

Para configurar repositórios remotos, o Salt Master precisa saber onde o repositório está por meio de um processo de configuração.

Os arquivos estão no /etc/salt/spm.repos.d/spm.repo diretório.

Example

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

Aqui, o arquivo contém o nome do repositório e o link para o repositório. Você também pode usar http, https, ftp ou o caminho do arquivo. Para usar o caminho do arquivo, você pode acessá-lo usando a URL: file: /// srv / spm_build.

Atualizar Metadados

Depois que o repositório é configurado no Salt master, os metadados do repositório são baixados usando o comando abaixo.

spm update_repo

Atualizar raízes de arquivo

Os pacotes SPM estão localizados no diretório srv / spm / salt. Adicione o seguinte caminho às raízes do arquivo no Salt master,

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

Agora, reinicie o salt master.

Instale o pacote Apache

Para instalar o pacote apache, use o seguinte comando.

spm install apache

Você também pode instalar diretamente do arquivo SPM usando o comando abaixo.

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

Removendo um Pacote

Para remover um pacote, por exemplo - apache, use o seguinte comando,

spm remove apache

Observe que, se algum arquivo tiver sido modificado, ele não será removido.

O Salt fornece acesso programático a todos os seus comandos. Salt fornece módulos diferentes para cada seção do sistema Salt. Vamos aprender os fundamentos da API python e sobre como executar os comandos salt básicos neste capítulo.

Configuração

o salt.config módulo é usado para acessar os detalhes de configuração do Salt.

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

Aqui o client_config lê o arquivo de configuração salt e retorna os detalhes da configuração como dicionário.

Carregador

o salt.loader módulo é usado para carregar cada módulo em Salt, como grãos, minions, etc.

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

Aqui, grains lê os detalhes dos grãos no sistema de Sal e os devolve.

Módulo Cliente

o salt.client O módulo é usado para executar os comandos salt, salt-call e salt-SSH de forma programática.

As classes python mais importantes são as seguintes -

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

A principal função fornecida pela maioria do módulo cliente é cmd. Esta função envolve as opções CLI e as executa, que é semelhante à linha de comando e retorna os resultados como estruturas de dados python.

LocalClient

O LocalClient é usado para enviar comandos do mestre para os lacaios do sal e retornar os resultados para o mestre.

import salt.client

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

Irá produzir o seguinte output -

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

Chamador

O chamador é usado para executar salt-call programaticamente e retornar os resultados.

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

Irá produzir o seguinte output -

True

SSHClient

O SSHCient é usado para executar o salt-ssh programaticamente e retornar os resultados.

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

Irá produzir o seguinte output -

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

CloudClient

O módulo salt.cloud é usado para executar os comandos salt-cloud de forma programática.

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

O módulo de nuvem fornece funções para criar VMs (criar), para destruir VMs (destruir), listar imagens fornecidas por um provedor de nuvem (list_images), listar locais de um provedor de nuvem (list_locations), listar tamanhos de máquina de um provedor de nuvem (list_sizes), etc.

Neste exemplo de trabalho, criaremos uma fórmula Salt que configurará o servidor da web apache junto com o software PHP. Salt é uma ótima maneira de executar comandos ad-hoc, mas você não gostaria de configurar continuamente sua infraestrutura dessa maneira. Ao criar um conjunto de fórmulas Salt, você pode reproduzir com segurança qualquer configuração.

Salt Formulas são arquivos de texto YAML simples e, por padrão, residem em seu Salt Master em /srv/salt/*. Vamos começar criando uma fórmula de sal para instalar o servidor web Apache e o PHP ao mesmo tempo.

Crie um arquivo chamado “websetup.sls” em /srv/salt/ diretório e adicione o seguinte código.

websetup.sls

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

Neste exemplo, observe o argumento “- pkgs:”. Cada item na lista abaixo “- pkgs:” será passado junto ao gerenciador de pacotes do SO para serem instalados juntos. Sempre que você tiver uma grande lista de pacotes para instalar, esta é a maneira mais eficiente de instalá-los.

Aplique esta fórmula ao mestre de sal usando o seguinte comando.

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

Agora, você verá o seguinte 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

Agora, você instalou os pacotes em minion2.

Highstate

Um “estado elevado” é uma maneira de Salt determinar qual das fórmulas do sal deve ser aplicada a um determinado lacaio. Execute um “highstate” usando o seguinte comando.

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

top.sls

Quando o lacaio pede para executar um estado elevado, como mencionado antes, o lacaio solicita o top.sls do mestre de Sal e procura por fórmulas que correspondam. Por padrão, este arquivo está localizado em /srv/salt/top.sls. Vamos adicionar nossa fórmula ao arquivo top.sls e definir minion2 como destino.

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

Agora, execute o highstate visando minion2 como mostrado abaixo.

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

Depois de aplicar isso, você poderá ver o seguinte 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

Agora, o servidor web Apache e o PHP estão instalados no minion2. Desta forma, temos que mirar lacaios usando ambostop.sls e highstate e instale o software necessário com trabalho mínimo e flexibilidade máxima.