Tutorial Ansible para iniciantes: manual, comandos e exemplo

O que é Ansible?

Ansible é uma ferramenta de automação e orquestração de código aberto para provisionamento de software, gerenciamento de configuração e implantação de software. O Ansible pode executar e configurar facilmente sistemas do tipo Unix, bem como Windows sistemas para fornecer infraestrutura como código. Ele contém sua própria linguagem de programação declarativa para configuração e gerenciamento do sistema.

O Ansible é popular pela sua simplicidade de instalação, facilidade de uso no que diz respeito à conectividade com os clientes, pela falta de agente para clientes Ansible e pela infinidade de habilidades. Funciona conectando-se via SSH para os clientes, portanto, não precisa de um agente especial no lado do cliente e, ao enviar módulos para os clientes, os módulos são executados localmente no lado do cliente e a saída é enviada de volta para o servidor Ansible.

Por usar SSH, pode facilmente conectar-se a clientes usando chaves SSH, simplificando todo o processo. Os detalhes do cliente, como nomes de host ou endereços IP e portas SSH, são armazenados em arquivos chamados arquivos de inventário. Depois de criar um arquivo de inventário e preenchê-lo, o ansible poderá usá-lo.

Por que usar o Ansible?

Aqui estão alguns prós/benefícios importantes de usar Ansible

• Uma das vantagens mais significativas do Ansible é que ele é gratuito para uso por todos.
• Não são necessárias habilidades especiais de administrador de sistema para instalar e usar o Ansible, e a documentação oficial é muito abrangente.
• Sua modularidade em relação a plugins, módulos, inventários e playbooks fazem do Ansible o companheiro perfeito para orquestrar grandes ambientes.
• O Ansible é muito leve e consistente e não há restrições em relação ao sistema operacional ou ao hardware subjacente.
• Também é muito seguro devido aos seus recursos sem agente e ao uso de recursos de segurança OpenSSH.
• Outra vantagem que incentiva a adoção do Ansible é sua curva de aprendizado suave determinada pela documentação abrangente e estrutura e configuração fáceis de aprender.

História do Ansible

Aqui estão marcos importantes da história do ansible:

• Em fevereiro de 2012 teve início o projeto Ansible. Foi desenvolvido pela primeira vez por Michael DeHaan, o criador do Cobbler e Func, Fedora Unified Network Controller.
• Inicialmente chamada de AnsibleWorks Inc, a empresa que financia a ferramenta ansible foi adquirida em 2015 pela RedHat e mais tarde, junto com a RedHat, passou sob a égide de IBM.
• Atualmente o Ansible vem incluído em distribuições como Fedora Linux, RHEL, Centos e Oracle Linux.

Termos importantes usados ​​no Ansible

• Servidor Ansible

  A máquina onde o Ansible está instalado e a partir da qual todas as tarefas e playbooks serão executados

• Módulo

  Basicamente, um módulo é um comando ou conjunto de comandos Ansible semelhantes destinados a serem executados no lado do cliente

• Tarefa

  Uma tarefa é uma seção que consiste em um único procedimento a ser concluído

• Tipo

  Uma forma de organizar tarefas e arquivos relacionados para serem posteriormente chamados em um playbook

• Fato

  Informações obtidas do sistema cliente a partir das variáveis ​​globais com a operação de coleta de fatos

• Estoque

  Arquivo contendo dados sobre os servidores clientes ansible. Definido em exemplos posteriores como arquivo hosts

• Jogar

  Execução de um manual

• Treinador

  Tarefa que é chamada apenas se um notificador estiver presente

• Notifier

  Seção atribuída a uma tarefa que chama um manipulador se a saída for alterada

• etiqueta

  Nome definido para uma tarefa que pode ser usada posteriormente para emitir apenas aquela tarefa específica ou grupo de tarefas.

Instalação Ansible no Linux

Depois de comparar e pesar suas opções e decidir pelo Ansible, o próximo passo é instalá-lo em seu sistema. Seguiremos as etapas de instalação em diferentes Linux distribuições, as mais populares, no próximo pequeno tutorial.

