Comment tester la connectivité d'un serveur avec curl sous Linux

LinuxBeginner
Pratiquer maintenant

Introduction

En administration système Linux, la vérification de la connectivité d'un serveur est une compétence fondamentale. Ce tutoriel vous guide à travers le processus de test de la connectivité du serveur à l'aide de l'outil cURL. cURL (Client URL) est un utilitaire en ligne de commande qui permet le transfert de données via divers protocoles réseau, ce qui en fait un outil essentiel pour le diagnostic et le dépannage des réseaux.

À la fin de ce tutoriel, vous comprendrez comment utiliser cURL pour vérifier la disponibilité du serveur, vérifier les temps de réponse, analyser les codes d'état HTTP et dépanner les problèmes de connexion. Ces compétences sont précieuses, que vous gériez des serveurs web, des API ou tout autre service réseau dans votre environnement Linux.

Comprendre les bases de cURL

cURL est un puissant outil en ligne de commande qui vous permet de transférer des données en utilisant divers protocoles, notamment HTTP, HTTPS, FTP, et bien d'autres. Avant de plonger dans les tests de connectivité, comprenons ce qu'est cURL et comment l'utiliser pour les opérations de base.

Installation de cURL

L'utilitaire cURL est pré-installé sur la plupart des distributions Linux, y compris votre environnement Ubuntu 22.04. Pour vérifier que cURL est installé, ouvrez votre terminal et exécutez :

curl --version

Vous devriez voir une sortie similaire à celle-ci :

curl 7.81.0 (x86_64-pc-linux-gnu) libcurl/7.81.0 OpenSSL/3.0.2 zlib/1.2.11 brotli/1.0.9 zstd/1.4.8 libidn2/2.3.2 libpsl/0.21.0 (+libidn2/2.3.2) libssh/0.9.6/openssl/zlib nghttp2/1.43.0 librtmp/2.3 OpenLDAP/2.5.13
Release-Date: 2022-01-05
Protocols: dict file ftp ftps gopher gophers http https imap imaps ldap ldaps mqtt pop3 pop3s rtmp rtsp scp sftp smb smbs smtp smtps telnet tftp
Features: alt-svc AsynchDNS brotli GSS-API HSTS HTTP2 HTTPS-proxy IDN IPv6 Kerberos Largefile libz NTLM NTLM_WB PSL SPNEGO SSL TLS-SRP UnixSockets zstd

Cela confirme que cURL est installé et affiche la version ainsi que les protocoles et fonctionnalités pris en charge.

Syntaxe de base de cURL

La syntaxe de base pour utiliser cURL est :

curl [options] [URL]

Essayons une commande cURL simple pour récupérer le contenu d'un site web :

curl https://example.com

Cette commande envoie une requête GET à example.com et affiche la réponse HTML dans votre terminal. Vous devriez voir du code HTML similaire à ce qui suit :

<!doctype html>
<html>
  <head>
    <title>Example Domain</title>
    <!-- More HTML content -->
  </head>
  <body>
    <div>
      <h1>Example Domain</h1>
      <p>This domain is for use in illustrative examples in documents...</p>
      <!-- More content -->
    </div>
  </body>
</html>

Enregistrement de la sortie dans un fichier

Au lieu d'afficher la sortie dans le terminal, vous pouvez l'enregistrer dans un fichier en utilisant l'option -o ou --output :

curl -o example.html https://example.com

Cette commande enregistre la réponse de example.com dans un fichier nommé example.html. Pour vérifier que le fichier a été créé :

ls -l example.html

Vous devriez voir une sortie confirmant l'existence du fichier :

-rw-rw-r-- 1 labex labex 1256 Mar 28 12:34 example.html

Pour afficher le contenu du fichier :

cat example.html

Vous devriez voir le même contenu HTML qui était précédemment affiché dans le terminal.

Comprendre les méthodes HTTP avec cURL

