Centro di Conoscenza DevOps
Centro di Conoscenza DevOps

Trasferimento sicuro dei file: Utilizzo dei moduli Ansible Copy e Fetch

Scopri come trasferire file in modo istantaneo e sicuro utilizzando i comandi ad-hoc di Ansible. Questa guida pratica si concentra sul modulo essenziale `copy` per inviare file dalla tua macchina di controllo ai nodi remoti e sul modulo `fetch` per recuperare configurazioni e log sulla tua workstation locale. Scopri argomenti critici come `src`, `dest`, `mode` e la struttura di destinazione unica creata da `fetch`, garantendo una gestione dei file efficiente e accurata attraverso la tua infrastruttura.

43 visualizzazioni

Trasferimento Sicuro di File: Utilizzo dei Moduli Ansible Copy e Fetch

Ansible è rinomato per le sue capacità di gestione della configurazione, ma lo spostamento efficiente di file tra la macchina di controllo e i nodi gestiti è un requisito fondamentale per qualsiasi strategia di deployment. Che si debba distribuire un file di configurazione personalizzato, caricare un artefatto di deployment o recuperare i log di sistema, il processo deve essere rapido, affidabile e sicuro.

Questo articolo si concentra sui due moduli principali per il trasferimento di file: copy e fetch. Dimostreremo come sfruttare questi moduli utilizzando la potente struttura di comandi ad-hoc di Ansible, consentendo operazioni di file rapide e una tantum senza la necessità di scrivere un playbook completo. Al termine di questa guida, sarete esperti nel caricare in modo sicuro file locali su sistemi remoti e nel recuperare i file necessari sul vostro nodo di controllo Ansible.

Prerequisiti

Prima di eseguire gli esempi seguenti, assicuratevi di avere quanto segue:

  1. Nodo di Controllo Ansible: Una macchina con Ansible installato.
  2. File di Inventario: Un file di inventario operativo (es. /etc/ansible/hosts) che definisca i vostri nodi gestiti.
  3. Connettività: Accesso tramite chiave SSH configurato per i vostri host remoti.

Tutti gli esempi assumeranno che il gruppo target sia denominato webservers nell'inventario.

Comprendere i Comandi Ad-Hoc per il Trasferimento di File

I comandi ad-hoc sono comandi a singola riga eseguiti direttamente dal terminale, ideali per attività rapide che non giustificano un playbook permanente. La struttura di base è:

ansible <gruppo-host> -m <nome-modulo> -a "chiave=valore chiave2=valore2 ..."

Per il trasferimento di file, utilizziamo i nomi dei moduli -m copy o -m fetch, passando gli argomenti richiesti utilizzando il flag -a.

Il Modulo copy: Caricamento di File sui Nodi Remoti

Il modulo copy viene utilizzato per trasferire un file situato sulla macchina di controllo Ansible a uno o più nodi gestiti. Questo è il metodo standard per la distribuzione di file di configurazione, script o piccoli asset.

Argomenti Chiave per copy

Il modulo copy richiede due argomenti essenziali e accetta diversi argomenti opzionali per la gestione della configurazione:

Argomento Descrizione Obbligatorio? Valore di Esempio
src Il percorso assoluto del file sulla macchina di controllo Ansible. Sì /tmp/config.conf
dest Il percorso assoluto in cui il file verrà posizionato sul nodo gestito remoto. Sì /etc/app/config.conf
owner Nome dell'utente che dovrebbe possedere il file sul nodo remoto. No nginx
group Nome del gruppo che dovrebbe possedere il file sul nodo remoto. No www-data
mode Permessi (ottali) da impostare sul file di destinazione. No 0644
backup Se yes, crea un file di backup prima di sovrascrivere l'originale. No yes

Esempio 1: Semplice Deployment di File

Supponiamo di avere un file Message of the Day (motd) personalizzato localmente e di volerlo caricare su tutti i webserver.

# Percorso del file locale: /home/user/ansible/motd_banner
# Destinazione remota: /etc/motd

ansible webservers -m copy -a "src=/home/user/ansible/motd_banner dest=/etc/motd"

Esempio 2: Impostazione di Permessi e Proprietà

Se si sta distribuendo un file di configurazione sicuro, è necessario specificare il proprietario, il gruppo e i permessi ristretti (ad esempio, solo il proprietario può leggere/scrivere).

# Distribuzione di un file di configurazione dell'applicazione, di proprietà di 'app_user', gruppo 'devops',
# con permessi di lettura/scrittura solo per il proprietario (0600).

ansible webservers -m copy -b -a "src=/tmp/app_settings.yaml dest=/etc/app/settings.yaml owner=app_user group=devops mode=0600"

Nota su -b: Il flag -b (o --become) è necessario quando la destinazione remota richiede permessi elevati (come la scrittura in /etc).

Il Modulo fetch: Recupero di File dai Nodi Remoti

Il modulo fetch esegue l'operazione inversa di copy: recupera un file dal nodo gestito e lo riporta alla macchina di controllo Ansible. Questo è utile per eseguire il backup di file di configurazione, recuperare log o raccogliere informazioni diagnostiche.