Instale Ansible em sistemas Centos/RedHat

Passo 1) Instale o repositório EPEL

[root@ansible-server ~]# sudo yum install epel-release

Passo 2) Instale o pacote ansible

[root@ansible-server ~]# sudo  yum install -y ansible

Instale o ansible em Ubuntu/Sistemas Debian

Passo 1) Execute uma atualização nos pacotes

$ sudo apt update

Passo 2) Instale o pacote software-properties-common

$ sudo apt install software-properties-common

Passo 3) Instale o arquivo de pacotes pessoais ansible

$ sudo apt-add-repository ppa:ansible/ansible

Passo 4) Instalar ansible

$ sudo apt update
$ sudo apt install ansible

Comandos ad hoc Ansible

Uma das maneiras mais simples de usar o Ansible é usando comandos ad-hoc. Eles podem ser usados ​​quando você deseja emitir alguns comandos em um servidor ou em vários servidores. Os comandos ad-hoc não são armazenados para usos futuros, mas representam uma maneira rápida de interagir com os servidores desejados.

Para este tutorial do Ansible, um arquivo simples de hosts de dois servidores será configurado, contendo host1 e host2.

Você pode ter certeza de que os hosts estão acessíveis no servidor ansible emitindo um comando ping em todos os hosts.

[root@ansible-server test_ansible]# ansible -i hosts all -m ping
host1 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
host2 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Explicação:

1. Status do comando, neste caso, SUCCESS
2. Host no qual o comando foi executado
3. O comando emitido através do parâmetro -m, neste caso, ping
4. Com o parâmetro -i, você pode apontar para o arquivo hosts.

Você pode emitir o mesmo comando somente em um host específico, se necessário.

[root@ansible-server test_ansible]# ansible -i hosts all -m ping --limit host2
host2 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Explicação:

1. O parâmetro limite pode ser usado para emitir comandos apenas em hosts específicos no arquivo do host
2. Nome do host conforme definido no arquivo de inventário

Se precisar copiar um arquivo para vários destinos rapidamente, você pode usar o módulo de cópia em ansible que usa SCP. Portanto, o comando e sua saída ficam assim:

[root@ansible-server test_ansible]# ansible -i hosts all -m copy -a "src=/root/test_ansible/testfile dest=/tmp/testfile"
host1 | SUCCESS => {
    "changed": true,
    "checksum": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
    "dest": "/tmp/testfile",
    "gid": 0,
    "group": "root",
    "md5sum": "d41d8cd98f00b204e9800998ecf8427e",
    "mode": "0644",
    "owner": "root",
    "size": 0,
    "src": "/root/.ansible/tmp/ansible-tmp-1562216392.43-256741011164877/source",
    "state": "file",
    "uid": 0
}
host2 | SUCCESS => {
    "changed": true,
    "checksum": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
    "dest": "/tmp/testfile",
    "gid": 0,
    "group": "root",
    "md5sum": "d41d8cd98f00b204e9800998ecf8427e",
    "mode": "0644",
    "owner": "root",
    "size": 0,
    "src": "/root/.ansible/tmp/ansible-tmp-1562216392.6-280302911361278/source",
    "state": "file",
    "uid": 0
}

Explicação:

1. Módulo de cópia definido
2. Os argumentos do módulo, neste caso, são o caminho absoluto de origem e o caminho absoluto de destino.
3. Saída do comando Ansible refletindo o sucesso do comando de cópia e outros detalhes, como somas de verificação sha1 ou md5 para verificação de integridade de arquivo e metadados como proprietário, tamanho ou permissões. Ansible possui vários módulos que interagem com instaladores usados, como yum, apt, dnf, etc.

No próximo exemplo, você descobrirá como instalar um pacote através do módulo yum em dois hosts Centos.

