Fabric – Automatizar a Execução de Comandos e Implantação no Linux por SSH

Tutoriais

No mundo em constante mudança do desenvolvimento de software, a gestão eficiente de servidores remotos é crucial. Seja você um administrador de sistemas, um engenheiro de software ou um desenvolvedor de software, ser capaz de executar comandos Linux em servidores remotos é uma tarefa comum.

É aqui que o Fabric, uma biblioteca de alto nível em Python projetada para executar comandos Linux remotamente via SSH, se torna uma ferramenta indispensável para qualquer pessoa que precise gerenciar sistemas remotos enquanto aproveita o poder do Python.

O que é o Fabric?

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

Ele fornece uma interface Pythonica 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 o Fabric?

Há várias razões convincentes para escolher o Fabric para suas necessidades de execução de comandos remotos:

  • Abordagem Pythonica – O Fabric adere à filosofia do Python, tornando 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, o 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 a execução de comandos remotos. Você define tarefas, que são essencialmente funções Python, e o Fabric se encarrega de executá-las em servidores remotos.
  • Casos de Uso – O Fabric é uma ferramenta versátil adequada para uma ampla gama de casos de uso, incluindo implantação de aplicativos, gerenciamento de configurações de servidor e execução de tarefas de manutenção do sistema.

Neste guia, abordaremos os passos para introduzir e começar a usar o Fabric para aprimorar a administração do servidor para grupos de servidores.

Como Instalar a Ferramenta de Automação Fabric 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 ter certos requisitos instalados no servidor do qual está administrando os servidores remotos antes de começar.

Você só precisa de certas instalações no servidor a partir do qual você está administrando os servidores remotos antes de começar.

Requisitos:

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

Fabric é facilmente instalado usando o gestor 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, geralmente chamado fabric ou python-fabric.

Instale o Fabric em Sistemas RHEL

No 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 instalar o pacote fabric.

sudo dnf install epel-release
sudo dnf install fabric

Instalar o Fabric em Sistemas Debian

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

sudo apt install fabric

Instalar o Fabric Usando PiP

Se fabric não estiver disponível em seus repositórios do sistema, você pode usar pip para instalá-lo como 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ê pode usar pip para obter a versão mais recente de fabric como mostrado:

pip3 install fabric

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

Vamos começar a aprender a usar 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' lida com todas as tarefas ao usar Fabric.

Executar 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 como desejar, mas precisará especificar o caminho do arquivo da seguinte maneira:

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

Fabric usa 'fabfile.py' para executar tarefas, o 'fabfile' deve estar localizado na mesma pasta onde você executa a Ferramenta Fabric.

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
Fabric Tool Usage

Vamos agora ver um exemplo de um fabfile.py para executar o comando uptime no computador local.

Exemplo 2: Abra um novo 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
Fabric: Check System Uptime

Executar Comandos do Linux Remotamente via SSH

A API Fabric usa um dicionário de configuração que é o equivalente em Python de uma matriz associativa conhecida como env, que armazena valores que controlam o que o Fabric faz.

O env.hosts é uma lista de servidores em que você deseja executar tarefas Fabric. Se sua rede for 192.168.0.0 e desejar gerenciar os hosts 192.168.0.2 e 192.168.0.6 com seu fabfile, você poderia configurar o 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 em que você executará tarefas Fabric, mas não faz mais nada. Portanto, você pode definir algumas tarefas, a Fabric fornece um conjunto de funções que você pode usar para interagir com seus computadores remotos.

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

  • run – que executa um comando shell em um computador remoto.
  • local – que executa o comando no computador local.
  • sudo – que executa um comando shell em um computador remoto, com privilégios de root.
  • Get – que baixa um ou mais arquivos de um computador remoto.
  • Put – que envia um ou mais arquivos para um computador remoto.

Exemplo 3: Para exibir uma mensagem em vários computadores, crie um fabfile.py como o 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
Fabric: Automate Linux Tasks on Remote Linux

Exemplo 4: Você pode aprimorar o fabfile.py que criou anteriormente para executar o comando de uptime no computador local para que execute o comando uptime e também verifique o uso de disco usando o comando df em vários computadores 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
Fabric: Automate Tasks on Multiple Linux Systems

Instalar automaticamente a pilha LAMP em servidor Linux remoto

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

Vamos escrever uma função que permitirá a instalação remota do LAMP 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

Nota: Devido à grande saída, não podemos criar um vídeo (gif animado) para este exemplo.

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

Opções úteis do Fabric

  • 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 a ser importado, além 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 formatos, use a opção --list, escolhas: short, normal, nested, 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 simplifica a execução de comandos remotos via SSH, fornecendo uma abordagem Pythonica amigável ao usuário. Sua capacidade de simplificar tarefas complexas e automatizar a administração de sistemas a torna uma ferramenta valiosa para administradores de sistemas, desenvolvedores e profissionais DevOps.

Se você está gerenciando um único servidor ou orquestrando um grande lançamento em escala, o Fabric pode ajudá-lo a concluir a tarefa de forma eficiente e eficaz.

Source:
https://www.tecmint.com/automating-linux-system-administration-tasks/