Requêtes réseau avec la bibliothèque standard

Introduction

Dans les opérations informatiques, vérifier la disponibilité des services web est une tâche courante. Même si les bibliothèques tierces comme requests sont populaires, certains environnements restreints vous obligent à utiliser uniquement la bibliothèque standard de Python.

Dans ce lab, vous utiliserez le module urllib de la bibliothèque standard de Python pour créer un vérificateur de connectivité simple. Cet exercice montre qu'il est souvent possible de créer des outils opérationnels utiles sans dépendances supplémentaires.

À la fin de ce lab, vous saurez :

Importer le module urllib.request.
Définir une fonction pour vérifier une URL.
Récupérer les codes d'état HTTP, par exemple 200 OK.
Gérer des exceptions telles que les erreurs du serveur ou les hôtes inaccessibles.
Afficher des messages d'état faciles à comprendre.

Importer les modules

Dans cette étape, vous allez commencer par créer un script Python et importer le module nécessaire. Le module urllib.request est l'outil intégré à Python qui permet d'ouvrir des URL. Vous pouvez le considérer comme un navigateur web, tel que Chrome ou Firefox, que vous contrôlez avec du code plutôt qu'avec une souris. Il permet à votre script de récupérer des données sur Internet.

Cette fonction est utile dans les opérations informatiques, car de nombreux systèmes fournissent des API basées sur HTTP ou des points de terminaison de vérification d'état. Même si les équipes adoptent ensuite des bibliothèques tierces, la compréhension des outils de la bibliothèque standard permet de mieux voir le fonctionnement sous-jacent du modèle requête-réponse.

Commencez par vérifier que vous vous trouvez dans le bon répertoire. Ouvrez votre terminal et accédez au dossier du projet :

cd ~/project

Créez maintenant un fichier Python nommé connectivity_check.py avec l'éditeur de texte nano, ou avec l'éditeur de votre choix :

nano connectivity_check.py

En Python, vous devez importer une bibliothèque avant de pouvoir l'utiliser. Ajoutez la ligne suivante au début de votre fichier. Vous importez urllib.request pour gérer la requête et urllib.error pour gérer les erreurs éventuelles dans les étapes suivantes.

import urllib.request
import urllib.error

Appuyez sur Ctrl+O, puis sur Enter pour enregistrer le fichier, et sur Ctrl+X pour quitter nano.

Vous pouvez vérifier le contenu du fichier avec la commande cat :

cat connectivity_check.py

Définir une fonction

Maintenant que les imports sont prêts, vous devez structurer votre code. Il est recommandé d'encapsuler la logique dans des fonctions. Le code devient ainsi réutilisable et plus facile à tester.

Les fonctions sont particulièrement utiles dans les scripts opérationnels, car une même action doit souvent être exécutée sur plusieurs cibles. Une fois la vérification réseau placée dans une fonction, vous pouvez l'appeler avec différentes URL sans dupliquer le code.

Dans cette étape, vous allez définir une fonction nommée check_url qui accepte une chaîne contenant une URL comme argument.

Ouvrez à nouveau le fichier connectivity_check.py :

nano connectivity_check.py

Ajoutez la définition de fonction suivante sous les instructions d'importation. Pour le moment, vous allez simplement ajouter l'instruction pass, qui sert d'espace réservé en Python et signifie « ne rien faire ». Vous ajouterez la logique dans les étapes suivantes.

import urllib.request
import urllib.error

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

Enregistrez le fichier et quittez l'éditeur (Ctrl+O, Enter, Ctrl+X).

Cette structure fournit la base du script. La fonction check_url prend un paramètre, url, qui correspond à l'adresse du site web à tester, par exemple « https://www.google.com ».

Effectuer la requête

Dans cette étape, vous allez implémenter la logique principale pour envoyer une requête et récupérer le code d'état HTTP. Un code d'état HTTP 200 signifie généralement « OK », autrement dit que la requête a réussi.

À un niveau général, une requête HTTP est un échange entre un client et un serveur. Votre script joue le rôle du client. Il envoie une requête à une URL, attend la réponse du serveur, puis examine des informations telles que le code d'état avant de décider de la suite.

Vous allez utiliser urllib.request.urlopen() pour ouvrir l'URL. Cette fonction renvoie un objet de réponse qui possède une méthode .getcode() permettant de récupérer le code d'état.