[root@ansible-server test_ansible]# ansible -i hosts all -m yum -a 'name=ncdu state=present'
host1 | SUCCESS => {
    "changed": true,
    "msg": "",
    "rc": 0,
    "results": [


"Loaded plugins: fastestmirror\nLoading mirror speeds from cached hostfile\n * base: mirror.netsite.dk\n * elrepo: mirrors.xservers.ro\n * epel: fedora.mirrors.telekom.ro\n * extras: centos.mirrors.telekom.ro\n * remi-php70: remi.schlundtech.de\n * remi-safe: remi.schlundtech.de\n * updates: centos.mirror.iphh.net\nResolving Dependencies\n--> Running transaction check\n---> Package ncdu.x86_64 0:1.14-1.el7 will be installed\n--> Finished Dependency Resolution\n\nDependencies Resolved\n\n================================================================================\n Package         Arch              Version                Repository       Size\n================================================================================\nInstalling:\n ncdu            x86_64            1.14-1.el7             epel             51 k\n\nTransaction Summary\n================================================================================\nInstall  1 Package\n\nTotal download size: 51 k\nInstalled size: 87 k\nDownloading packages:\nRunning transaction check\nRunning transaction test\nTransaction test succeeded\nRunning transaction\n  Installing : ncdu-1.14-1.el7.x86_64                                       1/1 \n  Verifying  : ncdu-1.14-1.el7.x86_64                                       1/1 \n\nInstalled:\n  ncdu.x86_64 0:1.14-1.el7                                                      \n\nComplete!\n"
    ]
}
host2 | SUCCESS => {
    "changed": true,
    "msg": "",
    "rc": 0,
    "results": [
        "Loaded plugins: fastestmirror\nLoading mirror speeds from cached hostfile\n * base: mirror.netsite.dk\n * elrepo: mirrors.leadhosts.com\n * epel: mirrors.nav.ro\n * extras: centos.mirrors.telekom.ro\n * remi-php70: mirrors.uni-ruse.bg\n * remi-safe: mirrors.uni-ruse.bg\n * updates: centos.mirror.iphh.net\nResolving Dependencies\n--> Running transaction check\n---> Package ncdu.x86_64 0:1.14-1.el7 will be installed\n--> Finished Dependency Resolution\n\nDependencies Resolved\n\n================================================================================\n Package         Arch              Version                Repository       Size\n================================================================================\nInstalling:\n ncdu            x86_64            1.14-1.el7             epel             51 k\n\nTransaction Summary\n================================================================================\nInstall  1 Package\n\nTotal download size: 51 k\nInstalled size: 87 k\nDownloading packages:\nRunning transaction check\nRunning transaction test\nTransaction test succeeded\nRunning transaction\n  Installing : ncdu-1.14-1.el7.x86_64                                       1/1 \n  Verifying  : ncdu-1.14-1.el7.x86_64                                       1/1 \n\nInstalled:\n  ncdu.x86_64 0:1.14-1.el7                                                      \n\nComplete!\n"
    ]
}

Explicação:

1. O módulo Yum é usado neste exemplo
2. Ele define os argumentos do módulo e, neste caso, você escolherá o nome do pacote e seu estado. Se o estado estiver ausente, por exemplo, o pacote será pesquisado e se encontrado, removido
3. Quando colorido em amarelo, você verá a saída do comando ansible com o estado alterado, ou seja, neste caso, que o pacote foi encontrado e instalado.
4. Status do comando yum install emitido via ansible. Neste caso o pacote ncdu.x86_64 0:1.14-1.el7 foi instalado.

Claro, todas as opções do instalador do yum podem ser usadas via ansible, incluindo atualização, instalação, versão mais recente ou remoção.

No exemplo abaixo, o mesmo comando foi emitido para remover o pacote ncdu instalado anteriormente.

