Verificação de integridade da página da Web usando curl

Eu gostaria de fazer uma verificação de integridade de um serviço chamando um URL específico. Parece que a solução mais simples seria usar o cron para fazer a verificação a cada minuto. Em caso de erros, o cron me envia um email.

Tentei usar cUrl para isso, mas não consigo enviar mensagens apenas por erros. Se eu tentar direcionar a saída para / dev / null, ele imprimirá o relatório de progresso.

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  5559  100  5559    0     0   100k      0 --:--:-- --:--:-- --:--:--  106k

Tentei examinar as opções de curvatura, mas simplesmente não consigo encontrar nada que se adapte à situação em que você deseja que ela seja silenciosa quanto ao sucesso, mas que faça barulho quanto a erros.

Existe uma maneira de fazer o curl fazer o que eu quero ou há alguma outra ferramenta que eu deveria estar olhando?

Que tal -sSf? Nas páginas do manual:

  -s/--silent
     Silent or quiet mode. Do not show progress meter or error messages.  
     Makes Curl mute.

  -S/--show-error
     When used with -s it makes curl show an error message if it fails.

  -f/--fail
     (HTTP)  Fail silently (no output at all) on server errors. This is mostly
     done to better enable scripts etc to better deal with failed attempts. In
     normal  cases  when a HTTP server fails to deliver a document, it returns
     an HTML document stating so (which often also describes  why  and  more).
     This flag will prevent curl from outputting that and return error 22.

     This method is not fail-safe and there are occasions where non-successful
     response codes will  slip  through,  especially  when  authentication  is
     involved (response codes 401 and 407).

Por exemplo:

curl -sSf http://example.org > /dev/null

Eu acho que, para a maneira mais simples de verificar se o site está ativo, você pode usar o seguinte método:

curl -Is http://www.google.com | head -n 1

Isso retornará HTTP/1.1 200 OK. Se o retorno não corresponder à sua saída, peça ajuda.

Você precisa do -ssinalizador (silencioso), -fsinalizador (falha no código de saída por erro) e pode usar o -osinalizador para redirecionar a saída:

curl www.websiteToTest.com -s -f -o /dev/null || echo "Website down." | mail -s "Website is down" [email protected] 

Este é apenas um mau exemplo para um script cron simples. Normalmente, você deseja receber apenas um e-mail se um site estiver inativo.

você pode capturar estatísticas de tempo da rede a partir de curl. latências de cada fase em um ciclo de solicitação / resposta podem ser úteis para determinar a integridade.

$ URL=https://example.com
$ curl "$URL" -s -o /dev/null -w \
> "response_code: %{http_code}\n
> dns_time: %{time_namelookup}
> connect_time: %{time_connect}
> pretransfer_time: %{time_pretransfer}
> starttransfer_time: %{time_starttransfer}
> total_time: %{time_total}
> "
response_code: 200

dns_time: 0.029
connect_time: 0.046
pretransfer_time: 0.203
starttransfer_time: 0.212
total_time: 0.212

Dessa maneira, você poderá tentar testar o site quando https estiver presente:

#!/bin/bash
# put your domain in this var
https=https://www.somewebsite.com

# save the status in some variable 
status=`curl $https -k -s -f -o /dev/null && echo "SUCCESS" || echo "ERROR"`    

# print results (or use it in your scripts)
echo "testing $https=$status"

Recentemente, fui convidado a criar algo que funcionaria mais como um batimento cardíaco sofisticado.

for i in `curl -s -L cnn.com |egrep --only-matching "http(s?):\/\/[^ \"\(\)\<\>]*" | uniq` ; do curl -s -I $i 2>/dev/null |head -n 1 | cut -d$' ' -f2; done

Ou, expandido para um pouco mais de legibilidade,

for i in $(curl -s -L cnn.com |egrep --only-matching 'http(s?):\/\/[^ \"\(\)\<\>]*' | uniq)
do
    curl -s -I "$i" 2>/dev/null | head -n 1 | cut -d' ' -f2
done

O que fiz foi curlum site, analise todos os links do html e, em seguida, curlos links analisados, produzindo apenas o código de status. Então eu procuraria por códigos de status http> = 400 para encontrar erros.

Responda:

#!/bin/bash -eu
timeout 3s curl -fIsS http://example.org > /dev/null
# and if you have TLS (https), check if it's about to expire:
true | openssl s_client -connect example.org:443 2>/dev/null | openssl x509 -noout -checkend "$((3600*24*20))"

Explicações:

• timeout 3sdefinirá um tempo limite de 3 segundos para sua solicitação. Responder mais devagar é considerado "não saudável"
• o -fsinalizador de ondulação falhará cedo, -Smostrará erros, -ssuprimirá a saída normal, -Ibuscará apenas cabeçalhos HTTP, não o conteúdo. (Como sempre, mais detalhes estão disponíveis sob man curlcomando.)
• A -checkenddiretiva openssl verifica as datas de validade de um certificado. No meu exemplo, são 20 dias (especificados em segundos).

O Curl possui códigos de status de saída muito específicos.
Por que não apenas verificar esses códigos ?

#!/bin/bash

##name: site-status.sh

FAIL_CODE=6

check_status(){
    LRED="\033[1;31m" # Light Red
    LGREEN="\033[1;32m" # Light Green
    NC='\033[0m' # No Color


    curl -sf "${1}" > /dev/null

    if [ ! $? = ${FAIL_CODE} ];then
        echo -e "${LGREEN}${1} is online${NC}"
    else
        echo -e "${LRED}${1} is down${NC}"
    fi
}


check_status "${1}"

Uso:

$ site-status.sh example.com

Resultado:

$ example.com is online

Notas:

Este script verifica apenas se o site pode ser resolvido.

Esse código deve ajudá-lo se tudo o que importa é que o site esteja ativo ou inativo.
No entanto, se você fizer algumas alterações no bloco if / else, poderá testar facilmente outros códigos de status, se desejar