Solución de Problemas de Contraseña de Sudo en Ansible

Introducción

Ansible es una poderosa herramienta de automatización que ayuda a gestionar y configurar servidores sin necesidad de intervención manual. Sin embargo, muchas tareas de Ansible requieren permisos elevados para ejecutarse correctamente. Al ejecutar comandos que necesitan privilegios de administrador, Ansible utiliza el mecanismo sudo, que podría solicitar una contraseña.

En este laboratorio, aprenderá a configurar correctamente los ajustes de contraseña de sudo en los playbooks de Ansible, a comprender los problemas comunes relacionados con sudo y a implementar las mejores prácticas para asegurar que su automatización se ejecute sin problemas con los permisos necesarios.

Instalación de Ansible y Creación de un Playbook Básico

En este primer paso, instalaremos Ansible y crearemos un playbook simple que requiere privilegios sudo. Esto nos ayudará a comprender los requisitos básicos para ejecutar tareas de Ansible con permisos elevados.

Instalación de Ansible

Comencemos instalando Ansible en nuestro sistema. Abra una terminal y ejecute los siguientes comandos:

sudo apt update
sudo apt install -y ansible

Después de que se complete la instalación, verifique que Ansible se haya instalado correctamente:

ansible --version

Debería ver una salida similar a esta, que muestra la versión de Ansible y la información de configuración:

ansible [core 2.12.x]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/labex/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3/dist-packages/ansible
  ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.10.x (main, Ubuntu, linux/x86_64)
  jinja version = 3.0.3
  libyaml = True

Crear un Playbook Básico de Ansible

Ahora, creemos un playbook simple de Ansible que requiere privilegios sudo. Este playbook instalará el paquete htop en el sistema local.

Cree un nuevo directorio para su proyecto Ansible:

mkdir -p ~/project/ansible-sudo-lab
cd ~/project/ansible-sudo-lab

A continuación, cree el archivo de inventario que define los hosts que Ansible gestionará. Para este laboratorio, usaremos localhost:

echo "localhost ansible_connection=local" > inventory

Ahora, cree un playbook básico que requiere privilegios sudo. Abra el editor VSCode y cree un nuevo archivo llamado basic_playbook.yml:

Haga clic en "File" en el menú de WebIDE
Seleccione "New File"
Copie y pegue el siguiente contenido:

---
- name: Basic sudo operation
  hosts: localhost
  become: true ## This enables sudo

  tasks:
    - name: Install htop
      apt:
        name: htop
        state: present
        update_cache: yes

Guarde el archivo como ~/project/ansible-sudo-lab/basic_playbook.yml

Este playbook tiene la directiva become: true, que le dice a Ansible que use sudo para ejecutar las tareas. La tarea en sí intenta instalar el paquete htop utilizando el módulo apt.

Ejecutar el Playbook

Ahora, ejecutemos nuestro playbook y observemos qué sucede:

cd ~/project/ansible-sudo-lab
ansible-playbook -i inventory basic_playbook.yml

Dado que el usuario labex tiene acceso sudo sin contraseña, el playbook debería ejecutarse correctamente sin solicitar una contraseña. Debería ver una salida similar a esta:

PLAY [Basic sudo operation] ******************************************

TASK [Gathering Facts] **********************************************
ok: [localhost]

TASK [Install htop] ************************************************
ok: [localhost]

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

El playbook se ejecutó correctamente porque nuestro usuario actual (labex) ya está configurado con acceso sudo sin contraseña. En los siguientes pasos, exploraremos cómo manejar escenarios donde se requiere una contraseña de sudo.

Comprensión de la Configuración de la Contraseña de Sudo en Ansible

En el paso anterior, creamos un playbook básico que usaba privilegios sudo sin requerir una contraseña. Sin embargo, en muchos escenarios del mundo real, necesitará proporcionar una contraseña de sudo para ejecutar comandos con privilegios. Exploremos cómo manejar las contraseñas de sudo en Ansible.

Cómo Ansible Maneja las Contraseñas de Sudo

Cuando Ansible necesita ejecutar un comando con privilegios elevados en un sistema remoto, utiliza la funcionalidad become. Por defecto, Ansible utiliza el comando sudo para la escalada de privilegios, pero puede configurarlo para usar otros métodos como su, pbrun o pfexec.

Si el usuario que ejecuta Ansible requiere una contraseña para usar sudo, Ansible necesita saber esta contraseña. Hay varias formas de proporcionar la contraseña de sudo a Ansible:

Opción de línea de comandos: -K o --ask-become-pass
Variable del playbook: become_password
Archivo de configuración: ansible.cfg
Ansible Vault: Para almacenar contraseñas de forma segura

Creación de un Usuario de Prueba con Requisito de Contraseña de Sudo

Para demostrar cómo manejar las contraseñas de sudo, creemos un usuario de prueba que requiera una contraseña para las operaciones de sudo:

sudo adduser ansible_test

Cuando se le solicite, ingrese la contraseña ansible123 y complete el proceso de creación del usuario.

A continuación, demos a este usuario privilegios sudo pero requiramos una contraseña:

echo "ansible_test ALL=(ALL) ALL" | sudo tee /etc/sudoers.d/ansible_test

Esta configuración permite al usuario ansible_test usar sudo, pero requerirá la contraseña del usuario cada vez.

Creación de un Playbook con Manejo de Contraseña de Sudo

Ahora, creemos un playbook que demuestre cómo manejar las contraseñas de sudo. Cree un nuevo archivo llamado sudo_password_playbook.yml en el WebIDE:

---
- name: Playbook with sudo password handling
  hosts: localhost
  become: true
  ## We'll provide the become_password when running the playbook

  tasks:
    - name: Get current user
      command: whoami
      register: current_user
      become: false ## This task doesn't need sudo

    - name: Print current user
      debug:
        msg: "Current user is {{ current_user.stdout }}"
      become: false ## This task doesn't need sudo

    - name: Run a command with sudo
      command: apt update
      register: sudo_output

    - name: Print sudo command result
      debug:
        msg: "Command ran with sudo: {{ sudo_output.rc == 0 }}"

Guarde este archivo como ~/project/ansible-sudo-lab/sudo_password_playbook.yml

Ejecución del Playbook con Entrada de Contraseña

Cuando desee ejecutar un playbook como un usuario que requiere una contraseña de sudo, puede usar la opción -K (o --ask-become-pass) para solicitar la contraseña:

ansible-playbook -i inventory sudo_password_playbook.yml -K

Dado que estamos ejecutando como el usuario labex, que tiene sudo sin contraseña, en realidad no se le solicitará una contraseña. Sin embargo, en un entorno de producción donde sudo sin contraseña no está configurado, Ansible le solicitaría que ingrese la contraseña de sudo.

Para simular este escenario con nuestro usuario de prueba, puede ejecutar el siguiente comando (aunque no funcionará completamente en este entorno de laboratorio debido a la falta de configuración de SSH):

ansible-playbook -i inventory sudo_password_playbook.yml -u ansible_test -K

Cuando se le solicite la contraseña BECOME, ingresaría ansible123.

Especificación de la Contraseña de Sudo en una Variable de Ansible

En lugar de ingresar la contraseña de forma interactiva, puede proporcionar la contraseña de sudo como una variable al ejecutar el playbook:

ansible-playbook -i inventory sudo_password_playbook.yml -e "ansible_become_password=ansible123"

Este enfoque es útil para scripts automatizados donde la entrada interactiva no es posible. Sin embargo, expone la contraseña en el historial de la línea de comandos, lo cual es un riesgo de seguridad. En un entorno de producción, debe usar Ansible Vault para almacenar información confidencial de forma segura.

Uso de Ansible Vault para la Gestión Segura de Contraseñas

En el paso anterior, exploramos diferentes formas de proporcionar contraseñas de sudo a los playbooks de Ansible. Sin embargo, almacenar contraseñas en archivos de texto sin formato o pasarlas en la línea de comandos no es seguro. En este paso, aprenderemos a usar Ansible Vault para gestionar de forma segura información sensible como las contraseñas de sudo.

¿Qué es Ansible Vault?

Ansible Vault es una función que le permite cifrar datos sensibles como contraseñas, claves API o certificados. Los archivos cifrados se pueden almacenar de forma segura en sistemas de control de versiones sin exponer la información sensible. Ansible puede descifrar automáticamente estos archivos durante la ejecución del playbook.

Creación de un Archivo Vault Cifrado

Creemos un archivo cifrado para almacenar nuestra contraseña de sudo:

cd ~/project/ansible-sudo-lab
ansible-vault create vault.yml

Se le pedirá que cree una nueva contraseña de vault. Ingrese vaultpassword123 y confírmela.

Después de establecer la contraseña del vault, se abrirá un editor. Ingrese el siguiente contenido en el editor:

---
vault_sudo_password: ansible123

Guarde el archivo y salga del editor.

Ahora, si intenta ver el contenido del archivo vault, verá que está cifrado:

cat vault.yml

Debería ver una salida similar a:

$ANSIBLE_VAULT;1.1;AES256
32623438613466396238613731623338376461653866353031313632316237613561393639613131
3562626166616332386265373761653835356134613561380a363761333362323238663136633439
32343032333832313562353261333530666639643239303436643363393630643639316232303564
3962356162356361370a313038333432353162333462323035323262396233333039326535356662
31363539613432656362326565613232336535393232653939323466323131393362

Uso de Variables Vault en un Playbook

Ahora, creemos un playbook que use la contraseña de sudo cifrada. Cree un nuevo archivo llamado secure_sudo_playbook.yml:

---
- name: Playbook with secure sudo password
  hosts: localhost
  become: true
  become_password: "{{ vault_sudo_password }}"
  vars_files:
    - vault.yml

  tasks:
    - name: Get sudo user
      command: whoami
      register: sudo_user

    - name: Print sudo user
      debug:
        msg: "Running as {{ sudo_user.stdout }}"

    - name: Check sudo access
      command: apt update
      register: apt_result
      failed_when: false

    - name: Print result
      debug:
        msg: "Sudo access successful: {{ apt_result.rc == 0 }}"

Guarde este archivo como ~/project/ansible-sudo-lab/secure_sudo_playbook.yml

Ejecución de un Playbook con Vault

Cuando ejecuta un playbook que incluye un archivo vault cifrado, necesita proporcionar la contraseña del vault. Hay varias formas de hacer esto:

Usando la opción --ask-vault-pass:

ansible-playbook -i inventory secure_sudo_playbook.yml --ask-vault-pass

Cuando se le solicite, ingrese la contraseña del vault: vaultpassword123

Usando un archivo de contraseña del vault:

Primero, cree un archivo que contenga la contraseña del vault:

echo "vaultpassword123" > vault_password_file
chmod 600 vault_password_file

Luego ejecute el playbook con el archivo de contraseña:

ansible-playbook -i inventory secure_sudo_playbook.yml --vault-password-file vault_password_file

Debería ver una salida similar a:

PLAY [Playbook with secure sudo password] ***************************

TASK [Gathering Facts] **********************************************
ok: [localhost]

TASK [Get sudo user] ***********************************************
changed: [localhost]

TASK [Print sudo user] *********************************************
ok: [localhost] => {
    "msg": "Running as root"
}

TASK [Check sudo access] *******************************************
changed: [localhost]

TASK [Print result] ************************************************
ok: [localhost] => {
    "msg": "Sudo access successful: True"
}

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

Mejores Prácticas para la Gestión de Contraseñas de Sudo

Aquí hay algunas mejores prácticas a seguir al gestionar contraseñas de sudo en Ansible:

Siempre use Ansible Vault para cifrar información sensible
Nunca almacene contraseñas de vault en el control de versiones
Use un método seguro para distribuir las contraseñas del vault (por ejemplo, un gestor de contraseñas)
Considere usar un ID de vault para diferentes entornos (desarrollo, staging, producción)
Rote las contraseñas del vault regularmente

En un entorno de producción, también podría considerar usar una herramienta como HashiCorp Vault o AWS Secrets Manager para una gestión de secretos aún más segura.

Solución de Problemas Comunes con las Contraseñas de Sudo

Incluso con una configuración adecuada, podría encontrar problemas con las contraseñas de sudo en Ansible. En este paso, exploraremos los problemas comunes y sus soluciones.

Problemas Comunes con las Contraseñas de Sudo

Estos son algunos problemas comunes que podría encontrar al usar sudo con Ansible:

Contraseña de sudo faltante: Ansible no puede encontrar la contraseña de sudo para ejecutar comandos con privilegios.
Contraseña de sudo incorrecta: La contraseña de sudo proporcionada es incorrecta.
Problemas de configuración de sudo: El usuario de destino no tiene los permisos de sudo correctos.
Sudo requiere un TTY: Algunos sistemas requieren que se asigne un TTY para los comandos sudo.

Exploremos cada uno de estos problemas y sus soluciones.

Creación de un Entorno Problemático para las Pruebas

Para comprender mejor estos problemas, creemos un escenario donde sudo requiere un TTY. Edite el archivo sudoers para nuestro usuario de prueba:

sudo cp /etc/sudoers.d/ansible_test /etc/sudoers.d/ansible_test.bak
echo 'Defaults:ansible_test requiretty' | sudo tee -a /etc/sudoers.d/ansible_test

