Como executar um script local em um servidor Linux remoto
Publicados: 2022-09-10
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 seguir em frente e realizar qualquer manutenção do sistema necessária.
O script de shell ajuda ao permitir que você envolva 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 atualizado e atualizado é uma dor e uma sobrecarga cansativa. Torna-se uma tarefa administrativa em si e consome a economia de tempo que o uso de scripts deveria proporcionar.
A solução ideal permitiria manter seus scripts em sua máquina local e executá-los nos computadores remotos pela conexão SSH. Isso lhe daria um gerenciamento simplificado com uma coleção centralizada de scripts, e o mesmo script atualizado é 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 se conectar aos computadores remotos de forma segura e conveniente, sem ser solicitada uma senha a cada vez.
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 sem atrito 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ê tenha uma conta de usuário no computador remoto.
Se você já estiver fazendo administração remota do sistema neles, esses dois requisitos já devem ser atendidos.
Para gerar um par de chaves SSH, digite:
ssh-keygen
Se você tem uma conta chamada “dave” em um computador chamado “fedora-36.local”, você pode enviar e instalar sua chave pública SSH com este comando:
ssh-copy-id [email protected]
Agora, fazer uma conexão SSH da maneira usual fará a autenticação usando as chaves SSH. Você é colocado em um prompt de comando no servidor remoto sem ser solicitado a fornecer uma senha.
ssh [email protected]
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 de nosso computador local.
Nosso roteiro é muito simples. Ele grava um timestamp em um arquivo chamado “timestamp.txt”, no servidor remoto. Observe que o script conclui com o comando exit. Isso é importante, em alguns sistemas mais antigos é possível que um script seja executado até a conclusão, mas a conexão SSH é mantida aberta.
#!/bin/bash data >> timestamp.txt saída 0
Copie este texto em um editor, salve-o como “local.sh” e use chmod para torná-lo executável.
chmod +x local.sh
Em nossa máquina local, iniciaremos o script assim:
ssh [email protected] 'bash -s' < local.sh
Veja como isso funciona.
- ssh [email protected] : A conexão SSH que estamos fazendo com a máquina remota. Isso usa o comando
ssh, 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 a entrada redirecionada ou canalizada.
- < local.sh : Estamos redirecionando o script para o Bash.
Quando o script é executado, retornamos ao prompt de comando da máquina local. Passando para nossa máquina remota, podemos usar cat para olhar dentro do arquivo “timestamp.txt”.
cat timestamp.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 os carimbos de data e hora correspondentes ao arquivo remoto.
cat timestamp.txt
Claro, em uma situação do mundo real, 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 timestamp.
Salve este script como “local2.sh” e torne-o executável com chmod .
#!/bin/bash echo "$1 $2 $3" >> timestamp.txt data >> timestamp.txt saída 0
O comando que precisamos usar é semelhante ao exemplo anterior, com algumas alterações.
ssh [email protected] "bash -s" -- < local2.sh "Como fazer\ Geek" "Linux" "Artigos"
O hífen duplo “ -- ” diz ao Bash que o que segue não deve ser considerado parâmetros de linha de comando para o comando ssh . Os três parâmetros para o script seguem o nome do script, como de costume. Observe que usamos uma barra invertida “ \ ” para escapar do espaço no parâmetro “How-To\ Geek”.
Podemos verificar com cat se nossos parâmetros foram recebidos e tratados corretamente no servidor remoto.
cat timestamp.txt
Executando uma seção de um script remotamente
Se você tiver um script que precise fazer algum processamento local para determinar quais ações podem ser necessárias nos servidores remotos, você pode adicionar uma seção diretamente a esse script para executar as ações remotas para você.
Podemos conseguir isso usando os documentos aqui. 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 [email protected] << _remote_commands # comandos a serem executados remotamente seriam adicionados aqui cd /home/dave/Documents #etc # Por fim, atualize o arquivo timestamp 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 comando ssh 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 opção -T (desativar alocação de pseudoterminal). Isso impede que o servidor remoto forneça um terminal interativo para essa 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 é interrompido quando o rótulo é encontrado. A execução do script continua com a linha que segue o rótulo.
Vamos executar nosso script misto de processamento local/remoto.
./local3.sh
Como esperado, vemos uma nova entrada no arquivo “timestamp.txt”.
cat timestamp.txt
Amplie seu alcance
Poder 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.
RELACIONADO: Como gerenciar servidores Linux com a interface Web do Cockpit