Tutoriel sur les bases de la commande Curl avec des exemples

Curl est un logiciel gratuit et open source que nous pouvons utiliser pour échanger des données avec des serveurs en utilisant l’un des nombreux protocoles pris en charge, tels que HTTP, HTTPS, FTP, FTP, SFTP. Comme Curl est un outil en ligne de commande, nous pouvons l’utiliser dans nos scripts, pour automatiser des tâches répétitives, par exemple. Il existe de nombreux cas d’utilisation que Curl peut couvrir. Dans ce tutoriel, cependant, nous voyons quelques-uns des plus courants.

Dans ce tutoriel, nous voyons comment utiliser Curl pour effectuer des requêtes GET et POST de base et comment définir les paramètres d’en-tête d’une requête.

Dans ce tutoriel, vous allez apprendre :

Comment installer Curl dans certaines des distributions Linux les plus utilisées
Comment effectuer des requêtes GET et POST avec Curl
Comment envoyer des données JSON et XML dans une requête POST avec Curl
Comment définir les paramètres d’en-tête d’une requête avec Curl

Installation

Curl est un logiciel gratuit et open source qui est développé sur github. Il est inclus dans les dépôts de toutes les distributions Linux les plus courantes, et il y a de fortes chances que vous constatiez qu’il est déjà installé sur votre système. Si vous devez l’installer explicitement, vous pouvez suivre ces instructions. Pour installer Curl sur Fedora :

sudo dnf install curl

Pour installer le paquet sur Ubuntu, Debian et d’autres distributions basées sur Debian, nous pouvons lancer la commande suivante :

sudo apt-get update && sudo apt-get install curl

Curl est également disponible dans le dépôt « Core » d’Archlinux. À partir de là, nous pouvons l’installer en exécutant :

sudo pacman -Sy curl

Exécution de requêtes GET

La méthode HTTP GET est utilisée pour récupérer des ressources à partir d’un serveur. Lorsque nous demandons une page Web à partir de notre navigateur ou que nous téléchargeons un fichier, nous utilisons cette méthode. Effectuer de telles requêtes avec Curl est une opération très facile. Dans l’exemple suivant, nous demandons la page https://www.google.com :

curl https://www.google.com

Lorsqu’il est invoqué de cette façon, curl imprime le corps de la réponse envoyée par le serveur sur la sortie standard. Dans ce cas, le contenu que nous recevons est le code HTML de la page. Étant donné que le contenu est envoyé sur la sortie standard, nous pouvons utiliser un canal pour l’alimenter en entrée d’une autre commande et le traiter et le manipuler davantage. Voici un exemple trivial. Supposons que nous voulions compter combien de fois le mot « google » apparaît dans le code source de la page renvoyée par la requête dans l’exemple précédent :

curl -s https://www.google.com | grep -i -o google | wc -w
85

Dans l’exemple ci-dessus, nous avons appelé Curl et utilisé l’option '-s' : c’est l’abréviation de '–silent' et modifier le comportement de Curl afin qu’il n’affiche pas le compteur de progression de la requête. Comme nous l’avons dit, le corps de la réponse est envoyé au descripteur de fichier de sortie standard, nous utilisons donc l’opérateur de redirection | (un tube) pour le passer en tant qu’entrée standard à grep que nous invoquons avec l’option -i, pour le rendre insensible à la casse, et avec -o pour qu’il n’affiche que la partie correspondante d’une ligne (dans ce cas, il n’affichera que le monde « google », au lieu de la ligne entière dans laquelle se trouve le mot). Enfin, nous envoyons le résultat produit par grep à la commande wc -w, qui renvoie le nombre de mots.

Téléchargement d’un fichier

Curl peut également être utilisé pour télécharger des fichiers. Puisque, comme nous l’avons dit, le corps d’une réponse est affiché sur la sortie standard, nous devons spécifier que nous voulons qu’elle soit sauvegardée sous forme de fichier sur notre système de fichiers, sinon nous verrions du charabia dans notre terminal. Dans de tels cas, nous pouvons utiliser l’option -o (abréviation de --output), et fournir, en argument, le nom à utiliser pour le fichier local. Supposons que nous voulions télécharger la dernière version de Firefox à partir du site officiel de Mozilla. Pour enregistrer l’archive tarball localement sous le nom firefox.tar.bz2, nous exécutons la commande suivante :