[root@ansible-server test_ansible]# ansible -i hosts all -m yum -a 'name=ncdu state=absent'
host1 | SUCCESS => {
    "changed": true,
    "msg": "",
    "rc": 0,
    "results": [
        "Loaded plugins: fastestmirror\nResolving Dependencies\n--> Running transaction check\n---> Package ncdu.x86_64 0:1.14-1.el7 will be erased\n--> Finished Dependency Resolution\n\nDependencies Resolved\n\n================================================================================\n Package         Arch              Version               Repository        Size\n================================================================================\nRemoving:\n ncdu            x86_64            1.14-1.el7            @epel             87 k\n\nTransaction Summary\n================================================================================\nRemove  1 Package\n\nInstalled size: 87 k\nDownloading packages:\nRunning transaction check\nRunning transaction test\nTransaction test succeeded\nRunning transaction\n  Erasing    : ncdu-1.14-1.el7.x86_64                                       1/1 \n  Verifying  : ncdu-1.14-1.el7.x86_64                                       1/1 \n\nRemoved:\n  ncdu.x86_64 0:1.14-1.el7                                                      \n\nComplete!\n"
    ]
}
host2 | SUCCESS => {
    "changed": true,
    "msg": "",
    "rc": 0,
    "results": [
        "Loaded plugins: fastestmirror\nResolving Dependencies\n--> Running transaction check\n---> Package ncdu.x86_64 0:1.14-1.el7 will be erased\n--> Finished Dependency Resolution\n\nDependencies Resolved\n\n================================================================================\n Package         Arch              Version               Repository        Size\n================================================================================\nRemoving:\n ncdu            x86_64            1.14-1.el7            @epel             87 k\n\nTransaction Summary\n================================================================================\nRemove  1 Package\n\nInstalled size: 87 k\nDownloading packages:\nRunning transaction check\nRunning transaction test\nTransaction test succeeded\nRunning transaction\n  Erasing    : ncdu-1.14-1.el7.x86_64                                       1/1 \n  Verifying  : ncdu-1.14-1.el7.x86_64                                       1/1 \n\nRemoved:\n  ncdu.x86_64 0:1.14-1.el7                                                      \n\nComplete!\n"
    ]
}

Explicação:

1. A saída do comando yum mostra que o pacote foi removido.

Outro recurso útil e essencial que o ansible utiliza para interagir com o servidor do cliente é reunir alguns fatos sobre o sistema. Assim, ele busca informações de hardware, software e versionamento do sistema e armazena cada valor em uma variável que pode ser usada posteriormente.

Se você precisar de informações detalhadas sobre os sistemas a serem modificados via ansible, o próximo comando pode ser usado. O módulo de configuração reúne fatos das variáveis ​​do sistema.

Os comandos do playbook Ansible usam o formato YAML, portanto, não há muita sintaxe necessária, mas o recuo deve ser respeitado. Como o nome diz, um manual é uma coleção de peças. Através de um playbook, você pode designar funções específicas para alguns hosts e outras funções para outros hosts. Ao fazer isso, você pode orquestrar vários servidores em cenários muito diversos, tudo em um único manual.

Para ter todos os detalhes precisos antes de continuar com os exemplos do manual Ansible, devemos primeiro definir uma tarefa. Estas são a interface para módulos ansible para funções e manuais.

Agora, vamos aprender o manual do Ansible por meio de um exemplo com um manual com uma peça, contendo várias tarefas conforme abaixo:

---

- hosts: group1
  tasks:
  - name: Install lldpad package
    yum:
      name: lldpad
      state: latest
  - name: check lldpad service status
    service:
      name: lldpad
      state: started

No exemplo do manual Ansible acima, o grupo1 de hosts no arquivo do host é direcionado para instalação do pacote lldpad usando o módulo yum e posteriormente o serviço lldpad criado após a instalação é iniciado usando o módulo de serviço usado principalmente para interagir com o conjunto systemd.

Explicação:

1. Grupo de hosts nos quais o playbook será executado
2. O módulo Yum é usado nesta tarefa para instalação do lldpad
3. O módulo de serviço é usado para verificar se o serviço está funcionando após a instalação

Cada playbook ansible funciona com um arquivo de inventário. O arquivo de inventário contém uma lista de servidores divididos em grupos para melhor controle de detalhes como Endereço IP e porta SSH para cada host.

O arquivo de inventário que você pode usar para este exemplo de manual do Ansible é semelhante ao abaixo. Existem dois grupos, denominados group1 e group2, cada um contendo host1 e host2 respectivamente.

[group1]
host1 ansible_host=192.168.100.2 ansible_ssh_port=22
[group2]
host2 ansible_host=192.168.100.3 ansible_ssh_port=22

