Ansible Tutorial para iniciantes no Linux

Um administrador do sistema, na grande maioria dos casos, precisa cuidar de mais de um servidor, então ele geralmente precisa executar tarefas repetitivas em todos eles. Nesses casos, a automação é obrigatória. Ansible é um software de código aberto de propriedade da Red Hat; Está escrito no Lanaguage de programação Python e é um software de gerenciamento de provisionamento e configuração que nos ajuda nos casos acima mencionados. Neste tutorial, veremos como instalá -lo e os conceitos básicos por trás de seu uso.

Neste tutorial, você aprenderá:

• Como instalar o Ansible nas distribuições Linux mais usadas
• Como configurar Ansible
• Qual é o inventário Ansible
• Quais são os módulos Ansible
• Como executar um módulo da linha de comando
• Como criar e executar um manual

Requisitos de software e convenções usadas

Instalando Ansible

O pacote Ansible está contido nos repositórios oficiais das distribuições Linux mais usadas para que possa ser facilmente instalado usando seus gerentes de pacotes nativos. Para instalá -lo no Debian, podemos executar:

$ sudo apt-get update && apt-get Install Ansible 

Para instalar o Ansible no Fedora: em vez disso:

$ sudo dnf installible 

Ansible está no repositório da “comunidade” do Archlinux; Podemos instalá -lo usando Pacman:

$ sudo pacman -sy Ansible 

Se queremos instalar o Ansible no CentOS8, temos que adicionar o EPEL-RELEASE Fonte de software para o nosso sistema, pois o pacote não está disponível nos repositórios padrão. Para fazer isso, executamos o seguinte comando:

$ sudo dnf install https: // dl.FedoraProject.org/pub/epel/epel-latest-8.Noarch.RPM 

Depois disso, podemos simplesmente correr:

$ sudo dnf installible 

Para outras instruções de instalação específicas de distribuição, podemos consultar a página dedicada
da documentação oficial da Ansible.

Apresentando Ansible

A peculiaridade fundamental de Ansible é que é um sem agente sistema de provisionamento. Isso significa que não precisamos instalar nenhum agente ou daemon de software nos servidores que queremos controlar. Tudo o que precisamos é instalar e configurar Ansible no chamado máquina de controle. O tarefas Configuraremos serão realizados, na grande maioria dos casos, por meio de um simples ssh conexão.

O arquivo de configuração Ansible

Ansible pode ser configurado especificando parâmetros e seus valores em um ou mais arquivos de configuração. O aplicativo, em ordem de prioridade, procura os seguintes arquivos:

1. O arquivo especificado através da variável Ansible_config
2. O Ansible.cfg arquivo no diretório de trabalho atual
3. O .Ansible.cfg arquivo no diretório inicial do usuário
4. O /etc/Ansible/Ansible.cfg arquivo

O /etc/Ansible/Ansible.cfg é o último, por isso é usado como fallback e o padrão. Por razões óbvias, este não é o local apropriado para descrever todos os parâmetros possíveis que podem ser especificados em um arquivo de configuração, no entanto, aqui está um trecho do conteúdo do arquivo:

[Padrão] #Alguns valores padrão básicos… #Inventory =/etc/Ansible/hosts #library =/usr/share/my_modules/#module_utils =/usr/share/my_module_utils/#remote_tmp = ~.Ansible/tmp #local_tmp = ~//.Ansible/tmp #plugin_filters_cfg =/etc/Ansible/plugin_filters.yml #forks = 5 #poll_interval = 15 #sudo_user = root #ask_sudo_pass = true #ask_pass = true #transport = smart #remote_port = 22 #module_lang = c #module_set_locale = false 

Os do exemplo são parâmetros comentados que são definidos com seus valores padrão. Entre eles, você pode ver o inventário parâmetros, que têm o /etc/Ansible/hosts valor. Veremos o que é isso na próxima seção.

O arquivo "hosts" ou "inventário"

O arquivo Ansible "hosts" é onde basicamente definimos o endereço IP ou os nomes de hosts das máquinas que queremos controlar com Ansible (este é o "inventário" no jargão Ansible). Em uma instalação padrão, o arquivo está localizado no /etc/Ansible diretório. Dentro do arquivo de inventário, os hosts podem ser agrupado ou não agrupado. Podemos especificar um host por si só, por exemplo:

servidor1 

Quando queremos executar operações em mais de um host, no entanto, é muito útil colocar hosts em grupos, criados, por exemplo, usando seu "papel" como critério. Supondo que os anfitriões com quem estamos lidando sejam todos usados ​​como servidores da web, poderíamos escrever:

[WebServers] Server1 Server2 

Módulos Ansible