curl \
  --output firefox.tar.gz \
  https://download-installer.cdn.mozilla.net/pub/firefox/releases/106.0.1/linux-x86_64/en-US/firefox-106.0.1.tar.bz2

Une chose importante à noter est que nous avons cité l’URL afin d’éviter que le shell n’interprète d’éventuels caractères spéciaux. Dès que nous lançons la commande, la progression du téléchargement s’affichera à l’écran :

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   137  100   137    0     0    176      0 --:--:-- --:--:-- --:--:--   176
 87 75.1M   87 65.6M    0     0  1486k      0  0:00:51  0:00:45  0:00:06 1454k^C

Comme alternative à l’option --output, nous pouvons utiliser --remote-name ou -O. Cela entraînera l’enregistrement du fichier avec son nom distant, firefox-106.0.1.tar.bz2 dans ce cas :

curl \
  --remote-name \
  'https://download-installer.cdn.mozilla.net/pub/firefox/releases/106.0.1/linux-x86_64/en-US/firefox-106.0.1.tar.bz2'

Exécution de requêtes POST

La méthode http POST permet de créer de nouvelles ressources sur un serveur. Les requêtes POST incluent généralement des données, qui peuvent être envoyées de différentes manières. Voyons quelques exemples.

Utilisation du type de contenu application/x-www-form-urlencoded

La façon la plus simple d’inclure des données dans une requête POST avec Curl est d’utiliser l’option --data (-d) ou --data-urlencode. Les données que nous envoyons doivent être encodées en urlencod. Si nous utilisons le premier, nous devons l’encoder au préalable ; si nous utilisons ce dernier (disponible dans les versions récentes de Curl), à la place, les données seront automatiquement encodées pour nous :

curl \
  --data-urlencode "name=John Smith" \
  --data-urlencode "age=30" \
  https://httpbin.org/post

Lorsque nous effectuons une requête comme celle que vous voyez ci-dessus, x-www-form-urlencoded est défini automatiquement dans l’en-tête de la requête en tant que valeur du paramètre Content-Type. Dans l’exemple ci-dessus, nous avons envoyé la requête au site https://httpbin.org, qui peut être utilisé pour tester les requêtes. Le serveur renvoie une réponse qui reflète les données envoyées dans la requête :

{
  "args": {}, 
  "data": "", 
  "files": {}, 
  "form": {
    "age": "30", 
    "name": "John Smith"
  }, 
  "headers": {
    "Accept": "*/*", 
    "Content-Length": "22", 
    "Content-Type": "application/x-www-form-urlencoded", 
    "Host": "httpbin.org", 
    "User-Agent": "curl/7.82.0", 
    "X-Amzn-Trace-Id": "Root=1-6356ba6c-325eb51e69a7a95021ee6249"
  }, 
  "json": null, 
  "origin": "xxx.xxx.x.xx", 
  "url": "https://httpbin.org/post"
}

Envoi de données JSON ou XML

Dans certains cas, nous pouvons avoir besoin d’envoyer une chaîne JSON en tant que données. Dans de tels cas, nous devons faire deux choses :

Définissez explicitement le paramètre d’en-tête Content-Type sur application/json
Passez la chaîne JSON en argument de l’option --data.

Voici un exemple d’une telle demande :

curl \
  --header "Content-Type: application/json" \
  --data '{"name": "John Smith", "age": 30 }' \
  https://httpbin.org/post

Le même principe doit être appliqué dans le cas où nous voulons envoyer des données XML, par exemple :

curl \
  --header "Content-Type: text/xml" \
  --data '<person><name>John Smith</name><age>30</age></person>' \
  https://httpbin.org/post

Utilisation du type de contenu multipart/form-data

Pour effectuer une requête POST et inclure des données à l’aide du type de contenu multipart/form-data, nous pouvons exécuter Curl avec l’option --form (-F). C’est ce que nous voulons utiliser, par exemple, lorsque nous devons télécharger un fichier. Voici la même requête que nous avons faite dans l’exemple précédent, mais effectuée avec ce type de contenu :

curl \
  --form "name=John Smith" \
  --form "age=30" \
   https://httpbin.org/post

Et voici la réponse correspondante envoyée par le serveur :

