Ansible Ubuntu · 11 min read · Dec 20, 2025

Cómo instalar y configurar Ansible en Ubuntu 22.04

Ansible es una herramienta de gestión de configuración muy popular diseñada para simplificar el proceso de control de un gran número de servidores. Puede automatizar el proceso de configuración de nuevos servidores e instalación de aplicaciones con un solo comando o archivo. Puedes controlar tantos servidores y ejecutar procesos en ellos simultáneamente desde un solo nodo. Ansible no requiere ningún software especial que deba ser instalado en los nodos del servidor y puede controlarlos a través de SSH.

En esta guía, aprenderemos cómo instalar y configurar Ansible en un servidor Ubuntu 22.04.

Requisitos previos

  • Dos o más sistemas de servidor que ejecuten Ubuntu 22.04 con el servidor OpenSSH instalado.
  • Tanto el servidor como los nodos son accesibles a través de direcciones IP públicas.
  • Un usuario no root con privilegios sudo está configurado en el servidor Ansible y un usuario root con una contraseña está configurado en los clientes Ansible.

Paso 1 - Instalar Ansible

Usaremos el repositorio oficial de Ansible para instalar su última versión. Agrega el repositorio oficial de Ansible al servidor.

$ sudo add-apt-repository ppa:ansible/ansible

Afortunadamente, Ubuntu viene con Ansible 2.9, que es lo que instalaremos. Ejecuta el siguiente comando para instalar Ansible.

$ sudo apt install ansible -y

Prueba tu instalación ejecutando el siguiente comando.

$ ansible --version
ansible [core 2.13.3rc1]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/navjot/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3/dist-packages/ansible
  ansible collection location = /home/navjot/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.10.4 (main, Jun 29 2022, 12:14:53) [GCC 11.2.0]
  jinja version = 3.0.3
  libyaml = True

Instala y activa el paquete python3-argcomplete para configurar el soporte de finalización de bash de Ansible.

$ sudo apt install python3-argcomplete
$ sudo activate-global-python-argcomplete3

Ahora puedes presionar la tecla Tab para obtener una lista de opciones para el shell bash.

Paso 2 - Configurar el archivo de inventario

Para poder conectarte a múltiples hosts, necesitas un archivo que registre los detalles de los nodos. Este archivo se llama archivo de inventario.

Dependiendo de cuántos servidores desees controlar, el archivo de inventario de Ansible también te permite organizarlos en grupos y subgrupos. También puedes establecer variables personalizadas aplicables a hosts o grupos seleccionados que pueden ser utilizadas posteriormente al pasar las instrucciones.

Ansible viene con un archivo de inventario predeterminado disponible en /etc/ansible/hosts. Ábrelo con el editor Nano.

$ sudo nano /etc/ansible/hosts

Pega el siguiente código al final del archivo.

[servers]
server1 ansible_host=203.0.113.111
server2 ansible_host=203.0.113.112
server3 ansible_host=203.0.113.113

[all:vars]
ansible_python_interpreter=/usr/bin/python3

La sección servers define la lista de nodos a los que deseas conectarte. Puedes crear tantos grupos como desees para organizar los servidores en múltiples grupos.

El grupo all:vars establece el parámetro ansible_python_interpreter en todos los hosts del inventario. Asegura que Ansible use el ejecutable de Python 3 en lugar de Python 2, que ha sido eliminado de las versiones recientes de Ubuntu.

Cuando termines, guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida confirmar tus cambios.

Nota: También puedes crear tu archivo de inventario en cualquier ubicación de tu elección, que luego puedes pasar usando el parámetro -i al ejecutar comandos de Ansible.

Puedes verificar tu lista de inventario con el siguiente comando.

$ ansible-inventory --list -y
all:
  children:
    servers:
      hosts:
        server1:
          ansible_host: 203.0.113.111
          ansible_python_interpreter: /usr/bin/python3
        server2:
          ansible_host: 203.0.113.112
          ansible_python_interpreter: /usr/bin/python3
        server3:
          ansible_host: 203.0.113.113
          ansible_python_interpreter: /usr/bin/python3
    ungrouped: {}

