Esse artigo foi produzido pelo site Linoxide.com e
trata de um script que executa a verificação de integridade do sistema
Linux. Esse Script coleta informações do sistema como por exemplo, hostname,
versão do kernel, uptime, uso de cpu, memória, disco dentre outras
informações.
O script, retorna um arquivo de texto que será gerado no diretório atual. Uma
variável será definida para fornecer um endereço de e-mail para o qual o
script poderá enviar o arquivo de relatório.
Além do status do sistema, o
script verificará um limite predefinido para a carga da CPU e o tamanho do
sistema de arquivos.
Observação
Importante:
Esse Script usa os comandos hostname, uptime,
who, mpstat, lscpu, ps, top, df, free, bc commands to get system information e
cut, grep, awk para processamento de texto.
Lembre-se: Certifique-se de que tem
todos esses comandos acima estejam funcionando, para exibir todos os resultados do sistema corretamente.
Compreendendo o script linuxhealthcheck.sh
Logo abaixo eu tentei exemplificar o funcionamento
do script, porém não copie do exemplo abaixo, pois no final da página estará
disponível o link para download do script completo e correto:
#tell que
shell para usar
#! / Bin /
bash
#Aqui vamos
colocar o endereço de e-mail para enviar e-mail com relatório. Se nenhum
e-mail - arquivo de log será salvo.
EMAIL='alerts@account.com
'
# Vamos criar
uma função para gerenciar facilmente o que fazer com a saída.
Function
sysstat {
#Print
header, hostname (nome do hostname usado), versão do kernel (uname -r),
Uptime (do comando uptime) e Last reboot time (do comando who)
echo -e
"
#! / Bin /
bash
Function
sysstat {
Echo -e
"
##################################################
##################
Relatório de
verificação de integridade (CPU, processo, uso de disco, memória)
##################################################
##################
#hostname
comando retorna hostname
Nome de host:
`hostname`
Comando
#uname com a chave -r retorna Versão do
Kernel Versão
do Kernel: `uname -r`
#uptime
comando usado para obter uptime, e com o comando sed nós cat saída do
processo para obter apenas uptime.
Tempo de
atividade: `uptime | Sed 's /.* up \ ([^,] * \),. * / \ 1 /' `
#who comando
é usado para obter o último tempo de reinicialização, awk para processamento
de saída
Last Reboot
Time: `who -b | Awk '{print $ 3, $ 4}'
**************************************************
*******************
CPU Load
-> Threshold <1 Normal> 1 Cuidado,> 2 Insalubre
**************************************************
*******************
"
#here
verificamos se o comando mpstat está no nosso sistema
MPSTAT =
`which mpstat`
#here we get
código de saída do comando anterior
MPSTAT = $?
#if estado de
saída não é 0, isto significa que o comando mpstat não foi
encontrado
(ou não existe no nosso sistema) se [$ MPSTAT! = 0]
então
Echo
"Instale o mpstat!"
Echo "Em
sistemas baseados em Debian:"
Echo
"sudo apt-get install sysstat"
Echo "Em
sistemas baseados em RHEL:"
Echo
"yum install sysstat"
outro
Echo -e
""
#here
verificamos da mesma forma se lscpu instalou
LSCPU =
`which lscpu`
LSCPU = $?
Se [$ LSCPU!
= 0]
então
RESULT = $
RESULT "lscpu necessário para procedimento resultados precisos"
outro
# If temos
lscpu instalado, podemos obter o número de CPU's em nosso sistema e obter
estatística para cada usando o comando mpstat.
Cpus = `lscpu
| Grep -e "^ CPU (s):" | Cut -f2 -d: | Awk '{print $ 1}'
I = 0
#here nós
fazemos loop para obter e imprimir estatísticas de uso da CPU para cada CPU.
Enquanto [$ i
-lt $ cpus]
Faz
# Aqui
obtemos estatísticas para a CPU e imprimi-lo. Awk comando ajuda para fazer
isso, uma vez que a saída não permite que isso fazer com grep. AWK verifica
se o terceiro valor é igual à variável $ i (muda de 0 para o número de CPU) e
imprime o valor% usr para este CPU
echo
"CPU $ i:` mpstat -P ALL | awk -v var = $ i ' {If ($ 3 == var) print $
4} '`"
#here
incrementamos a variável $ i para loop
let i = $ i +
1
feito
Fi
Echo -e
"
#here com
comando de uptime obtemos média de carga para o sistema, eo comando de corte
ajuda a processar o resultado.
Carga média:
`uptime | Awk -F'load média: '' {print $ 2} '| Cut -f1 -d, `
#same como
antes, mas com o comando awk, verificamos se o sistema é normal (se valor
inferior a 1, Caution (se entre 1 e 2) e Insaluável.
Status de
estado: `uptime | awk -F'load average: '' print $ 2} '| cut -f1 -d, | awk'
{if ($ 1> 2) imprimir
"Pouco
saudável"; Else if ($ 1> 1) print "Cuidado"; Else imprimir
"Normal"} '`
"
Fi
Echo -e
"
**************************************************
****************
Processo
**************************************************
****************
Memória
superior usando processos / aplicação
PID% MEM RSS
COMANDO
#with ps
comando temos uma lista de processos, awk mostram apenas as colunas
necessárias. Depois com o comando sort ordenamos por terceira coluna e
precisamos apenas do top 10, por isso usamos o comando head
`ps aux | Awk
'{print $ 2, $ 4, $ 6, $ 11}' | Sort -k3rn | Cabeça -n 10`
CPU superior
usando processo / aplicativo
Com o comando
#with top obtemos CPU de topo usando processos, e com a combinação de cabeça
e cauda chegamos top 10.
`top b -n1 |
Head -17 | Cauda -11`
**************************************************
********************
Uso do disco
-> Limiar <90 Normal> 90% Cuidado> 95 Insalubre
**************************************************
********************
"
#we obter o
uso do disco com o comando df. -P chave usada para ter postfix como saída
(houve problemas com compartilhamentos de rede, etc e -P resolver esses
problemas). Nós imprimimos a saída para o arquivo temporário para trabalhar
com informações mais do que um.
Df -Pkh |
grep -v 'Sistema de arquivos'> /tmp/df.status
#We criar
loop para processar linha a linha de df.status
enquanto ler
DISK
Faz
#here nós
começ a linha do df.status e imprima o resultado formatado com comando do awk
LINE = `echo
$ DISK | Awk '{print $ 1, "\ t", $ 6, "\ t", $ 5,
"usado", "\ t", $ 4, "espaço livre"
Echo -e $
LINE
eco
Feito </
tmp/df.status
Echo -e
"
Estado de
saúde "
eco
#here quase o
mesmo loop, mas verificamos o uso do disco e imprimimos Normal se valor menor
90, Atenção se entre 90 e 95 e Insalubre se maior que 95)
enquanto
lemos DISK
Faz
USAGE = `echo
$ DISK | Awk '{print $ 5}' | Cut -f1 -d% `
Se [$ USAGE
-ge 95]
então
STATUS =
'Insalubre'
Elif [$ USAGE
-ge 90]
então
STATUS =
'Cuidado'
outro
STATUS =
'Normal'
Fi
LINE = `echo
$ DISK | Awk '{print $ 1, "\ t", $ 6}' `
#here nós
imprimimos resultados com status
echo -ne $
LINE "\ t \ t" $ STATUS
eco
Feito </
tmp/df.status
#here
removemos o arquivo
df.status rm
/tmp/df.status
#here nós
obtemos a memória total, a memória usada, a memória livre, a troca usada e os
valores livres da troca e excepto os às variáveis.
TOTALMEM =
`free -m | Head -2 | Tail -1 | Awk '{print $ 2}'
# Todas as
variáveis como esta são usadas para armazenar valores como
float (estamos usando bc para fazer todas as operações matemáticas, já que
sem bc todos os valores serão inteiros). Também usamos se
adicionar
zero antes do valor, se valor menor que 1024 eo resultado da divisão será
menor que 1. TOTALBC = `eco 'scale = 2; if ($ TOTALMEM 0) print 0; $ TOTALMEM
/ 1024" |
Bc -l`
USEDMEM = `free -m | Head -2 | Tail -1 | Awk '{print $ 3}'
USEDBC = `eco
'scale = 2; if ($ USEDMEM 0) print 0; $ USEDMEM / 1024" | bc -l`
FREEMEM =
`free -m | Head -2 | Tail -1 | Awk '{print $ 4}' `
FREEBC =` eco
'escala = 2;
TOTALSWAP =
`free -m | Tail -1 | Awk '{print $ 2}'
TOTALSBC =
`eco 'scale = 2; if ($ TOTALSWAP 0) print 0; $ TOTALSWAP / 1024" |
Bc -l`
USEDSWAP = `free -m | Tail -1 | Awk '{print $ 3}'
USEDSBC =
`eco 'scale = 2; if ($ USEDSWAP 0) print 0; $ USEDSWAP / 1024" | bc -l`
FREESWAP =
`free -m | Tail -1 | Awk '{print $ 4}' `
FREESBC =`
echo 'scale = 2; if ($ FREESWAP 0) print 0; $ FREESWAP / 1024 "| bc -l`
Echo -e
"
**************************************************
******************
Memória
**************************************************
******************
Memória
física
Total \ tUsed
\ tFree \ t% Livre
# Como
obtemos valores em GB, também obtemos% de uso
dividindo
Free por Total $ {TOTALBC} GB \ t $ {USEDBC} GB \ t $ {FREEBC} GB \ t $ ($
FREEMEM * 100 / $ TOTALMEM) )%
Trocar
memória
Total \ tUsed
\ tFree \ t% Livre
#Same como
acima - valores em GB, e da mesma forma que obtemos% de uso
$ {TOTALSBC}
GB \ t $ {USEDSBC} GB \ t $ {FREESBC} GB \ t $ ($ FREESWAP * 100 / $
TOTALSWAP) )%
"
}
#here nós
fazemos o valor do nome de arquivo, usando hostname, e data.
FILENAME =
"health-`hostname` -`date +% y% m% d` -`date +% H% M`.txt"
# Aqui
executamos a função e salvamos o resultado no nome do arquivo gerado
sysstat> $
FILENAME
#here nós
imprimimos a saída ao usuário.
Echo -e
"Arquivo reportado $ FILENAME gerado no diretório atual." RESULTADO
$
#here
verificamos se o usuário fornece seu endereço de e-mail para enviar e-mail
se ["$
EMAIL"! = '']
então
#if email
proviced - verificamos se temos mailx comando para enviar e-mail
STATUS = `que
mail`
#if mailx
comando não existe no sistema (o comando anterior retornou código de saída
diferente de zero nós avisamos ao usuário que mailx não está instalado
se [ ?
"! = 0]
então
Echo "O
programa 'mail' não está instalado no momento."
#if mailx
instalado, enviamos e-mail com relatório para o usuário
mais
Cat $
FILENAME | Mail -s "$ FILENAME" $ EMAIL
Fi
Fi
|
 |
| Imagem: LinOxide.com |
Retorno – Relatório de Integridade do sistema
[Root @
linóxido script] # gato health-linoxide.com-140831-0909.txt | Mais
##################################################
################### Relatório de Verificação de
Saúde (CPU,
Processo,
Utilização de
Disco, Memória) ##################
################################################## #
Nome do host:
linoxide.com
Kernel
Versão: 3.15.4-x86_64-linoxide342
Tempo de
atividade : 7 dias
Última
reinicialização: 2014-08-27 08:46
**************************************************
*******************
CPU Load
-> Threshold <1 Normal> 1 Cuidado,> 2 Insalubre
****************
************************************************** -benzóico.
CPU0: 0,06
Carga Média:
0.00
Estado de
saúde: Normal
**************************************************
*******************
Processo
******************************
***************************************
=> Memória
superior usando processos / aplicação
PID% MEM RSS
COMANDO
1361 12.6
127896 / usr / lib / systemd / systemd-journald
1642 7.1
72252 / usr / sbin / rsyslogd
1644 1.9
20148 /usr/bin/python
2340 1.8
19092 / sbin / dhclient
1634 1.4
14748 / usr / sbin / NetworkManager
31410 0.8
8724 sshd:
31441 0.7
7888 sshd:
31432 0.7
7784 sshd:
2558 0,5 5988
/ usr / sbin / sshd
1 0,5 5412 /
sbin / init
=> Início
CPU usando processo / aplicação
PID USER PR
NI VIRT RES SHR S% CPU% MEM TEMPO + COMANDO
1 root 20 0
98572 5412 2796 S 0.0 0.5 0: 11.82 systemd
2 root 20 0 0
0 0 S 0.0 0.0 0: 00.00 kthreadd
3 raiz 20 0 0
0 0 S 0,0 0,0 0: 00,51 ksoftirqd / 0
5 raiz 0 -20
0 0 0 S 0,0 0,0 0: 00,00 kworker / 0: 0H
6 raiz 20 0 0
0 0 S 0,0 0,0 0: 03,33 kworker / U2: 0
7 raiz 20 0 0
0 0 S 0,0 0,0 0: 04,17 rcu_sched
8 raiz 20 0 0
0 0 S 0,0 0,0 0: 00,00 rcu_bh
9 raiz rt 0 0
0 0 S 0,0 0,0 0: 00,00 migração / 0
10 raiz 0 -20
0 0 0 S 0,0 0,0 0: 00,00 khelper
11 raiz 20 0
0 0 0 S 0,0 0,0 0: 00,00 kdevtmpfs
**************************************************
*******************
Uso do disco
-> Limiar <90 Normal> 90% Cuidado> 95 Insalubre
****************
************************************************** -benzóico.
/ Dev / root
/ 11% usado 13G espaço livre
Devtmpfs /
dev 0% usado 495M de espaço livre
Tmpfs / dev /
shm 0% usado 496M espaço livre
Tmpfs / run
1% usado 495M espaço livre
Tmpfs / sys /
fs / cgroup 0% usado 496M espaço livre
Tmpfs / tmp
0% usado 496M espaço livre
Estado de
saúde
/ Dev / root
/ Normal
devtmpfs /
dev Normal
tmpfs / dev /
shm Normal
tmpfs / run
Normal
tmpfs / sys /
fs / cgroup Normal
tmpfs / tmp
Normal
**************************************************
*******************
Memória
******************************
***************************************
=> Memória
física
Total Usado
Grátis% Gratuito
0,96 GB 0,46
GB 0,50 GB 52%
=> Trocar
Memória
Total Usado
Grátis% Gratuito
0.24GB 0GB
0.24GB 100%
[Root @
linoxide script] #
|
Download do script: script linuxhealthcheck.sh
Eu fiz um teste e comigo funcionou bem, considerando que utilizo a distribuição Debian Jessie.
Caso você também utilize esse script, compartilhe o seus resultado nos comentários.
Fonte desse artigo: linoxide.com - todos os créditos
tags: scripts, ferramentas, integridade,sistema
