Scripts Bash RHEL: Crie e Execute para Administração de Sistemas

Introdução

Neste laboratório, você aprenderá a criar e executar scripts Bash para administração de sistemas RHEL. Começará por criar scripts simples, depois aprimorá-los com comandos do sistema e torná-los executáveis. O laboratório progride para o uso de loops for para automatizar tarefas como coleta de informações do sistema e filtragem da saída de comandos com grep e expressões regulares. Finalmente, você construirá um script abrangente de informações do sistema RHEL, adquirindo habilidades práticas na automatização de tarefas administrativas e aproveitando os poderosos recursos do shell.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 82%. Recebeu uma taxa de avaliações positivas de 99% dos estudantes.

Criar e Executar um Script Bash Simples

Nesta etapa, você aprenderá a criar um script Bash básico e executá-lo. Scripts Bash são arquivos de texto simples contendo uma série de comandos que o shell Bash pode executar. Eles são ferramentas poderosas para automatizar tarefas repetitivas e combinar múltiplos comandos em uma única unidade executável.

Primeiro, você criará um novo diretório para armazenar seus scripts. É uma boa prática organizar seus arquivos, e colocar scripts em um diretório dedicado ajuda a manter seu diretório home organizado.

Crie um diretório para seus scripts.
Use o comando mkdir para criar um diretório chamado scripts dentro do seu diretório ~/project. É aqui que você armazenará seus scripts Bash.
```
mkdir ~/project/scripts
```
Não haverá saída direta deste comando se for bem-sucedido.
Crie seu primeiro arquivo de script Bash.
Navegue para o diretório scripts recém-criado e use o editor de texto nano para criar um arquivo chamado firstscript.sh. A extensão .sh é uma convenção comum para scripts de shell, embora não seja estritamente necessária.
```
cd ~/project/scripts
nano firstscript.sh
```
Dentro do editor nano, você verá uma tela em branco.
Adicione conteúdo ao seu script.
Todo script Bash deve começar com uma linha "shebang", #!/usr/bin/bash. Esta linha informa ao sistema operacional qual interpretador usar para executar o script (neste caso, Bash). Após o shebang, você adicionará um comando echo simples para imprimir uma mensagem no terminal.

Digite as seguintes linhas no editor nano:
```
#!/usr/bin/bash
echo "Hello, LabEx! This is my first Bash script."
```
Depois de inserir o conteúdo, salve o arquivo pressionando Ctrl+O, depois Enter para confirmar o nome do arquivo e Ctrl+X para sair do nano.

Seu terminal deve retornar ao prompt de comando.
Execute seu script usando o interpretador bash.
Você pode executar um script Bash informando explicitamente ao interpretador bash para executá-lo. Este método não exige que o script tenha permissões executáveis.
```
bash firstscript.sh
```
Você deve ver a saída do seu script:
```
Hello, LabEx! This is my first Bash script.
```
Isso confirma que seu script foi criado corretamente e executado com sucesso.

Aprimorar Script Bash com Comandos do Sistema e Torná-lo Executável

Nesta etapa, você aprimorará seu script Bash adicionando mais comandos do sistema e aprenderá como tornar o script diretamente executável. Tornar um script executável permite que você o execute como qualquer outro comando, sem chamar explicitamente o interpretador bash.

Navegue para o seu diretório de scripts.
Certifique-se de estar no diretório ~/project/scripts onde você criou firstscript.sh na etapa anterior.
```
cd ~/project/scripts
```
Edite firstscript.sh para incluir mais comandos do sistema.
Agora você adicionará comandos ao seu script que exibem informações do sistema, como dispositivos de bloco e espaço livre do sistema de arquivos. Isso demonstra como os scripts podem automatizar a coleta de dados do sistema.

Abra firstscript.sh usando nano:
```
nano firstscript.sh
```
Modifique o conteúdo do arquivo para corresponder ao seguinte. Este script agora:
- Imprime um cabeçalho para informações do dispositivo de bloco.
- Executa lsblk para listar os dispositivos de bloco.
- Imprime um cabeçalho para o espaço livre do sistema de arquivos.
- Executa df -h para exibir o uso do espaço em disco em um formato legível por humanos.
```
#!/usr/bin/bash
echo "Hello, LabEx! This is my first Bash script."
echo "#####################################################"
echo "LIST BLOCK DEVICES"
echo "#####################################################"
lsblk
echo "#####################################################"
echo "FILESYSTEM FREE SPACE STATUS"
echo "#####################################################"
df -h
```
Salve o arquivo pressionando Ctrl+O, depois Enter e Ctrl+X para sair do nano.
Torne o script executável.
Para executar um script diretamente (por exemplo, ./firstscript.sh), você precisa conceder a ele permissões executáveis. O comando chmod é usado para alterar as permissões do arquivo. +x adiciona permissão de execução para todos os usuários.
```
chmod +x firstscript.sh
```
Não haverá saída direta deste comando se for bem-sucedido.

