Automatización de la Configuración de VPS con Ansible: Inventario y Primer Playbook

Introducción

Ansible es una herramienta de automatización de código abierto utilizada para la gestión de configuraciones, el despliegue de aplicaciones y la provisión de infraestructura. Se conecta a los servidores a través de SSH y no requiere la instalación de ningún agente en las máquinas remotas, lo que lo hace simple y seguro de usar. Los casos de uso comunes incluyen la automatización de la configuración de servidores, mantener las configuraciones consistentes y desplegar aplicaciones en múltiples sistemas a la vez.

En este tutorial, configuras Ansible en tu máquina local y lo usas para automatizar la configuración de múltiples instancias VPS. En lugar de configurar cada servidor manualmente, defines tareas una vez y las aplicas en todas partes. Creas un inventario, escribes tu primer playbook y despliegas una pila de aplicaciones web funcional.

Entendiendo los Conceptos Básicos de Ansible

No estás escribiendo un script que ejecuta comandos uno por uno. Estás describiendo cómo deberían verse tus servidores después de que el playbook termine.

En este tutorial, usas solo algunos componentes básicos. El archivo de inventario define tus servidores VPS y cómo Ansible se conecta a ellos. El playbook es donde describes el estado deseado de tus servidores. Dentro del playbook, las tareas definen piezas individuales de ese estado deseado, como paquetes instalados, servicios en ejecución o archivos de configuración.

El concepto más importante aquí es la declaratividad. En lugar de escribir comandos exactos como lo harías en un script de shell, describes el resultado que deseas. Por ejemplo, no le dices a Ansible que ejecute un comando para instalar Nginx. Defines que Nginx debe estar instalado. No le dices que inicie un servicio manualmente. Defines que el servicio debe estar en ejecución y habilitado. Ansible luego decide qué acciones son necesarias para lograr ese estado.

Esto es diferente de un enfoque tradicional donde ejecutarías comandos manualmente en un orden específico. En tales scripts, necesitas manejar cada situación posible tú mismo. Con Ansible, la lógica está incorporada en los módulos que usas, como la gestión de paquetes, el control de servicios, la gestión de archivos y las comprobaciones HTTP.

Otro concepto clave es la idempotencia. Esto significa que ejecutar el mismo playbook varias veces no causa cambios innecesarios. Si el sistema ya coincide con el estado deseado, Ansible lo deja sin cambios. Por ejemplo, si Nginx ya está instalado, no lo reinstalará. Si un archivo de configuración ya coincide con lo que definiste, no se reescribirá.

Debido a la declaratividad y la idempotencia, puedes ejecutar el playbook de manera segura varias veces. En la primera ejecución, Ansible instala y configura todo. En lanzamientos posteriores, solo verifica el estado del sistema y lo cambia si es necesario.

Requisitos Previos

• Público objetivo: Administradores de sistemas principiantes
• Tiempo estimado: ~40–60 minutos
• Sistema operativo: Debian 13 en PC local y todos los nodos VPS
• Nodos VPS:
  • ans0: 192.168.10.10
  • ans1: 192.168.10.11
  • ans2: 192.168.10.12
• Acceso:
  • Acceso SSH a todas las instancias VPS
  • Un usuario con privilegios de sudo en cada VPS
• Red:
  • Puerto 22 abierto para SSH
  • Puerto 80 abierto para HTTP
• Máquina local:
  • Python 3 instalado
  • Acceso a Internet
• Objetivo final: Al final de este tutorial, configurarás automáticamente múltiples servidores VPS, instalarás Nginx, desplegarás PocketBase y lo harás accesible a través de un servidor web.

Paso 1: Instalar Ansible en la Máquina Local

Ansible se ejecuta en tu máquina local y se conecta a servidores remotos. Solo lo instalas una vez.

Actualiza las listas de paquetes:

sudo apt update

Instala Ansible:

sudo apt install ansible -y

Verifica la instalación:

ansible --version

Resultado esperado: Ves información de la versión. Esto confirma que Ansible está instalado y listo.

Paso 2: Preparar el Acceso SSH

Ansible utiliza SSH para conectarse a los servidores. Para evitar escribir contraseñas cada vez, usas claves SSH.

Genera la clave SSH:

ssh-keygen

Presiona Enter para aceptar los valores predeterminados. Esto crea un par de claves:

• La clave privada permanece en tu PC
• La clave pública se copia en los servidores

Copia la clave al VPS:

ssh-copy-id <TU_USUARIO>@192.168.10.10

ssh-copy-id <TU_USUARIO>@192.168.10.11

ssh-copy-id <TU_USUARIO>@192.168.10.12

Prueba el acceso:

ssh <TU_USUARIO>@192.168.10.10

Resultado esperado: Inicias sesión sin ingresar una contraseña.

Paso 3: Crear Proyecto e Inventario de Ansible

Ansible utiliza un archivo de inventario para saber qué servidores gestionar.

Crea el directorio del proyecto:

mkdir ~/ansible-vps

cd ~/ansible-vps

Crea el archivo de inventario:

nano inventory.ini

Inserta el siguiente contenido en el archivo de inventario:

[vps]
ans0 ansible_host=192.168.10.10
ans1 ansible_host=192.168.10.11
ans2 ansible_host=192.168.10.12
[vps:vars]
ansible_user=<TU_USUARIO>
ansible_python_interpreter=/usr/bin/python3

Explicación:

• [vps] es un nombre de grupo
• ans0, ans1, ans2 son nombres lógicos
• ansible_host define direcciones IP reales
• ansible_user indica a Ansible con qué usuario iniciar sesión

Prueba la conectividad:

ansible -i inventory.ini vps -m ping

Resultado esperado: Cada servidor devuelve "pong".

Paso 4: Crear tu Primer Playbook

Un playbook es un archivo donde describes las tareas que deseas ejecutar en los servidores.

Crea el archivo:

nano playbook.yml

Inserta el siguiente contenido en el archivo del playbook:

- name: Configure VPS nodes
  hosts: vps
  become: true
  tasks:
    - name: Test connectivity
      ping:
    - name: Update apt cache
      apt:
        update_cache: yes
    - name: Upgrade packages
      apt:
        upgrade: dist
    - name: Install Nginx
      apt:
        name: nginx
        state: present
    - name: Ensure Nginx is running
      service:
        name: nginx
        state: started
        enabled: true
    - name: Test HTTP connectivity
      uri:
        url: http://127.0.0.1/
        return_content: no
    - name: Create directory for PocketBase
      file:
        path: /opt/pocketbase/pb_public
        state: directory
    - name: Install unzip
      apt:
        name: unzip
        state: present
    - name: Download PocketBase
      get_url:
        url: https://github.com/pocketbase/pocketbase/releases/download/v0.36.7/pocketbase_0.36.7_linux_amd64.zip
        dest: /opt/pocketbase/pocketbase.zip
    - name: Unpack PocketBase
      unarchive:
        src: /opt/pocketbase/pocketbase.zip
        dest: /opt/pocketbase/
        remote_src: yes
    - name: Create Pocketbase index.html
      copy:
        dest: /opt/pocketbase/pb_public/index.html
        content: |
          <h1>Pocketbase</h1>
    - name: Create systemd service
      copy:
        dest: /etc/systemd/system/pocketbase.service
        content: |
          [Unit]
          Description=PocketBase Service
          After=network.target
          [Service]
          Type=simple
          ExecStart=/opt/pocketbase/pocketbase serve --http=127.0.0.1:8090
          Restart=always
          [Install]
          WantedBy=multi-user.target
    - name: Reload systemd
      command: systemctl daemon-reexec
    - name: Enable and start PocketBase
      service:
        name: pocketbase
        enabled: true
        state: started
    - name: Configure Nginx site
      copy:
        dest: /etc/nginx/sites-available/pocketbase
        content: |
          server {
              listen 80;
              server_name _;
              location / {
                  proxy_pass http://127.0.0.1:8090;
                  proxy_set_header Host $host;
                  proxy_set_header X-Real-IP $remote_addr;
              }
          }
    - name: Enable Nginx site
      file:
        src: /etc/nginx/sites-available/pocketbase
        dest: /etc/nginx/sites-enabled/pocketbase
        state: link
    - name: Remove default site
      file:
        path: /etc/nginx/sites-enabled/default
        state: absent
    - name: Restart Nginx
      service:
        name: nginx
        state: restarted
    - name: Check PocketBase availability
      uri:
        url: http://127.0.0.1:8090/_/
        return_content: no

Explicación:

• hosts: vps significa todos los servidores en el grupo
• become: true ejecuta tareas con privilegios elevados
• Cada tarea describe una acción
• Módulos como apt, service, file están integrados en Ansible

Paso 5: Ejecutar el Playbook

ansible-playbook -i inventory.ini playbook.yml

Resultado esperado: Las tareas se ejecutan en todos los nodos sin errores.

Verificación

Verifica el servidor web:

curl http://192.168.10.10/

Resultado esperado: Se devuelve una respuesta HTTP.

Abre en el navegador: http://192.168.10.10/_/

Resultado esperado: Se carga la interfaz de PocketBase.

Repite para otros nodos.

Revertir Cambios

sudo systemctl stop pocketbase

sudo systemctl disable pocketbase

sudo rm /etc/systemd/system/pocketbase.service

sudo rm -rf /opt/pocketbase

sudo apt remove nginx unzip -y

Recarga systemd:

sudo systemctl daemon-reload

Solución de Problemas

• Falla SSH: verifica claves y usuario
• Falla de ping de Ansible: asegura la conexión de red entre hosts
• Problemas con Nginx: systemctl status nginx
• Problemas con PocketBase: journalctl -u pocketbase

Conclusión

Instalaste la herramienta de automatización Ansible, creaste un inventario y escribiste tu primer playbook. Automatizaste el despliegue de Nginx y PocketBase en múltiples servidores.

Próximos pasos:

• Usar roles para una mejor estructura
• Agregar variables y plantillas
• Configurar HTTPS