{
  "args": {}, 
  "data": "", 
  "files": {}, 
  "form": {
    "age": "30", 
    "name": "John Smith"
  }, 
  "headers": {
    "Accept": "*/*", 
    "Content-Length": "243", 
    "Content-Type": "multipart/form-data; boundary=------------------------e231a6560f5118bd", 
    "Host": "httpbin.org", 
    "User-Agent": "curl/7.82.0", 
    "X-Amzn-Trace-Id": "Root=1-6356c1d1-05e70c5919d0971a3bd299e6"
  }, 
  "json": null, 
  "origin": "xxx.xx.x.xx", 
  "url": "https://httpbin.org/post"
}

Supposons que, dans le cadre de la demande, nous souhaitions télécharger une photo qui existe actuellement dans notre répertoire de travail, associée au champ « profil ». Voici la commande que nous exécuterions :

curl \
  --form "name=John Smith" \
  --form "age=30" \
  --form "profile=@pic.avif" \
  https://httpbin.org/post

Comme vous pouvez le remarquer, nous avons utilisé le symbole @ suivi du chemin de l’image, qui peut être absolu ou relatif. Le serveur renvoie cette réponse lorsque nous exécutons la requête. Notez que le fichier que nous avons téléchargé se trouve dans la section « fichiers » de la réponse, associé au champ de formulaire correspondant (j’ai utilisé la notation [...] pour omettre la valeur très longue, pour plus de commodité) :

{
  "args": {}, 
  "data": "", 
  "files": {
    "profile-picture": "data:image/jpeg;base64,iVBORw0KGgoAAAANSUhEUgAADwAAAAhwCAYAAACQvstyAAABhWlDQ1BJQ0MgcHJvZmlsZQAAKJF9kT1Iw0AcxV9btVoqIu0g4pChOlkQFXHUKhShQqgVWnUwufRDaNKQpLg4Cq4FBz8Wqw4uzro6uAqC[...]"
  }, 
  "form": {
    "age": "30", 
    "name": "John Smith"
  }, 
  "headers": {
    "Accept": "*/*", 
    "Content-Length": "153871", 
    "Content-Type": "multipart/form-data; boundary=------------------------94b6dea0b7f448d5", 
    "Host": "httpbin.org", 
    "User-Agent": "curl/7.82.0", 
    "X-Amzn-Trace-Id": "Root=1-6356c368-2f39e19a67106e4141410178"
  }, 
  "json": null, 
  "origin": "xxx.xx.x.xx", 
  "url": "https://httpbin.org/post"
}

Envoi du contenu d’un fichier

Curl fournit une syntaxe spéciale que nous pouvons utiliser pour obtenir le contenu d’un fichier, au lieu de télécharger le fichier. Supposons, par exemple, que notre nom soit stocké dans le fichier name.txt de notre répertoire de travail actuel. Pour passer son contenu en valeur du champ de formulaire « nom », nous utiliserions le symbole <, de la manière suivante :

curl --form "name=<name.txt" https://httpbin.org/post

Notez que tout le contenu du fichier sera utilisé la valeur du champ, caractères de saut de ligne inclus.

Définition des en-têtes de requête

Les paramètres d’en-tête sont utilisés pour fournir des informations supplémentaires à une demande : par exemple, Keep-Alive qui est utilisé pour contrôler combien une connexion doit rester ouverte ou User-Agent, qui est utilisé pour identifier le type d’application et de système d’exploitation, ou Accept, utilisé pour spécifier quels types MIME sont acceptés par le client. Pour définir les paramètres d’en-tête avec Curl, nous pouvons utiliser l’option -H (abréviation de --header) :

curl \
  --header "Accept: text/xml" \
  --header "User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:105.0) Gecko/20100101 Firefox/105.0" \
   https://httpbin.org/get

D’ailleurs, pour définir l’agent utilisateur d’une requête, Curl fournit un raccourci via l’option --user-agent (-A) :

curl --user-agent "User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:105.0) Gecko/20100101 Firefox/105.0" https://httpbin.org/get

Conclusions

Dans cet article, nous voyons l’utilisation de base de Curl. Nous avons appris à effectuer des requêtes en utilisant les méthodes http les plus courantes : GET et POST. Nous avons vu comment télécharger un fichier, comment envoyer différents types de données dans une requête POST, et comment on peut définir les paramètres d’en-tête d’une requête. Curl est un outil extrêmement utile : ici, nous venons de le présenter. Jetez un coup d’œil au manuel, vous serez surpris de ses nombreuses fonctionnalités !