Executar comandos automaticamente por SSH em muitos servidores

Há uma lista de endereços IP em um arquivo .txt, por exemplo:

1.1.1.1
2.2.2.2
3.3.3.3

Por trás de cada endereço IP, há um servidor e em cada servidor existe um sshd em execução na porta 22. Nem todos os servidores estão na known_hostslista (no meu PC, Ubuntu 10.04 LTS / bash).

Como posso executar comandos nesses servidores e coletar a saída?

Idealmente, eu gostaria de executar os comandos em paralelo em todos os servidores.

Vou usar autenticação de chave pública em todos os servidores.

Aqui estão algumas armadilhas em potencial:

• O ssh solicita que eu coloque a chave ssh dos servidores no meu known_hostsarquivo.
• Os comandos fornecidos podem retornar um código de saída diferente de zero, indicando que a saída é potencialmente inválida. Eu preciso reconhecer isso.
• Uma conexão pode falhar ao ser estabelecida com um determinado servidor, por exemplo, devido a um erro de rede.
• Deve haver um tempo limite, caso o comando seja executado por mais tempo do que o esperado ou o servidor fique inativo durante a execução do comando.

Os servidores são AIX / ksh (mas acho que isso realmente não importa.

Supondo que você não consiga instalar o pssh ou outros, você pode fazer algo semelhante 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"

Existem várias ferramentas disponíveis que permitem efetuar login e executar uma série de comandos em várias máquinas ao mesmo tempo. Aqui estão alguns:

• pssh
• pdsh
• clusterssh
• clusterit
• mussh

Se você gosta mais de scripts Python do que bashscripts, o Fabric pode ser a ferramenta para você.

Na página inicial do Fabric :

O Fabric é uma biblioteca e ferramenta de linha de comando Python (2.5 ou superior) para otimizar o uso do SSH para tarefas de implantação de aplicativos ou administração de sistemas.

Ele fornece um conjunto básico de operações para a execução de comandos locais ou remotos do shell (normalmente ou via sudo) e upload / download de arquivos, além de funcionalidade auxiliar, como solicitar ao usuário em execução a entrada ou interromper a execução.

O uso típico envolve a criação de um módulo Python contendo uma ou mais funções e, em seguida, executá-las por meio da ferramenta de linha de comando fab.

Eu uso o GNU paralelo para isso, mais especificamente você pode usar esta receita:

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

Com your.txtsendo o arquivo com o IP do servidor de endereços / nomes.

Configuração muito básica:

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

Autenticar com nome / senha não é realmente uma boa ideia. Você deve configurar uma chave privada para isso:

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

Eu sugiro Ansible.cc . É um gerenciador de configuração e despachante de comando.

Eu acho que você está procurando pssh e as versões paralelas relacionadas do usual scp, rsync, etc.

Criei uma ferramenta de código aberto chamada Overcast para facilitar esse tipo de coisa.

Primeiro você define seus 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

Em seguida, você pode executar vários comandos e arquivos de script entre eles, sequencialmente ou em paralelo, da seguinte maneira:

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

O projeto Hypertable adicionou recentemente uma ferramenta ssh de vários hosts. Essa ferramenta é criada com libssh e estabelece conexões e emite comandos de forma assíncrona e paralela para máximo paralelismo. Consulte Ferramenta SSH de vários hosts para obter a documentação completa. Para executar um comando em um conjunto de hosts, execute-o da seguinte maneira:

$ ht ssh 1.1.1.1,2.2.2.2,3.3.3.3 uptime

Você também pode especificar um nome de host ou padrão de IP, por exemplo:

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

Ele também suporta uma --random-start-delay <millis>opção que atrasará o início do comando em cada host por um intervalo aleatório entre 0 e <millis>milissegundos. Essa opção pode ser usada para evitar problemas de rebanho trovejante quando o comando em execução acessa um recurso central.

Eu desenvolvi o collectnode Muito simples e eficaz para executar tarefas em vários servidores (janelas incluídas)

Como usar o CollectNode:

1. Crie a lista de servidores para trabalhar:

   # cat hosts.file
   server1
   server2
   server3
   server4
   server5
   

2. Execute o CollectNode passando a lista de saques:

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

3. Opcionalmente, é possível filtrar os resultados, por exemplo, este comando exibe apenas o servidor em que a condição é realizada.

   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/

Apenas um alerta para uma pergunta muito boa:

A melhor solução que encontrei é, não surpreendentemente, o tmux.

Você pode fazer o Ctrl-B: configurar painéis de sincronização no tmux para obter resultados incríveis. Você deve ter todas as suas conexões ssh abertas, em diferentes painéis de 1 janela do Tmux para isso.

Talvez algo assim funcione, para executar o comando em vários hosts? suponha que todos os hosts estejam configurados em .ssh / config para login sem senha.

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

Crie um arquivo / etc / sxx / hosts

preencher assim:

[grp_ips]
1.1.1.1
2.2.2.2
3.3.3.3

compartilhe a chave ssh em todas as máquinas.

Instale o sxx do pacote:

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

Em seguida, execute o comando da seguinte maneira:

sxx username@grp_ips "whatever bash command"

Use o Paramiko http://www.paramiko.org/ e o paralelismo baseado em thread https://docs.python.org/3/library/threading.html . O código abaixo permite executar vários comandos em cada servidor em 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 as instruções acima para cada servidor.

Eu acho que "esperar" é o que você precisa.
Muitas pessoas nem sabem que existe. É um programa baseado em tcl que fará perguntas e possíveis respostas em seu nome. Dê uma olhada em https://wiki.tcl-lang.org/page/Expect