Data Bunch

Tutorial de minha autoria para instalação e configuração do MON #in #linux #debian

Osimar Medeiros — Thu, 23 Sep 2010 19:58:05 +0000

MON -> Ferramenta para monitorar a disponibilidade de serviços

O programa mon é utilizado para monitorar (remotamente ou localmente) serviços e disparar ações conforme os eventos.
Mon possui vários scripts monitores e alerts.
Os scripts podem ser complexos a ponto de executarem queries pré-definidas em bancos de dados remotos ou também enviar emails de alerta ao sysadmin.
Os scripts têm seus diretórios pré-definidos:

 /usr/lib/mon/mon.d -> armazena os scripts monitores (.monitor), que executam a checagem de algum serviço
 /usr/lib/mon/alert.d -> armazena os scripts alert (.alert), responsáveis por executar alguma ação quando identificado o problema (subir um daemon,
 reiniciar um serviço, etc).

Configurando o MON

Instalando

 aptitude install mon
 /etc/init.d/mon stop

Configurando o arquivo /etc/mon/mon.cf

 serverbind = localhost
 trapbind = localhost
 cfbasedir = /etc/mon
 alertdir= /usr/lib/mon/alert.d
 mondir = /usr/lib/mon/mon.d
 maxprocs = 20
 histlength = 100
 randstart = 60s

 hostgroup localnode localhost

 watch localhost
       service http
               description Monitoramento do apache
               interval 1m
               monitor http.monitor -p 80 -t 10 -o localhost
               period wd {Mon-Sun}
                       alert apache2.alert
                       alert file.alert -d /var/log/mon http.alert.log

Explicando o mon.cf

O arquivo /etc/mon/mon.cf é onde se define que servidores fazem bind, por quais portas e que rotinas de monitoramento são executadas, em que intervalo de tempo e o que acontece em caso de problemas.

hostgroup

 Define um nome de grupo de hosts a serem monitorados.
 localhost => nome do grupo monitorado
 localhost => nome do servidor pertencente ao grupo localhost, definido dentro do hostgroup (cláusula de definição)

watch

 Define quais serviços serão monitorados. O nome definido no parâmetro service dentro do watch deve ser o nome do script monitor, sem a extensão .monitor e deve constar no
 mondir, definido acima.
 Ou seja, em /usr/lib/mon/mon.d deve existir um script chamado http.monitor (neste exemplo).

service

 Este parâmetro é exatamente o nome do script existente sob /usr/lib/mon/mon.d, sem a extensão .monitor

description

 Permite fornecer uma descrição para a checagem sendo realizada. Para controle pessoal do usuário.

interval

 Intervalo de tempo entre as checagens. 1m = 1 minuto. 1h = 1 hora, e assim por diante.

period

 Período em que a checagem deve ser executada. É possível especificar horários ou períodos diferenciados. A sintaxe correta de como o período desejado
 pode ser especificado pode ser consultada na página de manual do módulo Perl Time::Period, acessível através do comando man Time::Period
 O timeperiod não pode ser setado para dias iguais. Por exemplo: wd {Mon-Mon}

alert

 Esta cláusula permite especificar alertas a serem gerados quando o script monitor retornar um valor diferente de zero (quando retornar um erro).
 O script definido nesta cláusula deve estar no alertdir setado acima. Neste caso, em /usr/lib/mon/alert.d/
 A cláusula file.alert é um script que gera um arquivo de log no endereço setado e com o nome de arquivo definido. Neste caso:
 /var/log/mon/http.alert.log

Permissões

Para usar o mon como monitoramento de serviços como apache, é necessário habilitar o usuário mon, criado na instalação, como pertencente ao grupo root.
Para fazer isto, edite o arquivo /etc/group:

 vim /etc/group
 Acrescente à linha que contiver este conteúdo root:x:0:, o usuário mon. Ficará assim: root:x:0:mon

 Ou execute o comando: usermod -o -G root mon

