Shell Script: Introdução e Como Automatizar Tarefas

Usando Shell Script vou monitorar um servidor web Apache, automatizar tarefas e rotinas

Nesse servidor temos uma aplicação com alguns serviços, como o sistema de vendas da empresa. Ou seja, temos alguns serviços críticos rodando nesse servidor.

Logo, ele deve sempre estar funcionando, pois caso aconteça algum problema e o serviço saia do ar, a empresa pode ter prejuízos.

Uma das possibilidade é monitorar esse servidor web e sempre que ele cair nós vamos reiniciá-lo… mas como sabemos que o servidor caiu?

Lendo o status do servidor

Quando acessamos uma página na internet, na verdade, o que estamos fazendo, é uma requisição para o servidor. Uma requisição nada mais é do que um pedido.

Neste caso, estamos pedindo uma página na web. Se tudo ocorrer bem, nosso servidor nos devolve a página que requisitamos e devolve também um código de status. Esse código informa o estado da requisição.

Se ele retornar 200 significa que tudo ocorreu bem. Já se o código for 404 significa que o que pedimos na requisição não foi encontrado. Esse erro é comum quando tentamos acessar uma página que não existe no servidor. Além desses existem outros códigos, como o 500 que é um erro interno no servidor.

Sabendo que o servidor retorna um código quando recebe uma requisição, podemos ficar monitorando esse código e sempre que ele for diferente de 200 reiniciamos o servidor.

Checando o código HTTP

Para checar o status do HTTP, nós podemos utilizar o comando curl. Este comando permite a transferencia de dados entre o servidor e o host.

Queremos que o curl mostre para gente (--write-out) o código HTTP (%{http_code}) da nossa requisição ao servidor:

curl --write-out %{http_code} www.multillidae.com.br

Bem, o Curl nos devolveu o código de status da requisição. Porém ele também devolveu todo o HTML da página e precisamos apenas do código HTTP.

Portanto, vamos falar para o curl pegar essa saída (--output), que é o código HTTP, e jogá-la no buraco negro do Linux, o /dev/null.

curl --write-out %{http_code} --output /dev/null www.multillidae.com.br

Bem, a resposta foi bem menor agora. Ele não nos retornou o código HTML, contudo ainda nos mostrou a progressão da requisição.

Novamente, queremos apenas o código HTTP, então vamos falar para curl se silenciar (--silent) e nos mostrar apenas o status:

curl --write-out %{http_code} --silent --output /dev/null www.multillidae.com.br

Agora sim, temos somente o código da requisição. Só que vamos ter que ficar checando este código toda hora para saber se o serviço está disponível ou não?

E se esquecer de checar? Ou, se não estiver disponível para checar o status da requisição? Deve existir uma maneira do sistema ficar checando de tempos e tempos o código HTTP e, caso existir algum problema, tentar reiniciar o servidor e me avisar que isso ocorreu.

Conhecendo o Shell Scripting

O Shell Script é uma linguagem de script utilizada em alguns sistemas operacionais, principalmentes em sistemas GNU/Linux.

Com o Shell nós conseguimos criar comandos para o Linux, ou melhor, criar tarefas para serem executadas de tempos em tempos, scripts de inicialização e muitas outras coisas.

Vamos começar a criar nosso script para checar o status do servidor. Primeiro criamos um arquivo com o nome verifica_servidor, como estamos falando em um arquivo Shell, vamos colocar a extensão .sh. Ficando assim: verifica_servidor.sh.

Existem vários tipos de Shells, um dos mais utilizados no mundo Linux é o Bash. O Bash nada mais é do que um interpretador de comandos. É ele quem lê e executa as linhas do nosso arquivo.

Já que vamos usar o Bash, precisamos falar na primeira linha do nosso arquivo que ele é o nosso interpretador:

#!/bin/bash

A gente vai checar o código HTTP, já sabemos como fazer isso, basta utilizar o curl. Mas ficar dando aquele comando toda hora no código pode prejudicar a nossa leitura no script, além de ser trabalhoso ficar toda hora digitando aquele comando extenso.

Portanto, vamos atribuir a saída daquele comando em uma variável, que no meu caso, vou chamar de codigo_http:

Quando estamos atribuindo um comando a uma variável, temos que envolve-lo dentro de $() para que o bash execute:

#!/bin/bash
codigo_http=$(curl --write-out %{http_code} --silent --output /dev/null www.multillidae.com.br)

Vamos pedir para o script imprimir a variável e ver se o comando funcionou como o esperado:

#!/bin/bash
codigo_http=$(curl --write-out %{http_code} --silent --output /dev/null www.multillidae.com.br)
echo $codigo_http

Agora, para o Bash interpretar este script:

bash verifica_servidor.sh

Funcionou! O que precisamos fazer agora é pedir para o Bash verificar se esse código é diferente de 200, ou seja, se (if) o código for diferente (-ne, not equal) de 200, tente reiniciar o servidor Apache HTTPD (systemctl restart httpd).

#!/bin/bash
codigo_http=$(curl --write-out %{http_code} --silent --output /dev/null www.multillidae.com.br)
if [ $codigo_http -ne 200 ]; then
    systemctl restart httpd
fi

Pronto, dessa maneira sempre que nosso servidor tiver uma resposta diferente de 200 ele tentará reiniciar.

