Atividades Linux Simplificado

Prévia do material em texto

Caderno de Atividades Linux Simplificado
Este caderno contém 3 atividades práticas sobre permissões de arquivos, utilização do
crontab e uma introdução ao shellscript com desenvolvimento de exemplo prático. Cada
atividade inclui uma introdução conceitual detalhada e exercícios práticos para
aplicação dos conhecimentos.
Sumário
Atividade 1: Permissões de Arquivos (chmod)
Atividade 2: Utilização do crontab
Atividade 3: Introdução ao shellscript com desenvolvimento de exemplo
Atividade 1: Permissões de Arquivos
(chmod)
Introdução Conceitual
O sistema de permissões no Linux é um dos pilares fundamentais da segurança e do
controle de acesso aos arquivos. Cada arquivo e diretório no sistema possui um
conjunto específico de permissões que determina quem pode ler, escrever ou executar o
arquivo. O comando chmod (change mode) é a ferramenta principal para modificar
essas permissões, permitindo um controle granular sobre como os usuários interagem
com os arquivos.
No Linux, as permissões são divididas em três categorias principais: proprietário (u),
grupo (g) e outros (o). Para cada uma dessas categorias, existem três tipos de
permissões que podem ser concedidas ou revogadas: leitura (r), escrita (w) e execução
(x). Essa estrutura cria um sistema flexível que permite configurar precisamente quem
pode fazer o quê com cada arquivo ou diretório no sistema.
O comando chmod pode ser utilizado de duas formas principais: através da notação
simbólica ou da notação octal (numérica). A notação simbólica utiliza letras e símbolos
para representar as permissões, enquanto a notação octal utiliza números para o
mesmo propósito.
1. 
2. 
3. 
Na notação simbólica, utilizamos os seguintes elementos: - Categorias de usuários: u
(proprietário), g (grupo), o (outros), a (todos) - Operadores: + (adicionar permissão), -
(remover permissão), = (definir permissão exata) - Tipos de permissão: r (leitura), w
(escrita), x (execução)
Na notação octal, cada permissão é representada por um valor numérico: - r (leitura) = 4
- w (escrita) = 2 - x (execução) = 1
Combinando esses valores, podemos representar todas as combinações possíveis de
permissões. Por exemplo, o valor 7 (4+2+1) representa permissões totais (rwx), enquanto
o valor 5 (4+1) representa permissões de leitura e execução (r-x).
Além das permissões básicas, o Linux também oferece permissões especiais que podem
ser definidas usando o comando chmod :
SUID (Set User ID) - Quando definido em um arquivo executável, o programa é
executado com os privilégios do proprietário do arquivo, não do usuário que o
executa. É representado pelo dígito 4 na posição de milhar da notação octal (por
exemplo, 4755).
SGID (Set Group ID) - Quando definido em um arquivo executável, o programa é
executado com os privilégios do grupo do arquivo. Quando definido em um
diretório, novos arquivos criados nesse diretório herdam o grupo do diretório. É
representado pelo dígito 2 na posição de milhar (por exemplo, 2755).
Sticky Bit - Quando definido em um diretório, apenas o proprietário de um arquivo
pode excluí-lo, mesmo que outros usuários tenham permissões de escrita no
diretório. É comumente usado em diretórios compartilhados como /tmp. É
representado pelo dígito 1 na posição de milhar (por exemplo, 1755).
Compreender profundamente o sistema de permissões e o uso do comando chmod é
essencial para qualquer administrador de sistemas Linux, pois permite implementar
políticas de segurança eficazes e garantir que os usuários tenham acesso apenas aos
recursos necessários para suas funções.
Exercício Prático
Objetivo
Neste exercício, você irá praticar o uso do comando chmod com notação simbólica e
octal para modificar permissões de arquivos e diretórios em um sistema Linux.
1. 
2. 
3. 
Tarefas
Crie um diretório chamado sistema_permissoes e, dentro dele, crie quatro
arquivos: documento.txt , script.sh , configuracao.conf e dados.db .
Verifique as permissões atuais dos arquivos usando o comando ls -l .
Modifique as permissões do arquivo documento.txt para que o proprietário
possa ler e escrever, o grupo possa apenas ler, e outros não tenham nenhuma
permissão (usando notação simbólica).
Modifique as permissões do arquivo script.sh para que o proprietário possa ler,
escrever e executar, o grupo possa ler e executar, e outros possam apenas executar
(usando notação octal).
Modifique as permissões do arquivo configuracao.conf para que apenas o
proprietário possa ler e escrever, sem nenhuma permissão para grupo ou outros
(usando notação simbólica).
Modifique as permissões do arquivo dados.db para que o proprietário tenha
todas as permissões, o grupo possa ler e escrever, e outros possam apenas ler
(usando notação octal).
Crie um diretório chamado compartilhado dentro de sistema_permissoes e
configure-o com o sticky bit, permitindo que todos possam ler, escrever e executar,
mas apenas o proprietário de um arquivo possa excluí-lo.
Verifique todas as permissões modificadas usando o comando ls -l .
Comandos Úteis
# Criar diretório e arquivos
mkdir -p sistema_permissoes
touch sistema_permissoes/documento.txt sistema_permissoes/
script.sh sistema_permissoes/configuracao.conf
sistema_permissoes/dados.db
# Verificar permissões
ls -l sistema_permissoes/
# Modificar permissões usando notação simbólica
chmod u=rw,g=r,o= sistema_permissoes/documento.txt
chmod u=rw,g=,o= sistema_permissoes/configuracao.conf
# Modificar permissões usando notação octal
chmod 751 sistema_permissoes/script.sh
1. 
2. 
3. 
4. 
5. 
6. 
7. 
8. 
chmod 764 sistema_permissoes/dados.db
# Criar diretório compartilhado com sticky bit
mkdir sistema_permissoes/compartilhado
chmod 1777 sistema_permissoes/compartilhado
# Verificar permissões modificadas
ls -la sistema_permissoes/
Questões para Reflexão
Por que é importante limitar as permissões de arquivos ao mínimo necessário para
cada usuário ou grupo?
Como as permissões de diretórios diferem das permissões de arquivos em termos
de comportamento?
Em quais situações você utilizaria a notação simbólica em vez da notação octal
para modificar permissões?
Quais são os riscos de segurança associados ao uso do bit SUID em arquivos
executáveis?
Em quais situações práticas o uso do sticky bit em diretórios é recomendado?
Atividade 2: Utilização do crontab
Introdução Conceitual
O crontab é uma das ferramentas mais poderosas e versáteis do sistema Linux para o
agendamento de tarefas. Seu nome deriva da junção de "cron", o daemon que executa
tarefas programadas, e "tab", abreviação de tabela, pois o crontab armazena uma lista
de comandos a serem executados em horários específicos. Esta ferramenta permite que
administradores de sistemas e usuários automatizem tarefas recorrentes, desde
backups noturnos até atualizações de software e limpeza de arquivos temporários, sem
necessidade de intervenção manual.
O daemon cron verifica a cada minuto se há tarefas agendadas para execução,
consultando os arquivos crontab de cada usuário e os arquivos crontab do sistema.
Quando encontra uma tarefa programada para aquele momento específico, o cron a
executa com os privilégios do usuário que a agendou. Esta automação é fundamental
1. 
2. 
3. 
4. 
5. 
para a manutenção eficiente de sistemas Linux, especialmente em ambientes de
servidor onde a confiabilidade e a consistência são cruciais.
Cada linha em um arquivo crontab representa uma tarefa agendada e segue uma sintaxe
específica com seis campos:
* * * * * comando_a_ser_executado
│ │ │ │ │
│ │ │ │ └── Dia da semana (0-7, onde 0 e 7 representam domingo)
│ │ │ └──── Mês (1-12)
│ │ └────── Dia do mês (1-31)
│ └──────── Hora (0-23)
└────────── Minuto (0-59)
Os cinco primeiros campos definem quando a tarefa será executada, e o sexto campo é o
comando a ser executado. Em cada campo de tempo, podemos usar:
Um valor específico (por exemplo, 5)
Um intervalo de valores (por exemplo, 1-5)
Uma lista de valores (por exemplo, 1,3,5)
Um valor de incremento (por exemplo, */2, que significa "a cada 2 unidades")
Um asterisco(*), que representa "todos os valores possíveis"
Para gerenciar as tarefas agendadas, o Linux oferece o comando crontab com várias
opções:
crontab -e : Edita o arquivo crontab do usuário atual
crontab -l : Lista o conteúdo do arquivo crontab do usuário atual
crontab -r : Remove o arquivo crontab do usuário atual
crontab -u [usuário] : Especifica o usuário cujo crontab será manipulado
(requer privilégios de superusuário)
O crontab, além de suas funcionalidades básicas de agendamento, oferece recursos
avançados que permitem implementar soluções sofisticadas para automação de tarefas
em sistemas Linux. Estes recursos avançados incluem variáveis de ambiente,
redirecionamento de saída, encadeamento de comandos, e integração com outros
sistemas de automação.
Uma característica importante do crontab é que ele executa comandos em um ambiente
limitado, com um conjunto reduzido de variáveis de ambiente em comparação com uma
sessão de terminal interativa. Para contornar essa limitação, podemos definir variáveis
de ambiente diretamente no arquivo crontab, antes das entradas de agendamento. Por
exemplo:
• 
• 
• 
• 
• 
• 
• 
• 
• 
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/
bin
SHELL=/bin/bash
MAILTO=admin@exemplo.com
A variável MAILTO é particularmente útil, pois define o endereço de e-mail para o qual
serão enviadas as saídas dos comandos executados pelo cron. Isso facilita o
monitoramento e a resolução de problemas em tarefas agendadas.
O crontab também permite o uso de expressões especiais para datas, como @reboot
(executa na inicialização do sistema), @daily (executa diariamente), @weekly
(executa semanalmente), @monthly (executa mensalmente) e @yearly (executa
anualmente):
@reboot /scripts/inicializacao.sh
@daily /scripts/backup_diario.sh
O crontab é uma ferramenta essencial no arsenal de qualquer administrador de
sistemas Linux, permitindo a automação de tarefas rotineiras e garantindo que
processos críticos sejam executados de forma confiável e pontual.
Exercício Prático
Objetivo
Neste exercício, você irá praticar o uso do crontab para agendar tarefas recorrentes em
um sistema Linux, desde configurações básicas até técnicas mais avançadas.
Tarefas
Abra o editor do crontab para o usuário atual usando o comando crontab -e . Se
for a primeira vez que você usa o crontab, o sistema pode pedir para escolher um
editor de texto.
Configure variáveis de ambiente no seu arquivo crontab para definir o caminho
(PATH), o shell padrão (SHELL) e o destinatário de e-mails (MAILTO).
Crie uma tarefa que execute o comando date >> /home/seu_usuario/
data_hora.log a cada 5 minutos. Este comando registrará a data e hora atual em
um arquivo de log.
1. 
2. 
3. 
Crie uma tarefa que execute o comando df -h >> /home/seu_usuario/
espaco_disco.log uma vez por dia às 8 da manhã. Este comando registrará
informações sobre o uso do espaço em disco.
Crie uma tarefa que execute o comando find /home/seu_usuario/Downloads
-type f -mtime +30 -delete uma vez por semana, aos domingos à meia-
noite. Este comando excluirá arquivos na pasta Downloads que não foram
modificados nos últimos 30 dias.
Crie um script chamado monitor_servicos.sh que verifique o status de
serviços críticos (como Apache, MySQL, SSH) e reinicie aqueles que não estiverem
funcionando. Agende este script para ser executado a cada 10 minutos.
Implemente uma tarefa que execute na inicialização do sistema (@reboot) para
configurar regras de firewall e iniciar serviços essenciais.
Liste todas as tarefas agendadas usando o comando crontab -l e verifique se
estão corretas.
Comandos Úteis
# Editar o crontab
crontab -e
# Configuração de variáveis de ambiente no crontab
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/
bin
SHELL=/bin/bash
MAILTO=seu_email@exemplo.com
# Exemplos de entradas no crontab:
# A cada 5 minutos
*/5 * * * * date >> /home/seu_usuario/data_hora.log
# Todos os dias às 8 da manhã
0 8 * * * df -h >> /home/seu_usuario/espaco_disco.log
# Todos os domingos à meia-noite
0 0 * * 0 find /home/seu_usuario/Downloads -type f -mtime +30 -
delete
# A cada 10 minutos
*/10 * * * * /home/seu_usuario/scripts/monitor_servicos.sh >> /
var/log/monitor_servicos.log 2>&1
# Na inicialização do sistema
4. 
5. 
6. 
7. 
8. 
@reboot /home/seu_usuario/scripts/inicializacao.sh >> /var/log/
inicializacao.log 2>&1
# Listar tarefas agendadas
crontab -l
Script monitor_servicos.sh
#!/bin/bash
# Lista de serviços a serem monitorados
SERVICOS=("apache2" "mysql" "ssh" "nginx")
# Função para verificar e reiniciar serviços
verificar_servico() {
servico=$1
echo "$(date) - Verificando serviço: $servico"
# Verifica se o serviço está ativo
if systemctl is-active --quiet $servico; then
echo "$(date) - Serviço $servico está funcionando 
corretamente."
else
echo "$(date) - ALERTA: Serviço $servico não está 
funcionando. Tentando reiniciar..."
# Tenta reiniciar o serviço
systemctl restart $servico
# Verifica se o reinício foi bem-sucedido
if systemctl is-active --quiet $servico; then
echo "$(date) - Serviço $servico reiniciado com 
sucesso."
# Envia notificação de sucesso
echo "O serviço $servico foi reiniciado com sucesso 
em $(hostname) às $(date)" | \
mail -s "Serviço $servico reiniciado" $MAILTO
else
echo "$(date) - ERRO: Falha ao reiniciar o serviço 
$servico."
# Envia notificação de falha
echo "FALHA ao reiniciar o serviço $servico em $
(hostname) às $(date). Intervenção manual necessária." | \
mail -s "URGENTE: Falha no serviço $servico" $MAILTO
fi
fi
echo "----------------------------------------"
}
# Verifica cada serviço da lista
for servico in "${SERVICOS[@]}"; do
verificar_servico $servico
done
echo "$(date) - Verificação de serviços concluída."
Questões para Reflexão
Como o crontab pode ajudar a automatizar tarefas de manutenção do sistema?
Quais são as vantagens de usar o crontab em comparação com a execução manual
de tarefas?
Como o uso de variáveis de ambiente no crontab pode melhorar a portabilidade e
a manutenção das tarefas agendadas?
Quais considerações de segurança devem ser levadas em conta ao configurar
tarefas no crontab?
Como você implementaria um sistema de notificação eficiente para alertar sobre
falhas em tarefas críticas agendadas no crontab?
Atividade 3: Introdução ao shellscript
com desenvolvimento de exemplo
Introdução Conceitual
O Shell Script é uma poderosa ferramenta de automação no ambiente Linux, permitindo
que administradores de sistemas e usuários avançados criem programas que executam
sequências de comandos diretamente no interpretador de comandos (shell). Esta
linguagem de script combina comandos do sistema operacional com estruturas de
controle de fluxo, variáveis e funções, possibilitando a criação de soluções
automatizadas para tarefas repetitivas ou complexas.
O shell mais comumente utilizado para scripts no Linux é o Bash (Bourne Again SHell),
que é o shell padrão na maioria das distribuições. No entanto, existem outros shells
disponíveis, como o sh (Bourne Shell), ksh (Korn Shell), zsh (Z Shell) e fish, cada um com
suas próprias características e extensões. O Bash é particularmente popular devido à
sua ampla disponibilidade e ao rico conjunto de recursos que oferece para programação
de scripts.
1. 
2. 
3. 
4. 
5. 
Um script shell é essencialmente um arquivo de texto contendo uma série de comandos
que o shell interpretará e executará sequencialmente. O primeiro passo para criar um
shell script é definir o interpretador que será utilizado, através do que chamamos de
"shebang" na primeira linha do arquivo:
#!/bin/bash
Esta linha indica ao sistema que o script deve ser executado pelo interpretador Bash
localizado em /bin/bash . Após definir o interpretador, podemos incluir comentários
para documentar o propósito e o funcionamento do script. Comentários são linhas que
começam com o caractere # e são ignoradas pelo interpretador:
# Este é um comentário explicativo
# Autor: Seu Nome
# Data: 29/05/2025
# Descrição: Script de exemplopara demonstrar conceitos básicos
Os shell scripts podem utilizar variáveis para armazenar e manipular dados. As variáveis
são definidas simplesmente atribuindo um valor a um nome, sem necessidade de
declaração prévia de tipo:
NOME="Maria"
IDADE=30
DATA_ATUAL=$(date +%Y-%m-%d) # Comando substituição
Para acessar o valor de uma variável, utilizamos o prefixo $ :
echo "Olá, $NOME! Hoje é $DATA_ATUAL."
Os shell scripts também oferecem estruturas de controle de fluxo, como condicionais e
loops, que permitem tomar decisões e repetir comandos com base em condições:
# Estrutura condicional if-else
if [ $IDADE -gt 18 ]; then
echo "$NOME é maior de idade."
else
echo "$NOME é menor de idade."
fi
# Loop for
for i in {1..5}; do
echo "Contagem: $i"
done
# Loop while
contador=1
while [ $contador -le 5 ]; do
echo "Iteração: $contador"
contador=$((contador + 1))
done
Além disso, os shell scripts podem receber argumentos de linha de comando, o que
aumenta sua flexibilidade:
echo "Nome do script: $0"
echo "Primeiro argumento: $1"
echo "Segundo argumento: $2"
echo "Todos os argumentos: $@"
echo "Número de argumentos: $#"
Funções são blocos de código reutilizáveis que podem ser definidos e chamados dentro
do script:
# Definição de função
saudacao() {
local nome=$1 # Variável local à função
echo "Olá, $nome!"
}
# Chamada de função
saudacao "Carlos"
O shell script é uma ferramenta extremamente versátil para automação de tarefas no
Linux, desde operações simples como backup de arquivos até processos complexos de
administração de sistemas. Dominar esta linguagem é essencial para qualquer
profissional que trabalhe com sistemas Linux, pois permite aumentar significativamente
a eficiência e a consistência na execução de tarefas administrativas.
Exercício Prático
Objetivo
Neste exercício, você irá desenvolver um shell script completo que demonstre os
conceitos básicos da linguagem e realize uma tarefa útil: um monitor de sistema que
coleta e exibe informações sobre o uso de recursos do computador.
Tarefas
Crie um arquivo chamado monitor_sistema.sh no diretório de sua escolha.
Adicione o shebang na primeira linha para especificar o interpretador Bash.
Inclua comentários explicativos no início do script, documentando seu propósito,
autor e data de criação.
Defina variáveis para armazenar o diretório de saída para relatórios e o nome do
arquivo de log.
Crie uma função que colete informações sobre o uso de CPU e exiba o resultado
formatado.
Crie uma função que colete informações sobre o uso de memória e exiba o
resultado formatado.
Crie uma função que colete informações sobre o uso de disco e exiba o resultado
formatado.
Crie uma função que liste os processos que estão consumindo mais recursos.
Implemente um menu interativo que permita ao usuário escolher qual informação
deseja visualizar.
Adicione a opção de gerar um relatório completo e salvá-lo em um arquivo.
Torne o script executável usando o comando chmod +x monitor_sistema.sh .
Execute o script e teste todas as suas funcionalidades.
Script Completo
#!/bin/bash
# ===================================================
# Monitor de Sistema - Script de exemplo para introdução ao 
Shell Script
# Autor: Seu Nome
# Data: 29/05/2025
# Descrição: Este script coleta e exibe informações sobre o uso 
de recursos
# do sistema, como CPU, memória, disco e processos.
# ===================================================
# Definição de variáveis
1. 
2. 
3. 
4. 
5. 
6. 
7. 
8. 
9. 
10. 
11. 
12. 
DIRETORIO_SAIDA="$HOME/relatorios"
ARQUIVO_LOG="$DIRETORIO_SAIDA/monitor_sistema_$(date +
%Y%m%d_%H%M%S).log"
TITULO="Monitor de Sistema v1.0"
# Cores para formatação da saída
VERMELHO='\033[0;31m'
VERDE='\033[0;32m'
AMARELO='\033[0;33m'
AZUL='\033[0;34m'
RESET='\033[0m'
# Função para exibir o cabeçalho
exibir_cabecalho() {
clear
echo -e "${AZUL}
====================================================${RESET}"
echo -e "${AZUL} $TITULO $
{RESET}"
echo -e "${AZUL}
====================================================${RESET}"
echo -e "${VERDE}Hostname:${RESET} $(hostname)"
echo -e "${VERDE}Data/Hora:${RESET} $(date)"
echo -e "${VERDE}Uptime:${RESET} $(uptime -p)"
echo -e "${AZUL}
====================================================${RESET}"
echo ""
}
# Função para verificar se diretório de saída existe, caso 
contrário, criar
verificar_diretorio() {
if [ ! -d "$DIRETORIO_SAIDA" ]; then
mkdir -p "$DIRETORIO_SAIDA"
echo -e "${VERDE}Diretório de saída criado: 
$DIRETORIO_SAIDA${RESET}"
fi
}
# Função para coletar informações sobre CPU
info_cpu() {
echo -e "${AZUL}=== Informações de CPU ===${RESET}"
echo ""
echo -e "${VERDE}Modelo de CPU:${RESET}"
lscpu | grep "Model name" | sed 's/Model name: *//g'
echo ""
echo -e "${VERDE}Uso de CPU por núcleo:${RESET}"
mpstat -P ALL | grep -v "Average"
echo ""
echo -e "${VERDE}Carga média (1, 5, 15 min):${RESET}"
uptime | awk -F'load average: ' '{print $2}'
echo ""
}
# Função para coletar informações sobre memória
info_memoria() {
echo -e "${AZUL}=== Informações de Memória ===${RESET}"
echo ""
echo -e "${VERDE}Visão geral da memória:${RESET}"
free -h
echo ""
echo -e "${VERDE}Uso detalhado da memória:${RESET}"
vmstat -s | head -10
echo ""
}
# Função para coletar informações sobre disco
info_disco() {
echo -e "${AZUL}=== Informações de Disco ===${RESET}"
echo ""
echo -e "${VERDE}Uso de espaço em disco:${RESET}"
df -h | grep -v "tmpfs"
echo ""
echo -e "${VERDE}Maiores diretórios em /home:${RESET}"
du -h /home --max-depth=2 2>/dev/null | sort -hr | head -10
echo ""
}
# Função para listar processos que consomem mais recursos
info_processos() {
echo -e "${AZUL}=== Processos Consumindo Mais Recursos ===$
{RESET}"
echo ""
echo -e "${VERDE}Top 5 processos por uso de CPU:${RESET}"
ps aux --sort=-%cpu | head -6
echo ""
echo -e "${VERDE}Top 5 processos por uso de memória:$
{RESET}"
ps aux --sort=-%mem | head -6
echo ""
}
# Função para gerar relatório completo
gerar_relatorio() {
verificar_diretorio
echo "Gerando relatório completo em $ARQUIVO_LOG..."
# Redireciona a saída para o arquivo de log
{
echo
"====================================================="
echo " RELATÓRIO DE 
SISTEMA "
echo
"====================================================="
echo "Hostname: $(hostname)"
echo "Data/Hora: $(date)"
echo "Uptime: $(uptime -p)"
echo
"====================================================="
echo ""
echo "=== Informações de CPU ==="
echo ""
echo "Modelo de CPU:"
lscpu | grep "Model name" | sed 's/Model name: *//g'
echo ""
echo "Uso de CPU por núcleo:"
mpstat -P ALL | grep -v "Average"
echo ""
echo "Carga média (1, 5, 15 min):"
uptime | awk -F'load average: ' '{print $2}'
echo ""
echo "=== Informações de Memória ==="
echo ""
echo "Visão geral da memória:"
free -h
echo ""
echo "Uso detalhado da memória:"
vmstat -s | head -10
echo ""
echo "=== Informações de Disco ==="
echo ""
echo "Uso de espaço em disco:"
df -h | grep -v "tmpfs"
echo ""
echo "Maiores diretórios em /home:"
du -h /home --max-depth=2 2>/dev/null | sort -hr | head
-10
echo ""
echo "=== Processos Consumindo Mais Recursos ==="
echo ""
echo "Top 5 processos por uso de CPU:"
ps aux --sort=-%cpu | head -6
echo ""
echo "Top 5 processos por uso de memória:"
ps aux --sort=-%mem | head -6
echo ""
echo
"====================================================="
echo "Relatório gerado em: $(date)"
echo
"====================================================="
} > "$ARQUIVO_LOG"
echo -e "${VERDE}Relatório gerado com sucesso em: 
$ARQUIVO_LOG${RESET}"
}
# Função para exibir o menu
exibir_menu() {
echo -e "${AZUL}Menu de Opções:${RESET}"
echo "1. Informações de CPU"
echo "2. Informações de Memória"
echo "3. Informações de Disco"
echo "4. Processos Consumindo Mais Recursos"
echo "5. Gerar Relatório Completo"
echo "0. Sair"
echo ""
echo -n "Escolha uma opção: "
}
# Função principal
main() {
local opcao
while true; do
exibir_cabecalho
exibir_menu
read opcao
case $opcao in
1)
exibir_cabecalhoinfo_cpu
;;
2)
exibir_cabecalho
info_memoria
;;
3)
exibir_cabecalho
info_disco
;;
4)
exibir_cabecalho
info_processos
;;
5)
exibir_cabecalho
gerar_relatorio
;;
0)
echo -e "${VERDE}Encerrando o Monitor de 
Sistema. Até logo!${RESET}"
exit 0
;;
*)
echo -e "${VERMELHO}Opção inválida. Por favor, 
tente novamente.${RESET}"
;;
esac
echo ""
echo -n "Pressione Enter para continuar..."
read
done
}
# Verificar se os comandos necessários estão instalados
for cmd in mpstat vmstat ps free df du; do
if ! command -v $cmd &> /dev/null; then
echo -e "${VERMELHO}Erro: O comando '$cmd' não está 
instalado. Por favor, instale o pacote necessário.${RESET}"
exit 1
fi
done
# Iniciar o programa
main
Instruções para Execução
Salve o conteúdo acima em um arquivo chamado monitor_sistema.sh .
Torne o script executável: bash chmod +x monitor_sistema.sh
Execute o script: bash ./monitor_sistema.sh
Navegue pelo menu interativo para explorar as diferentes funcionalidades.
Experimente gerar um relatório completo e verifique o arquivo gerado no diretório
de saída.
Questões para Reflexão
Como o uso de funções melhora a organização e a manutenção do script?
De que forma as variáveis de ambiente podem ser utilizadas para tornar o script
mais flexível?
1. 
2. 
3. 
4. 
5. 
1. 
2. 
Quais modificações você faria para adaptar este script às necessidades específicas
do seu ambiente?
Como você poderia expandir este script para incluir monitoramento de rede ou
alertas automáticos quando determinados limites de recursos forem atingidos?
Quais são as vantagens de usar um menu interativo em scripts de administração de
sistemas?
3. 
4. 
5. 
	Caderno de Atividades Linux Simplificado
	Sumário
	Atividade 1: Permissões de Arquivos (chmod)
	Introdução Conceitual
	Exercício Prático
	Objetivo
	Tarefas
	Comandos Úteis
	Questões para Reflexão
	Atividade 2: Utilização do crontab
	Introdução Conceitual
	Exercício Prático
	Objetivo
	Tarefas
	Comandos Úteis
	Script monitor_servicos.sh
	Questões para Reflexão
	Atividade 3: Introdução ao shellscript com desenvolvimento de exemplo
	Introdução Conceitual
	Exercício Prático
	Objetivo
	Tarefas
	Script Completo
	Instruções para Execução
	Questões para Reflexão