¿Cómo configurar el usuario SSH predeterminado para las conexiones de Ansible?

Introducción

Ansible es una poderosa herramienta de automatización que simplifica la gestión de servidores remotos. Un aspecto crucial de Ansible es la capacidad de establecer conexiones SSH seguras a estos servidores. En este tutorial, exploraremos cómo configurar el usuario SSH predeterminado para las conexiones de Ansible, asegurando un flujo de trabajo fluido y eficiente para sus tareas de gestión de servidores.

Instalación y Configuración de Ansible

Antes de configurar el usuario SSH para Ansible, necesitamos asegurarnos de que Ansible esté correctamente instalado y configurado en nuestro sistema.

Instalación de Ansible

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

sudo apt update
sudo apt install -y ansible

Una vez que la instalación se complete, verifique que Ansible esté instalado correctamente comprobando su versión:

ansible --version

Debería ver una salida similar a la siguiente:

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, x86_64)
  jinja version = 3.0.3
  libyaml = True

Creación de un Directorio de Trabajo de Ansible

A continuación, creemos una estructura de directorios para nuestro proyecto Ansible. Esto nos ayudará a mantener nuestros archivos organizados:

mkdir -p ~/project/ansible/inventory
cd ~/project/ansible

Creación de un Archivo de Inventario Básico

Ansible utiliza archivos de inventario para definir los hosts que gestiona. Creemos un archivo de inventario simple:

echo "[webservers]
localhost ansible_connection=local" > ~/project/ansible/inventory/hosts

Este archivo de inventario define un grupo llamado webservers con un solo host, localhost, e indica a Ansible que utilice una conexión local en lugar de SSH para este host.

Ahora, verifiquemos nuestro inventario:

ansible -i inventory/hosts --list-hosts all

Debería ver una salida como:

  hosts (1):
    localhost

Esto muestra que Ansible reconoce nuestro inventario y los hosts definidos en él.

Comprensión de las Conexiones y Configuración SSH de Ansible

Ansible utiliza principalmente SSH para conectarse a hosts remotos y ejecutar comandos. Exploremos cómo Ansible establece las conexiones SSH y cómo podemos configurar el usuario SSH predeterminado.

Cómo Ansible Utiliza SSH

Por defecto, Ansible intenta utilizar su usuario actual del sistema para establecer conexiones SSH. Esto significa que si ha iniciado sesión como el usuario labex y ejecuta un comando Ansible, Ansible intentará conectarse a los hosts remotos como el usuario labex.

Este comportamiento predeterminado puede no ser siempre lo que desea. Por ejemplo:

• El servidor remoto podría requerir un usuario diferente para el acceso.
• Es posible que desee utilizar un usuario dedicado para las tareas de automatización.
• Diferentes servidores podrían requerir diferentes usuarios.

Jerarquía de Configuración de Ansible

Ansible utiliza una jerarquía de fuentes de configuración para determinar qué usuario SSH utilizar:

1. Opciones de línea de comandos (prioridad más alta)
2. Opciones específicas de la tarea en los playbooks
3. Variables de host y grupo en el inventario
4. Archivo de configuración de Ansible
5. Valores predeterminados (prioridad más baja)

Creemos un archivo de configuración básico de Ansible para entender esto mejor:

cat > ~/project/ansible/ansible.cfg << 'EOF'
[defaults]
inventory = ./inventory/hosts
host_key_checking = False
EOF

Este archivo de configuración le dice a Ansible que:

• Utilice nuestro archivo de inventario por defecto.
• Desactive la comprobación de la clave del host (útil para pruebas en entornos de laboratorio).

Revisemos el archivo que acabamos de crear:

cat ~/project/ansible/ansible.cfg

Debería ver el contenido que acabamos de agregar al archivo.

Prueba de un Comando Ansible Básico

Ahora, ejecutemos un comando Ansible básico para ver el usuario actual:

cd ~/project/ansible
ansible localhost -m command -a "whoami"

La salida debería mostrar:

localhost | CHANGED | rc=0 >>
labex

Esto confirma que Ansible está ejecutando comandos como el usuario actual (labex).

Establecimiento del Usuario SSH Predeterminado para Ansible

Ahora que entendemos cómo Ansible utiliza SSH, exploremos diferentes formas de establecer el usuario SSH predeterminado para nuestras conexiones.

Método 1: Uso del Archivo de Configuración de Ansible

La forma más sencilla de establecer un usuario SSH predeterminado global es a través del archivo de configuración de Ansible. Modifiquemos nuestro archivo ansible.cfg:

cat > ~/project/ansible/ansible.cfg << 'EOF'
[defaults]
inventory = ./inventory/hosts
host_key_checking = False
remote_user = ansible_user
EOF

En esta configuración, agregamos el parámetro remote_user, que le indica a Ansible que utilice ansible_user como el usuario SSH predeterminado para todas las conexiones.

Método 2: Establecimiento del Usuario en el Archivo de Inventario

Otro enfoque es definir el usuario SSH en el archivo de inventario. Este método le permite establecer diferentes usuarios para diferentes hosts o grupos.

Modifiquemos nuestro archivo de inventario:

cat > ~/project/ansible/inventory/hosts << 'EOF'
[webservers]
localhost ansible_connection=local

[dbservers]
db.example.com ansible_user=db_admin

[all:vars]
ansible_user=default_user
EOF

En este ejemplo:

• Hemos agregado un nuevo grupo llamado dbservers con un host db.example.com y especificamos que Ansible debe utilizar el usuario db_admin al conectarse a este host.
• También hemos agregado una variable de grupo ansible_user=default_user que se aplica a todos los hosts a menos que se anule.

Método 3: Uso de Opciones de Línea de Comandos

También puede especificar el usuario SSH directamente en la línea de comandos al ejecutar comandos Ansible:

ansible localhost -m command -a "whoami" -u specific_user

La opción -u le indica a Ansible que utilice specific_user para este comando específico, anulando cualquier usuario definido en los archivos de configuración o en el inventario.

Método 4: Establecimiento del Usuario en Playbooks

Al utilizar playbooks de Ansible, puede especificar el usuario SSH a nivel de play:

Creemos un playbook simple para demostrar esto:

cat > ~/project/ansible/user_demo.yml << 'EOF'
---
- name: Demonstrate user configuration
  hosts: localhost
  remote_user: playbook_user
  
  tasks:
    - name: Show current user
      command: whoami
      register: current_user
      
    - name: Display current user
      debug:
        msg: "Current user is {{ current_user.stdout }}"
EOF

En este playbook, el parámetro remote_user establece el usuario SSH en playbook_user para todas las tareas en este play.

Precedencia de Usuario en Ansible

Comprender la precedencia de estos diferentes métodos es importante:

1. Las opciones de línea de comandos (bandera -u) tienen la prioridad más alta.
2. Configuración a nivel de tarea en playbooks.
3. Configuración a nivel de play en playbooks.
4. Variables de host en el inventario.
5. Variables de grupo en el inventario.
6. Configuración del archivo de configuración (remote_user en ansible.cfg).
7. Usuario predeterminado del sistema (prioridad más baja).

Esto significa que la configuración de usuario más específica anula las más generales.

Prueba y Verificación de la Configuración del Usuario SSH

Ahora que hemos configurado el usuario SSH predeterminado de diferentes maneras, probemos y verifiquemos nuestra configuración.

Prueba de la Configuración del Archivo de Configuración

Primero, ejecutemos un comando Ansible simple para ver si se aplican las configuraciones de nuestro archivo de configuración:

cd ~/project/ansible
ansible localhost -m command -a "whoami"

Dado que nos estamos conectando a localhost con ansible_connection=local, Ansible seguirá ejecutando comandos como el usuario actual, independientemente de la configuración de remote_user. Sin embargo, si se tratara de una conexión remota, Ansible intentaría utilizar el usuario ansible_user que especificamos en la configuración.

Uso de ansible-inventory para Comprobar la Configuración del Usuario

Ansible proporciona un comando llamado ansible-inventory que nos permite ver cómo Ansible interpreta nuestro inventario, incluyendo la configuración del usuario SSH:

ansible-inventory --list

Este comando genera una representación JSON del inventario, mostrando todas las variables asociadas con cada host, incluyendo la configuración del usuario SSH.

Prueba de la Configuración del Usuario con un Playbook

Ejecutemos el playbook que creamos en el paso anterior:

ansible-playbook user_demo.yml

La salida mostrará algo como:

PLAY [Demonstrate user configuration] ******************************************

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

TASK [Show current user] *******************************************************
changed: [localhost]

TASK [Display current user] ****************************************************
ok: [localhost] => {
    "msg": "Current user is labex"
}

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

La salida muestra que el comando todavía se ejecuta como el usuario labex, lo cual es lo esperado porque nos estamos conectando a localhost con ansible_connection=local.

Creación de un Ejemplo de Configuración de Usuario SSH Real

Creemos un ejemplo más realista que demuestre cómo configurar el usuario SSH para hosts remotos. Crearemos un nuevo playbook:

cat > ~/project/ansible/remote_user_example.yml << 'EOF'
---
- name: Example of remote user configuration
  hosts: all
  remote_user: admin_user
  
  tasks:
    - name: This task uses the play-level user (admin_user)
      debug:
        msg: "This would run as admin_user"
      
    - name: This task uses a specific user
      debug:
        msg: "This would run as operator_user"
      remote_user: operator_user
      
    - name: This task uses become to elevate privileges
      debug:
        msg: "This would run as the root user"
      become: true
      become_user: root
EOF

En este playbook:

• Establecemos remote_user: admin_user a nivel de play, lo que se aplica a todas las tareas por defecto.
• La segunda tarea anula esto con remote_user: operator_user.
• La tercera tarea utiliza become: true para elevar los privilegios al usuario root.

Este ejemplo muestra los diferentes niveles en los que puede configurar el usuario SSH en Ansible.

Configuración Avanzada del Usuario SSH y Solución de Problemas

Ahora que hemos cubierto los conceptos básicos de la configuración del usuario SSH predeterminado para Ansible, exploremos algunas técnicas avanzadas y pasos para la solución de problemas.