Explicação:

1. Nome do grupo
2. Hostname, com endereço IP e porta ssh, neste caso, o padrão, 22.

Outro exemplo útil do manual Ansible contendo, desta vez, duas jogadas para dois hosts é o próximo. Para o primeiro grupo de hosts, grupo1, o selinux estará habilitado. Se estiver habilitado, uma mensagem aparecerá na tela do host.

Para o segundo grupo de hosts, o pacote httpd será instalado somente se ansible_os_family for RedHat e ansible_system_vendor for HP.

Ansible_os_family e ansible_system_vendor são variáveis ​​reunidas com a opção Gather_facts e podem ser usadas como neste exemplo condicional.

---

- hosts: group1
  tasks:
  - name: Enable SELinux
    selinux:
      state: enabled
    when: ansible_os_family == 'Debian'
    register: enable_selinux

  - debug:
      Imsg: "Selinux Enabled. Please restart the server to apply changes."
    when: enable_selinux.changed == true

- hosts: group2
  tasks:
  - name: Install apache
    yum:
      name: httpd
      state: present
    when: ansible_system_vendor == 'HP' and ansible_os_family == 'RedHat'

Explicação:

1. Exemplo da cláusula quando, neste caso, o tipo de sistema operacional é Debian. A variável ansible_os_family é coletada por meio da funcionalidade Gather_facts.
2. A saída da tarefa é registrada para uso futuro, com o nome enable_selinux
3. Outro exemplo da cláusula quando. Neste caso, uma mensagem será exibida para o usuário host se o SELinux já estiver habilitado antes.
4. Outro exemplo da cláusula when que consiste em duas regras

Além das tarefas, existem também algumas tarefas específicas chamadas manipuladores. Os manipuladores devem ter um nome exclusivo em todo o playbook. Elas funcionam da mesma maneira que uma tarefa normal, mas um manipulador pode ser notificado por meio de um notificador.

Se um manipulador não for notificado durante a execução do manual, ele não será executado. No entanto, se mais de uma tarefa notificar um manipulador, este será executado apenas uma vez após todas as tarefas serem concluídas.

No exemplo mostrado abaixo, você pode ver como uma tarefa específica possui uma seção de notificação que chama outra tarefa. Se a saída da primeira tarefa for alterada, uma tarefa manipuladora será chamada. O melhor exemplo é alterar um arquivo de configuração e depois reiniciar esse serviço específico.

---

- hosts: group2
  tasks:
  - name: sshd config file modify port
    lineinfile:
     path: /etc/ssh/sshd_config
     regexp: 'Port 28675'
     line: '#Port 22'
    notify:
       - restart sshd
handlers
    - name: restart sshd
      service: sshd
        name: sshd
        state: restarted

Neste caso, se a primeira tarefa, “porta de modificação do arquivo de configuração sshd” for alterada, o que significa que se a porta não for 28675 em primeiro lugar, ela será modificada e a tarefa notificará o manipulador com o mesmo nome para executar e reiniciará o serviço sshd.

Explicação:

1. Exemplo de um notificador
2. Exemplo de um manipulador

Funções Ansible

Ao lidar com manuais extensos, é mais fácil dividir as tarefas em funções. Isso também ajuda na reutilização das funções no futuro. As funções são uma coleção de tarefas, que podem ser movidas de um playbook para outro, podem ser executadas de forma independente, mas apenas por meio de um arquivo de playbook.

As funções são armazenadas em diretórios separados e possuem uma estrutura de diretório específica.

[root@ansible-server test2]# tree
.
`-- role1
    |-- defaults
    |   `-- main.yml
    |-- handlers
    |   `-- main.yml
    |-- meta
    |   `-- main.yml
    |-- README.md
    |-- tasks
    |   `-- main.yml
    |-- tests
    |   |-- inventory
    |   `-- test.yml
    `-- vars
        `-- main.yml

7 directories, 8 files

O arquivo yaml no diretório defaults contém uma lista de variáveis ​​padrão que devem ser usadas junto com o playbook. O diretório handlers é usado para armazenar manipuladores. O metadiretório deve conter informações sobre o autor e as dependências de função. No diretório de tarefas, está o arquivo yaml principal da função.

