Exécuter automatiquement des commandes via SSH sur de nombreux serveurs

Il y a une liste d'adresses IP dans un fichier .txt, ex .:

1.1.1.1
2.2.2.2
3.3.3.3

Derrière chaque adresse IP, il y a un serveur et sur chaque serveur, il y a un sshd fonctionnant sur le port 22. Tous les serveurs ne figurent pas dans la known_hostsliste (sur mon PC, Ubuntu 10.04 LTS / bash).

Comment puis-je exécuter des commandes sur ces serveurs et collecter la sortie?

Idéalement, j'aimerais exécuter les commandes en parallèle sur tous les serveurs.

Je vais utiliser l'authentification par clé publique sur tous les serveurs.

Voici quelques pièges potentiels:

• Le SSH m'invite à mettre la clé SSH des serveurs donnés à mon known_hostsfichier.
• Les commandes données peuvent renvoyer un code de sortie différent de zéro, indiquant que la sortie est potentiellement non valide. J'ai besoin de le reconnaître.
• Une connexion peut ne pas être établie avec un serveur donné, par exemple à cause d’une erreur de réseau.
• Il devrait y avoir un délai d'expiration, au cas où la commande serait exécutée plus longtemps que prévu ou si le serveur ne fonctionnait pas pendant l'exécution de la commande.

