Introduction
Dans l'administration système Linux, vérifier la connectivité d'un serveur est une compétence fondamentale. Ce tutoriel vous guide à travers le processus de test de la connectivité 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 réseau et le dépannage.
À la fin de ce tutoriel, vous comprendrez comment utiliser cURL pour vérifier la disponibilité d'un serveur, mesurer les temps de réponse, analyser les codes d'état HTTP et résoudre 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 outil en ligne de commande puissant 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 des 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 un code HTML similaire au suivant :
<!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>
Enregistrer 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 que celui affiché précédemment 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 depuis 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 ne récupère que les en-têtes
Dans les étapes suivantes, nous explorerons comment utiliser ces différentes méthodes pour tester la connectivité et la fonctionnalité des serveurs.
Tester la connectivité de base d'un serveur
Maintenant que vous comprenez les bases de cURL, utilisons-le pour tester la connectivité d'un serveur. La capacité de vérifier si un serveur est actif 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 basique 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 corps du contenu. C'est utile pour des vérifications de connectivité rapides. 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 code HTTP/2 200 indique une connexion réussie : le serveur est actif 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. Quelques codes d'état courants incluent :
- 200 : OK - La requête a réussi
- 301/302 : Redirection - La ressource a été déplacée
- 404 : Non trouvé - La ressource n'existe pas
- 500 : Erreur interne du serveur - 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
...
Mesurer le 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 supprime)-w "...": Affiche une sortie formatée avec des informations de temporisation
Vous devriez voir une sortie similaire à :
Connect: 0.052s
Total: 0.157s
Cela vous indique le temps nécessaire pour établir une connexion et le temps total pour que la requête se termine.
Tester la résolution de nom 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 montre l'adresse IP vers laquelle la connexion est établie. 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éer un script de test de connexion simple
Créons un script shell simple pour tester la connectivité vers 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 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 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 offre un moyen rapide de vérifier la connectivité vers plusieurs serveurs à la fois.
Tests de connectivité avancés avec cURL
Maintenant que vous comprenez les tests de connectivité de base, explorons des fonctionnalités plus avancées de cURL qui peuvent aider au dépannage et aux tests détaillés.
Utiliser le mode verbeux pour un débogage détaillé
Le mode verbeux (option -v) est inestimable pour dépanner les problèmes de connectivité car il montre l'intégralité 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.
Tester différentes méthodes HTTP
Testons une requête POST vers un point de terminaison d'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"
}
Tester 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"
}
}
Tester les temps de réponse pour différents points de terminaison
Créons un script pour comparer les temps de réponse pour 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 surveiller les performances d'un serveur au fil du temps.
Tester la connectivité TCP vers 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 des connexions sécurisées :
curl -v https://example.com:443
La sortie verbeuse indiquera si la connexion a réussi ou s'il y a eu des problèmes.
Créer un outil de surveillance serveur complet
Maintenant que vous avez appris diverses techniques cURL pour les tests de connectivité, construisons un outil de surveillance serveur plus complet qui combine ces techniques.
Script de surveillance serveur complet
Créez un nouveau fichier de script :
nano server_monitor.sh
Ajoutez le contenu suivant :
#!/bin/bash
## Server Monitoring Script
## This script checks the availability and performance of specified servers
## Define colors for output
GREEN='\033[0;32m'
RED='\033[0;31m'
YELLOW='\033[0;33m'
NC='\033[0m' ## No Color
## Function to check server status
check_server() {
local url=$1
local timeout=5
echo -e "\n${YELLOW}Testing $url:${NC}"
## Test connection and get status code
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}✓ Status: $status_code (OK)${NC}"
elif [ "$status_code" -ge 100 ] && [ "$status_code" -lt 400 ]; then
echo -e "${GREEN}✓ Status: $status_code (Success/Redirect)${NC}"
elif [ "$status_code" -ge 400 ] && [ "$status_code" -lt 500 ]; then
echo -e "${RED}✗ Status: $status_code (Client Error)${NC}"
elif [ "$status_code" -ge 500 ]; then
echo -e "${RED}✗ Status: $status_code (Server Error)${NC}"
else
echo -e "${RED}✗ Status: Connection failed${NC}"
fi
## Measure response time if connection successful
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 "• Response time: ${response_time}s"
## Get server headers
echo "• Server headers:"
curl -s -I --connect-timeout $timeout "$url" | grep -E 'Server:|Content-Type:|Date:' | sed 's/^/ /'
fi
}
## Main function
main() {
echo -e "${YELLOW}===== Server Connectivity Monitor =====${NC}"
echo "Started at: $(date)"
## List of servers to monitor
servers=(
"https://www.google.com"
"https://www.github.com"
"https://www.example.com"
"https://httpbin.org/status/404" ## This will return a 404 status
"https://httpbin.org/status/500" ## This will return a 500 status
)
## Check each server
for server in "${servers[@]}"; do
check_server "$server"
done
echo -e "\n${YELLOW}===== Monitoring Complete =====${NC}"
echo "Finished at: $(date)"
}
## Run the main function
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 :
===== Server Connectivity Monitor =====
Started at: Tue Mar 28 13:15:01 UTC 2023
Testing https://www.google.com:
✓ Status: 200 (OK)
• Response time: 0.186s
• Server headers:
Date: Tue, 28 Mar 2023 13:15:02 GMT
Content-Type: text/html; charset=ISO-8859-1
Server: gws
Testing https://www.github.com:
✓ Status: 200 (OK)
• Response time: 0.247s
• Server headers:
Server: GitHub.com
Date: Tue, 28 Mar 2023 13:15:02 GMT
Content-Type: text/html; charset=utf-8
Testing https://www.example.com:
✓ Status: 200 (OK)
• Response time: 0.132s
• Server headers:
Content-Type: text/html; charset=UTF-8
Date: Tue, 28 Mar 2023 13:15:03 GMT
Server: ECS (nyb/1D2B)
Testing https://httpbin.org/status/404:
✗ Status: 404 (Client Error)
• Response time: 0.189s
• Server headers:
Date: Tue, 28 Mar 2023 13:15:03 GMT
Content-Type: text/html; charset=utf-8
Server: gunicorn/19.9.0
Testing https://httpbin.org/status/500:
✗ Status: 500 (Server Error)
• Response time: 0.192s
• Server headers:
Date: Tue, 28 Mar 2023 13:15:03 GMT
Content-Type: text/html; charset=utf-8
Server: gunicorn/19.9.0
===== Monitoring Complete =====
Finished at: Tue Mar 28 13:15:04 UTC 2023
Planifier des vérifications de connectivité régulières
Pour surveiller les serveurs régulièrement, vous pouvez configurer une tâche cron. Dans un environnement de production réel, 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 chaque minute pendant une durée spécifiée :
nano scheduled_monitor.sh
Ajoutez le contenu suivant :
#!/bin/bash
## Scheduled monitoring script
## This script runs the server_monitor.sh at regular intervals
## Check if duration parameter is provided
if [ $## -ne 1 ]; then
echo "Usage: $0 <duration_in_minutes>"
exit 1
fi
duration=$1
interval=60 ## seconds
iterations=$((duration * 60 / interval))
echo "Starting scheduled monitoring for $duration minutes..."
echo "Press Ctrl+C to stop monitoring"
for ((i = 1; i <= iterations; i++)); do
echo -e "\n===== Run $i of $iterations ====="
./server_monitor.sh
## Don't sleep after the last iteration
if [ $i -lt $iterations ]; then
echo "Next check in $interval seconds..."
sleep $interval
fi
done
echo "Scheduled monitoring completed."
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 serveur chaque minute pendant 2 minutes :
Starting scheduled monitoring for 2 minutes...
Press Ctrl+C to stop monitoring
===== Run 1 of 2 =====
===== Server Connectivity Monitor =====
...
(monitoring output)
...
Next check in 60 seconds...
(waits for 60 seconds)
===== Run 2 of 2 =====
===== Server Connectivity Monitor =====
...
(monitoring output)
...
Scheduled monitoring completed.
Dans un environnement de production, vous configureriez généralement une tâche cron, mais ce script offre 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é serveur 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 verbeux pour un débogage détaillé.
Vous avez créé plusieurs scripts pratiques qui démontrent la puissance de cURL pour la surveillance serveur et les tests de connectivité :
- Un script de test de connexion de base qui vérifie la connectivité vers plusieurs serveurs
- Un script de comparaison des temps de réponse pour mesurer et comparer les performances des serveurs
- Un outil de surveillance serveur complet qui fournit des informations détaillées sur l'état du serveur, les temps de réponse et les informations d'en-tête
- Un script de surveillance planifiée qui automatise les vérifications de connectivité régulières
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.
Alors que vous continuez à travailler avec des systèmes Linux, rappelez-vous que cURL n'est pas seulement utile pour tester la connectivité, mais aussi pour interagir avec des 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 pour des opérations réseau et un dépannage plus avancés à l'avenir.
