Módulo Ansible Shell

Introducción

En este laboratorio, aprenderás cómo utilizar el módulo Ansible Shell para ejecutar comandos de shell en hosts remotos. El módulo Shell es útil cuando necesitas ejecutar comandos de shell que no están cubiertos por los módulos de Ansible existentes o cuando requieres más flexibilidad y control sobre la ejecución.

Skills Graph

Ejecutar un Comando Simple de Shell

En este paso, ejecutarás un comando simple de shell en un host remoto utilizando el módulo Ansible Shell.

Primero, completa el archivo /home/labex/project/simple_shell_command.yml.
Agrega el siguiente contenido al archivo del 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: El host objetivo para ejecutar este playbook de Ansible es localhost.
• gather_facts: false: Deshabilita la recopilación de información del host.
• shell: ls -l: Especifica el comando a ejecutar.

En resumen, el propósito de este playbook es ejecutar el comando ls -l en el host local y mostrar la salida del comando.

Luego, muestra la salida del comando en el playbook de Ansible.

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

Ejemplo de salida:

[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

Aquí "command_output.stdout_lines":[...] es la salida del comando ls -l en el host objetivo.

Pasar Variables a Comandos de Shell

En este paso, aprenderás cómo pasar variables desde tu playbook de Ansible a comandos de shell ejecutados utilizando el módulo Shell.

Primero, completa el archivo /home/labex/project/pass_variables.yml.
Agrega el siguiente contenido al archivo del 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: El host objetivo para ejecutar este playbook de Ansible es localhost.
• vars: Define una variable llamada directory_path con el valor /home/labex.
• shell: ls "{{ directory_path }}": Ejecuta el comando ls para mostrar el contenido del directorio especificado por la variable directory_path.

En resumen, este playbook ejecuta el comando ls con una variable que representa una ruta de directorio (/home/labex) en el host local y muestra la salida del comando.

Luego, muestra la salida del comando en el playbook de Ansible.

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

Ejemplo de salida:

[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

Aquí "variable_command_output.stdout_lines": [...] es la salida del comando ls /home/labex en el host objetivo.

Manejar Fallos de Comandos

En este paso, aprenderás cómo manejar los fallos de comandos cuando ejecutas comandos de shell utilizando el módulo Shell. Manejarás casos en los que el comando de shell devuelve un código de salida distinto de cero, lo que indica un fallo.

Primero, completa el archivo /home/labex/project/handle_command_failure.yml.
Agrega el siguiente contenido al archivo del 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: El host objetivo para ejecutar este playbook de Ansible es localhost.
• shell: failing-command: Esta línea utiliza el módulo shell para ejecutar el comando failing-command. La salida de este comando se capturará y almacenará en la variable failing_command_output. Dado que el script failing-command no existe, este comando debe fallar.
• ignore_errors: yes: Esta línea instruye a Ansible a ignorar cualquier error que ocurra durante la ejecución del comando failing-command. Esto permite que el playbook continúe ejecutándose incluso si el comando falla.
• debug: Este módulo utiliza el módulo debug para mostrar un mensaje que dice "The command failed. Performing fallback action." Este mensaje solo se mostrará cuando se cumpla la condición failing_command_output.failed, lo que indica que la ejecución del comando anterior falló.

En resumen, el playbook intenta ejecutar un comando que se espera que falle, ignora cualquier error que ocurra durante su ejecución y luego muestra un mensaje que indica que el comando falló y se tomará una acción de respaldo según el estado de fallo del comando.

Luego, muestra la salida del comando en el playbook de Ansible.

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

Ejemplo de salida:

[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

La presencia de "msg": "The command failed. Performing fallback action." indica que la ejecución del comando failing-command falló.

Ejecutar Comandos de Shell Complejos

En este paso, ejecutarás comandos de shell más complejos utilizando el módulo Shell. Explorarás el uso de redirección de comandos, tuberías (pipelines) y estructuras de comandos complejas.

Primero, completa el archivo /home/labex/project/complex_shell_commands.yml.
Agrega el siguiente contenido al archivo del 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: El host objetivo para ejecutar este playbook de Ansible es localhost.
• shell: Redirige la salida del comando ls -l /home/labex al archivo /home/labex/output.txt y utiliza grep para filtrar el contenido relacionado con project.

En resumen, este playbook ejecuta un comando de shell complejo en el host local, filtra y redirige la salida a un archivo y luego muestra la salida de la ejecución del comando.

Luego, ejecuta el comando del playbook de Ansible.

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

Ejemplo de salida:

[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, visualiza el contenido del archivo /home/labex/output.txt:

cat /home/labex/output.txt

Ejemplo de salida:

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

Resumen

¡Felicidades! Has completado con éxito el laboratorio del módulo Ansible Shell. Has aprendido cómo usar el módulo Shell para ejecutar comandos de shell en hosts remotos, pasar variables a los comandos, manejar fallos de comandos y ejecutar comandos de shell complejos.

El módulo Shell ofrece gran flexibilidad y control para ejecutar comandos de shell en tus playbooks de Ansible. Sin embargo, ten precaución al usarlo, ya que ejecutar comandos de shell arbitrarios puede tener implicaciones de seguridad. Asegúrate siempre de confiar en los comandos y de validar cualquier entrada proporcionada por el usuario.

Ahora que tienes una buena comprensión del módulo Shell, puedes aprovecharlo para realizar diversas tareas de automatización y administrar tus hosts remotos de manera eficiente. ¡Que disfrutes scripting con Ansible!