Les serveurs sont AIX / ksh (mais je pense que cela n'a pas vraiment d'importance.

En supposant que vous ne puissiez pas installer pssh ou d’autres personnes, vous pourriez faire quelque chose comme:

tmpdir=${TMPDIR:-/tmp}/pssh.$$
mkdir -p $tmpdir
count=0
while IFS= read -r userhost; do
    ssh -n -o BatchMode=yes ${userhost} 'uname -a' > ${tmpdir}/${userhost} 2>&1 &
    count=`expr $count + 1`
done < userhost.lst
while [ $count -gt 0 ]; do
    wait $pids
    count=`expr $count - 1`
done
echo "Output for hosts are in $tmpdir"

Il existe plusieurs outils vous permettant de vous connecter à et d'exécuter des séries de commandes sur plusieurs ordinateurs à la fois. Voici un couple:

• pssh
• pdsh
• clusterssh
• cluster
• moules

Si vous utilisez plus les scripts Python que les bashscripts, alors Fabric est peut-être l'outil idéal.

Depuis la page d'accueil de Fabric :

Fabric est une bibliothèque Python (2.5 ou supérieure) et un outil de ligne de commande permettant de rationaliser l'utilisation de SSH pour le déploiement d'applications ou les tâches d'administration système.

Il fournit une suite d'opérations de base pour exécuter des commandes de shell locales ou distantes (normalement ou via sudo) et pour charger / télécharger des fichiers, ainsi que des fonctionnalités auxiliaires telles que l'invite de l'utilisateur en cours de saisie ou l'abandon de l'exécution.

Son utilisation typique consiste à créer un module Python contenant une ou plusieurs fonctions, puis à les exécuter via l’outil de ligne de commande fab.

J'utilise GNU parallèle pour cela, plus précisément vous pouvez utiliser cette recette:

parallel --tag --nonall --slf your.txt command

Avec your.txtêtre le fichier avec l'adresse IP / les noms du serveur.

Configuration très basique:

for host in $(cat hosts.txt); do ssh "$host" "$command" >"output.$host"; done

Authentifier avec nom / mot de passe n'est vraiment pas une bonne idée. Vous devez configurer une clé privée pour cela:

ssh-keygen && for host in $(cat hosts.txt); do ssh-copy-id $host; done

Je suggère Ansible.cc . C'est un gestionnaire de configuration et un répartiteur de commandes.

Je pense que vous êtes à la recherche de pssh et des versions parallèles des scp, rsync, etc.

J'ai construit un outil open-source appelé Overcast pour faciliter ce genre de choses.

D'abord, vous définissez vos serveurs:

overcast import vm.01 --ip 1.1.1.1 --ssh-key /path/to/key
overcast import vm.02 --ip 2.2.2.2 --ssh-key /path/to/key

Ensuite, vous pouvez exécuter plusieurs commandes et fichiers de script, séquentiellement ou parallèlement, comme suit:

overcast run vm.* uptime "free -m" /path/to/script --parallel

Le projet Hypertable a récemment ajouté un outil ssh multi-hôtes. Cet outil est construit avec libssh et établit des connexions et émet des commandes de manière asynchrone et en parallèle pour un parallélisme maximal. Voir Outil SSH multi-hôtes pour une documentation complète. Pour exécuter une commande sur un ensemble d'hôtes, vous devez l'exécuter comme suit:

$ ht ssh 1.1.1.1,2.2.2.2,3.3.3.3 uptime

Vous pouvez également spécifier un nom d'hôte ou un modèle IP, par exemple:

$ ht ssh 1.1.1.[1-99] uptime
$ ht ssh host[00-99] uptime

Il prend également en charge une --random-start-delay <millis>option qui retardera le début de la commande sur chaque hôte d’un intervalle de temps aléatoire compris entre 0 et <millis>millisecondes. Cette option peut être utilisée pour éviter des problèmes de tonnerre lorsque la commande en cours d'exécution accède à une ressource centrale.

J'ai développé collectnode Très simple et efficace pour exécuter des tâches sur plusieurs serveurs (Windows inclus)

Comment utiliser CollectNode:

1. Créez la liste du serveur, avec laquelle travailler:

   # cat hosts.file
   server1
   server2
   server3
   server4
   server5
   

2. Exécutez CollectNode en passant la liste des services:

   collectnode --file servers.txt --command='cat /etc/httpd/conf/httpd.conf |grep ^User'
   

3. En option, il est possible de filtrer les résultats. Par exemple, cette commande n’affiche que le serveur sur lequel la condition est remplie.

   collectnode --file servers.txt --command='cat /etc/httpd/conf/httpd.conf |grep ^User' --where="command contain User"
   

https://collectnode.com/5-tasks-collectnode-can-help-managing-servers/

Juste un heads-up pour une très bonne question:

La meilleure solution que j'ai trouvée est, sans surprise, tmux.

Vous pouvez faire Ctrl-B: setw synchronize-panes dans tmux pour des résultats étonnants. Pour cela, vous devez avoir toutes vos connexions ssh ouvertes, dans des sous-fenêtres différentes d'une fenêtre de Tmux.

Peut-être que quelque chose comme ceci fonctionne, pour exécuter la commande sur plusieurs hôtes? Supposons que tous les hôtes sont configurés dans .ssh / config pour une connexion sans mot de passe.

$ < hosts.txt xargs -I {} ssh {} command

Créez un fichier / etc / sxx / hosts

peupler comme ça:

[grp_ips]
1.1.1.1
2.2.2.2
3.3.3.3

partage la clé SSH sur toutes les machines.

Installez sxx à partir du paquet:

https://github.com/ericcurtin/sxx/releases

Puis lancez la commande comme ceci:

sxx username@grp_ips "whatever bash command"

Utilisez Paramiko http://www.paramiko.org/ et le parallélisme basé sur les threads https://docs.python.org/3/library/threading.html . Le code .below permet d'exécuter plusieurs commandes sur chaque serveur en parallèle!

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.load_system_host_keys()
ssh.connect(hostname, port, username, password)
t = threading.Thread(target=tasks[index], args=(ssh, box_ip,))
t.start()

Remarque: répétez les instructions ci-dessus pour chaque serveur.

Je pense "attendre" est ce dont vous avez besoin.
Beaucoup de gens ne savent même pas qu'il existe. C'est un programme basé sur tcl qui posera des questions et des réponses possibles en votre nom. Jetez un coup d'œil à https://wiki.tcl-lang.org/page/Expect