Permissões – /etc/passwd

Caso editando o /etc/group não resolva e continuem ocorrendo erros de permissão ao executar os alerts, edite o arquivo /etc/passwd:

 mon:x:0:0::/var/lib/mon:/bin/false

Reiniciando o mon

Após configurar o aplicativo, reinicie o programa:

 /etc/init.d/mon restart

Para testar se o mon está funcionando corretamente, pode-se usar o comando abaixo:

 monshow --detail localhost,http

localhost é o nome do servidor e http é o nome do serviço, podendo ser qualquer outro configurado no mon.

Exemplo de erro

 server: localhost
      time: Wed Sep 22 17:04:09 2010
      state: scheduler running
 Error: localhost/http not a valid service

Exemplo de sucesso

    server: localhost
      time: Wed Sep 22 17:07:49 2010
     state: scheduler running
 Detail for group localhost service http
 description
 -----------
   Monitoramento do apache
 summary
 -------
 hosts
 -----
   localhost
 -----DETAIL-----
 -----DETAIL-----
 opstatus: untested (7)
  exitval: undef
   depend:
  monitor:
 last check: 14874 days, 20:07 ago
 next_check: in 17s

Modelo de alert para reiniciar o apache

 Nome do arquivo: apache2.alert

 #!/bin/bash

 PID="/var/log/mon/apache.alert.pid"

 # Validando se o processo jah estah em execucao
 if [ -f "$PID" ] ; then
       echo "Processo ja estah em execucao com PID [`cat $PID`]"
       exit 0
 fi

 # Iniciando execucao do script
 while [ ! -z "`/bin/pidof httpd`" ] ; do
       echo "$$" > $PID
       /etc/init.d/apache2 stop
       sleep 2
 done

 # Iniciando o apache
 /etc/init.d/apache2 start
 rm -f "$PID"

RRDs, Nagios… a vida de sempre. #in #Linux #nagios #snmp

Osimar Medeiros — Wed, 30 Jun 2010 15:35:44 +0000

Já faz uma cara que não posto aqui. Me falta tempo. Desde que comecei monitorar os servidores da empresa (e subsidiárias, agregadas e afins), é só correria.

Devo ter montado uns 20 plugins pro Nagios, pra monitoramentos específicos, SNMP, RRDs, MRTGs, etc.

Devo ter montado umas 40 rotinas para clientes, em shellscript, perl e MySQL.

Devo ter respondido uns 450 mil emails. Atendido outras 900 mil ligações.

Reclamando ? Jamais.

Amo meu emprego.

E vamo correndo. Hoje já tenho mais uma rotina brutal pra montar.

Mexer em gigas de tabelas de bancos de dados, monta scripts, explain neles, testa, dá errado, refaz, o cliente enche, você se concentra e no fim, sim, sai sim.

Gambiarra jamais, irmão, irmã.

Faça as coisas direito.

Até.

mp3gain em linha de comando #in #linux #cli

Osimar Medeiros — Mon, 07 Jun 2010 00:54:17 +0000

Para equalizar o áudio de seus mp3, o Mp3Gain é um ótimo software. Melhor ainda é a simplicidade em normalizar suas músicas via linha de comando.

Fácil, basta usar um find pra relacionar as músicas recursivamente e o mp3gain -r pra normalizar o volume de todas elas.

Exemplo:

find /diretorio -name *.mp3 -exec mp3gain -r {} +

Aperfeiçoando o código. #in #linux #shellscript

Osimar Medeiros — Wed, 14 Apr 2010 15:44:04 +0000

Ultimamente tenho montado algumas rotinas automáticas para integrações com clientes. Normalmente monto em shellscript.

Com o uso diário da linguagem e aplicação de conceitos aplicados à programação, para otimizar e facilitar manutenção no código, vejo que eu mesmo estou programando muito melhor nessa linguagem.

O dia-a-dia realmente é um excelente professor.

