Monitorando a saída de comandos no terminal

Frequentemente na minha rotina de administrar servidores eu preciso executar um determinado comando repetidas vezes com a intenção de acompanhar alguma modificação no sistema.

Como esta é uma tarefa quase que obrigatória de ser executada neste tipo de ambiente, vou deixar aqui três dicas para os novos recrutas.

Acompanhando as atualizações em um arquivo

Se você precisa monitorar os acréscimos no final de um arquivo, como os arquivos de log do sistema, nada é melhor do que o comando tail. Esqueça o comando cat que você aprendeu no cursinho de Linux básico.

Enquanto o cat exibe todo o conteúdo do arquivo solicitado, o comando tail exibe apenas as suas últimas linhas.

Para facilitar ainda mais, usando o parâmetro -f é possível manter o tail em loop de forma que quando uma nova linha for adicionada no final do arquivo, ela será automaticamente exibida na tela sem a necessidade de se executar o comando ‘cat’ várias vezes.

Sua sintaxe é bem simples:

tail -f [seuarquivo]

Por padrão o comando tail, exibe as últimas 10 linhas do arquivo antes de começar a acompanhar os acréscimos. Para alterar este valor, caso você precise que algumas linhas antes sejam exibidas use o parâmetro -n [número de linhas], como no exemplo:

tail -n 50 -f [seuarquivo]

Assim, as últimas 50 linhas do [seuarquivo] serão exibidas e o comando tail ficará em constante monitoramento exibindo os novos incrementos.

Se você quiser testar no seu sistema sem qualquer compromisso tente monitorar o syslog (log principal do seu sistema).

tail -n 15 -f /var/log/syslog

Caso precise algo mais dê uma olhada na página de manual do comando tail. Embora ele tenha ainda um punhado de parâmetros a mais, basicamente com estes dois que citei você resolverá 99% dos seus problemas para monitorar arquivos.

Como o comando tail vem no pacote básico de ferramentas da maioria das distribuições,você pode simplesmente sair usando sem precisar instalar nada.
Cauda colorida

Caso o arquivo que você esteja visualizando esteja em formato de log de sistema, você ainda poderá usar um encanamento para o comando ccze, que em outros tempos era chamado ‘colorize’.

Por exemplo, o comando abaixo monitora o log do meu servidor proxy, exibindo as mensagens coloridas, o que facilita bastante a leitura das linhas.

tail -f /var/log/squid3/access.log|ccze

O comando ccze, não vem instalado por padrão. Então você deverá instalá-lo em seu sistema para poder usá-lo. No Debian, Ubuntu e outros derivados o comando abaixo resolve o problema;

sudo aptitude install ccze

Em outras distribuições, procure por um pacote com o nome ccze ou mesmo colorize.

Executando um comando repetidas vezes – modo 1

Eventualmente surge a necessidade de se executar um comando repetidas vezes para acompanhar o resultado de uma modificação no sistema, por exemplo. Para isto existe algumas
possibilidades. Como por exemplo usado o comando ‘watch’, cuja sintaxe básica é:

watch ‘comando’

Este comando permite que um dado comando seja executado várias vezes exibindo a sua saída em uma tela limpa. Por exemplo, vamos supor que eu queira monitorar as alterações no meu diretório /tmp.

Para ver o conteúdo de um diretório usa-se o comando “ls” (ls -l /tmp), certo? Para não ter que ficar digitando este comando várias vezes basta usar:

watch ‘ls -l /tmp’

Se o comando a ser monitorado for muito extenso e complexo, com caracteres coringas, espaços etc; certifique-se de manter todo ele, dentro de aspas, evitando assim problemas com a interpretação dos caracteres coringas.

Com isso a saída do comando ls será atualizada na tela a cada 2s (seria como se a cada 2s eu digita-se os comandos clear ; ls -l /tmp) para ver o conteúdo do diretório.

Da mesma forma se eu quiser monitorar as conexões TCP abertas em minha máquina bastaria usar:

watch ‘netstat -nt’

Assim a cada 2s o comando netstat será executado exibindo as conexões tcp que estejam abertas na minha máquina.

O comando watch possui alguns parâmetros interessantes que valem a pena serem comentados. Como por exemplo o parâmetro -n [tempo] que altera o intervalo de 2s para o tempo que você considerar suficiente para seu trabalho de monitoramento.

O parâmetro -d, destaca as alterações que ocorreram desde a última atualização, sendo assim, para que eu possa observar melhor as novas conexões eu poderia fazer assim:

watch -n 5 -d ‘netstat -nt’

Perceba que os parâmetros do comando watch devem sempre estar antes do seu comando e pra terminar, o comando watch está disponível em praticamente qualquer distribuição Linux.

Executando um comando repetidas vezes – modo 2

O comando watch é ótimo para você monitorar comandos cuja saída caibam na sua tela. Mas caso você precise acompanhar uma listagem pouco maior ele já não será agradável para se acompanhar.

Da mesma forma se você precisar ver um histórico das modificações na tela, o watch não o ajudará. Para estes casos então o melhor a fazer é usar um laço ‘while’, com o comando ‘sleep’ marcando o tempo.

A sintaxe é um pouco grandinha, mas não é difícl de memorizar. Então decore ai:

while [ 1 ]; do {seucomando}; sleep {tempo}; done

Perceba que ‘[ 1 ]’ deve ser usado exatamente assim, com espaços entre os símbolos. Na verdade poderia ser qualquer condição que seja sempre verdadeira, garantindo que o laço seja infinito;
{seucomando] pode ser o comando, ou comandos que você precise executar, e
{tempo} é o tempo desejado para esperar entre as execuções.

Por exemplo, para acompanhar o uso da partição /home no meu servidor Samba, eu posso executar o seguinte comando:

while [ 1 ]; do df /dev/mapper/Grupo-Home|tail -n 1; sleep 30m; done

Desta forma, o comando df /dev/mapper/Grupo-Home|tail -n 1 estaria sendo executado a cada 30 minutos e seu resultado sendo empilhado na tela para que depois de um tempo eu possa analisar o que está ocorrendo.

Veja que eu especifiquei ‘30m’ para corresponder a 30 minutos. Caso você só especifique um número será considerado como o número de segundos.

Para especificar em minutos, horas ou dias, acrescente o sufixo correspondente como por exemplo: ‘12m’, ‘5h’, ‘3d’ etc.

Veja entretanto que se o tempo for muito longo talvez seja mais coerente usar o cron para agendar tais execuções.

Por fim é importante ressaltar, que se houver necessidade você poderá usar vários comandos em sequencia, separados por “;” ou por “&&”. De forma que todos eles sejam executados um após o outro.

Eu costumo usar o exemplo a seguir quando estou fazendo testes com a minha interface de rede e tabela de roteamento.

while [ 1 ]; do ifconfig eth0 && ip route ; sleep 1; done

A diferença entre usar o ‘;’ e o ‘&&’ é que ‘;’ deixará que o segundo comando seja executado em qualquer situação. Usando ‘&&’ o segundo comando só será executado se o primeiro terminar com sucesso.

Conclusão

O objetivo deste texto foi mostrar como fazer algumas tarefas de monitoramento usando recursos genéricos, sem precisar apelar para ferramentas sofisticadas e que nem sempre estão disponíveis no sistema.

É importante deixar este aviso para que ninguém me venha a deixar comentários falando que já viu uma ferramenta de monitoramento de logs no Gnome, interfaces de rede ou os logs do squid.

O restante agora depende da sua criatividade e se precisar de mais detalhes sobre cada comando usado, consulte as suas páginas de manual: man {comando}.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.