5 automações em Shell Script essenciais para o dia a dia de um DevOps
Shell Script nunca saiu de moda, e sempre tem seu espaço dentro das ferramentas de DevOps, tenho utilizado algumas automações dentro do meu #homelab que agregam muito
Voltando com TUDO pessoal e bora falar de Shell Script e automação, que por sinal gosto demais. Quem trabalha com sistemas LINUX sabe o quão útil é ter uma automação que facilita a administração do sistema, desde uma simples instalação de aplicativo até um troubleshooting complexo. Pensando nessa ideia, eu estou escrevendo esse post para compartilhar alguns exemplos de Shell Scripts, que eu tenho usado no meu #homelab e que agregam demais, ganhando tempo, reduzindo erros humanos e aumentando a produtividade (não estou falando de ChatGPT haha), produtividade com Shell Scripts 💜 Bora né??
O que você vai aprender hoje
Hoje é dia de aprender mais sobre automação e sobre Shell Script, prepara seu café☕️ e venha curtir uma leitura📚 rica de conhecimentos sobre temas relevantes, o assunto abordado hoje é MUITO requerido pelo mercado de trabalho, e pode acelerar seu conhecimento dentro dos pilares de DevOps. Confira abaixo os principais tópicos de hoje:
- Por que você deve automatizar?
- Automação em DevOps
- Shell Script vs Ansible
- 5 automações em Shell Script
Por que você deve automatizar?
A automação em sistemas e infraestruturas é extremamente necessária, por diversos motivos. No geral, no âmbito corporativo, a automação é importante para empresas que desejam crescer e se tornar cada vez mais competitivas e eficientes no cenário complexo, e acelerado que temos visto hoje dia, com diversas tecnologias sendo criadas, métodos que mudam o tempo todo e os níveis de abstrações das infraestruturas. Ao automatizar processos e tarefas, as empresas podem economizar tempo, reduzir erros humanos e melhorar a produtividade. Veja abaixo alguns dos benefícios da automação, que valem para casos corporativos e #homelabs de DevOps:
- Eficiência: A automação pode economizar tempo e reduzir erros ao eliminar a necessidade de tarefas manuais. Os processos automatizados podem ser executados de forma mais rápida, o que pode resultar em maior eficiência e produtividade dos processos criados.
- Consistência: a automação garante que as tarefas sejam concluídas sempre da mesma forma, seguindo um padrão, o que ajuda a garantir consistência e confiabilidade diante do processo. Isso é especialmente importante para tarefas críticas, dentro de uma operação de um sistema ou organização.
- Escalabilidade: à medida que os sistemas e as organizações crescem, as tarefas manuais podem se tornar mais demoradas e complexas. A automação pode ajudar a escalar essas tarefas para acomodar o crescimento sem diminuir a qualidade ou a eficiência da automação.
- Eliminação de gastos: ao automatizar tarefas, as organizações podem reduzir a necessidade de trabalho manual e economizar nos gastos que normalmente são altos. Além disso, infraestruturas automatizadas, como por exemplo, Terraform, podem se beneficiar da ferramenta da Hashicorp para provisionamento dos recursos, garante que tudo seja gerenciado pelo Terraform, evitando custos com recursos ligados.
Automação em DevOps
Quando falamos sobre automação, logo nos lembramos de DevOps, e de fato ambos estão conectados: a automação é um pilar muito forte dentro da cultura DevOps, e ter o mindset de automação faz de você um engenheiro mais cobiçado pelas empresas e um profissional mais criativo. Você pode aplicar a automação em diversas etapas do processo de desenvolvimento de software, desde a parte de CI/CD, testes do sistema, até o provisionamento dos recursos, observabilidade e segurança do aplicativo/infraestrutura.
Eu escrevi um post bem legal sobre automação com Shell Script no passado, acredito que seja bacana de compartilhar com você para acrescentar no seu processo de aprendizado. É direto ao ponto, onde eu mostro como executar um Shell Script, como criar uma template para seu script, alguns cursos e livros que eu usei e que também podem agregar no conhecimento, e sair automatizando tarefas importantes dentro do seu projeto, trabalho. Que fiquei claro que dentro do processo de automação em DevOps, o Shell Script sempre terá seu lugar, quando estamos precisando de algo simples, funcional e rápido, lembre-se de automatizar e usar Shell Script.
Shell Script x Ansible
Acredito que muitos gostam também de automação com o Ansible, ferramenta focada em gerenciamento de configuração dentro do ciclo de DevOps. Quando usamos ambas as ferramentas (Shell Script & Ansible ), obtemos o máximo de automação possível, visto que, temos os módulos do Ansible super consistentes e juntamente, temos o Shell Script para atuar como parceiro dentro do processo, um se conectando ao outro para gerenciar configurações nos sistemas. Já usei MUITO essa combinação e posso indicar com toda certeza.
Shell scripts são normalmente usados para tarefas de administração de sistemas em um único servidor, enquanto o Ansible é usado para gerenciar vários servidores e pode ser usado para orquestrar fluxos de trabalho em vários sistemas. Existem n formas de passar comandos do Bash dentro de módulos do Ansible, aqui nesse link tem alguns exemplos. Nesse outro artigo eu compartilhei minha jornada quando eu estava indo do Shell Script para o Ansible. Outro artigo bacana que eu usei, foi para automatizar o processo de instalação do agente do Zabbix.
5 automações em Shell Script
Caindo com TUDO no mundo da automação, vamos para 5 casos de uso onde eu usei Shell Scripts para meu #homelab de DevOps, na preparação e gerenciamento do sistema operacional, tudo com muito LINUX🐧 🚀 📚
1- Atualização do S.O LINUX
Podemos iniciar com um Shell Script bem famoso de #homelab, que é a automação dos principais comandos de update e upgrade do sistema LINUX, seja Debian ou Fedora. Sempre que fazemos o provisionamento de imagem LINUX, temos que executar os comandos para atualizar os repositórios configurados do sistema, e atualizar os pacotes instalados no sistema operacional para a versão mais recente. Com um Shell Script isso fica mais prático e rápido. Pode parecer simples, mas no dia a dia, provisionando maquinetas LINUX ou até mesmo estudando, isso ajuda MUITO. Confira:
#!/usr/bin/env bash
# ------------------------------------------------------------------------ #
# Script Name: update-system.sh
# Description: Update the systems
# Site: https://amaurybsouza.medium.com/
# Written by: Amaury Souza
# Maintenance: Amaury Souza
# ------------------------------------------------------------------------ #
# Usage:
# $ ./system-backup.sh
# ------------------------------------------------------------------------ #
# Tested on:
# Bash 4.2.46
# ------------------------------------------------------------------------ #
# History: v1.0 22/04/2023, Amaury:
# - start de program
# - add bash commands
# v1.1 23/04/2022, Amaury:
# - code review
# v1.2 23/04/2023, Amaury:
# - check the applicability
# ------------------------------------------------------------------------ #
# Thankfulness:
#
#VARIABLES --------------------------------------------------------------- #
#
#FUNCTIONS
#
#CODE
sudo apt update ; apt upgrade -y
sudo apt list --upgradable
sudo apt autoremove -y
sudo apt clean
echo "System update completed!"
#END --------------------------------------------------------------------- #2- Backup do Sistema
Se existe um Shell Script super necessário é o de backup. Quantas vezes tive que fazer backup manualmente, rodando mkdir, tar, cp, mv e outros comandos do LINUX para criar um backup de algum diretório. Depois no fim, nem eu sabia onde que estava salvo o backup, era tenso demais, mas foi um processo necessário para que examinasse na prática, o processo de automação de tarefas no LINUX. O Shell Script que eu tenho usado no meu #homelab de DevOps é esse abaixo:
#!/usr/bin/env bash
# ------------------------------------------------------------------------ #
# Script Name: system-backup.sh
# Description: Backup from /etc directory
# Site: https://amaurybsouza.medium.com
# Written by: Amaury Souza
# Maintenance: Amaury Souza
# ------------------------------------------------------------------------ #
# Usage:
# $ ./system-backup.sh
# ------------------------------------------------------------------------ #
# Tested on:
# Bash 4.2.46
# ------------------------------------------------------------------------ #
# History: v1.0 30/05/2020, Amaury:
# - Start de program
# - Add function
# v1.1 30/05/2020, Amaury:
# - Adding new variables
# v1.2 30/05/2020, Amaury:
# - Executing new tests in my system
# ------------------------------------------------------------------------ #
# Thankfulness: Amaury
#
#VARIABLES --------------------------------------------------------------- #
ROOT_UID=0
timestamp=`date +%d-%m-%y-%H:%M`
dir_source=/etc
dir_dest=/backup
#FUNCTIONS --------------------------------------------------------------- #
compact() {
tar -cjvf $dir_dest/bkp-$timestamp-usr.tar.bz2 $dir_source
}
isroot() {
if [ "$UID" -ne "$ROOT_UID" ]
then
echo ""
echo "Must be root to run this script!"
echo ""
exit $E_NOTROOT
fi
}
#CODE -------------------------------------------------------------------- #
isroot
if [ -d $dir_dest ]
then
compact
else
if [ -f $dir_dest ]
then
echo "Not a dir $dir_dest it is a file"
sleep 2
else
mkdir $dir_dest
compact
fi
fi
#END -------------------------------------------------------------------- #3- Gerenciamento do firewalld no CentOS 7
Como uso CentOS aqui no meu #homelab, as vezes é necessário ajustar alguma regra de firewall e para não ter que ficar gerenciando isso de forma manual ou via Ansible, preferi seguir com um Shell Script simples, usando a lógica do case e deu muito certo, basicamente é acionar esse script que ele adiciona, carrega as regras e mostra as regras setadas no meu sistema.
#!/usr/bin/env bash
# ------------------------------------------------------------------------ #
# Script Name: firewalld.sh
# Description: Firewalld service management
# Site: https://amaurybsouza.medium.com
# Written by: Amaury Souza
# Maintenance: Amaury Souza
# ------------------------------------------------------------------------ #
# Usage:
# $ ./firewalld.sh
# ------------------------------------------------------------------------ #
# Tested on:
# Bash 4.2.46
# ------------------------------------------------------------------------ #
# History: v1.0 21/04/2023, Amaury:
# - Start de program
# - Add case feature
# v1.1 21/04/2023, Amaury:
# - Adding new variables
# v1.2 21/04/2023, Amaury:
# - Executing new tests in my system
# ------------------------------------------------------------------------ #
# Thankfulness:
#
#
#VARIABLES --------------------------------------------------------------- #
STATUS=`systemctl status firewalld | grep -i "running" | cut -d " " -f 4,5,6`
START=`systemctl start firewalld`
SHOW=`firewall-cmd --list-all | grep -i "services"`
RELOAD=`firewall-cmd --reload`
#CODE -------------------------------------------------------------------- #
clear
while true;do
echo " "
echo "Welcome at $0"
echo " "
echo "Choose a option below to start!
1- ensure firewalld service is installed
2- show firewalld status
3- start firewalld service
4- show available rules
5- add new rules
6- reload firewalld service
0- Exit script"
echo " "
echo -n "selected option: "
read option
case $option in
1)
if [ -x `command -v firewalld` ]
then
echo " "
echo "Installed and latest version"
sleep 2
echo " "
else
echo "Not installed yet"
sleep 2
echo " "
fi
;;
2)
echo " "
echo "Firewalld status: $STATUS"
;;
3)
echo "Starting service..."
sleep 2
echo "$START"
;;
4)
echo -n "Rules available... $SHOW"
echo " "
;;
5)
echo -n "Type a rule: "
read rule
if [ -z $rule ]
then
echo "You don't type nothing"
else
echo -n "Your rule: $rule"
echo " "
firewall-cmd --add-service=$rule --permanent
fi
echo
;;
6)
echo "Reloading..."
sleep 2
echo "$RELOAD"
;;
*)
echo "No input found please, try again!"
;;
esac
done
#END ------------------------------------------------------------------ #4- Instalação do Kind (Kubernetes local)
Como tudo hoje está sendo criado em containers, nada melhor do que termos, de fácil acesso, aquele Shell Script para uma instalação mais rápida do Kind (Kubernetes local). Às vezes é necessário algum teste, e com esse aplicativo instalado localmente na nossa maquineta facilita demais: você pode subir uma app, validar algum recurso do Kubernetes, testar seu deployment e mais outras opções.. Ponto interessante aqui de saber, para se ter o Kind funcionando no seu sistema, certifique-se de ter o Docker instalado e funcionando corretamente.
#!/usr/bin/env bash
# ------------------------------------------------------------------------ #
# Script Name: install-kind-kube.sh
# Description: install kubectl & kind apps
# Site: https://amaurybsouza.medium.com/
# Written by: Amaury Souza
# Maintenance: Amaury Souza
# Requirements: needs Docker installed
# ------------------------------------------------------------------------ #
# Usage:
# $ ./install-kind-kube.sh
# ------------------------------------------------------------------------ #
# Tested on:
# Bash 4.2.46
# ------------------------------------------------------------------------ #
# History: v1.0 10/03/2023, Amaury:
# - start de program
# - add the kubectl commands
# v1.2 10/03/2023, Amaury:
# - add the kind commands and checks
# ------------------------------------------------------------------------ #
# Thankfulness:
#
#
#VARIABLES --------------------------------------------------------------- #
#
#CODE
#KUBECTL
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
kubectl version --short
#KIND
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.11.1/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind
kind version
#END -------------------------------------------------------------------- #5- Gerenciamento do sistema
Para algumas pessoas é necessário ter o entendimento de como está o funcionamento do sistema, esse script tem por objetivo mostrar as informações básicas de hardware e software do sistema, tais como processador, memória, kernel, endereço de rede, serial number do desktop. Foi implementado para utilização em sistemas Debian/Ubuntu. Já estou trabalhando em outra versão que seja compatível com CentOS/Fedora.
#!/usr/bin/env bash
# ------------------------------------------------------------------------ #
# Script Name: hardware_systems.sh
# Description: Show informations about the systems.
# Written by: Amaury Souza
# Maintenance: Amaury Souza
# ------------------------------------------------------------------------ #
# Usage:
# $ ./hardware_systems.sh
# ------------------------------------------------------------------------ #
# Bash Version:
# Bash 4.4.19
# ------------------------------------------------------------------------ #
#CODE
function menuprincipal () {
clear
echo " "
echo HARDWARE MACHINE INFORMATION $0
echo " "
echo "Escolha uma opção abaixo para começar!
1 - Verificar processador do desktop
2 - Verificar kernel do sistema
3 - Verificar softwares instalados
4 - Versão do sistema operacional
5 - Verificar memória do equipamento
6 - Verificar serial number
7 - Verificar IP do sistema
0 - Sair do menu"
echo " "
echo -n "Opção escolhida: "
read opcao
case $opcao in
1)
function processador () {
TIME=2
CPU_INFO=`cat /proc/cpuinfo | grep -i "^model name" | cut -d ":" -f2 | sed -n '1p'`
echo "Modelo de CPU: $CPU_INFO"
sleep $TIME
}
processador
read -n 1 -p "<Enter> para menu principal"
menuprincipal
;;
2)
function kernel () {
#Para sistemas RED HAT: cat /etc/redhat-release
KERNEL_VERSION_UBUNTU=`uname -r`
KERNEL_VERSION_CENTOS=`uname -r`
if [ -f /etc/lsb-release ]
then
echo "Versão do kernel: $KERNEL_VERSION_UBUNTU"
else
echo "Versão do kernel: $KERNEL_VERSION_CENTOS"
fi
}
kernel
read -n 1 -p "<Enter> para menu principal"
menuprincipal
;;
3)
function softwares () {
#while true; do (antes eu estava usando esse recurso para controlar o menu, depois para corrigir adicionei uma function)
TIME=2
echo " "
echo "Escolha uma opção abaixo para listar os programas!
1 - Listar programas do Ubuntu
2 - Listar programas do Fedora
3 - Instalar programas padrões
4 - Voltar ao sistema"
echo " "
echo -n "Opção escolhida: "
read alternative
case $alternative in
1)
echo Listando todos os programas do sistema Ubuntu...
sleep $TIME
dpkg -l > /tmp/programas.txt
echo A lista de programas foi gerada e está disponível no /tmp do seu sistema
sleep $TIME
echo " "
echo "Você será redirecionado para o menu inicial do programa!" | tr [a-z] [A-Z]
sleep $TIME
;;
2)
echo Listando todos os programas do sistema Fedora...
sleep $TIME
yum list installed > /tmp/programas.txt
echo A lista de programas foi gerada e está disponível no /tmp
sleep $TIME
;;
3)
echo Instalando pogramas padrões..
LIST_OF_APPS="pinta brasero gimp vlc inkscape blender filezilla"
#usar o comando aptitude do Linux para tratar o loop de programas.
apt install aptitude -y
aptitude install -y $LIST_OF_APPS
;;
4)
echo Voltando para o menu principal...
sleep $TIME
;;
esac
#done
}
softwares
menuprincipal
;;
4)
function sistema () {
VERSION=`cat /etc/os-release | grep -i ^PRETTY`
if [ -f /etc/os-release ]
then
echo "A versão do seu sistema é: $VERSION"
else
echo "Sistema não suportado"
fi
}
sistema
read -n 1 -p "<Enter> para menu principal"
menuprincipal
;;
5)
function memory () {
TIME=2
MEMORY_FREE=`free -m | grep ^Mem | tr -s ' ' | cut -d ' ' -f 4`
MEMORY_TOTAL=`free -m | grep ^Mem | tr -s ' ' | cut -d ' ' -f 2`
MEMORY_USED=`free -m | grep ^Mem | tr -s ' ' | cut -d ' ' -f 3`
echo Verificando a memória do sistema...
echo "A memória livre é: $MEMORY_FREE"
sleep $TIME
echo "A memória total é: $MEMORY_TOTAL"
sleep $TIME
echo "A memória usada é: $MEMORY_USED"
}
memory
read -n 1 -p "<Enter> para menu principal"
menuprincipal
;;
6)
function serial () {
SERIAL_NUMBER=`dmidecode -t 1 | grep -i serial`
echo $SERIAL_NUMBER
}
serial
read -n 1 -p "<Enter> para menu principal"
menuprincipal
;;
7)
function ip () {
IP_SISTEMA=`hostname -I`
echo O IP do seu sistema é: $IP_SISTEMA
}
ip
read -n 1 -p "<Enter> para menu principal"
menuprincipal
;;
0)
echo Saindo do sistema...
sleep 2
exit 0
;;
*)
echo Opção inválida, tente novamente!
;;
esac
}
menuprincipalFinalizando
O foco principal do post é sobre automação em DevOps com Shell Scripts, mais precisamente em #homelab, sei que existem n formas de automatizar, integrações possíveis e mais outros exemplos de uso dentro da cultura DevOps, hoje foi uma visão do todo, justamente para dar aquele gatilho na mente dos leitores e assim despertar o mindset de automação. Fique sempre a vontade para comentar, trazer seus exemplos, questionamentos e dar aquele feedback. DevOps é colaboração também!
Espero que tenham curtido a leitura e os exemplos demonstrados nesse post, compartilha com a turma e bora ver mais ideias surgindo, outros exemplos de uso de Shell Scripts. E me diz aí:
- Tem utilizado Shell Scripts no seu #homelab ou está automatizando apenas com Ansible, Python?
- Se estiver usando Shell Scripts, poderia compartilhar algum insight com a gente? Quem sabe alguém esteja precisando de algo parecido.
- Gostou do meu modelo de cabeçalho para documentar os scripts?
Ansible (e similares) são sobre aplicar uma configuração a um ou mais servidores. Containers são sobre definir um estado inicial imutável para um software (via Dockerfile, por exemplo). São visões bem diferentes e o sucesso de containers reduziu bastante a utilidade de ferramentas como Ansible (gestão de configuração). Neste mundo conteinerizado é comum que os Shell Scripts encontrem um novo lugar:
- Podem estar em Dockerfiles definindo layers que sejam passos RUN mais complexos na criação da imagem.
- Podem estar em Dockerfiles definindo uma inicialização complexa do container (CMD ou ENTRYPOINT).
- Podem estar dentro da imagem ou do host de containers para simplificar a vida de quem cuida do ambiente /SysAdmin ou SRE).
É isso aí, bora automatizar, pode ser com Bash, Python, Ansible, o importante é criar esse senso, e sempre buscar a melhoria contínua, afinal estamos sempre aprendendo!! TMJ. 🚀🚀🚀
