Como executar um script local em um servidor Linux remoto

A criação de scripts de tarefas repetitivas melhora a eficiência da administração do sistema. Isso é ótimo para máquinas locais, mas e se você supervisionar servidores remotos? Você pode executar um script local em um computador remoto? Sim!

Conexões remotas

A administração remota do sistema geralmente envolve fazer uma conexão com o computador remoto por meio de uma  conexão shell segura  . A conexão SSH fornece um prompt de comando no computador remoto. Você pode então prosseguir e realizar qualquer manutenção do sistema necessária.

O script Shell ajuda, permitindo agrupar uma sequência de comandos em um script que pode ser executado como se fosse um programa, combinando muitas ações em uma instrução de linha de comando.

Com o passar do tempo, você ajustará e melhorará seus scripts. Se você tiver muitas máquinas remotas para administrar, manter a cópia de cada script em cada servidor atualizada e atualizada será uma tarefa difícil e uma sobrecarga cansativa. Torna-se uma tarefa administrativa em si e consome a economia de tempo que o uso de scripts supostamente proporciona.

A solução ideal permitiria manter seus scripts em sua máquina local e executá-los em computadores remotos por meio da conexão SSH. Isso proporcionaria um gerenciamento simplificado com uma coleção centralizada de scripts, e o mesmo script atualizado seria executado em todos os computadores.

Bash e SSH fornecem uma maneira de fazer exatamente isso.

Conexões SSH sem senha

A melhor maneira de fazer isso é com conexões sem senha, usando chaves SSH. Ao gerar chaves SSH em seu computador local e enviá-las para cada um dos computadores remotos, você pode conectar-se aos computadores remotos de forma segura e conveniente, sem ser solicitada uma senha todas as vezes.

Embora possam ser intimidantes para usuários iniciantes, as chaves SSH não são realmente difíceis. Eles são fáceis de gerar, simples de instalar nos servidores remotos e simples quando você os usa com SSH. Os únicos pré-requisitos são que os computadores remotos tenham o daemon SSH

 sshd 

em execução e que você possui uma conta de usuário no computador remoto.

Se você já estiver administrando sistema remotamente neles, ambos os requisitos já deverão estar satisfeitos.

Para gerar um par de chaves SSH, digite:

ssh-keygen

Se você tiver uma conta chamada “dave” em um computador chamado “fedora-36.local”, você pode enviar e instalar sua chave pública SSH nele com este comando:

ssh-copy-id dave@fedora-36.local

Agora, fazer uma conexão SSH da maneira usual irá autenticar usando as chaves SSH. Você é levado a um prompt de comando no servidor remoto sem ser solicitada uma senha.

ssh dave@fedora-36.local

Executando um script local remotamente

Para esses testes, nosso servidor remoto é um computador Linux chamado “fedora-36.local”. Configuramos chaves SSH e testamos nossa conexão sem senha com o servidor remoto do nosso computador local.

Nosso roteiro é muito simples. Ele grava um carimbo de data/hora em um arquivo chamado “timestamp.txt”, no servidor remoto. Observe que o script termina com o comando exit. Isso é importante, pois em alguns sistemas mais antigos é possível que um script seja executado até o fim, mas a conexão SSH permanece aberta.

#!/bin/bash
data >> carimbo de data/hora.txt
saída 0

Copie este texto em um editor, salve-o como “local.sh” e use-o chmodpara torná-lo executável .

chmod +x local.sh

Em nossa máquina local, iniciaremos o script assim:

ssh dave@fedora-36.local 'bash -s' <local.sh

Veja como isso funciona.

• ssh dave@fedora-36.local : A conexão SSH que estamos fazendo com a máquina remota. Isso usa o sshcomando, a conta de usuário pré-existente no servidor remoto e o endereço do servidor remoto.
• ‘bash -s’ : Isso faz com que o Bash leia comandos do fluxo de entrada padrão. Ele permite que o Bash leia entradas redirecionadas ou canalizadas.
• <local.sh : Estamos redirecionando o script para o Bash.