Uso de Claves SSH con Ansible

Al conectarse a hosts remotos, es una buena práctica utilizar la autenticación de clave SSH en lugar de contraseñas. Veamos cómo configurar la autenticación de clave SSH en Ansible:

cat > ~/project/ansible/ssh_key_example.yml << 'EOF'
---
- name: Example using SSH key authentication
  hosts: all
  remote_user: secure_user
  vars:
    ansible_ssh_private_key_file: ~/.ssh/id_rsa
  
  tasks:
    - name: Show SSH connection details
      debug:
        msg: "Connecting as {{ ansible_user }} using key {{ ansible_ssh_private_key_file }}"
EOF

En este ejemplo:

• Establecemos remote_user: secure_user como el usuario SSH predeterminado.
• Especificamos el archivo de clave privada SSH a utilizar con ansible_ssh_private_key_file.

Establecimiento de Diferentes Usuarios para Diferentes Entornos

En escenarios del mundo real, es posible que desee utilizar diferentes usuarios SSH para diferentes entornos (desarrollo, staging, producción). Veamos cómo lograr esto:

mkdir -p ~/project/ansible/group_vars

Ahora, creemos archivos de variables de grupo para diferentes entornos:

cat > ~/project/ansible/group_vars/development << 'EOF'
---
ansible_user: dev_user
EOF

cat > ~/project/ansible/group_vars/production << 'EOF'
---
ansible_user: prod_user
ansible_ssh_private_key_file: ~/.ssh/prod_key
EOF

Actualice el archivo de inventario para incluir estos grupos de entornos:

cat > ~/project/ansible/inventory/hosts << 'EOF'
[webservers]
localhost ansible_connection=local

[development]
dev.example.com

[production]
prod1.example.com
prod2.example.com

[all:vars]
ansible_user=default_user
EOF

Con esta configuración:

• Los hosts en el grupo development utilizarán el usuario SSH dev_user.
• Los hosts en el grupo production utilizarán el usuario SSH prod_user y una clave SSH específica.
• Todos los demás hosts utilizarán el usuario SSH default_user.

Solución de Problemas de la Configuración del Usuario SSH

Si encuentra problemas con la configuración del usuario SSH en Ansible, aquí hay algunos pasos para la solución de problemas:

1. Compruebe el inventario interpretado por Ansible

Para ver cómo Ansible interpreta su inventario, incluyendo todos los valores de las variables:

ansible-inventory --list

2. Ejecute Ansible con verbosidad

Ejecutar Ansible con mayor verbosidad puede ayudar a identificar problemas de conexión:

ansible localhost -m ping -vvv

La bandera -vvv aumenta el nivel de verbosidad, mostrando información detallada sobre el proceso de conexión SSH.

3. Pruebe la conexión SSH manualmente

Puede probar la conexión SSH manualmente para verificar que el usuario y la clave estén funcionando:

ssh -i ~/.ssh/id_rsa username@hostname

4. Compruebe si hay errores de conexión SSH

Los errores comunes de conexión SSH incluyen:

• Permiso denegado (clave pública) (Permission denied (publickey)): Esto indica un problema con la autenticación de la clave SSH.
• Fallo en la verificación de la clave del host (Host key verification failed): Esto ocurre cuando la clave del host ha cambiado.
• Conexión rechazada (Connection refused): Esto indica que el servicio SSH no se está ejecutando o está bloqueado por un firewall.

5. Cree un playbook de prueba de configuración de Ansible

Creemos un playbook simple para probar nuestra configuración del usuario SSH:

cat > ~/project/ansible/test_ssh_config.yml << 'EOF'
---
- name: Test SSH user configuration
  hosts: all
  gather_facts: no
  
  tasks:
    - name: Display connection information
      debug:
        msg: |
          Connected to: {{ inventory_hostname }}
          User: {{ ansible_user | default('not set') }}
          SSH Key: {{ ansible_ssh_private_key_file | default('not set') }}
EOF

Ejecute este playbook para ver la información de conexión para cada host:

ansible-playbook -i inventory/hosts test_ssh_config.yml

Este playbook le mostrará el usuario SSH y la clave que Ansible está utilizando para cada host, lo que puede ayudar a identificar problemas de configuración.

Resumen

En este laboratorio, ha aprendido a configurar el usuario SSH predeterminado para las conexiones de Ansible utilizando varios métodos. Ahora comprende cómo:

1. Instalar y configurar Ansible con una configuración básica.
2. Configurar el usuario SSH predeterminado a través del archivo de configuración de Ansible.
3. Establecer usuarios SSH en diferentes niveles: inventario, playbook y línea de comandos.
4. Verificar y probar su configuración de usuario SSH.
5. Solucionar problemas comunes de conexión SSH.

Estas habilidades le permitirán administrar su infraestructura de manera más efectiva con Ansible, asegurando conexiones seguras y confiables a sus servidores remotos. Al configurar correctamente el usuario SSH para sus conexiones de Ansible, puede implementar flujos de trabajo de automatización consistentes en diferentes entornos, manteniendo prácticas de seguridad apropiadas.