Esta configuración hace que sudo requiera un TTY cuando el usuario ansible_test ejecuta comandos sudo, lo que puede causar problemas con Ansible.

Creación de un Playbook para la Solución de Problemas

Cree un nuevo playbook llamado troubleshoot_sudo.yml que incluya algunas técnicas comunes de solución de problemas de sudo:

---
- name: Troubleshoot sudo issues
  hosts: localhost
  become: true
  become_method: sudo
  ## We'll provide the become_password when running the playbook

  tasks:
    - name: Check sudo version
      command: sudo --version
      register: sudo_version
      become: false

    - name: Print sudo version
      debug:
        msg: "{{ sudo_version.stdout_lines[0] }}"
      become: false

    - name: Check sudo configuration
      command: sudo -l
      register: sudo_config
      become: false
      failed_when: false

    - name: Print sudo configuration
      debug:
        msg: "{{ sudo_config.stdout_lines }}"
      become: false
      when: sudo_config.rc == 0

    - name: Test sudo command with pty
      command: apt update
      register: sudo_test
      failed_when: false
      vars:
        ansible_become_flags: "-H"

    - name: Print sudo test result
      debug:
        msg: "Sudo command {{ 'succeeded' if sudo_test.rc == 0 else 'failed' }}"

Guarde este archivo como ~/project/ansible-sudo-lab/troubleshoot_sudo.yml

Ejecución del Playbook para la Solución de Problemas

Ejecute el playbook para la solución de problemas:

ansible-playbook -i inventory troubleshoot_sudo.yml -K

Dado que estamos ejecutando como el usuario labex, que tiene sudo sin contraseña, el playbook debería ejecutarse correctamente.

Soluciones Comunes a los Problemas de Contraseña de Sudo

Aquí hay soluciones a los problemas comunes de contraseña de sudo:

1. Contraseña de sudo faltante

Si Ansible falla con un mensaje como "Missing sudo password" (Contraseña de sudo faltante), puede:

Usar la opción -K para solicitar la contraseña de sudo
Establecer la variable ansible_become_password en su inventario o playbook
Usar Ansible Vault para almacenar y proporcionar de forma segura la contraseña de sudo

2. Contraseña de sudo incorrecta

Si la contraseña de sudo es incorrecta:

Verifique dos veces la contraseña que está proporcionando
Verifique que la contraseña del usuario no haya expirado o haya sido cambiada
Verifique si la configuración de sudo ha cambiado en el sistema de destino

3. Problemas de configuración de sudo

Si el usuario no tiene los permisos de sudo correctos:

Verifique el archivo sudoers en el sistema de destino
Verifique que el usuario esté en los grupos correctos
Use sudo -l para verificar los privilegios de sudo del usuario

4. Sudo requiere un TTY

Si sudo requiere un TTY:

Agregue ansible_become_flags: "-H" a su playbook o inventario
Modifique el archivo sudoers para eliminar la opción requiretty
Use la opción pty: true en sus tareas

Restaurar la Configuración Original de Sudo

Restauraremos la configuración original de sudo para nuestro usuario de prueba:

sudo cp /etc/sudoers.d/ansible_test.bak /etc/sudoers.d/ansible_test
sudo rm /etc/sudoers.d/ansible_test.bak

Esto elimina la opción requiretty que agregamos anteriormente.

Resumen

En este laboratorio, ha aprendido a manejar las contraseñas de sudo en los playbooks de Ansible, un desafío común para muchos administradores e ingenieros de DevOps. Aquí hay un resumen de lo que logró:

Instaló Ansible y creó un playbook básico que usa privilegios de sudo
Aprendió diferentes métodos para proporcionar contraseñas de sudo a los playbooks de Ansible
Usó Ansible Vault para almacenar y gestionar de forma segura información sensible
Exploró problemas comunes con las contraseñas de sudo y aprendió a solucionarlos

Estas habilidades le ayudarán a crear playbooks de Ansible más seguros y confiables que puedan manejar varias configuraciones de sudo en diferentes entornos.

Puntos clave de este laboratorio:

Siempre use métodos seguros como Ansible Vault para almacenar información sensible
Comprenda las diferentes formas de proporcionar contraseñas de sudo a Ansible
Sepa cómo solucionar problemas comunes con las contraseñas de sudo
Siga las mejores prácticas para la gestión de contraseñas de sudo en Ansible

Con estas habilidades, ahora puede usar Ansible con confianza para tareas que requieren privilegios elevados, asegurando que su automatización se ejecute sin problemas y de forma segura.

Solución de Problemas: Contraseña de Sudo Faltante en Ansible