web-dev-qa-db-fra.com

Comment copier des fichiers entre deux nœuds en utilisant ansible

J'ai besoin de copier la machine de forme de fichier A sur la machine B alors que ma machine de contrôle depuis laquelle je lance toutes mes tâches ansibles est la machine C (machine locale).

J'ai essayé ce qui suit:

tilisez 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 sans fin.

tilisez les modules fetch & copy

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 jette 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.

ansible
83
user3228188

Pour copier des fichiers distants, vous pouvez utiliser le module synchroniser avec le mot clé 'delegate_to: source-server':

- 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 livret peut être exécuté à partir de votre machineC.

89
ant31

Comme ant31 l'a déjà indiqué, vous pouvez utiliser le module synchronize 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é à l'aide du paramètre delegate_to de la tâche (il est important de noter qu'il s'agit d'un paramètre de la tâche et non du module).

Vous pouvez placer la tâche sur ServerA ou ServerB, mais vous devez ajuster la direction du transfert en conséquence (à l'aide du paramètre mode 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
_

Ceci utilise la valeur par défaut _mode: Push_ afin que le fichier soit transféré du délégué (ServerA) à la télécommande actuelle (ServerB).

Cela peut sembler étrange, puisque 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é , qui dans ce cas est ServerA. Donc, appuyer (de ServerA à ServerB) est bien 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 a lieu 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
_

Ceci utilise _mode: pull_ pour inverser le sens du transfert. Encore une fois, gardez à l’esprit que la tâche est réellement exécutée sur ServerB. Tirer est donc le bon choix.

82
Florian Brucker

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

lorsque vous êtes sur remote_server, vous 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
2
CrusaderX

J'ai pu résoudre ce problème en utilisant local_action to scp to file de machineA à machineC puis en copiant le fichier sur machineB.

2
user3228188

Vous pouvez aussi utiliser deletgate avec 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 delegate, la commande est exécutée sur l'autre serveur et il scp le fichier pour lui-même.

0
Kris

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

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

Voici 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}
0
Aliabbas Kothawala