Dominando o Módulo Shell do Ansible: Libere o Poder dos Comandos Remotos

Introdução

Neste laboratório, você aprenderá como usar o módulo Ansible Shell para executar comandos shell em hosts remotos. O módulo Shell é útil quando você precisa executar comandos shell que não são cobertos por módulos Ansible existentes ou quando você precisa de mais flexibilidade e controle sobre a execução.

Executar um Comando Shell Simples

Nesta etapa, você executará um comando shell simples em um host remoto usando o módulo Ansible Shell.

Primeiro, complete o arquivo /home/labex/project/simple_shell_command.yml. Adicione o seguinte conteúdo ao arquivo playbook:

- name: Execute a Simple Shell Command
  hosts: localhost
  gather_facts: false

  tasks:
    - name: Execute ls -l command
      shell: ls -l
      register: command_output

    - name: Display command output
      debug:
        var: command_output.stdout_lines

hosts: localhost: O host de destino para executar este playbook Ansible é localhost.
gather_facts: false: Desabilita a coleta de informações do host.
shell: ls -l: Especifica o comando a ser executado.

Em resumo, o objetivo deste playbook é executar o comando ls -l no host local e exibir a saída do comando.

Em seguida, exiba a saída do comando no playbook Ansible.

ansible-playbook /home/labex/project/simple_shell_command.yml

Exemplo de saída:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [Execute a Simple Shell Command] ******************************************

TASK [Execute ls -l command] ***************************************************
changed: [localhost]

TASK [Display command output] **************************************************
ok: [localhost] => {
    "command_output.stdout_lines": [
        "total 16",
        "-rwxrwxrwx 1 labex root 285 Mar  8 13:33 complex_shell_commands.yml",
        "-rwxrwxrwx 1 labex root 221 Mar  8 13:33 handle_command_failure.yml",
        "-rwxrwxrwx 1 labex root 222 Mar  8 13:33 pass_variables.yml",
        "-rwxrwxrwx 1 labex root 266 Mar  8 13:36 simple_shell_command.yml"
    ]
}

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Aqui "command_output.stdout_lines":[...] é a saída de ls -l no host de destino.

Passar Variáveis para Comandos Shell

Nesta etapa, você aprenderá como passar variáveis do seu playbook Ansible para comandos shell executados usando o módulo Shell.

Primeiro, complete o arquivo /home/labex/project/pass_variables.yml. Adicione o seguinte conteúdo ao arquivo playbook:

- name: Pass Variables to Shell Commands
  hosts: localhost
  gather_facts: false
  vars:
    directory_path: /home/labex

  tasks:
    - name: Execute ls command with a variable
      shell: ls "{{ directory_path }}"
      register: variable_command_output

    - name: Display variable command output
      debug:
        var: variable_command_output.stdout_lines

hosts: localhost: O host de destino para executar este playbook Ansible é localhost.
vars: Define uma variável chamada directory_path com o valor /home/labex.
shell: ls "{{ directory_path }}": Executa o comando ls para exibir o conteúdo da variável chamada directory_path.

Em resumo, este playbook executa o comando ls com uma variável representando um caminho de diretório (/home/labex) no localhost e exibe a saída do comando.

Em seguida, exiba a saída do comando no playbook Ansible.

ansible-playbook /home/labex/project/pass_variables.yml

Exemplo de saída:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [Pass Variables to Shell Commands] ****************************************

TASK [Execute ls command with a variable] **************************************
changed: [localhost]

TASK [Display variable command output] *****************************************
ok: [localhost] => {
    "variable_command_output.stdout_lines": [
        "Code",
        "Desktop",
        "golang",
        "project"
    ]
}

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Aqui "variable_command_output.stdout_lines": [...] é a saída de ls /home/labex no host de destino.

Lidar com Falhas de Comando

Nesta etapa, você aprenderá como lidar com falhas de comando ao executar comandos shell usando o módulo Shell. Você lidará com casos em que o comando shell retorna um status de saída diferente de zero, indicando uma falha.

Primeiro, complete o arquivo /home/labex/project/handle_command_failure.yml. Adicione o seguinte conteúdo ao arquivo playbook:

- name: Handle Command Failure
  hosts: localhost
  gather_facts: false

  tasks:
    - name: Execute a failing command
      shell: failing-command
      register: failing_command_output
      ignore_errors: yes

    - name: Handle command failure
      debug:
        msg: "The command failed. Performing fallback action."
      when: failing_command_output.failed

