Automatizzare la Configurazione di VPS con Ansible: Inventario e Primo Playbook

Introduzione

Ansible è uno strumento di automazione open source utilizzato per la gestione delle configurazioni, il deployment delle applicazioni e il provisioning dell'infrastruttura. Si connette ai server tramite SSH e non richiede l'installazione di alcun agente sulle macchine remote, il che lo rende semplice e sicuro da usare. I casi d'uso comuni includono l'automazione della configurazione dei server, il mantenimento delle configurazioni coerenti e il deployment delle applicazioni su più sistemi contemporaneamente.

In questo tutorial, configurerai Ansible sulla tua macchina locale e lo utilizzerai per automatizzare la configurazione di più istanze VPS. Invece di configurare manualmente ogni server, definisci i compiti una volta e li applichi ovunque. Creerai un inventario, scriverai il tuo primo playbook e distribuirai uno stack di applicazioni web funzionante.

Comprendere i Concetti Fondamentali di Ansible

Non stai scrivendo uno script che esegue comandi uno per uno. Stai descrivendo come dovrebbero apparire i tuoi server dopo che il playbook è terminato.

In questo tutorial, utilizzerai solo alcuni componenti fondamentali. Il file di inventario definisce i tuoi server VPS e come Ansible si connette a loro. Il playbook è dove descrivi lo stato desiderato dei tuoi server. All'interno del playbook, i compiti definiscono i singoli pezzi di quello stato desiderato, come pacchetti installati, servizi in esecuzione o file di configurazione.

Il concetto più importante qui è la dichiaratività. Invece di scrivere comandi esatti come faresti in uno script shell, descrivi il risultato che desideri. Ad esempio, non dici ad Ansible di eseguire un comando per installare Nginx. Definisci che Nginx deve essere installato. Non gli dici di avviare un servizio manualmente. Definisci che il servizio deve essere in esecuzione e abilitato. Ansible decide quindi quali azioni sono necessarie per raggiungere quello stato.

Questo è diverso da un approccio tradizionale in cui eseguiresti manualmente i comandi in un ordine specifico. In tali script, devi gestire ogni possibile situazione da solo. Con Ansible, la logica è integrata nei moduli che utilizzi, come la gestione dei pacchetti, il controllo dei servizi, la gestione dei file e i controlli HTTP.

Un altro concetto chiave è l'idempotenza. Ciò significa che eseguire lo stesso playbook più volte non causa cambiamenti non necessari. Se il sistema corrisponde già allo stato desiderato, Ansible lo lascia invariato. Ad esempio, se Nginx è già installato, non lo reinstallerà. Se un file di configurazione corrisponde già a quello che hai definito, non verrà riscritto.

Grazie alla dichiaratività e all'idempotenza, puoi eseguire il playbook in sicurezza più volte. Alla prima esecuzione, Ansible installa e configura tutto. Nei lanci successivi, controlla solo lo stato del sistema e lo modifica se necessario.

Prerequisiti

• Pubblico target: Amministratori di sistema principianti
• Tempo stimato: ~40–60 minuti
• Sistema operativo: Debian 13 su PC locale e tutti i nodi VPS
• Nodi VPS:
  • ans0: 192.168.10.10
  • ans1: 192.168.10.11
  • ans2: 192.168.10.12
• Accesso:
  • Accesso SSH a tutte le istanze VPS
  • Un utente con privilegi sudo su ciascun VPS
• Rete:
  • Porta 22 aperta per SSH
  • Porta 80 aperta per HTTP
• Macchina locale:
  • Python 3 installato
  • Accesso a Internet
• Obiettivo finale: Alla fine di questo tutorial, configurerai automaticamente più server VPS, installerai Nginx, distribuirai PocketBase e lo renderai accessibile tramite un server web.

Passo 1: Installa Ansible sulla Macchina Locale

Ansible viene eseguito sulla tua macchina locale e si connette ai server remoti. Lo installi solo una volta.

Aggiorna le liste dei pacchetti:

sudo apt update

Installa Ansible:

sudo apt install ansible -y

Controlla l'installazione:

ansible --version

Risultato atteso: Vedi le informazioni sulla versione. Questo conferma che Ansible è installato e pronto.

Passo 2: Prepara l'Accesso SSH

Ansible utilizza SSH per connettersi ai server. Per evitare di digitare le password ogni volta, utilizzi le chiavi SSH.

Genera la chiave SSH:

ssh-keygen

Premi Invio per accettare i valori predefiniti. Questo crea una coppia di chiavi:

• La chiave privata rimane sul tuo PC
• La chiave pubblica viene copiata sui server