Já para o Nagios, monto plugins mais em Perl que em shellscript. Em Perl preciso capturar o conceito de hash e array, que ainda me traz confusão.

Mas eu chego lá !

Meus primeiros 2 plugins para o Nagios #linux #nagios #debian #shellscript

Osimar Medeiros — Thu, 14 Jan 2010 19:20:09 +0000

Montei 2 plugins para o Nagios. Um checa se os IPs informados como parâmetro estão listados em uma série de RBLs e o outro plugin baixa um arquivo do SNDS (SmartNetworkDataServices – serviço do Hotmail), para verificação de bloqueios de IPs naquele provedor (de longe, o mais crítico).

Depois de muita briga, os plugins finalmente ficaram prontos. Ambos em shell script.

Palhinha dos dois:

#!/bin/bash

log_file=”/endereco_do_arquivo_de_log”
pid_file=”/endereco_do_arquivo_de_pid”
rbls=”/endereco_do_arquivo_de_rbls (.rblcheckrc)”
stored_logs=”/endereco_do_arquivo_temporario_de_logs”

# Funcoes de ajuda, mensagens de log, remocao de arquivo de PID e envio de email

help(){
echo “echo “echo “Usage $0 -c \”

[[/]][

[[/]]]>\”"

}log_msg(){

msg=”[`date`] PID $$: $1″
echo $msg >> $log_file
if [ "$DEBUG" -a "$2" != 1 ]; then
echo $msg
fi
}

kill_pid(){
rm -f $pid_file
}

notification(){
echo -e “$1″ “$2″ | mail -e -s “$3″ $4
}

# Valida se os programas necessarios estao instalados
err=”"
ipcalc=$(which ipcalc) || err=”ipcalc”;
rblcheck=$(which rblcheck) || err=”rblcheck”;
sed=$(which sed) || err=”sed”;
cut=$(which cut) || err=”cut”;
cat=$(which cat) || err=”cat”;
rm=$(which rm) || err=”rm”;
mail=$(which mail) || err=”mail”;
rm=$(which rm) || err=”rm”;
if [ ! -z "$err" ]; then
log_msg “Comando nao encontrado: $err”
kill_pid
exit 0
fi

# Valida se arquivo de rbls existe
if [ ! -f $rbls ] ; then
log_msg “Arquivo de rbls $rbls nao encontrado”
kill_pid
exit 0
fi

# Extracao de argumentos na linha de comando
while getopts c:d:e: OPTION ; do
case $OPTION in
c)
CLASS=$OPTARG
;;
d)
DEBUG=1
;;
e)
EMAIL=$OPTARG
;;
esac

done

# Valida parametros obrigatorios
if [ -z "$CLASS" ]; then
help;
kill_pid
exit 0
fi

#Verifica se o plugin ja esta em execucao
if [ -f $pid_file ] ; then
pid=$(cat $pid_file)
if [[ "$pid" =~ [0-9]+ ]] ; then
return=$(ps -p $pid | wc -l)
if [ $return -gt 1 ] ; then
log_msg “Plugin ja esta em execucao com PID $pid”
kill_pid
exit 0
fi
fi
fi

#Armazena o ID do processo no arquivo de PID
echo $$ > $pid_file

# Calcula intervalo de IPs fornecidos
listed=0
cat /dev/null > $stored_logs
for str in $CLASS; do
# Valida IP/classe
if [ ! $str =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$\/[0-9]+$?$ ]; then
log_msg “Formato de IP invalido”
kill_pid
exit 0
fi

