Come copiare file tra due nodi utilizzando ansible

Devo copiare il file dalla macchina A alla macchina B mentre la mia macchina di controllo da cui eseguo tutte le mie attività ansible è la macchina C (macchina locale)

Ho provato quanto segue:

Usa il comando scp nel modulo shell di ansible

hosts: machine2
user: user2
tasks:
  - name: Copy file from machine1 to machine2 
    shell: scp user1@machine1:/path-of-file/file1 /home/user2/file1

Questo approccio va avanti e avanti non finisce mai.

usa fetch & copy moduli

hosts: machine1
user: user1
tasks:
  - name: copy file from machine1 to local
    fetch: src=/path-of-file/file1 dest=/path-of-file/file1

hosts: machine2
user: user2
tasks:
  - name: copy file from local to machine2
    copy: src=/path-of-file/file1 dest=/path-of-file/file1

Questo approccio mi genera un errore come segue:

error while accessing the file /Users/<myusername>/.ansible/cp/ansible-ssh-machine2-22-<myusername>, error was: [Errno 102] Operation not supported on socket: u'/Users/<myusername>/.ansible/cp/ansible-ssh-machine2-22-<myusername>'

Eventuali suggerimenti sarebbero utili.

Per copiare file da remoto a remoto è possibile utilizzare il modulo di sincronizzazione con delegate_to: source-serverla parola chiave " ":

- hosts: serverB
  tasks:    
   - name: Copy Remote-To-Remote (from serverA to serverB)
     synchronize: src=/copy/from_serverA dest=/copy/to_serverB
     delegate_to: serverA

Questo playbook può essere eseguito dalla tua macchina C.

Come già sottolineato da ant31 puoi usare il synchronizemodulo per questo. Per default, i file modulo trasferisce tra la macchina di controllo e la corrente host remoto ( inventory_host), tuttavia, che possono essere modificate mediante il compito delegate_toparametro (è importante notare che questo è un parametro del compito , non del modulo).

È possibile posizionare l'attività su ServerAo ServerB, ma è necessario regolare la direzione del trasferimento di conseguenza (utilizzando il modeparametro di synchronize).

Posizionamento dell'attività ServerB

- hosts: ServerB
  tasks:
    - name: Transfer file from ServerA to ServerB
      synchronize:
        src: /path/on/server_a
        dest: /path/on/server_b
      delegate_to: ServerA

Questo utilizza l'impostazione predefinita mode: push, quindi il file viene trasferito da delegate ( ServerA) a remote ( ServerB) corrente .

Questo potrebbe sembrare strano, poiché l'attività è stata assegnata a ServerB(via hosts: ServerB). Tuttavia, è necessario tenere presente che l'attività viene effettivamente eseguita sull'host delegato , che in questo caso lo è ServerA. Quindi spingere (da ServerAa ServerB) è davvero la direzione corretta. Ricorda inoltre che non possiamo semplicemente scegliere di non delegare affatto, poiché ciò significherebbe che il trasferimento avviene tra la macchina di controllo e ServerB.

Posizionamento dell'attività ServerA

- hosts: ServerA
  tasks:
    - name: Transfer file from ServerA to ServerB
      synchronize:
        src: /path/on/server_a
        dest: /path/on/server_b
        mode: pull
      delegate_to: ServerB

Questo utilizza mode: pullper invertire la direzione di trasferimento. Ancora una volta, tieni presente che l'attività viene effettivamente eseguita ServerB, quindi tirare è la scelta giusta.

Sono stato in grado di risolvere questo problema usando local_action su scp su file da machineA a machineC e quindi copiando il file su machineB.

Se hai bisogno di sincronizzare i file tra due nodi remoti tramite ansible puoi usare questo:

- name: synchronize between nodes
  environment:
    RSYNC_PASSWORD: "{{ input_user_password_if_needed }}"
  synchronize:
    src: rsync://user@remote_server:/module/
    dest: /destination/directory/
    // if needed
    rsync_opts:
       - "--include=what_needed"
       - "--exclude=**/**"
    mode: pull
    delegate_to: "{{ inventory_hostname }}"

quando remote_serverè attivo è necessario avviare rsync con la modalità daemon. Esempio semplice:

pid file = /var/run/rsyncd.pid
lock file = /var/run/rsync.lock
log file = /var/log/rsync.log
port = port

[module]
path = /path/to/needed/directory/
uid = nobody
gid = nobody
read only = yes
list = yes
auth users = user
secrets file = /path/to/secret/file

Un modo semplice per utilizzare il modulo di copia per trasferire il file da un server a un altro

Ecco il playbook

---
- hosts: machine1 {from here file will be transferred to another remote machine}
  tasks:
  - name: transfer data from machine1 to machine2

    copy:
     src=/path/of/machine1

     dest=/path/of/machine2

    delegate_to: machine2 {file/data receiver machine}

Se si desidera eseguire rsync e utilizzare l'utente personalizzato e la chiave ssh personalizzata, è necessario scrivere questa chiave nelle opzioni di rsync.

---
 - name: rsync
   hosts: serverA,serverB,serverC,serverD,serverE,serverF
   gather_facts: no
   vars:
     ansible_user: oracle
     ansible_ssh_private_key_file: ./mykey
     src_file: "/path/to/file.txt"
   tasks:
     - name: Copy Remote-To-Remote from serverA to server{B..F}
       synchronize:
           src:  "{{ src_file }}"
           dest: "{{ src_file }}"
           rsync_opts:
              - "-e ssh -i /remote/path/to/mykey"
       delegate_to: serverA

Puoi usare anche deletgatecon scp:

- name: Copy file to another server
  become: true
  shell: "scp -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null admin@{{ inventory_hostname }}:/tmp/file.yml /tmp/file.yml"
  delegate_to: other.example.com

A causa del delegatecomando viene eseguito sull'altro server ed è scpil file a se stesso.