Copia la chiave sul VPS:

ssh-copy-id <YOUR_USERNAME>@192.168.10.10

ssh-copy-id <YOUR_USERNAME>@192.168.10.11

ssh-copy-id <YOUR_USERNAME>@192.168.10.12

Testa l'accesso:

ssh <YOUR_USERNAME>@192.168.10.10

Risultato atteso: Accedi senza inserire una password.

Passo 3: Crea Progetto Ansible e Inventario

Ansible utilizza un file di inventario per sapere quali server gestire.

Crea la directory del progetto:

mkdir ~/ansible-vps

cd ~/ansible-vps

Crea il file di inventario:

nano inventory.ini

Inserisci il seguente contenuto nel file di 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=<YOUR_USERNAME>
ansible_python_interpreter=/usr/bin/python3

Spiegazione:

• [vps] è un nome di gruppo
• ans0, ans1, ans2 sono nomi logici
• ansible_host definisce gli indirizzi IP reali
• ansible_user dice ad Ansible quale utente utilizzare per accedere

Testa la connettività:

ansible -i inventory.ini vps -m ping

Risultato atteso: Ogni server restituisce "pong".

Passo 4: Crea il Tuo Primo Playbook

Un playbook è un file in cui descrivi i compiti che vuoi eseguire sui server.

Crea il file:

nano playbook.yml

Inserisci il seguente contenuto nel file del playbook:

- name: Configura i nodi VPS
  hosts: vps
  become: true
  tasks:
    - name: Testa la connettività
      ping:
    - name: Aggiorna la cache di apt
      apt:
        update_cache: yes
    - name: Aggiorna i pacchetti
      apt:
        upgrade: dist
    - name: Installa Nginx
      apt:
        name: nginx
        state: present
    - name: Assicurati che Nginx sia in esecuzione
      service:
        name: nginx
        state: started
        enabled: true
    - name: Testa la connettività HTTP
      uri:
        url: http://127.0.0.1/
        return_content: no
    - name: Crea la directory per PocketBase
      file:
        path: /opt/pocketbase/pb_public
        state: directory
    - name: Installa unzip
      apt:
        name: unzip
        state: present
    - name: Scarica 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: Decomprimi PocketBase
      unarchive:
        src: /opt/pocketbase/pocketbase.zip
        dest: /opt/pocketbase/
        remote_src: yes
    - name: Crea index.html per Pocketbase
      copy:
        dest: /opt/pocketbase/pb_public/index.html
        content: |
          <h1>Pocketbase</h1>
    - name: Crea servizio systemd
      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: Ricarica systemd
      command: systemctl daemon-reexec
    - name: Abilita e avvia PocketBase
      service:
        name: pocketbase
        enabled: true
        state: started
    - name: Configura il sito Nginx
      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: Abilita il sito Nginx
      file:
        src: /etc/nginx/sites-available/pocketbase
        dest: /etc/nginx/sites-enabled/pocketbase
        state: link
    - name: Rimuovi il sito predefinito
      file:
        path: /etc/nginx/sites-enabled/default
        state: absent
    - name: Riavvia Nginx
      service:
        name: nginx
        state: restarted
    - name: Verifica la disponibilità di PocketBase
      uri:
        url: http://127.0.0.1:8090/_/
        return_content: no

Spiegazione:

• hosts: vps significa tutti i server nel gruppo
• become: true esegue i compiti con privilegi elevati
• Ogni compito descrive un'azione
• I moduli come apt, service, file sono integrati in Ansible

Passo 5: Esegui il Playbook

ansible-playbook -i inventory.ini playbook.yml

Risultato atteso: I compiti vengono eseguiti su tutti i nodi senza errori.

Verifica

Controlla il server web:

curl http://192.168.10.10/

Risultato atteso: Viene restituita una risposta HTTP.

Apri nel browser: http://192.168.10.10/_/

Risultato atteso: L'interfaccia di PocketBase si carica.

Ripeti per gli altri nodi.

Ripristino delle Modifiche

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

Ricarica systemd:

sudo systemctl daemon-reload

Risoluzione dei Problemi

• SSH fallisce: controlla le chiavi e l'utente
• Ansible ping fallisce: assicurati della connessione di rete tra gli host
• Problemi con Nginx: systemctl status nginx
• Problemi con PocketBase: journalctl -u pocketbase

Conclusione

Hai installato lo strumento di automazione Ansible, creato un inventario e scritto il tuo primo playbook. Hai automatizzato il deployment di Nginx e PocketBase su più server.

Prossimi passi:

• Usa i ruoli per una struttura migliore
• Aggiungi variabili e template
• Configura HTTPS