Requisições de rede usando a biblioteca padrão

Introdução

Em operações, verificar a disponibilidade de serviços web é uma tarefa comum. Embora bibliotecas de terceiros, como requests, sejam populares, em alguns ambientes restritos você precisa usar apenas a biblioteca padrão do Python.

Neste laboratório, você usará o módulo urllib da biblioteca padrão do Python para criar um verificador simples de conectividade. Isso demonstra que muitas ferramentas úteis para operações podem ser criadas sem dependências adicionais.

Ao final deste laboratório, você saberá como:

Importar o módulo urllib.request.
Definir uma função para verificar uma URL.
Obter códigos de status HTTP, como 200 OK.
Tratar exceções, como erros do servidor ou hosts inacessíveis.
Exibir mensagens de status fáceis de entender.

Importar módulos

Nesta etapa, você começará criando um script Python e importando o módulo necessário. O módulo urllib.request é a ferramenta integrada do Python para abrir URLs. Pense nele como um navegador web, como Chrome ou Firefox, que você controla por código em vez de usar o mouse. Ele permite que o script obtenha dados da internet.

Isso é útil em operações porque muitos sistemas disponibilizam APIs baseadas em HTTP ou endpoints de verificação de integridade. Mesmo quando as equipes adotam bibliotecas de terceiros posteriormente, entender as ferramentas da biblioteca padrão ajuda você a compreender melhor o modelo subjacente de requisição e resposta.

Primeiro, confirme se você está no diretório correto. Abra o terminal e navegue até a pasta do projeto:

cd ~/project

Agora, crie um novo arquivo Python chamado connectivity_check.py usando o editor de texto nano ou qualquer outro editor de sua preferência:

nano connectivity_check.py

Em Python, antes de usar uma biblioteca, precisamos importá-la. Adicione a linha a seguir ao início do arquivo. Estamos importando urllib.request para tratar a requisição e urllib.error para tratar possíveis erros posteriormente.

import urllib.request
import urllib.error

Pressione Ctrl+O e, em seguida, Enter para salvar o arquivo. Depois, pressione Ctrl+X para sair do nano.

Você pode verificar o conteúdo do arquivo usando o comando cat:

cat connectivity_check.py

Definir a função

Agora que os imports estão prontos, precisamos estruturar o código. É uma boa prática encapsular a lógica em funções. Isso torna o código reutilizável e mais fácil de testar.

As funções são especialmente úteis em scripts operacionais porque a mesma ação geralmente precisa ser executada para vários destinos. Depois que a verificação de rede estiver dentro de uma função, você poderá chamá-la para URLs diferentes sem duplicar o código.

Nesta etapa, você definirá uma função chamada check_url que recebe uma string de URL como argumento.

Abra novamente o arquivo connectivity_check.py:

nano connectivity_check.py

Adicione a definição da função a seguir abaixo das instruções de importação. Por enquanto, adicionaremos apenas a instrução pass, que indica “não fazer nada” em Python. Preencheremos a lógica nas próximas etapas.

import urllib.request
import urllib.error

def check_url(url):
    print(f"Checking connectivity for: {url}")
    ## Logic will go here
    pass

Salve o arquivo e saia do editor (Ctrl+O, Enter, Ctrl+X).

Essa estrutura estabelece a base do programa. A função check_url recebe um parâmetro, url, que será o endereço do site que queremos testar, como "https://www.google.com".

Fazer a requisição

Nesta etapa, implementaremos a lógica principal para enviar uma requisição e obter o código de status HTTP. Um código de status HTTP 200 normalmente significa “OK” ou sucesso.

Em termos gerais, uma requisição HTTP é uma conversa entre cliente e servidor. O seu script é o cliente. Ele envia uma requisição para uma URL, espera a resposta do servidor e, em seguida, verifica metadados, como o código de status, antes de decidir o que fazer.

Usaremos urllib.request.urlopen() para abrir a URL. Essa função retorna um objeto de resposta que possui o método .getcode() para obter o código de status.

Abra o arquivo connectivity_check.py:

nano connectivity_check.py

Atualize a função check_url para que fique assim. Observe que estamos adicionando um tempo limite de 5 segundos para evitar que o script fique travado quando o servidor não responder.

import urllib.request
import urllib.error

def check_url(url):
    print(f"Checking connectivity for: {url}")

    ## Open the URL with a 5-second timeout
    response = urllib.request.urlopen(url, timeout=5)

    ## Get the status code
    status_code = response.getcode()

    print(f"Status Code: {status_code}")