# Verifica se possui mascara de rede
if [[ $str =~ .*\/.* ]]; then
log_msg “Iniciando execucao do script para $str…”
hostmin=$(ipcalc -b $str|grep HostMin|sed ‘s/[^\.0-9]*//g’)
hostmax=$(ipcalc -b $str|grep HostMax|sed ‘s/[^\.0-9]*//g’)
else
hostmin=$str
hostmax=$str
fi

# Obtem o IP inicial e final para aplicar o loop
from=$(echo $hostmin|cut -d’.’ -f4)
to=$(echo $hostmax|cut -d’.’ -f4)
initial=$(echo $hostmin|sed ‘s/[0-9]*$//g’)

# Consulta cada IP
for i in $(seq $from $to) ; do
log_msg “Consultando IP $initial$i” 1
result=`rblcheck -c $(cat $rbls) $initial$i | grep “$initial$i listed”`
if [ ! -z "$result" ]; then
listed=1
log_msg “$result”
echo “$result” >> $stored_logs
fi
done
done

# Retorno
if [[ $listed == 1 ]] ; then
cat $stored_logs
notification “Resultado da checagem de IPs: \n\n” “`cat $stored_logs`” “RBLCHECK WARNING” $EMAIL
kill_pid
rm -f $stored_logs
exit 0
else
result=”OK. Nenhum IP bloqueado.”
echo “$result” >> $stored_logs
notification “Resultado da checagem de IPs: \n\n” “`cat $stored_logs`” “RBLCHECK IS OK” $EMAIL
kill_pid
rm -f $stored_logs
exit 0
fi

log_msg “$result”
[ $DEBUG ] || echo $result

E SNDSCHECK:

#!/bin/bash

ADDR=”https://endereco_do_arquivo_de_IPs_bloqueados”

DEST=”/endereco_local_do_arquivo_de_IPs_bloqueados”
LOG=”/endereco_do_arquivo_de_logs”
ERR=”/endereco_do_arquivo_de_erros”
STORED_LOGS=”/endereco_do_arquivo_de_logs_temporarios”
PID_FILE=”/endereco_do_arquivo_de_pid”

log_msg(){
msg=”[ `/bin/date` ] $1″
echo “$msg” >> $LOG
}

log_err(){
msg=”[ `/bin/date` ] $1″
echo “$msg” >> $ERR
}

help(){
echo “Usage $0 -e ”
}

kill_pid(){
rm -f $PID_FILE
}

remove_file(){
rm -f $DEST$FILE
}

# Extracao de argumentos na linha de comando
while getopts e: OPTION ; do
case $OPTION in
e)
EMAIL=$OPTARG
;;
esac
done

# Validando dependencias
erro=”"
wget=$(which wget) || err=”wget”;
cat=$(which cat) || err=”cat”;
date=$(which date) || err=”date”;
mail=$(which mail) || err=”mail”;
if [ ! -z $erro ] ; then
log_err “Aplicativo nao encontrado: $erro”
exit $STATE_CRITICAL
fi

if [ ! -d $DEST ] ; then
log_err “Diretorio de destino nao encontrado: $DEST”
exit $STATE_CRITICAL
fi

# Valida parametros do script
if [ ! $EMAIL ] ; then
help;
exit $STATE_CRITICAL
fi

# Valida se processo ja esta em execucao
if [ -f $PID_FILE ] ; then
pid=$(cat $PID_FILE)
if [[ "$PID_FILE" =~ [0-9]+ ]] ; then
retorno=$(ps -e $pid | wc -l)
if [ $retorno -gt 1 ] ; then
log_err “Plugin ja esta em execucao com PID $pid”
echo “Plugin ja esta em execucao com PID $pid”
kill_pid
exit $STATE_WARNING
fi
fi
fi

#Armazena o ID do processo no arquivo de PID
echo $$ > $PID_FILE

# Download do arquivo
if ! wget -q –no-verbose -T 60 –no-check-certificate -P $DEST $ADDR ; then
log_err “Erro ao baixar arquivo.”
echo “Erro ao baixar arquivo.”
exit $STATE_CRITICAL
fi

# Retorno para o Nagios
if [[ $blocked == 1 ]] ; then
echo $IPS | sed -r “s/ /\n/g” > $STORED_LOGS
cat $STORED_LOGS
echo -e “Os IPs abaixo estao bloqueados no Hotmail: \n\n” “`echo $IPS | sed -r ‘s/ /\n/g’`” | mail -e -s “SNDSCheck WARNING” $EMAIL
exit $STATE_WARNING
else
IPS=”Nao ha IPs bloqueados no Hotmail.”
echo $IPS
echo -e “$IPS” | mail -e -s “SNDSCheck is OK” $EMAIL
exit $STATE_OK
fi

kill_pid
remove_file

Limpeza de cache #linux #linux #linux

Osimar Medeiros — Wed, 09 Dec 2009 12:14:01 +0000

Script para limpeza de cache, com cálculo de utilização de memória RAM. O script só faz o drop_cache se a memória utilizada for superior a algum valor.

#!/bin/sh

# Salve este script no diretório /etc/cron.hourly e dê permissão

# de execução a ele. Desse modo a cada hora sera verificada se a

# porcentagem de memória utilizada pelo sistema atingiu o valor definido

# na variável ‘percent’. Caso positivo, o script informará ao kernel

# que este deverá alterar o valor da opção ‘drop_caches’ para 3.

# Mais detalhes: ‘man proc’ -> /proc/sys/vm/drop_caches.

PATH=”/bin:/usr/bin:/usr/local/bin”

# Porcentagem máxima de uso da memória, antes de executar a limpeza:

# Obs.: Altere conforme sua necessidade.

percent=40

# Quantidade de memória RAM no sistema:

ramtotaloriginal=`grep -F “MemTotal:” < /proc/meminfo | awk ‘{print $2}’`

ramtotal=`calc $ramtotaloriginal/1024`

echo “Quantidade de memoria RAM no sistema:” $ramtotal “MB”

# Quantidade de RAM livre:

ramlivreoriginal=`grep -F “MemFree:” < /proc/meminfo | awk ‘{print $2}’`

ramlivre=`calc $ramlivreoriginal/1024`

echo “Quantidade de memoria RAM livre:” $ramlivre “MB”

# RAM utilizada pelo sistema:

ramusadaoriginal=`expr $ramtotaloriginal – $ramlivreoriginal`

ramusada=`calc $ramusadaoriginal/1024`

echo “Quantidade de memoria RAM utilizada:” $ramusada “MB”

# Porcentagem de RAM utilizada pelo sistema:

putil=`expr $ramusadaoriginal \* 100 / $ramtotaloriginal`

echo “Porcentagem de memoria RAM utilizada pelo sistema:” $putil”%”

# Checando porcentagem:

echo “Checando porcentagem…”

if [ $putil -gt $percent ]

then

echo “Sincronizando os dados cacheados na memoria com o(s) disco(s)…”

sync

echo “Dropando cache…”

echo 3 > /proc/sys/vm/drop_caches

else

echo “Remove-se as variaveis da memoria e finaliza-se o script…”

echo unset $percent% $ramtotal”MB” $ramlivre”MB” $ramusada”MB” $putil%

exit $?

# Fim

Configurando servidores, montando benchmarks, instalando MediaWiki… tudo ao mesmo tempo agora.

Osimar Medeiros — Fri, 20 Nov 2009 10:49:49 +0000

Estou configurando 9 servidores via ssh, montando estatísticas de concorrência de processos, instalando MediaWiki no servidor local.

E ainda tentarei montar um shell script com um roteiro de instalações de pacotes, para o setup dos servidores.

Belo feriado.

Perl versus Windows Live ID.

Osimar Medeiros — Thu, 12 Nov 2009 10:28:20 +0000

Briga de foice num quarto escuro com sebo passado no chão.

Como sempre, Microsoft dificultando as coisas.

Tentando montar um script que faça log on no SNDS da Microsoft, acesse algumas URLs, e deslogue.

Quem disse que consigo ?

RBLCHECK completo – checagem de IPs com shell script

Osimar Medeiros — Tue, 03 Nov 2009 20:03:53 +0000

Completando o pôst em que falo sobre o rblcheck, montei um shell script para fazer a checagem e tratamento de ocorrência (caso seja encontrado algum IP listado em algum dos rbls checados).

ORIGIN=”/home/endereco_do_arquivo/arquivo_de_ips.ext”
RESULTS=”/home/endereco_do_arquivo_de_resultados/arquivo_de_resultados.ext”

start_rblcheck() {
msg “Iniciando execucao…”

msg “Validando dependencias…”

if [ ! -x /usr/bin/rblcheck ] ; then
msg “/urs/bin/rblcheck nao instalado”
exit 0
fi

if [ ! -f $ORIGIN ] ; then
msg “$ORIGIN nao encontrado”
exit 0
fi

msg “Dependencias validadas com sucesso…”

msg “Rblcheck iniciado…”

while read IPS ; do
RBL=`/usr/bin/rblcheck $IPS|grep “$IPS listed by”`
if [ ! -z "$RBL" ] ; then
msg “$RBL”
fi
done < $ORIGIN > $RESULTS

msg “Execucao finalizada”.”\n”
msg “Arquivo de resultados salvo em $RESULTS”
}

msg() {
echo “[ `date` ] $1″
}

case $1 in
start)
start_rblcheck;
;;
*)
echo “Script para checagem de IPs pelo RBLCHECK”
echo “Usage: $0 start”
exit 1
;;
esac