Execute o script diretamente.
Agora que o script é executável, você pode executá-lo especificando seu caminho. Como está no seu diretório atual, você usa ./ seguido pelo nome do script.

./firstscript.sh

Você deve ver uma saída semelhante a esta, combinando sua mensagem inicial com a saída de lsblk e df -h:

Hello, LabEx! This is my first Bash script.
#####################################################
LIST BLOCK DEVICES
#####################################################
NAME        MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
loop0         7:0    0 10.2G  1 loop /
loop1         7:1    0  200M  1 loop /usr/local/bin
loop2         7:2    0  200M  1 loop /usr/local/go
loop3         7:3    0  200M  1 loop /usr/local/java
loop4         7:4    0  200M  1 loop /usr/local/node
loop5         7:5    0  200M  1 loop /usr/local/python
#####################################################
FILESYSTEM FREE SPACE STATUS
#####################################################
Filesystem      Size  Used Avail Use% Mounted on
overlay          10G  4.0G  6.1G  40% /
tmpfs            64M     0   64M   0% /dev
tmpfs           7.8G     0  7.8G   0% /sys/fs/cgroup
shm              64M     0   64M   0% /dev/shm
/dev/loop0       10G  4.0G  6.1G  40% /
tmpfs           7.8G     0  7.8G   0% /proc/asound
tmpfs           7.8G     0  7.8G   0% /proc/acpi
tmpfs           7.8G     0  7.8G   0% /proc/scsi
tmpfs           7.8G     0  7.8G   0% /sys/firmware

A saída exata para lsblk e df -h pode variar ligeiramente dependendo do ambiente específico, mas a estrutura e a presença da saída dos comandos devem ser semelhantes.

Usar Loops For para Automatizar a Obtenção do Hostname em Servidores RHEL

Nesta etapa, você aprenderá sobre loops for em Bash e como usá-los para automatizar tarefas em vários servidores. Loops for são instruções fundamentais de fluxo de controle que permitem que você execute um bloco de código repetidamente para cada item em uma lista. Isso é particularmente útil para gerenciar múltiplos sistemas de forma eficiente.

Para este exercício, demonstraremos o conceito usando localhost com diferentes abordagens para simular o trabalho com vários servidores.

Recuperar hostname usando comandos locais.
Antes de usar um loop, vamos ver como você normalmente obteria o hostname do sistema local. Usaremos diferentes métodos para demonstrar o conceito.
```
hostname
hostname -f
```
Você deve ver uma saída semelhante a esta:
```
684791f71c0e35fea6cc1243
684791f71c0e35fea6cc1243
```
Isso demonstra que você pode recuperar com sucesso informações de hostname usando diferentes opções. Observe que, neste ambiente de contêiner, todas as opções de hostname retornam o mesmo ID de contêiner.
Criar um loop for para automatizar a recuperação de hostname com diferentes opções.
Agora, vamos usar um loop for para executar diferentes comandos de hostname de forma mais eficiente. O loop for iterará sobre uma lista de opções de hostname, executando o comando hostname com cada opção.
```
for OPTION in "" "-f" "-s"; do
  echo "hostname ${OPTION}:"
  hostname ${OPTION}
  echo ""
done
```
Vamos detalhar este comando:
- for OPTION in "" "-f" "-s";: Esta parte inicializa o loop. OPTION é uma variável que assumirá o valor de cada item na lista (string vazia, -f, -s) durante cada iteração.
- do: Marca o início dos comandos a serem executados no loop.
- echo "hostname ${OPTION}:";: Isso exibe qual opção está sendo usada.
- hostname ${OPTION};: Este é o comando executado em cada iteração. ${OPTION} se expande para o valor atual da variável OPTION.
- echo "";: Adiciona uma linha em branco para melhor legibilidade.
- done: Marca o fim do loop.
Você deve ver uma saída semelhante a esta:
```
hostname :
684791f71c0e35fea6cc1243

hostname -f:
684791f71c0e35fea6cc1243

hostname -s:
684791f71c0e35fea6cc1243
```
Isso demonstra o poder dos loops for na automatização de tarefas repetitivas com diferentes parâmetros.

