Ejecuta automáticamente comandos a través de SSH en muchos servidores

Hay una lista de direcciones IP en un archivo .txt, por ejemplo:

1.1.1.1
2.2.2.2
3.3.3.3

Detrás de cada dirección IP hay un servidor, y en cada servidor hay un sshd ejecutándose en el puerto 22. No todos los servidores están en la known_hostslista (en mi PC, Ubuntu 10.04 LTS / bash).

¿Cómo puedo ejecutar comandos en estos servidores y recopilar la salida?

Idealmente, me gustaría ejecutar los comandos en paralelo en todos los servidores.

Usaré la autenticación de clave pública en todos los servidores.

Aquí hay algunos peligros potenciales:

• El ssh me pide que coloque la clave ssh de los servidores dados en mi known_hostsarchivo.
• Los comandos dados pueden devolver un código de salida distinto de cero, lo que indica que la salida es potencialmente inválida. Necesito reconocer eso.
• Es posible que no se pueda establecer una conexión con un servidor determinado, por ejemplo, debido a un error de red.
• Debería haber un tiempo de espera, en caso de que el comando se ejecute por más tiempo de lo esperado o el servidor se caiga mientras se ejecuta el comando.

Los servidores son AIX / ksh (pero creo que eso realmente no importa.

Suponiendo que no puede instalar pssh u otros, puede hacer algo similar a:

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"

Existen varias herramientas que le permiten iniciar sesión y ejecutar series de comandos en varias máquinas al mismo tiempo. Aquí hay una pareja:

• pssh
• pdsh
• clusterssh
• clusterit
• mussh

Si te gustan las secuencias de bashcomandos de Python más que las secuencias de comandos, Fabric podría ser la herramienta para ti.

Desde la página de inicio de Fabric :

Fabric es una biblioteca de Python (2.5 o superior) y una herramienta de línea de comandos para simplificar el uso de SSH para la implementación de aplicaciones o tareas de administración de sistemas.

Proporciona un conjunto básico de operaciones para ejecutar comandos de shell locales o remotos (normalmente o mediante sudo) y cargar / descargar archivos, así como funciones auxiliares, como solicitar al usuario en ejecución que ingrese o anular la ejecución.

El uso típico implica crear un módulo de Python que contenga una o más funciones y luego ejecutarlas a través de la herramienta de línea de comandos fab.

Yo uso GNU paralelo para eso, más específicamente puedes usar esta receta:

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

Al your.txtser el archivo con la dirección IP / nombres del servidor.

Configuración muy básica:

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

Autenticar con nombre / contraseña no es realmente una buena idea. Debe configurar una clave privada para esto:

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

Sugiero Ansible.cc . Es un administrador de configuración y un despachador de comandos.

Creo que estás buscando pssh y las versiones paralelas relacionadas de los habituales scp, rsync, etc.

He construido una herramienta de código abierto llamado Tormenta de hacer este tipo de cosas más fácil.

Primero define sus servidores:

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

Luego puede ejecutar múltiples comandos y archivos de script a través de ellos, ya sea secuencialmente o en paralelo, de la siguiente manera:

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

El proyecto Hypertable ha agregado recientemente una herramienta ssh de múltiples hosts. Esta herramienta está construida con libssh y establece conexiones y emite comandos de forma asíncrona y en paralelo para obtener el máximo paralelismo. Consulte Herramienta SSH de múltiples hosts para obtener la documentación completa. Para ejecutar un comando en un conjunto de hosts, debe ejecutarlo de la siguiente manera:

$ ht ssh 1.1.1.1,2.2.2.2,3.3.3.3 uptime

También puede especificar un nombre de host o un patrón de IP, por ejemplo:

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

También admite una --random-start-delay <millis>opción que retrasará el inicio del comando en cada host en un intervalo de tiempo aleatorio entre 0 y <millis>milisegundos. Esta opción se puede utilizar para evitar problemas de rebaño cuando el comando que se ejecuta accede a un recurso central.

He desarrollado collectnode Muy simple y efectivo para ejecutar tareas en varios servidores (ventanas incluidas)

Cómo usar CollectNode:

1. Cree la lista de servidores para trabajar con:

   # cat hosts.file
   server1
   server2
   server3
   server4
   server5
   

2. Ejecute CollectNode pasando la lista de servicios:

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

3. Opcionalmente, es posible filtrar los resultados, por ejemplo, este comando solo muestra el servidor donde se cumple la condición.

   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/

Solo un aviso para una muy buena pregunta:

La mejor solución que he encontrado es, no sorprendentemente, tmux.

Puede hacer Ctrl-B: setw sincronizar paneles en tmux para obtener un resultado sorprendente. Debe tener todas sus conexiones ssh abiertas, en diferentes paneles de 1 ventana de Tmux para esto.

¿Tal vez algo como esto funciona, para ejecutar comandos en varios hosts? supongamos que todos los hosts están configurados en .ssh / config para iniciar sesión sin contraseña.

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

Crear un archivo / etc / sxx / hosts

poblar así:

[grp_ips]
1.1.1.1
2.2.2.2
3.3.3.3

Compartir clave ssh en todas las máquinas.

Instale sxx desde el paquete:

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

Luego ejecute el comando así:

sxx username@grp_ips "whatever bash command"

Utilice Paramiko http://www.paramiko.org/ y paralelismo basado en hilos https://docs.python.org/3/library/threading.html. ¡El código de abajo permite ejecutar múltiples comandos en cada servidor en paralelo!

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()

Nota: repita las instrucciones anteriores para cada servidor.

Creo que "esperar" es lo que necesitas.
Mucha gente ni siquiera sabe que existe. Es un programa basado en tcl que hará preguntas y posibles respuestas en su nombre. Echa un vistazo a https://wiki.tcl-lang.org/page/Expect