Pesquisa de site

Fabric - Execute comandos Shell remotamente por SSH no Linux

No mundo em constante mudança do desenvolvimento de software, o gerenciamento remoto eficiente de servidores é crucial. Quer você seja um administrador de sistema, um engenheiro de software ou um desenvolvedor de software, ser capaz de executar comandos do Linux em servidores remotos é uma tarefa comum.

É aqui que o Fabric, uma biblioteca Python de alto nível projetada para executar comandos Linux remotamente via SSH, a torna uma ferramenta indispensável para quem precisa gerenciar sistemas remotos enquanto aproveitando o poder do Python.

O que é tecido?

Fabric é uma biblioteca Python versátil que simplifica o processo de execução de comandos shell em servidores remotos por meio de conexões SSH. Foi inicialmente desenvolvido por Jeff Forcier e mais tarde tornou-se um projeto de código aberto.

Ele fornece uma interface Pythonic de alto nível para trabalhar com sistemas remotos, permitindo automatizar tarefas, implantar código e gerenciar configurações em vários servidores sem esforço.

Por que usar tecido?

Existem vários motivos convincentes para escolher o Fabric para suas necessidades de execução remota de comandos:

  • Abordagem Python – Fabric adere à filosofia do Python, tornando mais fácil para desenvolvedores e administradores de sistema escrever scripts em uma linguagem com a qual já estão familiarizados.
  • SSH e Paramiko – O Fabric depende da biblioteca Paramiko para lidar com conexões SSH, que fornece uma maneira segura e confiável de executar comandos remotamente.
  • Fluxo de trabalho baseado em tarefas – O Fabric incentiva uma abordagem orientada a tarefas para execução remota de comandos. Você define tarefas, que são essencialmente funções Python, e o Fabric se encarrega de executá-las em servidores remotos.
  • Casos de uso – Fabric é uma ferramenta versátil adequada para uma ampla variedade de casos de uso, incluindo implantação de aplicativos, gerenciamento de configurações de servidor e execução de tarefas de manutenção de sistema.

Neste guia, abordaremos as etapas para apresentar e começar a usar o Fabric para aprimorar a administração de servidores para grupos de servidores.

Como instalar a ferramenta Fabric Automation no Linux

Uma característica importante do fabric é que as máquinas remotas que você precisa administrar só precisam ter o servidor OpenSSH padrão instalado.

Você só precisa de determinados requisitos instalados no servidor a partir do qual está administrando os servidores remotos antes de começar.

Requisitos:

  • Python 2.5+ com os cabeçalhos de desenvolvimento
  • Python-setuptools e pip (opcional, mas preferido) gcc

Fabric é facilmente instalado usando o gerenciador de pacotes pip, mas você também pode preferir escolher seu gerenciador de pacotes padrão yum, dnf ou apt/apt-get para instalar o pacote fabric , normalmente chamado de fabric ou python-fabric.

Instale o Fabric em sistemas RHEL

Em distribuições baseadas em RHEL, como CentOS Stream, Rocky Linux e AlmaLinux, você deve ter o repositório EPEL instalado e habilitado no sistema para instale o pacote fabric.

sudo dnf install epel-release
sudo dnf install fabric

Instale o Fabric em sistemas Debian

Em distribuições baseadas em Debian, como Ubuntu e Linux Mint, os usuários podem simplesmente fazer o apt para instalar o pacote fabric como mostrando:

sudo apt install fabric

Instale o Fabric usando PiP

Se o fabric não estiver disponível nos repositórios do seu sistema, você pode usar o pip para instalá-lo conforme mostrado.

sudo yum install python3-pip       [On RedHat based systems] 
sudo dnf install python3-pip       [On Fedora 22+ versions]
sudo apt install python3-pip       [On Debian based systems]

Depois que o pip for instalado com sucesso, você poderá usar pip para obter a versão mais recente do fabric conforme mostrado:

pip3 install fabric

Como usar o Fabric para automatizar tarefas de administração do Linux

Vamos começar a usar o Fabric. Como parte do processo de instalação, um script Python chamado 'fab' foi adicionado a um diretório no PATH do seu sistema. O script 'fab' cuida de todas as tarefas ao usar o Fabric.

Execute comandos do Linux localmente

Por convenção, você precisa começar criando um arquivo Python chamado fabfile.py usando seu editor de texto favorito. Lembre-se de que você pode dar a este arquivo um nome diferente conforme desejar, mas precisará especificar o caminho do arquivo da seguinte forma:

fab --fabfile /path/to/the/file.py

Fabric usa 'fabfile.py' para executar tarefas, o 'fabfile' deve estar localizado no mesmo diretório onde você executa o Ferramenta de tecido.

Exemplo 1: Vamos criar um Hello World básico primeiro.

vi fabfile.py

Adicione essas linhas de código ao arquivo.

def hello():
       print('Hello world, Tecmint community')

Salve o arquivo e execute o comando abaixo.

fab hello

Vejamos agora um exemplo de fabfile.py para executar o comando uptime na máquina local.

Exemplo 2: Abra um novo arquivo fabfile.py da seguinte maneira:

vi fabfile.py

E cole as seguintes linhas de código no arquivo.

#!  /usr/bin/env python
from fabric.api import local
def uptime():
  local('uptime')

Em seguida, salve o arquivo e execute o seguinte comando:

fab uptime

Execute comandos do Linux remotamente por SSH

A API Fabric usa um dicionário de configuração que é equivalente em Python a um array associativo conhecido como env, que armazena valores que controlam o que o Fabric faz.

O env.hosts é uma lista de servidores nos quais você deseja executar tarefas do Fabric. Se sua rede é 192.168.0.0 e deseja gerenciar hosts 192.168.0.2 e 192.168.0.6 com seu fabfile , você poderia configurar env.hosts da seguinte forma:

#!/usr/bin/env python
from  fabric.api import env
env.hosts = [ '192.168.0.2', '192.168.0.6' ]

A linha de código acima especifica apenas os hosts nos quais você executará tarefas do Fabric, mas não fará mais nada. Para que você possa definir algumas tarefas, o Fabric fornece um conjunto de funções que você pode usar para interagir com suas máquinas remotas.

Embora existam muitas funções, as mais comumente usadas são:

  • run – que executa um comando shell em uma máquina remota.
  • local – que executa o comando na máquina local.
  • sudo – que executa um comando shell em uma máquina remota, com privilégios de root.
  • Get – que baixa um ou mais arquivos de uma máquina remota.
  • Put – que carrega um ou mais arquivos para uma máquina remota.

Exemplo 3: Para ecoar uma mensagem em várias máquinas, crie um fabfile.py como o mostrado abaixo.

#!/usr/bin/env python
from fabric.api import env, run
env.hosts = ['192.168.0.2','192.168.0.6']
def echo():
      run("echo -n 'Hello, you are tuned to Tecmint ' ")

Para executar as tarefas, execute o seguinte comando:

fab echo

Exemplo 4: Você pode melhorar o fabfile.py que você criou anteriormente para executar o comando uptime na máquina local para que ele executa o comando uptime e também verifica o uso do disco usando o comando df em várias máquinas da seguinte maneira:

#!/usr/bin/env python
from fabric.api import env, run
env.hosts = ['192.168.0.2','192.168.0.6']
def uptime():
      run('uptime')
def disk_space():
     run('df -h')

Salve o arquivo e execute o seguinte comando:

fab uptime
fab disk_space

Instale automaticamente a pilha LAMP no servidor Linux remoto

Exemplo 4: Vejamos um exemplo de implantação de um servidor LAMP (Linux, Apache, MySQL/MariaDB e PHP) em um servidor Linux remoto.

Escreveremos uma função que permitirá que o LAMP seja instalado remotamente usando privilégios de root.

Para RHEL/CentOS e Fedora
#!/usr/bin/env python
from fabric.api import env, run
env.hosts = ['192.168.0.2','192.168.0.6']
def deploy_lamp():
  run ("yum install -y httpd mariadb-server php php-mysql")
Para Debian/Ubuntu e Linux Mint
#!/usr/bin/env python
from fabric.api import env, run
env.hosts = ['192.168.0.2','192.168.0.6']
def deploy_lamp():
  sudo("apt-get install -q apache2 mysql-server libapache2-mod-php php-mysql")

Salve o arquivo e execute o seguinte comando:

fab deploy_lamp

Observação: Devido à grande produção, não podemos criar um screencast (gif animado) para este exemplo.

Agora você pode automatizar tarefas de gerenciamento de servidor Linux usando Fabric e seus recursos e exemplos dados acima…

Opções úteis de tecido

  • Você pode executar fab --help para visualizar informações úteis e uma longa lista de opções de linha de comando disponíveis.
  • Uma opção importante --fabfile=PATH que ajuda você a especificar um arquivo de módulo Python diferente para importar, diferente de fabfile.py.
  • Para especificar um nome de usuário a ser usado ao conectar-se a hosts remotos, use a opção --user=USER.
  • Para usar uma senha para autenticação e/ou sudo, use a opção --password=PASSWORD.
  • Para imprimir informações detalhadas sobre o comando NAME, use a opção --display=NAME.
  • Para visualizar os formatos use a opção --list, opções: curto, normal, aninhado, use a opção --list-format=FORMAT.
  • Para imprimir uma lista de comandos possíveis e sair, inclua a opção --list.
  • Você pode especificar o local do arquivo de configuração a ser usado usando a opção --config=PATH.
  • Para exibir uma saída de erro colorida, use --colorize-errors.
  • Para visualizar o número da versão do programa e sair, use a opção --version.
Resumo

Fabric é uma poderosa biblioteca Python que agiliza a execução remota de comandos por meio de SSH, fornecendo uma abordagem Pythonic fácil de usar. Sua capacidade de simplificar tarefas complexas e automatizar o gerenciamento de sistemas o torna uma ferramenta valiosa para administradores de sistemas, desenvolvedores e profissionais de DevOps.

Esteja você gerenciando um único servidor ou orquestrando uma implantação em grande escala, o Fabric pode ajudá-lo a realizar o trabalho com eficiência e eficácia.