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

Posted by Osimar Medeiros on

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

Posted by Osimar Medeiros on

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é.

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

Posted by Osimar Medeiros on

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

Posted by Osimar Medeiros on

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 \”<ADDRESS>[[/]<NETMASK>][ <ADDRESS>[[/]<NETMASK>]]>\”"

}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 <EMAIL>”
}

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

# Retencao dos IPs
listed=0
FILE=$(ls $DEST | grep ipStatus)
IPS=$(cat $DEST$FILE | cut -d , -f 1,2 | sed -r “s/,/\n/g” | sort | uniq)
if [ ! -z "$IPS" ] ; then
blocked=1
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

Posted by Osimar Medeiros on

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 $?
fi
# Fim

RBLCHECK completo – checagem de IPs com shell script

Posted by Osimar Medeiros on

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

Posted by Osimar Medeiros on

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…

PHP5 + SOAP 1.1

Posted by Osimar Medeiros on

Alguns clientes da empresa onde trampo tiveram problemas ao usar nossa API (usamos SOAP versão 1.1.), com o PHP5.

Como usamos o PHP4, não havíamos notado essa zica.

Para montar um método em nossos webservices, usando o PHP5, como descobriu um desenvolvedor nosso, tem-se que incluir a referência abaixo:

soap_version’ => SOAP_1_1,’features’ => SOAP_USE_XSI_ARRAY_TYPE

Veja um exemplo:

<?php
$ws = new SoapClient(“http://endereco_do_wsdl/?wsdl”, array(‘soap_version’ => SOAP_1_1,’features’ => SOAP_USE_XSI_ARRAY_TYPE));
$contatos = array(0 => array (“manterLista” => 1,
“listas” => array (0 => array (“listaId” => 24)),
“campos” => array (0 => array (“tag” => “email”,”valor” => “teste@teste.com.br”),
1 => array (“tag” => “nome”,”valor”=> “Teste”))
),
1 => array (“manterLista” => 1,
“listas” => array (0 => array (“listaId” => 24)),
“campos” => array (0 => array (“tag” => “email”,”valor” => “blabla@blabla.com.br”),
1 => array (“tag” => “nome”,”valor”=> “Blabla”))
)
);
$resp = $ws->AdicionaAtualizaContatos(“login”,”senha”,$contatos);
print “<pre>”;
print_r($resp);
?>

E aí roda normalmente.

Sincronia entre máquinas com rsync

Posted by Osimar Medeiros on

Não é novidade que pra usar qualquer distro Linux, é preciso mexer bastante no shell. A interface gráfica ajuda muito, mas certas (e as mais tensas) necessidades só podem ser resolvidas com o uso da CLI (command line interface).

Para realizar backups confiáveis no Linux, não seria diferente. O rsync é um dos melhores da categoria.

Veja abaixo:

rsync –recursive –update –copy-links –perms –force –compress –progress –log-file=/tmp/rlog.txt -Ph /home/osimar/pictures root@192.168.0.52:/home/maquina2

Nesta linha de comando, pede-se: sincronia de pastas entre máquinas conectadas na rede.

Cópia recursiva, atualizando arquivos modificados, copiando permissões, forçando cópia não permitidas, comprimindo os arquivos no transporte pela rede, exibindo barra de progresso, gerando um arquivo de log, para outra máquina.

Simples e muito eficaz.

SED – fácil, porém útil

Posted by Osimar Medeiros on

Muita gente fala mal do sed, porque é simples e vicia. Bem, eu sou um iniciante no mundo do Linux e frequentemente tenho usado o sed.

Para uma substituição simples em blocos de texto, ele faz o que promete.

Suponha que você tenha um arquivo texto e, dentro dele, precise substituir várias palavras por outras. Usando o vim ou o gedit, você poderia substituir, por exemplo ‘ por “.

Mas, suponha que você tenha um arquivo contendo vários IPs. Como você substituiria uma série numéria por outra expressão, se você não sabe quais números vai substituir ? É aí que entra o sed.

Veja abaixo:

sed -r “s/([0-9]{2,}\.[0-9]{2,}\.[0-9]{2,}\.[0-9]{1,})/Este é o IP \1/g” /endereco_do_arquivo/arquivo.ext

A string acima significa que, usando as expressões regulares, você pesca qualquer sequência numéria que tenha a ordem de um IP e a substitui por ela própria, dentro de uma outra string, dando sentido ao conjunto.

Elementos: -r = significa que vai usar expressão regular no script

([0-9… = é a sequência que o sed busca dentro do arquivo original

\1 = é o resultado da busca anterior (linha a linha)

De modos que, se no arquivo original você tinha:

192.168.0.1

192.168.0.2, etc, etc, agora você teria:

Este é o IP 192.168.0.1

Este é o IP 192.168.0.2

e assim por diante.

Para gerar um arquivo de queries SQL isto seria útil. Economizaria tempo.

Checagem de IPs

Posted by Osimar Medeiros on

Vamos supor que você precise fazer checagens dos IPs de sua empresa no Spamhaus. Ao invés de ir no site e checar um por um, experimente o programinha RBLCHECK, que roda direto no shell. Para checar vários, sem precisar ir manualmente, use o esquema abaixo (exemplo):

ADDR=”/home/…/…/arquivo_contendo_os_ips.txt”
while read IPS ; do
rblcheck $IPS
done < $ADDR

Bem simples.

Elementos:

$IPs – variável que recebe linha por linha os IPs contidos no arquivo.
$ADDR – variável que contém o endereço do arquivo de IPs a serem checados.

Você pode dar a saída do script no próprio shell ou para outro arquivo, para armazenamento local.

Geração simples de arquivo

Posted by Osimar Medeiros on

Vamos supor que você esteja testando a performance do seu recém instalado banco de dados. Você precisa de um database gigante e quer testar o LOAD DATA INFILE do MySQL.

Obviamente não servirá montar uma procedure que gere uma base gigante. Você precisa carregar um arquivo. Na sua base você quer inserir código, nome, email e endereço.

Então abra seu shell e mande:

for cont in $(seq 50000) ; do
echo “$cont;Nome$cont;teste$cont@gmail.com;Rua Numero $cont, casa $cont”
done

Elementos:

$cont = Contador.

seq 50000 = número de linhas que você quer popular em seu arquivo. Pode ser o número que você quiser, claro.

Usando o for, você manda o shell printar a linha contendo os dados que você quer, separados por ponto-e-vírgula (poderia ser por qualquer delimitação de campos) e, com o contador, as linhas são geradas com dados únicos, de modos que você pode usar as constrainsts normalmente em sua tabela.

Depois é só testar o LOAD DATA INFILE com este arquivo.