cURL utilise la méthode HTTP GET par défaut, mais vous pouvez spécifier d'autres méthodes en utilisant l'option -X. Les méthodes HTTP courantes incluent :

  • GET : Récupérer des données d'un serveur
  • POST : Soumettre des données à un serveur
  • PUT : Mettre à jour des données existantes sur un serveur
  • DELETE : Supprimer des données d'un serveur
  • HEAD : Similaire à GET mais récupère uniquement les en-têtes

Dans les étapes suivantes, nous explorerons comment utiliser ces différentes méthodes pour tester la connectivité et la fonctionnalité du serveur.

Tester la connectivité de base du serveur

Maintenant que vous comprenez les bases de cURL, utilisons-le pour tester la connectivité du serveur. La capacité de vérifier si un serveur est opérationnel et répond correctement est une compétence cruciale pour les administrateurs système et les développeurs.

Test de connexion simple

Le test de connectivité le plus élémentaire consiste à envoyer une requête à un serveur et à voir s'il répond. Testons la connectivité aux serveurs de Google :

curl -I https://www.google.com

L'option -I (ou --head) indique à cURL d'envoyer une requête HEAD, qui ne récupère que les en-têtes sans le contenu du corps. Ceci est utile pour les vérifications rapides de la connectivité. Vous devriez voir une sortie similaire à :

HTTP/2 200
content-type: text/html; charset=ISO-8859-1
date: Tue, 28 Mar 2023 12:34:56 GMT
server: gws
content-length: 219
x-xss-protection: 0
x-frame-options: SAMEORIGIN

Le HTTP/2 200 indique une connexion réussie - le serveur est opérationnel et répond.

Vérification des codes d'état HTTP

Les codes d'état HTTP sont des réponses standardisées que les serveurs envoient pour indiquer le résultat d'une requête client. Certains codes d'état courants incluent :

  • 200 : OK - La requête a réussi
  • 301/302 : Redirection - La ressource a été déplacée
  • 404 : Not Found - La ressource n'existe pas
  • 500 : Internal Server Error - Le serveur a rencontré une erreur

Testons une URL inexistante pour voir une réponse 404 :

curl -I https://www.google.com/nonexistent-page

La sortie devrait inclure un code d'état 404 :

HTTP/2 404
content-type: text/html; charset=UTF-8
date: Tue, 28 Mar 2023 12:35:01 GMT
server: gws
content-length: 1565
...

Mesure du temps de réponse

Pour mesurer le temps nécessaire à un serveur pour répondre, utilisez l'option -w avec une chaîne de format :

curl -s -o /dev/null -w "Connect: %{time_connect}s\nTotal: %{time_total}s\n" https://www.google.com