Organizando servidores en grupos y subgrupos

Este es un consejo útil si tienes muchos servidores, algunos de los cuales realizan funciones específicas. Por ejemplo, puedes usar este método para agrupar servidores web y servidores de base de datos por separado. Incluso puedes hacer que un host sea parte de múltiples grupos. Para lograr eso, tu archivo de inventario debería verse algo así:

[webservers]
203.0.113.111
203.0.113.112

[dbservers]
203.0.113.113
server_hostname

[development]
203.0.113.111
203.0.113.113

[production]
203.0.113.112
server_hostname

Paso 3 - Configurar claves SSH

Para que Ansible pueda conectarse a los servidores, debes configurar claves SSH entre tu servidor Ansible y los hosts especificados en el archivo de inventario. Esto funcionará solo si los clientes de Ansible no tienen una clave pública habilitada y tienen una cuenta root habilitada con una contraseña.

Usa los siguientes pasos para crear y configurar una clave SSH para Ansible y sus nodos.

Crea la clave para Ansible.

$ ssh-keygen -t rsa -b 4096 -C "Clave de Ansible"

Copia la clave pública a tus cuentas en los servidores remotos. Para esto, usaremos el comando ssh-copy-id.

$ ssh-copy-id -i $HOME/.ssh/id_rsa.pub [email protected]
$ ssh-copy-id -i $HOME/.ssh/id_rsa.pub [email protected]
$ ssh-copy-id -i $HOME/.ssh/id_rsa.pub [email protected]

Eso es todo. Ahora Ansible debería poder comunicarse con tus servidores.

Configurar claves SSH en nodos con clave pública existente

Si los clientes ya tienen claves públicas habilitadas, entonces tendrás que seguir ciertos pasos adicionales. Para eso, necesitas crear un nuevo usuario accesible solo por Ansible en cada servidor nodo. Ese usuario tendrá privilegios sudo accesibles sin contraseña y solo podrá ser accedido desde tu servidor Ansible.

Para crear un usuario ansible, ejecuta el siguiente comando.

$ sudo adduser ansible

Elige una contraseña fuerte y deja todos los demás campos vacíos.

Ahora, configura el acceso sudo sin contraseña para este usuario a través del siguiente comando.

$ echo "ansible ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/ansible

Ahora que has agregado y configurado el nuevo usuario, puedes copiar la clave SSH desde tu servidor Ansible al servidor nodo usando el siguiente comando.

$ ssh-copy-id [email protected]

Se te pedirá una contraseña para el usuario ansible. Ingrésala y la clave SSH será copiada.

A continuación, desactiva el inicio de sesión basado en contraseña para el usuario ansible en el servidor nodo.

$ sudo usermod -L ansible

Ahora, tu servidor nodo solo es accesible desde el servidor Ansible, ya que solo ese servidor tiene la clave pública para él y no puedes usarla con privilegios sudo en el servidor nodo directamente, ya que el inicio de sesión por contraseña está deshabilitado.

Tendrás que repetir estos pasos para cada servidor nodo. Además, reemplaza el usuario root con el usuario ansible en este tutorial.

Paso 4 - Probar conexión

Después de configurar el archivo de inventario y las claves SSH, debemos verificar si Ansible puede conectarse a los servidores.

Escribe el siguiente comando para verificar la conexión. Este comando probará la conexión a todos los servidores desde el archivo de inventario.

$ ansible all -m ping -u root

Este comando utiliza el módulo ping de Ansible para ejecutar una prueba de conectividad en todos los servidores. Deberías obtener una salida como la siguiente.

server1 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
server2 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
server3 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Si esta es la primera vez que usas Ansible, se te pedirá que confirmes la autenticidad de todos los servidores. Cuando se te pida, escribe yes y presiona ENTER para confirmar.

Paso 5 - Ejecutar algunos comandos básicos

Vamos a ejecutar algunos comandos básicos en los servidores usando Ansible. Para ejecutar cualquier comando en el servidor, se utiliza el siguiente formato.

$ ansible all -a "comando" -u

Verificar uso de disco

Primero, verifiquemos el uso de disco en todos nuestros servidores.