O diretório de testes contém um arquivo de playbook yaml de amostra e um arquivo de inventário de amostra e é usado principalmente para fins de teste antes de criar a função real.

O diretório vars contém o arquivo yaml no qual serão definidas todas as variáveis ​​utilizadas pela função. Os modelos de diretório e os arquivos de diretório devem conter arquivos e modelos que serão usados ​​pelas tarefas na função.

Para criar a árvore de diretórios para uma função, você deve usar o seguinte comando com o último parâmetro, o nome da função:

[root@ansible-server test2]# ansible-galaxy init role1

Ansible também funciona bem com modelos. Como linguagem de modelagem, ele usa Jinja2.

No próximo exemplo, você descobrirá a aparência de um modelo jinja2 básico e o usará em uma função.

No tempo de execução, dependendo, digamos, em qual datacenter seu servidor está localizado, você pode selecionar entre mais de um nameserver, cada um correspondendo a um datacenter, usando a variável “resolver_ip_addresses”.

{% for resolver in resolver_ip_addresses %}
nameserver {{ resolver }}
{% endfor %}

options timeout:1
options attempts:5
options rotate

Neste exemplo, no diretório do playbook, estão definidas algumas variáveis, incluindo uma variável chamada resolver_ip_addresses com valores diferentes dependendo do datacenter.

- name: Set resolver for server
  template:
    src: dns.j2
    dest: /etc/resolv.conf
    group: root
    owner: root
    mode: "0644"
    tag: resolver	

Explicação:

1. Nome do modelo a ser usado. O modelo está localizado no diretório de modelos no caminho da função
2. Caminho de destino do nome do arquivo a ser substituído pelo modelo, no lado do cliente.
3. Permissões do arquivo de destino

As tarefas de funções também podem ter um campo tag, que possui um nome atribuído. Mais de uma tarefa pode compartilhar a mesma tag. Ao executar um playbook ansible, você também pode especificar a tag, para que essas tarefas sejam executadas.

Estudo de caso Ansible

Nesta seção, analisaremos um estudo de caso de um playbook essencial do ansible que possui três funções. O objetivo disso é dar um exemplo prático do que falamos antes. Alguns dos exemplos usados ​​anteriormente neste tutorial do manual Ansible serão adaptados e usados ​​neste manual.

Abaixo está a estrutura de diretórios do manual. O arquivo Yaml que será utilizado será p4.yml.

[root@ansible-server test_ansible]# ls -lrth
total 16K
-rw-r--r--. 1 root root   0 Jul  3 10:13 testfile
-rw-r--r--. 1 root root 203 Jul  3 13:30 p1.yml
-rw-r--r--. 1 root root 125 Jul  3 15:00 hosts
-rw-r--r--. 1 root root 488 Jul  3 16:40 p2.yml
-rw-r--r--. 1 root root 188 Jul  4 17:33 p4.yml
drwxr-xr-x. 5 root root  47 Jul  4 17:35 roles
[root@ansible-server test_ansible]# cd roles
[root@ansible-server roles]# ls -lrth
total 12K
drwxr-xr-x. 9 root root 4.0K Jul  4 12:52 httpd
drwxr-xr-x. 9 root root 4.0K Jul  4 13:55 selinux
drwxr-xr-x. 9 root root 4.0K Jul  4 16:54 resolver

O playbook tem três funções, uma chamada resolvedor que define um servidor de nomes específico nos servidores, copiando um arquivo do servidor para o destino /etc/resolv.conf. Outro se chama httpd e instala o pacote httpd com módulo yum, e o terceiro habilita o SELinux e notifica o usuário logado para reinicializar o sistema. Cada função foi criada usando o comando ansible-galaxy.

Função do resolvedor, tarefa main.yml:

Função HTTP, tarefa main.yml:

Função Selinux, tarefa main.yml:

Abaixo está o manual p4.yml definido. Ele será executado em todos os hosts, se não for especificado de outra forma na linha de comando, será executado como usuário root na porta 22 (SSH), coletará fatos antes de executar as funções e executará todas as três funções mencionadas anteriormente. Cada função pode ser executada de forma independente, especificando a tag na linha de comando do ansible-playbook com o parâmetro –t.

---

- hosts: all
  user: root
  port: 22
  gather_facts: True
  roles:
    - { role: selinux, tags: selinux }
    - { role: httpd, tags: httpd }
    - { role: resolver, tags: resolver }

Executando o playbook p4.yml em dois hosts e interpretando a saída. O mesmo comando pode ser executado com o parâmetro –check para uma simulação. Caso queira usar autenticação por senha, use o parâmetro -k.

Explicação:

1. Comando Ansible-playbook que executa p4.yml
2. O Playbook ignora a função SELinux porque já está habilitado.
3. Ansible descobriu que o pacote httpd já está instalado, então ele retorna ok.
4. O resolvedor foi definido e o resolvedor de função teve o status alterado.

Folha de referências dos comandos Ansible

Instale o repositório EPEL em sistemas Centos/RHEL

[root@ansible-server ~]# sudo yum install epel-release

Instale o pacote ansible em sistemas Centos/RHEL

[root@ansible-server ~]# sudo  yum install -y ansible

Execute uma atualização nos pacotes no Debian/Ubuntu sistemas

$ sudo apt update

Instale o pacote software-properties-common no Debian/Ubuntu sistemas

$ sudo apt install software-properties-common

Instalar o arquivo de pacotes pessoais do Ansible no Debian/Ubuntu sistemas

$ sudo apt-add-repository ppa:ansible/ansible

Instale o ansible no Debian/Ubuntu sistemas

$ sudo apt update
$ sudo apt install ansible

Emita um comando ping em todos os servidores definidos no arquivo de inventário denominado hosts

 
[root@ansible-server test_ansible]# ansible -i hosts all -m ping

Emita um comando ping apenas no host2

[root@ansible-server test_ansible]# ansible -i hosts all -m ping --limit host2

Copie o arquivo “testfile” em todos os hosts no arquivo de inventário

[root@ansible-server test_ansible]# ansible -i hosts all -m copy -a "src=/root/test_ansible/testfile dest=/tmp/testfile"

Instale o pacote ncdu em todos os hosts

[root@ansible-server test_ansible]# ansible -i hosts all -m yum -a 'name=ncdu state=present'

Remova o pacote ncdu em todos os hosts

[root@ansible-server test_ansible]# ansible -i hosts all -m yum -a 'name=ncdu state=absent'

Construa a estrutura de diretórios para a função denominada role1.

[root@ansible-server test2]# ansible-galaxy init role1

Manual p4.yml de simulação

[root@ansible-server test_ansible]# ansible-playbook -i hosts p4.yml --check

Execute o playbook p4.yml com autenticação por senha para todos os hosts

[root@ansible-server test_ansible]# ansible-playbook -i hosts p4.yml -k

Resumo

Em um mundo com tecnologia que muda continuamente em um ritmo rápido e cresce incrivelmente rápido ao mesmo tempo, os administradores de sistemas e engenheiros de devops devem pensar em diferentes abordagens sobre como automatizar tarefas rotineiras e orquestrar grandes conjuntos de servidores.

Embora existam muitos alternativa ao Ansible (Chef, Puppet) que fazem a mesma coisa com algumas diferenças, o Ansible conseguiu superar todos eles com sua simplicidade, segurança aprimorada e, o mais importante, sua curva de aprendizado suave. Devido a essas qualidades e à rápida adoção do Ansible, criamos um tutorial cheio de exemplos para que você tenha uma primeira experiência ainda mais integrada ao trabalhar com o Ansible.

Neste tutorial básico do Ansible, descrevemos o ansible e falamos um pouco sobre sua história. Mencionamos os pontos fortes do Ansible e as vantagens que o ansible pode trazer para a automação e orquestração de infraestruturas de diversos portes. Definimos os termos essenciais usados ​​pelo Ansible e definimos a estrutura dos playbooks do Ansible. Exemplos completos acompanharam todas as informações com explicações detalhadas.