Argomenti Chiave per fetch

Il modulo fetch richiede il file sorgente sul nodo remoto e una directory di destinazione sulla macchina di controllo.

Argomento Descrizione Obbligatorio? Valore di Esempio
src Il percorso assoluto del file sul nodo gestito remoto. Sì /var/log/nginx/error.log
dest Il percorso assoluto della directory sulla macchina di controllo dove i file verranno salvati. Sì /tmp/backups/logs
flat Se yes, il nome del file risultante non conterrà la struttura del nome host (non raccomandato quando si recupera da più host). No no (predefinito)

Differenza Critica: Struttura della Destinazione

A differenza del modulo copy, il modulo fetch crea automaticamente un percorso di sottodirectory strutturato basato sul nome host remoto per prevenire collisioni di nomi di file quando si recuperano file da più server.

Il percorso risultante sulla macchina di controllo sarà simile a questo:

<dest>/<hostname>/<src>

Ad esempio, il recupero di /etc/nginx/nginx.conf da host1 a /tmp/backups si traduce in:

/tmp/backups/host1/etc/nginx/nginx.conf

Esempio 3: Recupero di Backup di Configurazione Remota

Per recuperare il file di configurazione in esecuzione da tutti i webserver in una directory di backup locale:

# Recupera nginx.conf da tutti i webserver nella directory locale /tmp/config_backups

ansible webservers -m fetch -a "src=/etc/nginx/nginx.conf dest=/tmp/config_backups"

Dopo aver eseguito questo comando, se avete mirato a webserver1 e webserver2, la vostra struttura di directory locale sarebbe:

/tmp/config_backups/
├── webserver1
│   └── etc
│       └── nginx
│           └── nginx.conf
└── webserver2
    └── etc
        └── nginx
            └── nginx.conf

Esempio 4: Recupero di un Singolo File Senza Struttura dell'Host (flat=yes)

Se siete assolutamente certi di recuperare un file da un solo host, o se avete bisogno solo del contenuto del file (non della struttura di origine), potete usare flat=yes. Questo fa sì che il file venga posizionato direttamente nella cartella di destinazione, prendendo il nome del file remoto originale.

# Recupera un rapporto sullo stato di salute locale da un singolo host, salvandolo direttamente.

ansible webserver1 -m fetch -a "src=/tmp/health_status.txt dest=/tmp/reports flat=yes"

# Percorso risultante: /tmp/reports/health_status.txt

Attenzione: Usate flat=yes solo quando targetizzate un singolo host o se intendete sovrascrivere il file nelle esecuzioni successive, poiché Ansible non preverrà i conflitti.

Migliori Pratiche e Considerazioni sulla Sicurezza

Quando si gestiscono file utilizzando Ansible, la sicurezza e l'idempotenza sono di fondamentale importanza:

1. Impostare Sempre i Permessi con copy

Non caricare mai un file di configurazione senza definire esplicitamente mode e owner. Se ci si affida all'umask predefinita del sistema remoto, file sensibili (come chiavi SSH o credenziali di database) potrebbero ritrovarsi con diritti di accesso eccessivamente permissivi.

# Cattiva Pratica (Modalità derivata da umask)
- name: Distribuisci chiave insicura
  ansible.builtin.copy:
    src: private.key
    dest: /etc/app/private.key

# Buona Pratica (Restringere esplicitamente l'accesso)
- name: Distribuisci chiave sicura
  ansible.builtin.copy:
    src: private.key
    dest: /etc/app/private.key
    mode: '0600'
    owner: root

2. Usare backup=yes per Cambiamenti Critici

Quando si usa copy per sovrascrivere un file esistente e critico (ad esempio, /etc/sudoers), includere backup=yes. Ansible creerà una copia di backup con timestamp sul nodo remoto prima di sovrascrivere il file, fornendo un'opzione di rollback facile.

3. Considerare il Modulo synchronize per Trasferimenti di Grandi Dimensioni

Mentre copy e fetch sono eccellenti per operazioni ad-hoc rapide e file di configurazione piccoli, se è necessario trasferire grandi strutture di directory o sono necessari trasferimenti delta efficienti (trasferendo solo le modifiche), il modulo synchronize (che sfrutta rsync) è lo strumento raccomandato per prestazioni e gestione superiori.

I moduli copy e fetch sono strumenti indispensabili nel toolkit dell'amministratore Ansible, fornendo metodi robusti e sicuri per manipolare file in un'infrastruttura. Padroneggiando la sintassi dei comandi ad-hoc e comprendendo gli argomenti chiave, è possibile gestire in modo efficiente gli artefatti di deployment ed eseguire le necessarie operazioni di recupero dati senza il sovraccarico di creare playbook completi per compiti semplici.

Modulo Direzione Esempio di Comando Ad-Hoc
copy Nodo di Controllo -> Nodo Gestito ansible all -m copy -a "src=/local/file dest=/remote/path mode=0644"
fetch Nodo Gestito -> Nodo di Controllo ansible all -m fetch -a "src=/remote/file dest=/local/dir"