$ ansible all -a "df -h" -u root
server1 | CHANGED | rc=0 >>
Filesystem      Size  Used Avail Use% Mounted on
tmpfs           198M  972K  197M   1% /run
/dev/sda2        50G  3.9G   44G   9% /
tmpfs           989M     0  989M   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           198M  4.0K  198M   1% /run/user/1000

server2 | CHANGED | rc=0 >>
Filesystem      Size  Used Avail Use% Mounted on
tmpfs           198M  922K  197M   1% /run
/dev/sda2        50G  4.9G   43G  10% /
tmpfs           989M     0  989M   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           198M  4.0K  198M   1% /run/user/1000

Dirigir a hosts y grupos individuales

Hasta ahora, hemos estado ejecutando comandos en todos los servidores remotos a la vez. Pero eso no siempre es el caso. Para ejecutar un comando en solo un servidor, debes usar el siguiente formato.

$ ansible server1 -a "uptime" -u root
server1 | CHANGED | rc=0 >>
 21:38:26 up 11 min,  2 users,  load average: 0.00, 0.20, 0.19

El comando anterior verifica el tiempo de actividad en server1 desde el grupo de inventario.

También puedes dirigir múltiples servidores usando el siguiente formato.

$ ansible server1:server2 -m ping -u root

También puedes dirigir grupos o subgrupos directamente desde el archivo de inventario.

$ ansible groupname -m ping -u

Actualizar todos los servidores

Para este tutorial, asumimos que todos los servidores remotos están ejecutando el sistema operativo Debian o Ubuntu.

Ejecuta el siguiente comando para actualizar el software en todos tus servidores.

$ ansible all -m apt -a "update_cache=yes upgrade=yes" -u root

El parámetro -m define el módulo que Ansible debe ejecutar. El parámetro -a se refiere a los argumentos o comandos para el módulo asociado. Aquí, estamos utilizando el módulo apt de Ansible para actualizar servidores, así como usamos el módulo ping en nuestro último ejemplo. El update_cache actualiza la caché de APT en el servidor y upgrade=yes le dice a Ansible que ejecute el comando apt upgrade.

Si estás usando el usuario ansible como se documentó anteriormente, necesitas modificar el comando ansible para ejecutarlo con privilegios sudo elevados.

$ ansible server2 -m apt -a "update_cache=yes upgrade=yes" -K -b -u ansible

Aquí, -K pide una contraseña de escalada de privilegios. -b ejecuta la operación ansible con become, lo que te permite ser otro usuario. Ambas variables combinadas permiten que ansible se ejecute con privilegios sudo elevados. Necesitarás usar esto para todos los comandos que requieran privilegios sudo.

A veces, algunos de estos comandos de actualización pueden requerir un reinicio, así que ejecuta el siguiente comando para reiniciar todos tus servidores.

$ ansible all -a "reboot" -u root

Estos fueron solo algunos de los comandos básicos que puedes ejecutar usando Ansible.

Paso 6 - Introducción a los Playbooks

Los comandos anteriores te permiten ejecutar tareas únicas, pero si deseas configurar múltiples servidores o ejecutar la misma secuencia de comandos en múltiples servidores, necesitas configurar playbooks. Los playbooks son archivos escritos en YAML y contienen instrucciones para automatizar una secuencia de tareas para configurar aplicaciones y servicios.

Ahora crearemos un playbook para instalar Nginx y configurar una página HTML en el nodo Ansible. Crea un directorio para Ansible en tu directorio personal.

$ mkdir ~/ansible

Crea y abre el archivo del playbook para editar.

$ cd ~/ansible
$ nano testplaybook.yml

Los playbooks utilizan el formato YAML para definir uno o más plays. Un play es un conjunto de tareas ordenadas dispuestas de manera que automatizan un proceso. Los plays se definen como una lista YAML.

El primer paso para definir un play es determinar qué hosts son el objetivo usando la directiva hosts: all. La directiva become se utiliza para indicar que las siguientes tareas deben ser ejecutadas por un superusuario.