Criar e Executar um Script Bash com Loop For para Servidores RHEL

Nesta etapa, você encapsulará o loop for que aprendeu na etapa anterior em um script Bash. Isso permite que você salve a lógica de automação e a reutilize facilmente. Você também aprenderá sobre a variável de ambiente PATH e como tornar seus scripts acessíveis de qualquer diretório.

Navegue para o seu diretório de scripts.
Certifique-se de estar no diretório ~/project/scripts.
```
cd ~/project/scripts
```
Crie um novo script para recuperação de hostname.
Você criará um script chamado get_hostnames.sh que contém o loop for para recuperar informações de hostname usando diferentes opções.

Abra get_hostnames.sh usando nano:
```
nano get_hostnames.sh
```
Adicione o seguinte conteúdo ao arquivo:
```
#!/usr/bin/bash
## This script retrieves hostname information using different options.

for OPTION in "" "-f" "-s"; do
  echo "Getting hostname with option: ${OPTION}"
  hostname ${OPTION}
  echo "------------------------"
done

exit 0
```
Salve o arquivo pressionando Ctrl+O, depois Enter e Ctrl+X para sair do nano.

Vamos detalhar os novos elementos:
- ## This script...: Linhas começando com # são comentários. Elas são ignoradas pelo shell, mas são úteis para documentar seu script.
- echo "Getting hostname with option: ${OPTION}": Esta linha fornece feedback durante a execução do script, indicando qual opção está sendo usada no momento.
- exit 0: Este comando sai explicitamente do script com um código de status de 0, que convencionalmente indica sucesso.
Torne o script executável.
Assim como na etapa anterior, você precisa dar ao seu novo script permissões executáveis.
```
chmod +x get_hostnames.sh
```
Não haverá saída direta deste comando se for bem-sucedido.

Execute o script do seu diretório atual.
Execute o script para verificar sua funcionalidade.

./get_hostnames.sh

Você deve ver uma saída semelhante a esta:

Getting hostname with option:
684791f71c0e35fea6cc1243
------------------------
Getting hostname with option: -f
684791f71c0e35fea6cc1243
------------------------
Getting hostname with option: -s
684791f71c0e35fea6cc1243
------------------------

Entenda a variável de ambiente PATH.
A variável de ambiente PATH é uma lista de diretórios que o shell pesquisa por comandos executáveis. Quando você digita um comando como ls ou grep, o shell procura nos diretórios listados em PATH para encontrar o arquivo executável correspondente.

Exiba sua variável PATH atual:
```
echo $PATH
```
Você verá uma lista de diretórios separada por dois pontos. Por exemplo:
```
/home/labex/.local/bin:/home/labex/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin
```
Observe que ~/project/scripts (ou /home/labex/project/scripts) normalmente não está incluído no PATH padrão. É por isso que você teve que usar ./get_hostnames.sh para executar seu script.
Adicione seu diretório de scripts ao PATH (Opcional, para referência futura).
Embora não seja estritamente necessário para esta etapa do laboratório, é prática comum adicionar um diretório bin ou scripts pessoal ao seu PATH para que você possa executar seus scripts personalizados de qualquer local. Você pode fazer isso adicionando uma linha como export PATH=$PATH:~/project/scripts ao seu arquivo ~/.bashrc ou ~/.zshrc. Para este laboratório, continuaremos a executar scripts especificando seu caminho.

Filtrar a Saída de Comandos com Grep e Expressões Regulares no RHEL

Nesta etapa, você aprenderá como usar o comando grep com expressões regulares para filtrar e extrair informações específicas de forma eficiente da saída de comandos e arquivos. grep é um utilitário poderoso para pesquisar conjuntos de dados de texto simples em busca de linhas que correspondam a uma expressão regular. Expressões regulares (regex) são sequências de caracteres que definem um padrão de pesquisa.

Pesquisar informações específicas de usuário e grupo em arquivos do sistema.
Você usará grep para encontrar informações sobre o usuário e grupo labex nos arquivos /etc/passwd e /etc/group. Esses arquivos armazenam informações de conta de usuário e grupo, respectivamente.

