britho
commented
3 years ago Neste exercício, você escreverá e executará um playbook do Ansible.
Resultados
Você deverá ser capaz de escrever um playbook usando a sintaxe YAML básica e a estrutura de playbook do Ansible e executá-lo com êxito usando o comando ansible-playbook.
Faça login na workstation como student usando a senha student.
Na workstation, execute o comando lab playbook-basic start. Essa função garante que os hosts gerenciados serverc.lab.example.com e serverd.lab.example.com estejam acessíveis na rede. Ela também garante que o arquivo de configuração e o arquivo de inventário corretos do Ansible sejam instalados no nó de controle.
[student@workstation ~]$ lab playbook-basic start
O diretório de trabalho /home/student/playbook-basic foi criado na workstation para este exercício. Esse diretório já foi preenchido com um arquivo de configuração ansible.cfg e também um arquivo de inventário inventory, o que define um grupo web que inclui ambos os hosts gerenciados listados acima como membros.
Nesse diretório, use um editor de texto para criar um playbook chamado site.yml. Esse playbook contém uma ação, que deve se direcionar a membros do grupo de host web. O playbook deve usar tarefas para garantir que as seguintes condições sejam atendidas nos hosts gerenciados:
O pacote httpd esteja presente, usando o módulo yum.
O arquivo files/index.html local seja copiado para /var/www/html/index.html em cada host gerenciado usando o módulo copy.
O serviço httpd seja iniciado e esteja habilitado, usando o módulo service. Você pode usar o comando ansible-doc para ajudá-lo a entender as palavras-chave necessárias para cada um dos módulos.
Depois que o playbook for criado, verifique sua sintaxe e, então, use ansible-playbook para executá-lo e implementar a configuração.
Mude para o diretório /home/student/playbook-basic.
[student@workstation ~]$ cd ~/playbook-basic
Use o editor de texto para criar um novo playbook chamado /home/student/playbook-basic/site.yml. Comece a escrever uma ação direcionada aos hosts no grupo de hosts web.
Crie e abra o ~/playbook-basic/site.yml. A primeira linha do arquivo deve ter três traços para indicar o início do playbook.
---
A próxima linha inicia a ação. Ela precisa começar com um traço e um espaço antes da primeira palavra-chave da ação. Nomeie a ação com uma string arbitrária documentando qual é o propósito da ação, usando a palavra-chave name.
---
- name: Install and start Apache HTTPD
Adicione um par de palavra-chave e valor hosts para especificar que a ação é executada no grupo de hosts web do inventário. Certifique-se de que a palavra-chave hosts tem recuo de dois espaços de modo que se alinhe à palavra-chave name na linha anterior.
O arquivo site.yml completo deve aparecer com o seguinte conteúdo:
---
- name: Install and start Apache HTTPD
hosts: web
Continue para editar o arquivo /home/student/playbook-basic/site.yml e adicione uma palavra-chave tasks e as três tarefas para sua ação que foram especificadas nas instruções.
Adicione uma palavra-chave tasks com um recuo de dois espaços (alinhada com a palavra-chave hosts) para iniciar a lista de tarefas. Seu arquivo deve aparecer com o seguinte conteúdo:
---
- name: Install and start Apache HTTPD
hosts: web
tasks:
Adicione a primeira tarefa. Faça um recuo de quatro espaços e inicie a tarefa com um traço e um espaço e, então, dê um nome à tarefa, como httpd package is present. Use o módulo yum para essa tarefa. Recue mais dois espaços nas palavras-chave do módulo; configure o nome do pacote como httpd e o estado do pacote como present. A tarefa deverá aparecer com o seguinte conteúdo:
- name: httpd package is present
yum:
name: httpd
state: present
Adicione a segunda tarefa: Corresponda ao formato da tarefa anterior e dê um nome à tarefa, como correct index.html is present. Use o módulo copy. As palavras-chave do módulo devem definir a chave src como files/index.html e a chave dest como /var/www/html/index.html. A tarefa deverá aparecer com o seguinte conteúdo:
- name: correct index.html is present
copy:
src: files/index.html
dest: /var/www/html/index.html
Adicione a terceira tarefa para iniciar e habilitar o serviço httpd. Corresponda ao formato das duas tarefas anteriores e dê um nome à nova tarefa, como httpd is started. Use o módulo service para essa tarefa. Defina a chave name do serviço como httpd, a chave state como started e a chave enabled como true. A tarefa deverá aparecer com o seguinte conteúdo:
- name: httpd is started
service:
name: httpd
state: started
enabled: true
Todo o seu playbook do Ansible site.yml deve corresponder ao seguinte exemplo: Certifique-se de que o recuo das palavras-chave da ação, a lista de tarefas e as palavras-chave de cada tarefa estejam todas corretas.
---
- name: Install and start Apache HTTPD
hosts: web
tasks:
- name: httpd package is present
yum:
name: httpd
state: present
- name: correct index.html is present
copy:
src: files/index.html
dest: /var/www/html/index.html
- name: httpd is started
service:
name: httpd
state: started
enabled: true
Salve o arquivo e feche o editor de texto.
Antes de executar seu playbook, execute o comando ansible-playbook --syntax-check site.yml para verificar sua sintaxe. Se ela relatar algum erro, corrija-o antes de ir para a próxima etapa. Você verá uma saída semelhante à seguinte:
[student@workstation playbook-basic]$ ansible-playbook --syntax-check site.yml
playbook: site.yml
Execute o playbook. Leia a saída gerada para garantir que todas as tarefas foram concluídas com êxito.
[student@workstation playbook-basic]$ ansible-playbook site.yml
PLAY [Install and start Apache HTTPD] ******************************************
TASK [Gathering Facts] *********************************************************
ok: [serverd.lab.example.com]
ok: [serverc.lab.example.com]
TASK [httpd package is present] ************************************************
changed: [serverd.lab.example.com]
changed: [serverc.lab.example.com]
TASK [correct index.html is present] *******************************************
changed: [serverd.lab.example.com]
changed: [serverc.lab.example.com]
TASK [httpd is started] ********************************************************
changed: [serverd.lab.example.com]
changed: [serverc.lab.example.com]
PLAY RECAP *********************************************************************
serverc.lab.example.com : ok=4 changed=3 unreachable=0 failed=0
serverd.lab.example.com : ok=4 changed=3 unreachable=0 failed=0
Se tudo tiver corrido bem, você deverá ser capaz de executar o playbook uma segunda vez e ver todas as tarefas concluídas sem nenhuma alteração nos hosts gerenciados.
[student@workstation playbook-basic]$ ansible-playbook site.yml
PLAY [Install and start Apache HTTPD] ******************************************
TASK [Gathering Facts] *********************************************************
ok: [serverd.lab.example.com]
ok: [serverc.lab.example.com]
TASK [httpd package is present] ************************************************
ok: [serverd.lab.example.com]
ok: [serverc.lab.example.com]
TASK [correct index.html is present] *******************************************
ok: [serverc.lab.example.com]
ok: [serverd.lab.example.com]
TASK [httpd is started] ********************************************************
ok: [serverd.lab.example.com]
ok: [serverc.lab.example.com]
PLAY RECAP *********************************************************************
serverc.lab.example.com : ok=4 changed=0 unreachable=0 failed=0
serverd.lab.example.com : ok=4 changed=0 unreachable=0 failed=0
Use o comando curl para verificar se ambos serverc e serverd estão configurados como um servidor HTTPD.
[student@workstation playbook-basic]$ curl serverc.lab.example.com
This is a test page.
[student@workstation playbook-basic]$ curl serverd.lab.example.com
This is a test page.Encerramento
Em workstation, execute o script lab playbook-basic finish para limpar os recursos criados neste exercício.
[student@workstation ~]$ lab playbook-basic finish
Isso conclui o exercício orientado.
Objetivos
Depois de concluir esta seção, você deverá ser capaz de escrever um playbook básico do Ansible e executá-lo usando o comando ansible-playbook.
Playbooks do Ansible e comandos ad hoc
Os comandos ad hoc podem ser executados como uma tarefa simples e única em um conjunto de hosts direcionados como um comando avulso. O verdadeiro poder do Ansible, contudo, está em aprender como usar playbooks para executar múltiplas tarefas complexas em um conjunto de hosts direcionados de uma maneira facilmente reproduzível.
Uma ação é um conjunto ordenado de tarefas executadas em relação a hosts selecionados no inventário. Um playbook é um arquivo de texto contendo uma lista de uma ou mais ações a serem executadas em uma ordem específica.
Os playbooks permitem que você altere um conjunto longo e complexo de tarefas manuais em uma rotina facilmente reproduzível com resultados previsíveis e com êxito. Em um playbook, você pode salvar a sequência de tarefas em uma ação em um formato legível e imediatamente executável. As tarefas em si, devido à maneira na qual elas foram escritas, documentam as etapas necessárias para implantar seu aplicativo ou infraestrutura.
Formato de um playbook do Ansible
Para ajudar você a entender o formato de um playbook, revise este comando ad hoc de um capítulo anterior:
Ele pode ser reescrito como uma ação de tarefa única e salvo em um playbook. O playbook resultante terá o seguinte conteúdo:
--- - name: Configure important user consistently hosts: servera.lab.example.com tasks: - name: newbie exists with UID 4000 user: name: newbie uid: 4000 state: presentUm playbook é um arquivo de texto escrito em formato YAML e é normalmente salvo com a extensão
yml. O playbook usa recuo com caracteres de espaço para indicar a estrutura de seus dados. O YAML não estabelece requisitos rigorosos em relação à quantidade de espaços usada para o recuo, mas há duas regras básicas.Os elementos de dados no mesmo nível da hierarquia (como itens na mesma lista) devem ter o mesmo recuo.
Itens que são filhos de um outro item devem ter mais recuo que os seus pais.
Você também pode adicionar linhas em branco por questões de legibilidade.
Apenas o caractere de espaço pode ser usado como recuo; caracteres de tabulação não são permitidos.
Se você usar o editor de texto vi, poderá aplicar algumas configurações que podem facilitar a edição dos seus playbooks. Por exemplo, você pode adicionar a linha a seguir ao seu arquivo
$HOME/.vimrce, quando vi detectar que você está editando um arquivo YAML, ele fará um recuo com dois espaços quando a tecla Tab for pressionada. As linhas seguintes serão automaticamente recuadas.Um playbook começa com uma linha composta por três traços (
---) como início do marcador de documento. Ele pode terminar em três pontos (...) como final de marcador de documento, embora, na prática, isso seja frequentemente omitido.Entre esses marcadores, o playbook é definido como uma lista de ações. Um item em uma lista YAML começa com um único traço seguido por um espaço. Por exemplo, uma lista YAML poderá aparecer com o seguinte conteúdo:
Em , a linha depois de
---começa com um traço e inicia a primeira ação (e somente ela) na lista de ações.A própria ação é uma coleção de pares de chave-valor. As chaves em uma mesma ação devem ter o mesmo recuo. O exemplo a seguir mostra um trecho YAML com três chaves. As duas primeiras chaves têm valores simples. A terceira tem uma lista de três itens como um valor.
name: just an example hosts: webservers tasks: - first - second - thirdA ação de exemplo original tem três chaves,
name,hostsetasks, porque todas essas chaves têm o mesmo recuo.A primeira linha da ação de exemplo começa com um traço e um espaço (indicando que a ação é o primeiro item de uma lista) e, então, a primeira chave, o atributo
name. A chavenameassocia com a ação uma string arbitrária de rótulo. Isso identifica para que serve a ação. A chavenameé opcional, mas é recomendada, já que ela ajuda a documentar seu playbook. Isso é particularmente útil quando um playbook contém várias ações.A segunda chave na ação é um atributo
hosts, que especifica os hosts nos quais as tarefas da ação são executadas. Assim como o argumento para o comando ansible, o atributohoststoma um padrão de host como um valor, como os nomes de hosts gerenciados ou grupos no inventário.Finalmente, a última chave na ação é o atributo
tasks, cujo valor especifica uma lista de tarefas a serem executadas para esta ação. Este exemplo tem uma única tarefa, que executa o módulousercom argumentos específicos (para garantir que o usuárionewbieexiste e que tem uma UID 4000).tasks: - name: newbie exists with UID 4000 user: name: newbie uid: 4000 state: presentO atributo
tasksé a parte da ação que realmente lista, em ordem, as tarefas a serem executadas nos hosts gerenciados. Cada tarefa na lista é, em si, uma coleção de pares de chave-valor.Neste exemplo, a única tarefa na ação tem duas chaves:
nameé um rótulo opcional que documenta o propósito da tarefa. É recomendável nomear todas as suas tarefas para ajudar a documentar o propósito de cada etapa do processo de automação.useré o módulo a ser executado para esta tarefa. Seus argumentos são passados como uma coleção de pares de chave-valor, que são filhos do módulo (name,uidestate).Abaixo, é apresentado outro exemplo de um atributo
taskscom múltiplas tarefas, usando o móduloservicepara garantir que vários serviços de rede estejam habilitados para iniciar durante o boot:tasks: - name: web server is enabled service: name: httpd enabled: true - name: NTP server is enabled service: name: chronyd enabled: true - name: Postfix is enabled service: name: postfix enabled: trueA ordem na qual as ações e tarefas são listadas em um playbook é importante porque o Ansible as executa na mesma ordem.
Os playbooks que você viu até agora são exemplos básicos, e você verá exemplos mais sofisticados do que pode fazer com ações e tarefas à medida que este curso prosseguir.
Execução de playbooks
O comando ansible-playbook é usado para executar playbooks. O comando é executado no nó de controle e o nome do playbook a ser executado é passado como um argumento:
Quando você executa o playbook, a saída é gerada para mostrar a ação e as tarefas sendo executadas. A saída também relata os resultados de cada tarefa executada.
O exemplo a seguir mostra o conteúdo de um playbook simples e o resultado de sua execução.
Observe que o valor da chave
namede cada ação e tarefa é exibido quando o playbook é executado. (A tarefaGathering Factsé uma tarefa especial que o módulosetupnormalmente executa de forma automática no início de uma ação. Isso é abordado posteriormente no curso). Para playbooks com múltiplas ações e tarefas, a definição dos atributosnametorna fácil monitorar o progresso da execução do playbook.Você também deverá ver que a tarefa
latest httpd version installedéalteradaparaservera.lab.example.com. Isso significa que a tarefa alterou algo nesse host para garantir que sua especificação foi atendida. Neste caso, significa que o pacote httpd provavelmente não foi instalado ou não era a versão mais recente.Em geral, as tarefas nos playbooks do Ansible são idempotentes e é seguro executar o playbook várias vezes. Se os hosts gerenciados direcionados já estiverem no estado correto, nenhuma mudança deve ser feita. Por exemplo, suponha que o playbook do exemplo anterior é executado novamente:
Dessa vez, todas as tarefas foram passadas com o status
oke nenhuma alteração foi relatada.Aumento do detalhamento de saída
A saída padrão fornecida pelo comando ansible-playbook não fornece informações detalhadas de execução de tarefas. O comando ansible-playbook -v oferece informações adicionais, com um total de quatro níveis.
Verificação de sintaxe
Antes de executar um playbook, é recomendável realizar uma verificação para garantir que a sintaxe do conteúdo esteja correta. O comando ansible-playbook oferece uma opção
--syntax-checkque pode ser usada para verificar a sintaxe de um playbook. O exemplo a seguir mostra verificação com êxito da sintaxe de um playbook.Quando uma verificação de sintaxe falha, um erro de sintaxe é reportado. A saída também inclui o local aproximado do problema de sintaxe no playbook. O exemplo a seguir mostra uma verificação de sintaxe de um playbook que falhou, na qual o separador de espaço está ausente após o atributo
nameda ação.Execução de uma simulação
Você pode usar a opção
-Cpara executar uma simulação da execução do playbook. Isso faz com que o Ansible relate que mudanças teriam ocorrido se o playbook fosse executado, mas não faz nenhuma mudança real nos hosts gerenciados.O exemplo a seguir mostra a simulação de um playbook contendo uma tarefa única para garantir que a versão mais recente do pacote httpd esteja instalada em um host gerenciado. Observe que a simulação informa que a tarefa realizaria uma mudança no host gerenciado.
Página do man
ansible-playbook(1)Intro to Playbooks — Ansible Documentation
Playbooks — Ansible Documentation
Check Mode ("Dry Run") — Ansible Documentation