No script há um arquivo contendo os IPs a serem checados. Há o destino do arquivo de resultados. O restante do script valida se o rblcheck está instalado, se o arquivo de IPs e a pasta de destino existem.

Depois o script faz a checagem dos IPs (linha a linha no arquivo) e, para cada linha onde houver um IP listado, ele insere esta saída no arquivo de resultados.

Finito.

Conversão de IP em representação numérica (e vice-versa) no MySQL

Osimar Medeiros — Tue, 27 Oct 2009 17:12:24 +0000

Para quem costuma utilizar os serviços de monitoramento online de IPs, tipo SNDS da Microsoft, ou SenderScore, é bom saber que muitas vezes, ao consultar um IP, a URL da página exibe uma info que você pode não reconhecer.

Por exemplo: https://postmaster.live.com/snds/dataIP.aspx?ip=3141348145

Veja que o parâmetro (a representação numérica) representa um IP. E como faz-se para saber que IP é este ?

No MySQL, faça:

SELECT inet_ntoa(3141348145);

Veja o resultado da query:

mysql> SELECT inet_ntoa(3141348145);
+———————–+
| inet_ntoa(3141348145) |
+———————–+
| 187.61.43.49 |
+———————–+
1 row in set (0.02 sec)

O IP é 187.61.43.49.

Para fazer o contrário, também é possível:

mysql> SELECT inet_aton(’187.61.43.49′);
+—————————+
| inet_aton(’187.61.43.49′) |
+—————————+
| 3141348145 |
+—————————+
1 row in set (0.01 sec)

Para o IP é necessário encapsulá-lo com aspas.

Caso precise consultar muitos IPs simultaneamente, você pode gerar as URLs, com o uso do CONCAT, ainda no MySQL.

Veja:

mysql> SELECT CONCAT(“http://url_a_ser_concatenada?”,mtaIPs_ip) FROM mtaPoolsIPs LIMIT 5;
+—————————————————+
| CONCAT(“http://url_a_ser_concatenada?”,mtaIPs_ip) |
+—————————————————+
| http://url_a_ser_concatenada?187.61.28.10         |
| http://url_a_ser_concatenada?187.61.28.100        |
| http://url_a_ser_concatenada?187.61.28.101        |
| http://url_a_ser_concatenada?187.61.28.102        |
| http://url_a_ser_concatenada?187.61.28.103        |
+—————————————————+
5 rows in set (0.01 sec)

De modos que sua tarefa diária de consulta de IPs se torna muito mais automatizada que fazer tudo à mão…