Primeiro, vamos procurar a entrada do usuário labex em /etc/passwd:
```
grep "labex" /etc/passwd
```
Saída esperada:
```
labex:x:1000:1000::/home/labex:/bin/bash
```
Em seguida, encontre a entrada do grupo labex em /etc/group:
```
grep "labex" /etc/group
```
Saída esperada:
```
labex:x:1000:
```
Esses comandos demonstram o uso básico de grep para encontrar correspondências exatas de strings.
Filtrar a saída de lscpu usando grep e expressões regulares.
O comando lscpu exibe informações sobre a arquitetura da CPU. Frequentemente, você só precisa de linhas específicas de sua extensa saída. Você pode usar grep com uma expressão regular para filtrar linhas que começam com "CPU".
```
lscpu | grep '^CPU'
```
Vamos detalhar este comando:
- lscpu: Gera as informações da CPU.
- |: Este é um pipe, que pega a saída padrão de lscpu e a alimenta como entrada padrão para o comando grep.
- grep '^CPU': Pesquisa por linhas que começam com a string literal "CPU". O ^ (acento circunflexo) é uma âncora de expressão regular que corresponde ao início de uma linha.
Saída esperada (pode variar ligeiramente dependendo do ambiente):
```
CPU op-mode(s):                     32-bit, 64-bit
CPU(s):                             4
CPU family:                         6
```
Filtrar arquivos de configuração, ignorando comentários e linhas em branco.
Arquivos de configuração geralmente contêm comentários (linhas começando com #) e linhas em branco que não são relevantes para a configuração real. Você pode usar grep com vários padrões para excluir essas linhas. Vamos demonstrar isso com o arquivo /etc/passwd.
```
grep -v '^#' /etc/passwd | head -5
```
Vamos detalhar este comando:
- grep -v '^#' /etc/passwd: A opção -v inverte a correspondência, o que significa que ela seleciona linhas que não correspondem ao padrão. ^# corresponde a linhas que começam com #. Portanto, esta parte filtra as linhas de comentário.
- |: Canaliza a saída do primeiro comando grep para o próximo comando.
- head -5: Mostra apenas as primeiras 5 linhas da saída.
Saída esperada (mostrando entradas de conta de usuário sem comentários):
```
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
```
Pesquisar padrões específicos em arquivos do sistema.
Você pode usar grep para pesquisar padrões específicos em vários arquivos do sistema. Vamos pesquisar entradas relacionadas ao shell no arquivo /etc/passwd.
```
grep "bash" /etc/passwd
```
Saída esperada (mostrando usuários com shell bash):
```
root:x:0:0:root:/root:/bin/bash
labex:x:1000:1000::/home/labex:/bin/bash
```
Este comando ajuda a identificar usuários que têm bash como seu shell padrão.

Construir um Script Abrangente de Informações do Sistema RHEL

Nesta etapa final, você combinará todos os conceitos aprendidos até agora – scripts Bash, loops for, ssh para execução remota e grep com expressões regulares para filtragem – para construir um script abrangente que coleta informações do sistema de vários servidores RHEL. O script salvará os dados coletados em arquivos de saída separados para cada servidor.

Navegue para o seu diretório de scripts.
Certifique-se de estar no diretório ~/project/scripts.
```
cd ~/project/scripts
```

Crie um novo script chamado system_info.sh.
Este script coletará informações do sistema usando diferentes abordagens para demonstrar os conceitos e redirecionará a saída para arquivos distintos em seu diretório ~/project.

Abra system_info.sh usando nano:

nano system_info.sh

Adicione o seguinte conteúdo ao arquivo:

#!/usr/bin/bash

## Define variables for output directory
OUT_DIR='/home/labex/project'

## Loop through different information gathering approaches
for APPROACH in "basic" "detailed"; do
  OUTPUT_FILE="${OUT_DIR}/output-${APPROACH}.txt"

  echo "Gathering ${APPROACH} system information..."
  ## Clear previous output file or create a new one
  > "${OUTPUT_FILE}"

  ## Get hostname information
  echo "#### Hostname Information ###" >> "${OUTPUT_FILE}"
  if [ "${APPROACH}" = "basic" ]; then
    hostname >> "${OUTPUT_FILE}"
  else
    hostname -f >> "${OUTPUT_FILE}"
  fi
  echo "" >> "${OUTPUT_FILE}" ## Add a blank line for readability

  ## Get CPU information (only lines starting with CPU)
  echo "#### CPU Information ###" >> "${OUTPUT_FILE}"
  lscpu | grep '^CPU' >> "${OUTPUT_FILE}"
  echo "" >> "${OUTPUT_FILE}"

  ## Get system users with bash shell
  echo "#### Users with Bash Shell ###" >> "${OUTPUT_FILE}"
  grep "bash" /etc/passwd >> "${OUTPUT_FILE}"
  echo "" >> "${OUTPUT_FILE}"

  ## Get system information based on approach
  if [ "${APPROACH}" = "basic" ]; then
    echo "#### Basic System Info ###" >> "${OUTPUT_FILE}"
    uname -r >> "${OUTPUT_FILE}"
  else
    echo "#### Detailed System Info ###" >> "${OUTPUT_FILE}"
    uname -a >> "${OUTPUT_FILE}"
  fi
  echo "" >> "${OUTPUT_FILE}"

  echo "Information saved to ${OUTPUT_FILE}"
  echo "-----------------------------------------------------"
done

echo "Script execution complete."

Salve o arquivo pressionando Ctrl+O, depois Enter e Ctrl+X para sair do nano.

Elementos-chave deste script:

OUT_DIR='/home/labex/project': A variável é usada para tornar o script mais flexível e legível.
OUTPUT_FILE="${OUT_DIR}/output-${APPROACH}.txt": Constrói o nome do arquivo de saída dinamicamente para cada abordagem.
> "${OUTPUT_FILE}": Isso redireciona a saída de um comando vazio para o arquivo, efetivamente limpando seu conteúdo se ele existir ou criando-o se não existir. Isso garante um arquivo novo para cada execução.
>> "${OUTPUT_FILE}": Isso anexa a saída do comando ao arquivo especificado.
if [ "${APPROACH}" = "basic" ]; then ... else ... fi: Declarações condicionais que executam comandos diferentes com base na abordagem que está sendo usada.
echo "#### Section Header ###": Adiciona cabeçalhos claros ao arquivo de saída para melhor organização.

Torne o script executável.
```
chmod +x system_info.sh
```
Não haverá saída direta deste comando se for bem-sucedido.

Execute o script system_info.sh.
Execute seu script abrangente. Ele coletará informações do sistema usando diferentes abordagens e salvará os resultados em arquivos separados.

./system_info.sh

Você deve ver a saída em seu terminal indicando o progresso do script:

Gathering basic system information...
Information saved to /home/labex/project/output-basic.txt
-----------------------------------------------------
Gathering detailed system information...
Information saved to /home/labex/project/output-detailed.txt
-----------------------------------------------------
Script execution complete.

Revise os arquivos de saída gerados.
Verifique o conteúdo dos arquivos output-basic.txt e output-detailed.txt em seu diretório ~/project para verificar se o script coletou as informações conforme o esperado.

cat ~/project/output-basic.txt
cat ~/project/output-detailed.txt

O conteúdo de cada arquivo deve ser semelhante a este (os valores reais variarão):

output-basic.txt:

#### Hostname Information ###
684791f71c0e35fea6cc1243

#### CPU Information ###
CPU op-mode(s):                     32-bit, 64-bit
CPU(s):                             4
CPU family:                         6

#### Users with Bash Shell ###
root:x:0:0:root:/root:/bin/bash
labex:x:1000:1000::/home/labex:/bin/bash

#### Basic System Info ###
5.4.0-162-generic

output-detailed.txt:

#### Hostname Information ###
684791f71c0e35fea6cc1243

#### CPU Information ###
CPU op-mode(s):                     32-bit, 64-bit
CPU(s):                             4
CPU family:                         6

#### Users with Bash Shell ###
root:x:0:0:root:/root:/bin/bash
labex:x:1000:1000::/home/labex:/bin/bash

#### Detailed System Info ###
Linux 684791f71c0e35fea6cc1243 5.4.0-162-generic #179-Ubuntu SMP Mon Aug 14 08:51:31 UTC 2023 x86_64 x86_64 x86_64 GNU/Linux

Este script final demonstra como você pode combinar vários recursos do Bash e comandos Linux para criar ferramentas de automação poderosas para tarefas de administração do sistema.

Resumo

Neste laboratório, você aprendeu os passos fundamentais para criar e executar scripts Bash para administração de sistemas RHEL. Você começou configurando um diretório dedicado para scripts e, em seguida, criou um script Bash simples, entendendo a importância da linha shebang e usando o comando echo. Você explorou diferentes métodos de execução de scripts, incluindo diretamente com o interpretador bash e tornando-os executáveis.

Além disso, você aprimorou suas habilidades de script incorporando comandos do sistema e automatizando tarefas usando loops for para coletar informações do sistema com diferentes abordagens. Você também aprendeu como filtrar a saída de comandos de forma eficaz usando grep e expressões regulares, uma habilidade crucial para analisar informações do sistema. Finalmente, você aplicou esses conceitos para construir um script abrangente de informações do sistema RHEL, demonstrando como combinar vários comandos e construções de script para coletar e apresentar dados valiosos do sistema.

Criar e Executar Scripts Bash no RHEL