hosts: localhost: O host de destino para executar este playbook Ansible é localhost.
shell: failing-command: Esta linha usa o módulo shell para executar o comando failing-command. A saída deste comando será capturada e armazenada na variável failing_command_output. Como o script failing-command não existe, este comando deve falhar.
ignore_errors: yes: Esta linha instrui o Ansible a ignorar quaisquer erros que ocorram durante a execução do failing-command. Isso permite que o playbook continue a ser executado mesmo que o comando falhe.
debug: Este módulo usa o módulo debug para exibir uma mensagem que diz "The command failed. Performing fallback action." (O comando falhou. Executando ação de fallback.) Esta mensagem só será exibida quando a condição failing_command_output.failed for atendida, indicando que a execução do comando anterior falhou.

Em resumo, o playbook tenta executar um comando que deve falhar, ignora quaisquer erros que ocorram durante sua execução e, em seguida, exibe uma mensagem indicando que o comando falhou e uma ação de fallback será tomada com base no status de falha do comando.

Em seguida, exiba a saída do comando no playbook Ansible.

ansible-playbook /home/labex/project/handle_command_failure.yml

Exemplo de saída:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [Handle Command Failure] **************************************************

TASK [Execute a failing command] ***********************************************
fatal: [localhost]: FAILED! => {"changed": true, "cmd": "failing-command", "delta": "0:00:00.009169", "end": "2024-03-08 13:46:22.701946", "msg": "non-zero return code", "rc": 127, "start": "2024-03-08 13:46:22.692777", "stderr": "/bin/sh: line 1: failing-command: command not found", "stderr_lines": ["/bin/sh: line 1: failing-command: command not found"], "stdout": "", "stdout_lines": []}
...ignoring

TASK [Handle command failure] **************************************************
ok: [localhost] => {
    "msg": "The command failed. Performing fallback action."
}

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=1

A presença de "msg": "The command failed. Performing fallback action." indica que a execução deste comando failing-command falhou.

Executar Comandos Shell Complexos

Nesta etapa, você executará comandos shell mais complexos usando o módulo Shell. Você explorará o uso de redirecionamento de comando, pipelines e estruturas de comando complexas.

Primeiro, complete o arquivo /home/labex/project/complex_shell_commands.yml. Adicione o seguinte conteúdo ao arquivo playbook:

- name: Execute Complex Shell Commands
  hosts: localhost
  gather_facts: false

  tasks:
    - name: Execute complex command
      shell: ls -l /home/labex | grep 'project' > /home/labex/output.txt
      register: complex_command_output

    - name: Display complex command output
      debug:
        var: complex_command_output.stdout_lines

hosts: localhost: O host de destino para executar este playbook Ansible é localhost.
shell: Redireciona a saída de ls -l /home/labex para o arquivo /home/labex/output.txt e usa grep para filtrar o conteúdo sobre project.

Em resumo, este playbook executa um comando shell complexo no localhost, filtra e redireciona a saída para um arquivo e, em seguida, exibe a saída da execução do comando.

Em seguida, execute o comando ansible playbook.

ansible-playbook /home/labex/project/complex_shell_commands.yml

Exemplo de saída:

[WARNING]: No inventory was parsed, only implicit localhost is available
[WARNING]: provided hosts list is empty, only localhost is available. Note that
the implicit localhost does not match 'all'

PLAY [Execute Complex Shell Commands] ******************************************

TASK [Execute complex command] *************************************************
changed: [localhost]

TASK [Display complex command output] ******************************************
ok: [localhost] => {
    "complex_command_output.stdout_lines": []
}

PLAY RECAP *********************************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Finalmente, visualize o conteúdo do arquivo /home/labex/output.txt:

cat /home/labex/output.txt

Exemplo de saída:

drwxr-xr-x 1 labex labex 4096 Mar 8 13:49 project

Resumo

Parabéns! Você concluiu com sucesso o laboratório do Módulo Shell do Ansible. Você aprendeu como usar o módulo Shell para executar comandos shell em hosts remotos, passar variáveis para comandos, lidar com falhas de comando e executar comandos shell complexos.

O módulo Shell oferece grande flexibilidade e controle sobre a execução de comandos shell em seus playbooks Ansible. No entanto, tenha cautela ao usá-lo, pois a execução de comandos shell arbitrários pode ter implicações de segurança. Sempre certifique-se de que confia nos comandos e sanitize quaisquer entradas fornecidas pelo usuário.

Agora que você tem um bom entendimento do módulo Shell, pode aproveitá-lo para realizar várias tarefas de automação e gerenciar seus hosts remotos de forma eficiente. Feliz scripting Ansible!