Só que, dessa forma não sabemos quando ele foi reiniciado. Nós podemos querer saber quando ele foi reiniciado para descobrir o motivo disso ter ocorrido.

Vamos falar para nosso script para que ele escreva (echo) uma mensagem quando antes de tentar reiniciar o servidor.

Para manter um log mais organizado, vou colocar a mensagem, a data e hora do ocorrido.

Conseguimos pegar a data do sistema utilizando o comando date. Podemos pedir para ele nos mostrar a data completa passando o parâmetro %F (full date). Se esse parâmetro for o primeiro, temos que passar o sinal de + antes:

date +%F

Com Criando anotações no Javaele também conseguimos pedir a hora do sistema. Para isso, basta usar o parâmetro %T (time).

date +%T

Então, para imprimir data e hora podemos usar o comando: date +%F %T:

Hum… não funcionou. Como utilizamos um espaço para separar a data da hora, temos que falar para o date escapá-lo (\). Logo, o comando fica:

date +%F\ %T

Conseguimos obter a data e a hora. Vamos colocá-las no nosso código. Como date é um comando, temos que envolve-lo dentro de $().

#!/bin/bash
codigo_http=$(curl --write-out %{http_code} --silent --output /dev/null www.multillidae.com.br)
if [ $codigo_http -ne 200 ]; then
    echo "Houve um problema com o servidor, tentando reiniciá-lo  $(date +%F\ %T)"
    systemctl restart httpd
fi

Só que, dessa maneira, a mensagem será impressa na tela. Precisamos redirecionar a saída do comando echo para o nosso arquivo.

Então vamos falar para o Bash redirecionar (>>) para o arquivo onde ficarão salvos nossos logs. No meu caso, esse arquivo fica na pasta /logs/servidor.log. Uma coisa bacana é que se esse arquivo não existir, o Bash o cria.

#!/bin/bash
codigo_http=$(curl --write-out %{http_code} --silent --output /dev/null www.multillidae.com.br)
if [ $codigo_http -ne 200 ]; then
    echo "Houve um problema com o servidor, tentando reiniciá-lo  $(date +%F\ %T)" >> /logs/servidor.log
    systemctl restart httpd
fi

Agora, se o servidor apresentar um problema, basta executarmos o script que ele tentará reiniciar o servidor e ainda irá gravar uma mensagem no log para a gente.

Mas ainda temos que executar esse script para ele funcionar. Nós precisamos de alguma coisa que o execute automaticamente, sem precisar ficar nos preocupando em executar o script.

Agendando tarefas com o cron

Queremos que esse script seja executado de tempos em tempos. Para isso, podemos utilizar uma ferramenta do Linux chamada cron. Com ela conseguimos agendar nossas tarefas para que elas sejam executados a cada segundo, hora, dia da semana, quando nos for conveniente.

Logo, vamos editar o arquivo do cron para que ele fique gerenciando nosso script. Para abrir o arquivo de configuração do cron, basta digitar: crontab -e:

Esse arquivo é dividido em colunas, onde cada coluna representa uma unidade de tempo e a última representa a tarefa a ser executada.

As colunas são divididas em:

Minutos Horas Dia do mes Mês Dia da semana Comando

Como se trata de um serviço crítico, vamos falar para o cron executá-lo a cada minuto (*/1). Para isso basta colocar (*/1) na coluna de minutos e o asterisco (*) em todos os demais campos.

No caso do comando, vamos passar o caminho para ele, no meu caso está em /scripts/.

*/1 * * * * bash /scripts/verifica_servidor.sh

Pronto! Agora nosso script será executado a cada minuto e, caso tenha algum problema, o script tentará reiniciar o servidor.

Para saber mais

Existem versões mais curtas dos parâmetros que utilizamos com o comando curl. O --write-out pode ser substituído por -w, o --silent por -s e o --output por -o.

Além do Bash, existem muitos outros interpretadores Shells, como o Korn Shell e o Z Shell.

Esse foi apenas um exemplo de automatizar tarefas com o Shell Scripting, existem muitas outras, como por exemplo enviar um e-mail sempre que o servidor web cair.

Aqui na Alura temos dois cursos sobre Shell Scripting que além de ensinar como enviar emails automaticamente, ensina como monitorar o consumo de memória, como converter imagens automaticamente, fazer backups na nuvem e muito mais.

Além dos scripts em Shell, existem outras ferramentas que ajudam a monitorar os servidores. Um exemplo é o Kubernetes, um serviço que gerencia containers como o Docker.

O Kubernetes consegue monitorar os containers de nossa aplicação e garantir que caso algum container caia, outro suba em seu lugar.

Na Alura temos um curso sobre o Kubernetes. Nele você aprenderá como o Kubernetes gerencia os containers, como realizar técnicas como o balanceamento de carga e até como implementá-lo na nuvem. Um recurso muito utilizado nos dias de hoje.

Serviços como Amazon EC2 ou Google Cloud são muito utilizados quando queremos fazer o deploy da sua webapp. A vantagem é que o próprio serviço monitora o estado do servidor e garante que sua aplicação fique sempre disponível.

Aqui na Alura, temos um curso sobre Amazon EC2. Nele você aprenderá sobre como colocar sua aplicação na nuvem, sobre os tipos de clouds que existem, como escalar automaticamente sua aplicação, entre outras coisas.