Cette commande :

  • -s : Fonctionne en mode silencieux (pas de messages de progression ou d'erreur)
  • -o /dev/null : Redirige la sortie vers /dev/null (la rejette)
  • -w "..." : Affiche une sortie formatée avec des informations de chronométrage

Vous devriez voir une sortie similaire à :

Connect: 0.052s
Total: 0.157s

Cela vous indique combien de temps il a fallu pour établir une connexion et le temps total nécessaire à l'exécution de la requête.

Test de la résolution de noms de domaine

Parfois, les problèmes de connectivité proviennent de problèmes DNS. Pour tester si un nom de domaine peut être résolu en une adresse IP :

curl -v https://www.example.com 2>&1 | grep "Trying"

Ceci utilise l'option -v (verbose) et filtre la ligne "Trying", qui affiche l'adresse IP à laquelle on se connecte. Vous devriez voir une sortie comme :

* Trying 93.184.216.34:443...

Cela confirme que le nom de domaine a été résolu avec succès en une adresse IP.

Création d'un script de test de connexion simple

Créons un script shell simple pour tester la connectivité à plusieurs sites. Ouvrez un éditeur de texte :

nano connection_test.sh

Ajoutez le contenu suivant au fichier :

#!/bin/bash

echo "Testing server connectivity..."

for site in google.com example.com github.com nonexistent-site.xyz; do
  echo -n "Testing $site: "

  ## Use curl with a 5-second timeout
  status_code=$(curl -s -o /dev/null -w "%{http_code}" --connect-timeout 5 "https://$site" 2> /dev/null)

  if [ $? -eq 0 ] && [ "$status_code" -lt 400 ]; then
    echo "OK (Status: $status_code)"
  else
    echo "Failed (Status: $status_code)"
  fi
done

echo "Testing complete!"

Enregistrez le fichier en appuyant sur Ctrl+O, puis sur Entrée, et quittez avec Ctrl+X.

Rendez le script exécutable :

chmod +x connection_test.sh

Exécutez le script :

./connection_test.sh

Vous devriez voir une sortie indiquant l'état de la connectivité de chaque site :

Testing server connectivity...
Testing google.com: OK (Status: 200)
Testing example.com: OK (Status: 200)
Testing github.com: OK (Status: 200)
Testing nonexistent-site.xyz: Failed (Status: 000)
Testing complete!

Ce script fournit un moyen rapide de vérifier la connectivité à plusieurs serveurs à la fois.

Tests de connectivité avancés avec cURL

Maintenant que vous comprenez les tests de connectivité de base, explorons les fonctionnalités plus avancées de cURL qui peuvent aider au dépannage et aux tests détaillés.

Utilisation du mode verbose pour un débogage détaillé

Le mode verbose (option -v) est inestimable pour le dépannage des problèmes de connectivité car il affiche l'ensemble du processus de requête et de réponse :

curl -v https://example.com

La sortie sera complète, montrant la résolution DNS, la poignée de main TLS, les en-têtes de requête, les en-têtes de réponse, et plus encore :

*   Trying 93.184.216.34:443...
* Connected to example.com (93.184.216.34) port 443 (#0)
* ALPN: offers h2
* ALPN: offers http/1.1
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.3 (IN), TLS handshake, Encrypted Extensions (8):
* TLSv1.3 (IN), TLS handshake, Certificate (11):
* TLSv1.3 (IN), TLS handshake, CERT verify (15):
* TLSv1.3 (IN), TLS handshake, Finished (20):
* TLSv1.3 (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN: server accepted h2
* Server certificate:
*  subject: C=US; ST=California; L=Los Angeles; O=Internet Corporation for Assigned Names and Numbers; CN=www.example.org
*  start date: Nov 24 00:00:00 2022 GMT
*  expire date: Nov 24 23:59:59 2023 GMT
*  subjectAltName: host "example.com" matched cert's "example.com"
*  issuer: C=US; O=DigiCert Inc; CN=DigiCert TLS RSA SHA256 2020 CA1
*  SSL certificate verify ok.
* using HTTP/2
* h2 [:method: GET]
* h2 [:path: /]
* h2 [:scheme: https]
* h2 [:authority: example.com]
* h2 [user-agent: curl/7.81.0]
* h2 [accept: */*]
* Using Stream ID: 1
> GET / HTTP/2
> Host: example.com
> user-agent: curl/7.81.0
> accept: */*
>
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
* Connection state changed (MAX_CONCURRENT_STREAMS == 100)!
< HTTP/2 200
< age: 587269
< cache-control: max-age=604800
< content-type: text/html; charset=UTF-8
< date: Tue, 28 Mar 2023 12:40:01 GMT
< etag: "3147526947+ident"
< expires: Tue, 04 Apr 2023 12:40:01 GMT
< last-modified: Thu, 17 Oct 2019 07:18:26 GMT
< server: ECS (nyb/1D2B)
< vary: Accept-Encoding
< x-cache: HIT
< content-length: 1256
<
<!doctype html>
<html>
<head>
    <title>Example Domain</title>
    <!-- More HTML content -->
</head>
<body>
    <div>
        <h1>Example Domain</h1>
        <p>This domain is for use in illustrative examples in documents...</p>
        <!-- More content -->
    </div>
</body>
</html>
* Connection #0 to host example.com left intact

Cette sortie détaillée vous aide à identifier exactement où une connexion pourrait échouer.

Test de différentes méthodes HTTP

Testons une requête POST vers un point de terminaison API de test :

curl -X POST -d "name=test&email=test@example.com" https://httpbin.org/post

Cette commande :

  • -X POST : Spécifie une requête POST
  • -d "name=test&email=test@example.com" : Envoie des données de formulaire dans la requête

Vous devriez recevoir une réponse JSON montrant vos données soumises :

{
  "args": {},
  "data": "",
  "files": {},
  "form": {
    "email": "test@example.com",
    "name": "test"
  },
  "headers": {
    "Accept": "*/*",
    "Content-Length": "32",
    "Content-Type": "application/x-www-form-urlencoded",
    "Host": "httpbin.org",
    "User-Agent": "curl/7.81.0",
    "X-Amzn-Trace-Id": "Root=1-642295b1-0d2340ef34f2e8ea6270241a"
  },
  "json": null,
  "origin": "198.51.100.42",
  "url": "https://httpbin.org/post"
}

Test avec des en-têtes personnalisés

De nombreuses API nécessitent des en-têtes spécifiques pour l'authentification ou pour spécifier le type de contenu. Testons cela :

curl -H "User-Agent: MyCustomAgent" -H "Authorization: Bearer test-token" https://httpbin.org/headers

Cette commande :

  • -H "User-Agent: MyCustomAgent" : Définit un en-tête User-Agent personnalisé
  • -H "Authorization: Bearer test-token" : Définit un en-tête Authorization

La réponse affichera les en-têtes envoyés dans votre requête :

{
  "headers": {
    "Accept": "*/*",
    "Authorization": "Bearer test-token",
    "Host": "httpbin.org",
    "User-Agent": "MyCustomAgent",
    "X-Amzn-Trace-Id": "Root=1-642295c3-73cac0a73b34b1c93a8ce520"
  }
}

Test des temps de réponse pour différents points de terminaison

Créons un script pour comparer les temps de réponse de différents serveurs :

nano response_time.sh

Ajoutez le contenu suivant :

#!/bin/bash

echo "Testing response times..."

for site in google.com bing.com baidu.com duckduckgo.com yahoo.com; do
  echo -n "$site: "
  curl -s -o /dev/null -w "%{time_total}s" "https://$site"
  echo ""
done

echo "Testing complete!"

Enregistrez le fichier et rendez-le exécutable :

chmod +x response_time.sh

Exécutez le script :

./response_time.sh

La sortie affichera le temps de réponse pour chaque site :

Testing response times...
google.com: 0.187s
bing.com: 0.232s
baidu.com: 0.412s
duckduckgo.com: 0.298s
yahoo.com: 0.342s
Testing complete!

Ceci est utile pour comparer les performances de différents serveurs ou pour surveiller les performances d'un serveur au fil du temps.

Test de la connectivité TCP à des ports spécifiques

Parfois, vous devez tester si un port spécifique est ouvert sur un serveur. cURL peut également être utilisé pour cela :

curl -v telnet://example.com:80

Si le port est ouvert, vous verrez un message de connexion réussie :

* Trying 93.184.216.34:80...
* Connected to example.com (93.184.216.34) port 80 (#0)

Appuyez sur Ctrl+C pour terminer la connexion.

De même, vous pouvez tester les connexions sécurisées :

curl -v https://example.com:443

La sortie verbose montrera si la connexion a réussi ou s'il y a eu des problèmes.

Création d'un outil complet de surveillance de serveur

Maintenant que vous avez appris diverses techniques cURL pour les tests de connectivité, construisons un outil de surveillance de serveur plus complet qui combine ces techniques.

Script de surveillance de serveur complet

Créez un nouveau fichier de script :

nano server_monitor.sh

Ajoutez le contenu suivant :

#!/bin/bash

## Script de surveillance de serveur
## Ce script vérifie la disponibilité et les performances des serveurs spécifiés

## Définir les couleurs pour la sortie
GREEN='\033[0;32m'
RED='\033[0;31m'
YELLOW='\033[0;33m'
NC='\033[0m' ## Pas de couleur

## Fonction pour vérifier l'état du serveur
check_server() {
  local url=$1
  local timeout=5

  echo -e "\n${YELLOW}Test de $url:${NC}"

  ## Tester la connexion et obtenir le code d'état
  status_code=$(curl -s -o /dev/null -w "%{http_code}" --connect-timeout $timeout "$url" 2> /dev/null)

  if [ "$status_code" -eq 200 ]; then
    echo -e "${GREEN}✓ Statut: $status_code (OK)${NC}"
  elif [ "$status_code" -ge 100 ] && [ "$status_code" -lt 400 ]; then
    echo -e "${GREEN}✓ Statut: $status_code (Succès/Redirection)${NC}"
  elif [ "$status_code" -ge 400 ] && [ "$status_code" -lt 500 ]; then
    echo -e "${RED}✗ Statut: $status_code (Erreur client)${NC}"
  elif [ "$status_code" -ge 500 ]; then
    echo -e "${RED}✗ Statut: $status_code (Erreur serveur)${NC}"
  else
    echo -e "${RED}✗ Statut: Échec de la connexion${NC}"
  fi

  ## Mesurer le temps de réponse si la connexion réussit
  if [ "$status_code" -gt 0 ]; then
    response_time=$(curl -s -o /dev/null -w "%{time_total}" --connect-timeout $timeout "$url" 2> /dev/null)
    echo -e "• Temps de réponse: ${response_time}s"

    ## Obtenir les en-têtes du serveur
    echo "• En-têtes du serveur:"
    curl -s -I --connect-timeout $timeout "$url" | grep -E 'Server:|Content-Type:|Date:' | sed 's/^/  /'
  fi
}

## Fonction principale
main() {
  echo -e "${YELLOW}===== Moniteur de connectivité du serveur =====${NC}"
  echo "Démarré à: $(date)"

  ## Liste des serveurs à surveiller
  servers=(
    "https://www.google.com"
    "https://www.github.com"
    "https://www.example.com"
    "https://httpbin.org/status/404" ## Ceci renverra un statut 404
    "https://httpbin.org/status/500" ## Ceci renverra un statut 500
  )

  ## Vérifier chaque serveur
  for server in "${servers[@]}"; do
    check_server "$server"
  done

  echo -e "\n${YELLOW}===== Surveillance terminée =====${NC}"
  echo "Terminé à: $(date)"
}

## Exécuter la fonction principale
main

Enregistrez le fichier et rendez-le exécutable :

chmod +x server_monitor.sh

Exécutez le script :

./server_monitor.sh

La sortie fournira un aperçu complet de l'état de chaque serveur :

===== Moniteur de connectivité du serveur =====
Démarré à: Tue Mar 28 13:15:01 UTC 2023

Test de https://www.google.com:
✓ Statut: 200 (OK)
• Temps de réponse: 0.186s
• En-têtes du serveur:
  Date: Tue, 28 Mar 2023 13:15:02 GMT
  Content-Type: text/html; charset=ISO-8859-1
  Server: gws

Test de https://www.github.com:
✓ Statut: 200 (OK)
• Temps de réponse: 0.247s
• En-têtes du serveur:
  Server: GitHub.com
  Date: Tue, 28 Mar 2023 13:15:02 GMT
  Content-Type: text/html; charset=utf-8

Test de https://www.example.com:
✓ Statut: 200 (OK)
• Temps de réponse: 0.132s
• En-têtes du serveur:
  Content-Type: text/html; charset=UTF-8
  Date: Tue, 28 Mar 2023 13:15:03 GMT
  Server: ECS (nyb/1D2B)

Test de https://httpbin.org/status/404:
✗ Statut: 404 (Erreur client)
• Temps de réponse: 0.189s
• En-têtes du serveur:
  Date: Tue, 28 Mar 2023 13:15:03 GMT
  Content-Type: text/html; charset=utf-8
  Server: gunicorn/19.9.0

Test de https://httpbin.org/status/500:
✗ Statut: 500 (Erreur serveur)
• Temps de réponse: 0.192s
• En-têtes du serveur:
  Date: Tue, 28 Mar 2023 13:15:03 GMT
  Content-Type: text/html; charset=utf-8
  Server: gunicorn/19.9.0

===== Surveillance terminée =====
Terminé à: Tue Mar 28 13:15:04 UTC 2023

Planification de contrôles de connectivité réguliers

Pour surveiller les serveurs régulièrement, vous pouvez configurer une tâche cron. Dans un véritable environnement de production, vous pourriez ajouter ce script à crontab pour qu'il s'exécute à intervalles réguliers. À des fins de démonstration, créons un script wrapper simple qui exécute la surveillance toutes les minutes pendant une durée spécifiée :

nano scheduled_monitor.sh

Ajoutez le contenu suivant :

#!/bin/bash

## Script de surveillance planifiée
## Ce script exécute server_monitor.sh à intervalles réguliers

## Vérifier si le paramètre de durée est fourni
if [ $## -ne 1 ]; then
  echo "Utilisation: $0 <durée_en_minutes>"
  exit 1
fi

duration=$1
interval=60 ## secondes
iterations=$((duration * 60 / interval))

echo "Démarrage de la surveillance planifiée pendant $duration minutes..."
echo "Appuyez sur Ctrl+C pour arrêter la surveillance"

for ((i = 1; i <= iterations; i++)); do
  echo -e "\n===== Exécution $i sur $iterations ====="
  ./server_monitor.sh

  ## Ne pas dormir après la dernière itération
  if [ $i -lt $iterations ]; then
    echo "Prochaine vérification dans $interval secondes..."
    sleep $interval
  fi
done

echo "Surveillance planifiée terminée."

Enregistrez le fichier et rendez-le exécutable :

chmod +x scheduled_monitor.sh

Exécutez le script pendant 2 minutes (vous pouvez augmenter ou diminuer selon vos besoins) :

./scheduled_monitor.sh 2

Cela exécutera le script de surveillance du serveur toutes les minutes pendant 2 minutes :

Démarrage de la surveillance planifiée pendant 2 minutes...
Appuyez sur Ctrl+C pour arrêter la surveillance

===== Exécution 1 sur 2 =====
===== Moniteur de connectivité du serveur =====
...
(sortie de surveillance)
...
Prochaine vérification dans 60 secondes...
(attend 60 secondes)

===== Exécution 2 sur 2 =====
===== Moniteur de connectivité du serveur =====
...
(sortie de surveillance)
...
Surveillance planifiée terminée.

Dans un environnement de production, vous configureriez généralement une tâche cron à la place, mais ce script fournit un moyen simple d'effectuer une surveillance planifiée pendant cet exercice de laboratoire.

Résumé

Dans ce laboratoire, vous avez exploré comment utiliser cURL pour tester la connectivité des serveurs dans un environnement Linux. En commençant par les bases, vous avez appris à envoyer des requêtes HTTP simples et à enregistrer les réponses dans des fichiers. Vous avez ensuite progressé vers des opérations plus complexes, notamment la vérification des codes d'état HTTP, la mesure des temps de réponse et l'utilisation du mode verbose pour un débogage détaillé.

Vous avez créé plusieurs scripts pratiques qui démontrent la puissance de cURL pour la surveillance des serveurs et les tests de connectivité :

  1. Un script de test de connexion de base qui vérifie la connectivité à plusieurs serveurs
  2. Un script de comparaison des temps de réponse pour mesurer et comparer les performances des serveurs
  3. Un outil complet de surveillance de serveur qui fournit des informations détaillées sur l'état du serveur, les temps de réponse et les informations d'en-tête
  4. Un script de surveillance planifiée qui automatise les vérifications régulières de la connectivité

Ces outils et techniques sont inestimables pour les administrateurs système, les développeurs et toute personne travaillant avec des systèmes en réseau. En maîtrisant cURL, vous disposez désormais d'un outil puissant dans votre arsenal pour diagnostiquer et résoudre les problèmes de connectivité dans votre environnement Linux.

Au fur et à mesure que vous continuerez à travailler avec les systèmes Linux, rappelez-vous que cURL n'est pas seulement utile pour tester la connectivité, mais aussi pour interagir avec les API, télécharger des fichiers et automatiser diverses tâches liées au réseau. Les compétences que vous avez acquises dans ce laboratoire serviront de base à des opérations réseau et à un dépannage plus avancés à l'avenir.