Os módulos Ansible são basicamente pequenos programas usados ​​para executar as tarefas de que precisamos; Cada um deles foi projetado para realizar uma única operação básica, a fim de garantir a granularidade. Eles podem ser executados a partir da linha de comando ou dentro Playbooks. A lista completa de todos os módulos pode ser encontrada na página dedicada da documentação oficial. Novamente, aqui não podemos examinar todos os módulos, mas aqui estão alguns exemplos.

Os módulos Apt, DNF e Yum são usados ​​para gerenciar pacotes com os gerentes de arquivo o nome
de. O módulo Seboolean é usado para gerenciar o status de Selinux booleans, o módulo de usuário é usado para gerenciar contas de usuário, etc.

Usando módulos da linha de comando

Como dissemos na seção anterior, os módulos podem ser usados ​​na linha de comando ou nos manuais. Vamos nos concentrar no último na próxima seção; Aqui vamos demonstrar como usar um módulo da linha de comando, com o Ansible comando. Neste exemplo, usaremos o ping módulo. Este módulo não tem nada a ver com o comando ping, mas é usado para verificar se podemos fazer login nos servidores remotos e que um intérprete Python está instalado neles. O módulo retorna o valor "pong" no sucesso:

$ ANSIBILBLE WebServers -M Ping --k -Pass 

Invocamos o comando Ansible, especificando que queremos executar a tarefa nos membros dos hosts do grupo "Webs" e com o -m opção, passamos o nome do módulo que queremos usar. Nós também usamos o --Ask-pas opção, por quê? Embora eu tenha adicionado anteriormente os servidores remotos de impressão digital ao arquivo "hosts conhecidos" da máquina de controle, não configurei o acesso SSH via chave pública, para que uma senha SSH seja fornecida quando executarmos uma tarefa. O --Ask-pas a opção faz com que a senha seja solicitada interativamente. Aqui está a saída do comando
acima:

Senha SSH: servidor2 | Sucesso => ​​"Ansible_facts": "descobriu_interpreter_python": "/usr/bin/python", "alterado": false, "ping": "pong" server1 | Sucesso => ​​"Ansible_facts": "descobriu_interpreter_python": "/usr/bin/python", "alterado": false, "ping": "pong" 

Ansible Playbooks

O que é um manual? Playbooks Ansible não são outros arquivos YAML, onde especificamos as tarefas que queremos executar usando Ansible, e os hosts em que devem ser executados. Vamos ver um exemplo de manual. No arquivo a seguir, configuramos uma tarefa para garantir que o editor de texto do VIM esteja instalado e na versão mais recente disponível:

--- - Nome: Update WebServers Hosts: WebServers Remote_User: Egdoc Torne -se: Sim Tarefas: - Nome: Verifique se o VIM está instalado e na versão mais recente DNF: Nome: Vim Estado: mais recente… 

Vamos analisar o acima. O --- e .. Podemos ver, respectivamente, no início e no final do arquivo, fazem parte da sintaxe YAML padrão: eles são opcional e marque o início e o final do arquivo. As instruções e seus valores são representados em um formato de dicionário, como valor chave pares.

Um manual pode conter vários chamados tocam; Nesse caso, acabamos de definir um. De fato, a primeira coisa que fizemos foi especificar seu nome, que neste exemplo é "atualizar servidores da web". A segunda chave que usamos é anfitriões: Com ele, podemos definir o grupo host que as tarefas devem ser executadas em. Nesse caso, especificamos servidores da web como valor, que compreende as máquinas que definimos nos exemplos anteriores (Server1 e Server2).

A próxima chave que usamos foi remote_user. Com ele, podemos especificar qual é o usuário que devemos fazer login como, via ssh, nos servidores remotos. Depois disso, usamos o tornar-se chave. Esta chave aceita um valor booleano e com ela especificamos se
Escalada de privilégios deve ser usado para executar as tarefas ou não. Nesse caso, como fazemos login nas máquinas remotas usando o usuário "EGDOC" e precisamos de privilégios root para instalar um pacote, definimos -o como sim. É importante notar
Essa escalada de privilégio é configurada no /etc/Ansible/Ansible.cfg Arquivo de configuração, na seção dedicada. Nesse caso, os valores padrão são os seguintes:

[privilége_escalation] #se tornar = true #se tornar_method = sudo #se tornar_user = root #se tornar_ask_pass = false 

Depois de definir o jogar Informações, começamos a especificar nossa lista de tarefas. Para isso, usamos o tarefas palavra -chave. Cada tarefa tem um nome que é usado para documentação e manipuladores de tarefas.

Com DNF: Especificamos que queremos usar o módulo "DNF", que, como vimos antes, é usado para gerenciar pacotes usando o gerenciador de pacotes padrão na família Red Hat Family of Distribuições. Dentro desta seção, com o nome palavra -chave
Especificamos o nome dos pacotes. Neste exemplo, estamos interessados ​​apenas em um único pacote, mas vários pacotes podem ser especificados usando uma lista. Por exemplo:

DNF: Nome: [Vim, Nano] 

Com o estado palavra -chave do DNF Módulo, basicamente especificamos o que queremos fazer com o (s) paco (s) especificado (s). Nesse caso, usamos mais recente Como o valor: com ele, garantimos que o pacote esteja instalado e na versão mais recente disponível na distribuição usada na máquina remota. Outros possíveis valores que podemos usar são remover ou ausente, que faz com que o (s) pacote seja desinstalado, ou presente que apenas garantem que o pacote seja instalado. Eu recomendo que você verifique a documentação oficial do módulo para obter a lista completa de chaves e valores que podem ser usados ​​com o módulo.

Aqui vamos nós, acabamos de definir nosso primeiro manual. Como podemos executá -lo?

Executando um manual

Para executar um manual, usamos o dedicado Ansible-playbook comando. O comando aceita uma série de opções e leva um ou mais arquivos de manual como argumentos. Para executar o manual que definimos na seção anterior, por exemplo, executaríamos o seguinte comando:

$ Ansible-Playbook --k-pass --- Ask-Become-Pass/Path/To/Playbook.yml 

Você pode notar que, neste caso, invocamos o comando com o --Ask-become-pass opções. Esta opção é necessária porque no arquivo de playbook atribuímos o sim valor para o tornar-se Chave, pois precisamos de escalada de privilégios para instalar pacotes nas máquinas remotas. O --Ask-become-pass a opção faz para que o sudo A senha é perguntada quando executamos o manual. Nesse caso, já que usamos também --Ask-pas, A senha SSH será usada como senha padrão para escalada de privilégios. Aqui está a saída que recebemos quando executamos o manual:

Senha SSH: Torne -se senha [Padrões para a senha SSH]: play [Atualizar servidores] ******************************* **************************************************** **************************************************** ****** Tarefa [Reunião de fatos] ********************************* **************************************************** **************************************************** ** OK: [Server1] OK: [Server2] Tarefa [Verifique se VIM está instalado na versão mais recente] ************************* **************************************************** ********************************** **************************************************** **************************************************** ************************************************* servidor1 : ok = 2 alterado = 1 inacessível = 0 falhou = 0 pulado = 0 resgatado = 0 ignorado = 0 servidor2:ok = 2 alterado = 1 inacessível = 0 falhou = 0 pulado = 0 resgatado = 0 ignorado = 0 

Primeiro, somos solicitados a fornecer a senha "ssh", depois o "se tornar" um. Como já dissemos, a senha do SSH será usada como o valor padrão neste caso. Como você pode ver antes da tarefa que especificamos no manual, outra tarefa é executada: “Reunir fatos”. Esta tarefa é executada por padrão para reunir variáveis ​​úteis sobre hosts remotos que podem ser usados ​​em manuais.

Depois que as tarefas são executadas, obtemos uma recapitulação do (s) jogo (s) que especificamos. Nesse caso, podemos ver, que duas tarefas foram executadas corretamente (ok = 2) e uma tarefa causou uma mudança (alterado = 1). Isso faz sentido: a mudança ocorreu desde que o pacote Vim foi instalado.

Agora, se tentarmos executar o manual novamente, podemos ver que nenhuma alteração ocorre, já que o VIM já está instalado e na última versão disponível:

Jogue recapitular ************************************************** **************************************************** **************************************************** ***** servidor1: ok = 2 alterado = 0 inacessível = 0 falhou = 0 pulado = 0 resgatado = 0 ignorado = 0 servidor2: ok = 2 alterado = 0 inacessível = 0 falhou = 0 ignorado = 0 resgatado = 0 ignorado = 0 

Conclusões

Neste tutorial, aprendemos o que é Ansible e quais são suas peculiaridades. Vimos como instalá -lo em algumas das distribuições Linux mais usadas, como configurá -lo e alguns conceitos básicos: o que é um inventário e quais são os
Módulos Ansible. Também vimos como executar um módulo da linha de comando e como escrever e executar um manual. Isso foi feito como uma introdução ao mundo Ansible; Deixar -se com as mãos sujas, experimente e leia a documentação oficial para um conhecimento mais profundo!

Tutoriais do Linux relacionados:

• Uma introdução à automação, ferramentas e técnicas do Linux
• Coisas para instalar no Ubuntu 20.04
• Mastering Bash Script Loops
• Coisas para instalar no Ubuntu 22.04
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
• Mint 20: Melhor que o Ubuntu e o Microsoft Windows?
• Ubuntu 20.04 Guia
• Loops aninhados em scripts de basquete
• Com que frequência você tem que reiniciar seu servidor Linux?
• Sistema Linux Hung? Como escapar para a linha de comando e…