Comment copier des fichiers entre deux nœuds à l'aide d'ansible

Je dois copier la machine de formulaire A sur la machine B alors que ma machine de contrôle à partir de laquelle j'exécute toutes mes tâches ansible est la machine C (machine locale)

J'ai essayé ce qui suit:

Utilisez la commande scp dans le module shell d'ansible

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

Cette approche continue et ne s'arrête jamais.

utiliser des modules d'extraction et de copie

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

Cette approche me lance une erreur comme suit:

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

Toute suggestion serait utile.

Pour copier des fichiers distants vers distants, vous pouvez utiliser le module de synchronisation avec delegate_to: source-serverle mot-clé ' ':

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

Ce playbook peut fonctionner à partir de votre machine C.

Comme ant31 l'a déjà souligné, vous pouvez utiliser le synchronizemodule pour cela. Par défaut, le module transfère des fichiers entre la machine de contrôle et l'hôte distant actuel ( inventory_host), mais cela peut être modifié en utilisant le delegate_toparamètre de la tâche (il est important de noter qu'il s'agit d'un paramètre de la tâche , pas du module).

Vous pouvez placer la tâche sur l'un ServerAou l' autre ServerB, mais vous devez ajuster la direction du transfert en conséquence (en utilisant le modeparamètre de synchronize).

Placer la tâche sur 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

Cela utilise la valeur par défaut mode: push, de sorte que le fichier est transféré du délégué ( ServerA) vers le remote ( ServerB) actuel .

Cela peut sembler étrange, car la tâche a été placée sur ServerB(via hosts: ServerB). Cependant, il faut garder à l'esprit que la tâche est réellement exécutée sur l'hôte délégué , ce qui dans ce cas l'est ServerA. Donc pousser (de ServerAvers ServerB) est en effet la bonne direction. Rappelez-vous également que nous ne pouvons pas simplement choisir de ne pas déléguer du tout, car cela signifierait que le transfert se produit entre la machine de contrôle et ServerB.

Placer la tâche sur 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

Cela permet mode: pulld'inverser le sens de transfert. Encore une fois, gardez à l'esprit que la tâche est réellement exécutée ServerB, donc tirer est le bon choix.

Si vous avez besoin de synchroniser des fichiers entre deux nœuds distants via ansible, vous pouvez utiliser ceci:

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

quand remote_servervous devez démarrer rsync avec le mode démon. Exemple 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

J'ai pu résoudre ce problème en utilisant local_action pour scp vers un fichier de machineA vers machineC, puis en copiant le fichier vers machineB.

Un moyen simple d'utiliser le module de copie pour transférer le fichier d'un serveur à un autre

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

Si vous voulez faire rsync et utiliser un utilisateur personnalisé et une clé ssh personnalisée, vous devez écrire cette clé dans les options 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

Vous pouvez également utiliser deletgateavec 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

En raison de delegatela commande est exécutée sur l'autre serveur et c'est scple fichier à lui-même.