Ouvrez connectivity_check.py :

nano connectivity_check.py

Modifiez la fonction check_url afin qu'elle corresponde au code suivant. Notez que vous ajoutez un délai d'expiration de 5 secondes pour éviter que le script ne reste bloqué si le serveur ne répond pas.

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}")

Remarque : à ce stade, si l'URL est invalide ou si le serveur est arrêté, le script s'interrompra avec une erreur, car vous n'avez pas encore ajouté la gestion des erreurs. Vous corrigerez cela à l'étape suivante.

Enregistrez le fichier et quittez l'éditeur.

Gérer les erreurs

La programmation réseau est imprévisible. Les serveurs peuvent être indisponibles, les recherches DNS peuvent échouer et les connexions Internet peuvent être interrompues. Si urlopen échoue, la fonction lève une exception. Pour rendre le script robuste, vous devez gérer ces exceptions avec un bloc try...except.

Dans la supervision réelle, il est important de distinguer les différents types d'échec. Un serveur qui renvoie 500 a bien été atteint et signale un problème interne. Une URLError signifie souvent que la requête n'a jamais atteint un point de terminaison HTTP utilisable. Un bon opérateur traite ces deux situations comme des catégories d'incident différentes.

Vous allez gérer deux types d'erreurs précis :

urllib.error.HTTPError : le serveur a répondu, mais avec un code d'erreur, par exemple 404 Not Found ou 500 Server Error.
urllib.error.URLError : le serveur n'a pas pu être atteint, par exemple en raison d'une absence de connexion Internet ou d'un domaine incorrect.

Considérez le bloc try...except comme un filet de sécurité. Si un problème survient, par exemple une interruption de la connexion Internet, le programme ne s'arrête pas brutalement. Il passe au bloc except, où vous pouvez intercepter l'erreur et afficher un message utile.

Ouvrez connectivity_check.py :

nano connectivity_check.py

Modifiez la fonction afin d'encapsuler la logique de la requête dans un bloc 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}")

Ce code tente d'exécuter les lignes placées dans le bloc try. Si une erreur se produit, Python cesse d'exécuter ce bloc et passe au bloc except correspondant.

Enregistrez le fichier et quittez l'éditeur.

Tester le script

Dans cette dernière étape, vous allez rendre le script exécutable en ajoutant un bloc principal qui appelle votre fonction. Vous pourrez ainsi exécuter directement le script depuis le terminal.

Le modèle if __name__ == "__main__": est une convention Python qui sépare les fonctions réutilisables du code à exécuter lors d'une exécution directe. Ce choix de conception facilite la réutilisation ultérieure : un autre script peut importer check_url sans lancer automatiquement les appels de test.

Vous allez effectuer un test avec une URL connue comme fonctionnelle, telle que https://www.example.com. Vous pouvez également essayer une URL fictive pour observer la gestion des erreurs.

Ouvrez connectivity_check.py :

nano connectivity_check.py

Ajoutez le code suivant à la fin du fichier :

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)

Le bloc if __name__ == "__main__": garantit que ce code ne s'exécute que lorsque le script est lancé directement, et non lorsqu'il est importé comme module dans un autre script.

Enregistrez le fichier et quittez l'éditeur.

Exécutez maintenant votre script pour observer les résultats :

python3 connectivity_check.py

Vous devriez obtenir une sortie similaire à celle-ci :

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

(Remarque : le message d'erreur exact de l'URL invalide peut varier légèrement selon l'environnement réseau.)

Résumé

Dans ce lab, vous avez créé avec succès un vérificateur de connectivité réseau à l'aide de la bibliothèque standard de Python. Vous avez appris à :

Importer des modules : utiliser urllib.request et urllib.error.
Effectuer des requêtes HTTP : utiliser urlopen pour se connecter à un serveur web.
Gérer les réponses : récupérer les codes d'état HTTP pour vérifier la disponibilité d'un service.
Gérer les erreurs : implémenter des blocs try...except pour traiter HTTPError et URLError, afin de rendre le script robuste face aux défaillances réseau.

Cette compétence est fondamentale pour créer des scripts de supervision, des vérifications d'état et de simples outils d'extraction de données web dans les environnements où l'installation de dépendances externes est impossible.