Observação: neste momento, se a URL for inválida ou o servidor estiver indisponível, o script será encerrado com um erro porque ainda não adicionamos o tratamento de erros. Corrigiremos isso na próxima etapa.

Salve o arquivo e saia do editor.

Tratar erros

A programação de rede é imprevisível. Servidores ficam indisponíveis, buscas DNS falham e conexões com a internet são interrompidas. Quando urlopen falha, ele gera uma exceção. Para tornar o script robusto, precisamos tratar essas exceções usando um bloco try...except.

Essa distinção entre diferentes modos de falha é importante no monitoramento real. Quando um servidor retorna 500, significa que você alcançou o servidor e ele informou um problema interno. Um URLError geralmente significa que a requisição nem chegou a um endpoint HTTP utilizável. Bons profissionais de operações tratam esses casos como classes diferentes de incidente.

Trataremos dois tipos específicos de erro:

urllib.error.HTTPError: o servidor respondeu, mas com um código de erro, como 404 Not Found ou 500 Server Error.
urllib.error.URLError: não foi possível alcançar o servidor, por exemplo, por falta de internet ou por causa de um domínio incorreto.

Pense no bloco try...except como uma rede de segurança. Se algo der errado, como uma interrupção da conexão com a internet, o código não será encerrado abruptamente. Em vez disso, ele passará para o bloco except, onde poderemos capturar o erro e exibir uma mensagem útil.

Abra o arquivo connectivity_check.py:

nano connectivity_check.py

Modifique a função para envolver a lógica da requisição em um bloco try:

import urllib.request
import urllib.error

def check_url(url):
    print(f"Checking connectivity for: {url}")

    try:
        ## Attempt to open the URL
        response = urllib.request.urlopen(url, timeout=5)
        status_code = response.getcode()
        print(f"Success! Status Code: {status_code}")

    except urllib.error.HTTPError as e:
        ## Server responded with an error (e.g., 404, 500)
        print(f"HTTP Error: {e.code}")

    except urllib.error.URLError as e:
        ## Failed to reach the server
        print(f"URL Error: {e.reason}")

Esse código tenta executar as linhas dentro do bloco try. Se ocorrer um erro, o Python interromperá a execução do bloco try e passará para o bloco except correspondente.

Salve o arquivo e saia do editor.

Testar o script

Nesta etapa final, tornaremos o script executável adicionando um bloco principal que chama a nossa função. Isso permite executar o script diretamente no terminal.

O padrão if __name__ == "__main__": é uma convenção do Python que separa as funções reutilizáveis do código que deve ser executado quando o arquivo é executado diretamente. Essa pequena decisão de projeto facilita a reutilização posterior, pois outro script pode importar check_url sem disparar automaticamente as chamadas de teste.

Vamos testar o script com uma URL conhecida por funcionar, como https://www.example.com. Você também pode testar uma URL falsa para observar o tratamento de erros.

Abra o arquivo connectivity_check.py:

nano connectivity_check.py

Adicione o código a seguir ao final do arquivo:

if __name__ == "__main__":
    ## Test with a valid URL
    target_url = "https://www.example.com"
    check_url(target_url)

    print("-" * 20)

    ## Test with an invalid URL to see error handling
    invalid_url = "https://www.this-domain-does-not-exist-12345.com"
    check_url(invalid_url)

O bloco if __name__ == "__main__": garante que esse código seja executado somente quando o script for executado diretamente, e não quando for importado como módulo em outro script.

Salve o arquivo e saia do editor.

Agora, execute o script para ver os resultados:

python3 connectivity_check.py

Você deverá ver uma saída semelhante a esta:

Checking connectivity for: https://www.example.com
Success! Status Code: 200
--------------------
Checking connectivity for: https://www.this-domain-does-not-exist-12345.com
URL Error: [Errno -2] Name or service not known

(Observação: a mensagem de erro exata para a URL inválida pode variar um pouco dependendo do ambiente de rede.)

Resumo

Neste laboratório, você criou com sucesso um verificador de conectividade de rede usando a biblioteca padrão do Python. Você aprendeu a:

Importar módulos: usar urllib.request e urllib.error.
Fazer requisições HTTP: usar urlopen para se conectar a um servidor web.
Tratar respostas: obter códigos de status HTTP para verificar a disponibilidade de um serviço.
Gerenciar erros: implementar blocos try...except para tratar HTTPError e URLError, tornando o script resistente a falhas de rede.

Essa habilidade é fundamental para criar scripts de monitoramento, verificações de integridade e web scrapers simples em ambientes nos quais não é possível instalar dependências externas.