Aide-mémoire cURL

Commandes utiles de cURL avec paramètres

Voici une fiche mémo pour les commandes cURL les plus utiles avec leurs paramètres :

une personne avec un signe en forme de tire-bouchon

L’image ci-dessus est générée par Flux - modèle IA de texte à image.

cURL est un outil essentiel en ligne de commande pour effectuer des requêtes HTTP et transférer des données. Pour un guide complet des outils de développement incluant Git, Docker, VS Code, bash, Terraform, PostgreSQL, GitHub Actions et la gestion des paquets Linux, consultez Outils de développement : Le guide complet des flux de travail de développement modernes.

Utilisation de base de cURL

  • Télécharger un fichier : curl http://example.com/file.zip -o file.zip
  • Télécharger plusieurs fichiers : curl -O URL1 -O URL2
  • Suivre les redirections : curl -L http://example.com/file
  • Afficher uniquement les en-têtes : curl -I http://example.com

Authentification

  • Authentification de base : curl -u username:password http://example.com. Curl définit l’en-tête Authorization: Basic à partir de cet utilisateur et ce mot de passe. L’en-tête identique, construit avec printf et base64, se trouve dans la fiche mémo d’encodage et de décodage Base64.
  • Utiliser un fichier .netrc : curl --netrc-file .netrc http://example.com

Méthodes HTTP

  • Requête POST : curl -X POST -d 'name=value' http://example.com
  • Requête PUT : curl -X PUT -d @file http://example.com
  • Méthode personnalisée : curl -X METHOD http://example.com

En-têtes et données

  • Ajouter un en-tête personnalisé : curl -H "X-Header: Value" http://example.com
  • Envoyer des données JSON : curl -H "Content-Type: application/json" -d '{"key":"value"}' http://example.com
  • Envoyer des données de formulaire : curl -F "key=value" -F "file=@localfile" http://example.com

Options SSL/TLS

  • Ignorer la vérification du certificat SSL : curl -k https://example.com
  • Utiliser un certificat client : curl --cert cert.pem --key key.pem https://example.com

Proxy et réseau

  • Utiliser un proxy : curl -x proxysever.server.com:PORT http://example.com
  • Limiter le débit de téléchargement : curl --limit-rate 1000B -O http://example.com/file

Contrôle de la sortie

  • Mode silencieux : curl -s http://example.com
  • Mode verbeux : curl -v http://example.com
  • Écrire la sortie dans un fichier : curl -o file.html http://example.com
  • Sauvegarder avec le nom de fichier distant : curl -O http://example.com/file.zip

Divers

  • Reprendre un téléchargement interrompu : curl -C - -o partial_file.zip http://example.com/file.zip
  • Définir un délai d’attente : curl --connect-timeout 10 http://example.com
  • Utiliser un fichier de configuration : curl -K config_file http://example.com

Cette fiche mémo couvre les commandes cURL les plus couramment utilisées et leurs paramètres, offrant une référence rapide pour diverses opérations HTTP et transferts de données.

Commandes cUrl avancées

Voici quelques commandes curl avancées pour le débogage :

  1. Sortie verbeuse : curl -v https://example.com Cette commande fournit des informations détaillées sur la requête et la réponse, y compris les en-têtes et les détails de la connexion.

  2. Décharge complète de la trace : curl --trace - https://example.com Cela affiche un décodage hexadécimal de toutes les données entrantes et sortantes, offrant une vue complète de toute la communication.

  3. Trace avec horodatage : curl --trace - --trace-time https://example.com Cela ajoute des horodatages à la sortie de la trace, ce qui aide à analyser les problèmes liés au timing.

  4. Imprimer uniquement les en-têtes de réponse : curl -s -o /dev/null -D - https://example.com Cette commande n’affiche que les en-têtes de réponse, utile pour une analyse rapide des en-têtes.

  5. Imprimer uniquement les en-têtes de requête : curl -v -s -o /dev/null --stderr - https://example.com | grep '^>' Cette commande complexe filtre uniquement les en-têtes de requête, ce qui est utile pour inspecter ce qui est envoyé.

  6. Utiliser Pantheon Debugger : curl -I -H "Pantheon-Debug:1" https://example.com Cette commande utilise l’en-tête Debug de Pantheon pour obtenir des informations supplémentaires sur une requête, utile pour les sites hébergés par Pantheon.

  7. Forcer le protocole HTTP/2 : curl --http2 https://example.com Cela garantit l’utilisation du protocole HTTP/2, qui peut être combiné avec -I pour vérifier la prise en charge de HTTP/2.

  8. Débogage avec netcat : Dans un terminal : nc -l 1234 Dans un autre : curl http://127.0.0.1:1234 Cela vous permet de voir exactement ce que curl envoie, utile pour le débogage de la charge utile.

Ces commandes avancées offrent des capacités puissantes de débogage, permettant aux développeurs d’inspecter divers aspects des communications HTTP et de résoudre des problèmes complexes.

Cas d’utilisation courants de cUrl

curl est un outil en ligne de commande polyvalent avec de nombreuses applications. Voici certains des cas d’utilisation les plus courants de curl :

