Qual é a maneira mais limpa de ssh e executar vários comandos no Bash?

Eu já tenho um agente ssh configurado e posso executar comandos em um servidor externo no script Bash, fazendo coisas como:

ssh blah_server "ls; pwd;"

Agora, o que eu realmente gostaria de fazer é executar muitos comandos longos em um servidor externo. Incluir tudo isso entre aspas seria bastante feio, e eu realmente prefiro evitar o ssh'ing várias vezes apenas para evitar isso.

Então, existe uma maneira de fazer isso de uma só vez entre parênteses ou algo assim? Estou procurando algo ao longo das linhas de:

ssh blah_server (
   ls some_folder;
   ./someaction.sh;
   pwd;
)

Basicamente, ficarei feliz com qualquer solução, desde que esteja limpa.

Editar

Para esclarecer, estou falando sobre fazer parte de um script bash maior. Outras pessoas podem precisar lidar com o script no final da linha, então eu gostaria de mantê-lo limpo. Eu não quero ter um script bash com uma linha que se parece com:

ssh blah_server "ls some_folder; ./someaction.sh 'some params'; pwd; ./some_other_action 'other params';"

porque é extremamente feio e difícil de ler.

Que tal um documento do Bash Here :

ssh otherhost << EOF
  ls some_folder; 
  ./someaction.sh 'some params'
  pwd
  ./some_other_action 'other params'
EOF

Para evitar os problemas mencionados por @Globalz nos comentários, você poderá (dependendo do que está fazendo no site remoto) evitar a substituição da primeira linha por

ssh otherhost /bin/bash << EOF

Observe que você pode fazer a substituição de variáveis ​​no documento Aqui, mas pode ser necessário lidar com problemas de cotação. Por exemplo, se você citar a "string de limite" (ou seja, EOFacima), não poderá fazer substituições de variáveis. Mas sem citar a cadeia de limite, as variáveis ​​são substituídas. Por exemplo, se você definiu $NAMEacima em seu script de shell, poderá fazer

ssh otherhost /bin/bash << EOF
touch "/tmp/${NAME}"
EOF

e criaria um arquivo no destino otherhostcom o nome do que você atribuiu $NAME. Outras regras sobre a citação de scripts de shell também se aplicam, mas são muito complicadas para entrar aqui.

Edite seu script localmente e coloque-o no ssh, por exemplo

cat commands-to-execute-remotely.sh | ssh blah_server

onde se commands-to-execute-remotely.shparece com sua lista acima:

ls some_folder
./someaction.sh
pwd;

Para corresponder ao seu código de amostra, você pode agrupar seus comandos dentro de qoutes únicos ou duplos. Por exemplo

ssh blah_server "
  ls
  pwd
"

Eu vejo duas maneiras:

Primeiro você faz um soquete de controle como este:

 ssh -oControlMaster=yes -oControlPath=~/.ssh/ssh-%r-%h-%p <yourip>

e execute seus comandos

 ssh -oControlMaster=no -oControlPath=~/.ssh/ssh-%r-%h-%p <yourip> -t <yourcommand>

Dessa forma, você pode escrever um comando ssh sem realmente se reconectar ao servidor.

O segundo seria gerar dinamicamente o script, scpinserindo-o e executando-o.

Isso também pode ser feito da seguinte maneira. Coloque seus comandos em um script, vamos chamá-lo de command-inc.sh

#!/bin/bash
ls some_folder
./someaction.sh
pwd

Salve o arquivo

Agora execute-o no servidor remoto.

ssh user@remote 'bash -s' < /path/to/commands-inc.sh

Nunca falhou por mim.

Coloque todos os comandos em um script e ele pode ser executado como

ssh <remote-user>@<remote-host> "bash -s" <./remote-commands.sh

SSH e executar vários comandos no Bash.

Separe os comandos com ponto-e-vírgula dentro de uma sequência, transmitidos para eco, todos direcionados para o comando ssh. Por exemplo:

echo "df -k;uname -a" | ssh 192.168.79.134

Pseudo-terminal will not be allocated because stdin is not a terminal.
Filesystem     1K-blocks    Used Available Use% Mounted on
/dev/sda2       18274628 2546476  14799848  15% /
tmpfs             183620      72    183548   1% /dev/shm
/dev/sda1         297485   39074    243051  14% /boot
Linux newserv 2.6.32-431.el6.x86_64 #1 SMP Sun Nov 10 22:19:54 EST 2013 x86_64 x86_64 x86_64 GNU/Linux

Para quem tropeça aqui como eu - tive sucesso ao escapar do ponto e vírgula e da nova linha:

Primeiro passo: o ponto e vírgula. Dessa forma, não quebramos o comando ssh:

ssh <host> echo test\;ls
                    ^ backslash!

Listou o diretório remoto hosts / home (conectado como root), enquanto

ssh <host> echo test;ls
                    ^ NO backslash

listou o diretório de trabalho atual.

Próxima etapa: dividindo a linha:

                      v another backslash!
ssh <host> echo test\;\
ls

Isso novamente listou o diretório ativo remoto - formatação aprimorada:

ssh <host>\
  echo test\;\
  ls

Se realmente melhor do que aqui documento ou aspas em torno de linhas quebradas - bem, não eu para decidir ...

(Usando o bash, Ubuntu 14.04 LTS.)

As respostas postadas usando seqüências de linhas múltiplas e vários scripts bash não funcionaram para mim.

• Cordas multilinhas longas são difíceis de manter.
• Os scripts bash separados não mantêm variáveis ​​locais.

Aqui está uma maneira funcional de ssh e executar vários comandos, mantendo o contexto local.

LOCAL_VARIABLE=test

run_remote() {
    echo "$LOCAL_VARIABLE"
    ls some_folder; 
    ./someaction.sh 'some params'
    ./some_other_action 'other params'
}

ssh otherhost "$(set); run_remote"

Não tenho certeza se o mais limpo para comandos longos, mas certamente o mais fácil:

ssh user@host "cmd1; cmd2; cmd3"

Isso funciona bem para criar scripts, pois você não precisa incluir outros arquivos:

#!/bin/bash
ssh <my_user>@<my_host> "bash -s" << EOF
    # here you just type all your commmands, as you can see, i.e.
    touch /tmp/test1;
    touch /tmp/test2;
    touch /tmp/test3;
EOF

A maneira mais fácil de configurar seu sistema para usar sessões ssh únicas por padrão com multiplexação.

Isso pode ser feito criando uma pasta para os soquetes:

mkdir ~/.ssh/controlmasters

E adicionando o seguinte à sua configuração .ssh:

Host *
    ControlMaster auto
    ControlPath ~/.ssh/controlmasters/%r@%h:%p.socket
    ControlMaster auto
    ControlPersist 10m

Agora, você não precisa modificar nenhum do seu código. Isso permite várias chamadas para ssh e scp sem criar várias sessões, o que é útil quando é necessário que haja mais interação entre as máquinas local e remota.

Graças à resposta do @ terminus, http://www.cyberciti.biz/faq/linux-unix-osx-bsd-ssh-multiplexing-to-speed-up-ssh-connections/ e https://en.wikibooks.org / wiki / OpenSSH / Cookbook / Multiplexação .