Definiremos tres tareas: una para agregar un usuario, una para actualizar todos los paquetes y la última para instalar el servidor Nginx. La sección vars del playbook se utiliza para definir variables personalizadas. Definimos dos variables, una para el usuario que necesitamos agregar y la segunda para definir el estado del paquete que necesitamos instalar. Para usar la variable, necesitamos encerrar el nombre de la variable entre dobles llaves.

El módulo ansible.builtin.user se utiliza para agregar un nuevo usuario con privilegios sudo. Para agregar el usuario, estamos usando las variables name, password y group. La variable group se establece en sudo para otorgar permisos de superusuario al usuario. No puedes poner la contraseña en texto plano en el archivo del playbook, por lo tanto, agregaremos un secreto hash SHA. Usaremos la utilidad mkpasswd para eso. Para instalarla, ejecuta el siguiente comando para instalar el paquete whois.

$ sudo apt install whois

Genera la contraseña hash. Se te pedirá la contraseña habitual y se te dará una cadena hash para ella. Toma nota de la clave hash para usarla en el archivo del playbook.

$ mkpasswd --method=sha-512
Password:
$6$dGbprm2oVqClDDDh$Epk6r5eXYkYBaQpQpP.H7VCdz0g9Aj0aO8hjy/WXq4WmfQ7GvQP2/cl/cNhd7.LRFuCKix9uCF2t8X5/Pv0Lk1

La directiva update_cache es para actualizar la lista de repositorios del sistema, así como el comando apt update, y la directiva upgrade: dist le dice a Ansible que realice la actualización del sistema. La tercera tarea es autoexplicativa, que instala la última versión del servidor Nginx.

Basado en la información que discutimos, pega el siguiente código en el archivo. Pega la clave hash que obtuviste como el valor para la variable password.

---
- name: Test playbook
  hosts: all
  become: true
  vars:
      state: latest
      user: navjot
  tasks:
  - name: Add the user {{ user }}
    ansible.builtin.user:
      name: "{{ user }}"
      password: '$6$dGbprm2oVqClDDDh$Epk6r5eXYkYBaQpQpP.H7VCdz0g9Aj0aO8hjy/WXq4WmfQ7GvQP2/cl/cNhd7.LRFuCKix9uCF2t8X5/Pv0Lk1'
      group: sudo
  - name: Upgrade all apt packages
    apt:
      update_cache: yes
      upgrade: dist
  - name: Install the {{ state }} of package "nginx"
    apt:
      name: "nginx"
      state: "{{ state }}"

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida confirmar tus cambios.

Para ejecutar el playbook, ejecuta el siguiente comando. La bandera --ask-become-pass pedirá tu contraseña de root para realizar una operación elevada.

$ ansible-playbook testplaybook.yml --ask-become-pass

Obtendrás la siguiente salida.

BECOME password:

PLAY [Test playbook] *************************************************************************************************

TASK [Gathering Facts] *********************************************************************************************
ok: [server1]
ok: [server2]
ok: [server3]

TASK [Add the user casablanca] *************************************************************************************
changed: [server3]
changed: [server2]
changed: [server1]

TASK [Upgrade all apt packages] ************************************************************************************
changed: [server1]
changed: [server2]
changed: [server3]

TASK [Install the latest of package "nginx"] ***********************************************************************
changed: [server3]
changed: [server2]
changed: [server1]

PLAY RECAP ***********************************************************************************************************
server1                    : ok=4    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
server2                    : ok=4    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
server3                    : ok=4    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Esto confirma que tu playbook se ejecutó con éxito.

Si estás usando un archivo de inventario personalizado, necesitas incluir la ubicación del archivo en el comando de la siguiente manera.

$ ansible-playbook -i /etc/ansible/custominventory testplaybook.yml --ask-become-pass

Conclusión

Eso concluye nuestro tutorial sobre la instalación y configuración de Ansible en el servidor Ubuntu 22.04. Si tienes alguna pregunta, publícalas en los comentarios a continuación.

Share: X/Twitter LinkedIn
#Ansible Ubuntu

Recibe nuevas publicaciones en tu bandeja de entrada.

No spam. Cancela la suscripción en cualquier momento.