Cómo copiar archivos entre dos nodos usando ansible

Necesito copiar el archivo de la máquina A a la máquina B, mientras que mi máquina de control desde donde ejecuto todas mis tareas ansible es la máquina C (máquina local)

He probado lo siguiente:

Use el comando scp en el módulo shell de ansible

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

Este enfoque sigue y nunca termina.

utilizar módulos de recuperación y copia

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

Este enfoque me arroja un error de la siguiente manera:

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

Cualquier sugerencia sería útil.

Para copiar archivos de remoto a remoto, puede usar el módulo de sincronización con delegate_to: source-serverla palabra clave ' ':

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

Este libro de jugadas puede ejecutarse desde su máquina C.

Como ya señaló ant31, puede usar el synchronizemódulo para esto. De forma predeterminada, el módulo transfiere archivos entre la máquina de control y el host remoto actual ( inventory_host), sin embargo, eso se puede cambiar usando el delegate_toparámetro de la tarea (es importante tener en cuenta que este es un parámetro de la tarea , no del módulo).

Puede colocar la tarea en ServerAo ServerB, pero debe ajustar la dirección de la transferencia en consecuencia (utilizando el modeparámetro de synchronize).

Colocando la tarea en 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

Esto usa el predeterminado mode: push, por lo que el archivo se transfiere desde el delegado ( ServerA) al control remoto actual ( ServerB).

Esto puede sonar extraño, ya que la tarea se ha colocado en ServerB(vía hosts: ServerB). Sin embargo, hay que tener en cuenta que la tarea se ejecuta realmente en el host delegado , que en este caso es ServerA. Entonces empujar (de ServerAa ServerB) es de hecho la dirección correcta. También recuerde que no podemos simplemente elegir no delegar en absoluto, ya que eso significaría que la transferencia ocurre entre la máquina de control y ServerB.

Colocando la tarea en 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

Esto se usa mode: pullpara invertir la dirección de transferencia. Nuevamente, tenga en cuenta que la tarea se ejecuta realmente ServerB, por lo que tirar es la opción correcta.

Pude resolver esto usando local_action para scp al archivo de machineA a machineC y luego copiando el archivo a machineB.

Si necesita sincronizar archivos entre dos nodos remotos a través de ansible, puede usar esto:

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

cuando remote_serveresté encendido , debe iniciar rsync con el modo demonio. Ejemplo simple:

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

Una forma sencilla de utilizar el módulo de copia para transferir el archivo de un servidor a otro

Aquí está el libro de jugadas

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

Si desea hacer rsync y usar un usuario personalizado y una clave ssh personalizada, debe escribir esta clave en las opciones de 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

También puedes usar 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

Porque delegateel comando se ejecuta en el otro servidor y scpes el archivo para sí mismo.