Jak kopiować pliki między dwoma węzłami za pomocą ansible

Muszę skopiować plik z komputera A na komputer B, podczas gdy moją maszyną sterującą, z której uruchamiam wszystkie moje zadania ansible, jest komputer C (komputer lokalny)

Próbowałem następujących rzeczy:

Użyj polecenia scp w module powłoki ansibla

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

To podejście po prostu trwa i nigdy się nie kończy.

użyj modułów pobierania i kopiowania

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

Takie podejście generuje następujący błąd:

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>'

Wszelkie sugestie byłyby pomocne.

Aby skopiować pliki zdalne na zdalne, możesz użyć modułu synchronizacji ze delegate_to: source-serversłowem kluczowym „ ”:

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

Ten podręcznik można uruchomić z poziomu komputera C.

Jak już wskazał ant31, możesz użyć synchronizedo tego modułu. Domyślnie moduł przesyła pliki między maszyną sterującą a bieżącym zdalnym hostem ( inventory_host), jednak można to zmienić za pomocą delegate_toparametru zadania (należy zauważyć, że jest to parametr zadania , a nie modułu).

Możesz umieścić zadanie na albo ServerAlub ServerB, ale musisz odpowiednio dostosować kierunek transferu (za pomocą modeparametru synchronize).

Włączanie zadania 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

Używa wartości domyślnej mode: push, więc plik zostanie przesłany z delegate ( ServerA) do bieżącego remote ( ServerB).

Może to brzmieć dziwnie, ponieważ zadanie zostało umieszczone na ServerB(via hosts: ServerB). Należy jednak pamiętać, że zadanie jest faktycznie wykonywane na hoście delegowanym , którym w tym przypadku jest ServerA. Zatem pchanie (od ServerAdo ServerB) jest rzeczywiście właściwym kierunkiem. Pamiętaj również, że nie możemy po prostu zrezygnować z delegowania w ogóle, ponieważ oznaczałoby to, że transfer odbywa się między maszyną sterującą a ServerB.

Włączanie zadania 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

Służy mode: pulldo odwrócenia kierunku transferu. Ponownie pamiętaj, że zadanie jest faktycznie wykonywane ServerB, więc ciągnięcie jest właściwym wyborem.

Jeśli chcesz zsynchronizować pliki między dwoma zdalnymi węzłami za pośrednictwem ansible, możesz użyć tego:

- 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 }}"

kiedy jest włączony remote_server, musisz uruchomić rsync w trybie demona. Prosty przykład:

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

Udało mi się rozwiązać ten problem, używając lokalnego polecenia scp do pliku z komputera A do komputera C, a następnie kopiując plik do komputera B.

Prosty sposób wykorzystania modułu kopiowania do przesłania pliku z jednego serwera na drugi

Oto poradnik

---
- 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}

Jeśli chcesz wykonać rsync i użyć niestandardowego użytkownika i niestandardowego klucza ssh, musisz wpisać ten klucz w opcjach 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

Możesz użyć również deletgatez 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

Ponieważ delegatepolecenie jest uruchamiane na innym serwerze i jest scpplikiem dla siebie.