Interactions Web

  1. Téléchargement de fichiers : curl peut télécharger des fichiers depuis des URLs.
  2. Web scraping : curl peut récupérer le contenu des pages web à des fins de scraping.
  3. Test de sites web : curl est utile pour vérifier si un site web est accessible et récupérer son contenu.

Interactions avec les API

  1. Envoi de requêtes API : curl prend en charge diverses méthodes HTTP (GET, POST, PUT, DELETE) pour interagir avec les API.
  2. Test des points de terminaison API : curl offre un moyen rapide de tester et de déboguer les points de terminaison API sans avoir besoin d’un client API dédié.

Dépannage du réseau

  1. Vérification de la connectivité : curl peut être utilisé pour vérifier les connexions réseau et résoudre les problèmes.
  2. Test DNS : curl permet de forcer des serveurs DNS spécifiques pour résoudre les problèmes liés au DNS.
  3. Inspection des en-têtes : curl peut afficher les en-têtes HTTP, ce qui est utile pour le débogage.

Transfert de données

  1. Opérations FTP : curl prend en charge le transfert de fichiers en utilisant le protocole de transfert de fichiers (FTP).
  2. Interactions SMTP : curl peut être utilisé pour envoyer des e-mails via le protocole simple de transfert de courrier (SMTP).

Sécurité et authentification

  1. Connexions SSL : curl prend en charge les connexions sécurisées en utilisant SSL/TLS.
  2. Authentification : curl peut gérer diverses méthodes d’authentification, y compris l’authentification de base et les certificats clients.

Développement et débogage

  1. Simulation de différentes méthodes HTTP : curl permet aux développeurs de tester facilement diverses méthodes HTTP.
  2. Journalisation verbeuse : le mode verbeux de curl fournit des informations détaillées sur le cycle requête-réponse, aidant ainsi au débogage.

Ces cas d’utilisation démontrent la flexibilité de curl comme outil pour les interactions web, les tests d’API, le dépannage du réseau et les tâches de développement.

Test de performance des sites web avec cURL

curl est un outil puissant pour tester la performance des sites web. Voici comment vous pouvez l’utiliser pour mesurer divers aspects de la vitesse de chargement d’un site web :

Test de performance de base

Pour obtenir une mesure simple du temps de chargement d’un site web, utilisez cette commande :

curl -o /dev/null -s -w "Total Time: %{time_total}s\n" "https://example.com"

Cette commande affichera le temps total qu’il a fallu pour récupérer le site web[2].

Métriques de performance détaillées

Pour une analyse plus complète, vous pouvez utiliser curl pour mesurer plusieurs métriques de performance :

curl -s -w 'Testing Website Response Time for :%{url_effective}\n\nLookup Time:\t\t%{time_namelookup}\nConnect Time:\t\t%{time_connect}\nPre-transfer Time:\t%{time_pretransfer}\nStart-transfer Time:\t%{time_starttransfer}\n\nTotal Time:\t\t%{time_total}\n' -o /dev/null https://example.com

Cette commande fournit un découpage des différentes étapes du processus de chargement, y compris le temps de recherche DNS, le temps de connexion et le temps total[1].

Métriques avancées

Pour une analyse encore plus détaillée, vous pouvez inclure des métriques supplémentaires :

curl -o /dev/null -w "HTTP Version: %{http_version}\nPage Size: %{size_download} bytes\nResponse Code: %{response_code}\nDNS Lookup: %{time_namelookup} sec\nConnect Time: %{time_connect} sec\nTime to First Byte: %{time_starttransfer} sec\nTotal Time: %{time_total} sec\n" -s https://example.com

Cette commande inclut des informations sur la version HTTP, la taille de la page et le code de réponse[3].

Benchmarking de plusieurs requêtes

Pour tester la cohérence ou surveiller les performances au fil du temps, vous pouvez utiliser une boucle pour effectuer plusieurs requêtes :

for i in {1..5}; do curl -o /dev/null -s -w "Request $i Total Time: %{time_total}\n" https://example.com; done

Cela exécutera le test cinq fois et affichera le temps total pour chaque requête[3].

Création d’un script de test de performance

Vous pouvez créer un simple script bash pour automatiser ces tests et enregistrer les résultats :

#!/bin/bash
curl -s -w 'Testing Website Response Time for :%{url_effective}\n\nLookup Time:\t\t%{time_namelookup}\nConnect Time:\t\t%{time_connect}\nPre-transfer Time:\t%{time_pretransfer}\nStart-transfer Time:\t%{time_starttransfer}\n\nTotal Time:\t\t%{time_total}\n' -o /dev/null URL > webspeedtest_"$(date)"

Remplacez “URL” par le site web que vous souhaitez tester. Ce script enregistrera les résultats dans un fichier horodaté[5].

En utilisant ces commandes et scripts curl, vous pouvez efficacement mesurer et surveiller la performance des sites web, vous aidant à identifier les goulots d’étranglement potentiels et à optimiser les temps de chargement.

Liens utiles

S'abonner

Recevez de nouveaux articles sur les systèmes, l'infrastructure et l'ingénierie IA.