Quando o script é executado, retornamos ao prompt de comando da máquina local. Indo para nossa máquina remota, podemos usar cat para examinar o arquivo “timestamp.txt”.

carimbo de data/hora do gato.txt

Podemos ver o carimbo de data/hora da última — e atualmente única — conexão. A execução do script local várias vezes adiciona carimbos de data/hora correspondentes ao arquivo remoto.

carimbo de data/hora do gato.txt

É claro que, em uma situação do mundo real, o seu script faria algo mais útil. Mas mesmo nosso exemplo trivial demonstra que um script local está sendo executado em um servidor remoto.

Passando argumentos para o script

Você pode passar argumentos de linha de comando para o script. Modificaremos nosso script para esperar três parâmetros de linha de comando. Eles são redirecionados para o arquivo “timestamp.txt” junto com o carimbo de data/hora.

Salve este script como “local2.sh” e torne-o executável com chmod.

#!/bin/bash
echo "$1 $2 $3" >> timestamp.txt
data >> carimbo de data/hora.txt
saída 0

O comando que precisamos usar é semelhante ao exemplo anterior, com algumas alterações.

ssh dave@fedora-36.local "bash -s" -- < local2.sh "Como fazer\ Geek" "Linux" "Artigos"

O hífen duplo ” --” informa ao Bash que o que se segue não deve ser considerado parâmetro de linha de comando para o sshcomando. Os três parâmetros do script seguem o nome do script, como sempre. Observe que usamos uma barra invertida ” \” para escapar do espaço no parâmetro “How-To\ Geek”.

Podemos verificar catse nossos parâmetros foram recebidos e tratados corretamente no servidor remoto.

carimbo de data/hora do gato.txt

Executando uma seção de um script remotamente

Se você tiver um script que precisa fazer algum processamento local para determinar quais ações podem ser necessárias nos servidores remotos, você pode adicionar uma seção diretamente nesse script para executar as ações remotas para você.

Podemos conseguir isso usando aqui documentos . Aqui, os documentos nos permitem redirecionar linhas de uma seção rotulada de um script para um comando. O processamento local pode ser realizado acima e abaixo do documento aqui.

Este é o script “local3.sh”, que contém um documento aqui.

#!/bin/bash
# processamento local pode ser feito aqui
# processamento remoto é feito aqui
ssh -T dave@fedora-36.local << _remote_commands
# comandos a serem executados remotamente seriam adicionados aqui
cd /home/dave/Documentos
#etc.
# Finalmente, atualize o arquivo de carimbo de data/hora
echo "Script3.sh:" $(data) >> /home/dave/timestamp.txt
# este é o rótulo que marca o fim do redirecionamento
_remote_commands
# mais processamento local pode ser feito aqui
saída 0

Estamos usando o sshcomando com os mesmos detalhes de conexão de antes. Estamos nos conectando como usuário “dave” em um servidor remoto chamado “fedora-36.local”. Também estamos usando a -Topção (desativar alocação de pseudoterminal). Isto impede que o servidor remoto forneça um terminal interativo para esta conexão.

O redirecionamento ” <<” é seguido pelo nome de um rótulo. Neste exemplo, estamos usando “_remote_commands”. Não há nada de especial neste rótulo, é simplesmente um rótulo.

Todos os comandos que aparecem nas linhas após o redirecionamento são enviados pela conexão SSH. O redirecionamento para quando o rótulo é encontrado. A execução do script continua com a linha após o rótulo.

Vamos executar nosso script misto de processamento local/remoto.

./local3.sh

Como esperado, vemos uma nova entrada no arquivo “timestamp.txt”.

carimbo de data/hora do gato.txt

Amplie seu alcance

Ser capaz de executar scripts remotamente — que são escritos, armazenados e mantidos localmente — fornece uma ferramenta de administração conveniente. Saber que exatamente a mesma versão de um script é executada em todos os seus servidores remotos torna o gerenciamento muito mais fácil.