Intégration de proxy avec des clients REST API : configuration de Postman, Insomnia, cURL et HTTPie

Lors du développement et des tests d'API, il est souvent nécessaire d'envoyer des requêtes via des serveurs proxy. Cela peut être nécessaire pour contourner des restrictions géographiques, tester le comportement de l'API depuis différentes régions, garantir l'anonymat ou travailler avec des services qui bloquent les IP des centres de données. Dans ce guide, nous allons examiner comment configurer correctement un proxy dans des clients API REST populaires et éviter les erreurs courantes.

Nous allons examiner quatre des outils les plus populaires pour travailler avec des API : Postman (une interface graphique pour la plupart des développeurs), Insomnia (une alternative moderne avec une interface utilisateur conviviale), cURL (un outil classique en ligne de commande) et HTTPie (un client CLI moderne avec une syntaxe lisible). Pour chaque outil, nous fournirons des exemples de code et examinerons les particularités de la configuration.

Quels types de proxy conviennent pour travailler avec des API

Avant de configurer un proxy dans les clients API, il est important de comprendre quel type de proxy convient à votre tâche. Les clients API REST prennent en charge deux protocoles principaux : HTTP/HTTPS et SOCKS5. Le choix dépend des exigences de l'API spécifique et du niveau de sécurité dont vous avez besoin.

Les proxies HTTP/HTTPS fonctionnent au niveau du protocole HTTP et sont idéaux pour la plupart des requêtes API REST. Ils comprennent la structure du trafic HTTP, peuvent mettre en cache les réponses et modifier les en-têtes. Les proxies HTTPS chiffrent en outre la connexion entre le client et le serveur proxy, ce qui est important lors de la transmission de données sensibles, telles que les clés API ou les jetons d'autorisation.

Les proxies SOCKS5 fonctionnent à un niveau plus bas et transmettent tout type de trafic sans modification. Ils sont plus lents que les proxies HTTP, mais offrent une meilleure anonymité et conviennent aux cas où l'API utilise des protocoles non standards ou nécessite une transparence complète de la connexion. Les SOCKS5 prennent également en charge le trafic UDP, bien que cela soit rarement nécessaire pour les API REST.

Configuration du proxy dans Postman : paramètres globaux et locaux

Postman est l'outil graphique le plus populaire pour travailler avec les API REST, utilisé par des millions de développeurs. Il prend en charge deux méthodes de configuration des proxies : les paramètres globaux (s'appliquent à toutes les requêtes) et les paramètres au niveau de l'environnement. Examinons les deux options en détail.

Configuration globale du proxy dans Postman

Les paramètres globaux du proxy se trouvent dans le menu Paramètres (icône d'engrenage en haut à droite). Cette méthode est pratique lorsque vous souhaitez que toutes les requêtes de Postman passent toujours par le même serveur proxy. Instructions étape par étape :

1. Ouvrez Postman et cliquez sur l'icône d'engrenage (Paramètres) en haut à droite
2. Allez à l'onglet "Proxy"
3. Activez l'option "Ajouter une configuration proxy personnalisée"
4. Choisissez le type de proxy : HTTP, HTTPS ou SOCKS5
5. Entrez l'adresse du serveur proxy (par exemple : proxy.example.com)
6. Indiquez le port (généralement 8080 pour HTTP, 1080 pour SOCKS5)
7. Si le proxy nécessite une authentification, activez "Authentification Proxy" et entrez votre identifiant/mot de passe
8. Cliquez sur "Enregistrer" et fermez la fenêtre des paramètres

Après cela, toutes les requêtes de Postman passeront automatiquement par le proxy spécifié. Une caractéristique importante : Postman envoie également des télémétries et vérifie les mises à jour via le proxy, ce qui peut créer un trafic supplémentaire. Si vous utilisez un proxy avec un trafic limité, cela doit être pris en compte.

Configuration du proxy via des variables d'environnement

Une méthode plus flexible consiste à utiliser des variables d'environnement. Cela permet de basculer rapidement entre différents proxies pour différents projets ou API. Créez un nouvel environnement et ajoutez les variables suivantes :

PROXY_HOST = proxy.example.com
PROXY_PORT = 8080
PROXY_USER = votre_nom_utilisateur
PROXY_PASS = votre_mot_de_passe

Ensuite, dans les paramètres globaux du proxy, utilisez ces variables au lieu de valeurs spécifiques : {{PROXY_HOST}} et {{PROXY_PORT}}. Vous pouvez maintenant créer plusieurs environnements (par exemple, "Proxy de Production", "Proxy de Test", "Proxy US") et basculer entre eux d'un simple clic.

Utilisation du proxy système

Postman peut également utiliser les paramètres proxy de votre système d'exploitation. Pour cela, dans les paramètres Proxy, sélectionnez l'option "Utiliser le Proxy Système". C'est pratique si vous avez déjà configuré le proxy au niveau du système d'exploitation (par exemple, via les paramètres Windows ou macOS) et que vous souhaitez que Postman utilise les mêmes paramètres que votre navigateur.

Configuration du proxy dans Insomnia

Insomnia est une alternative moderne à Postman avec une interface épurée et un code source ouvert. La configuration du proxy dans Insomnia est légèrement différente de celle de Postman et nécessite de modifier le fichier de configuration ou d'utiliser des variables d'environnement. Examinons les deux méthodes.

Configuration via des variables d'environnement

La méthode la plus simple pour configurer un proxy dans Insomnia consiste à utiliser les variables d'environnement standard HTTP_PROXY et HTTPS_PROXY. Insomnia lit automatiquement ces variables à partir du système. Définissez-les avant de lancer Insomnia :

Linux/macOS :

export HTTP_PROXY="http://nom_utilisateur:mot_de_passe@proxy.example.com:8080"
export HTTPS_PROXY="http://nom_utilisateur:mot_de_passe@proxy.example.com:8080"
insomnia

Windows (PowerShell) :

$env:HTTP_PROXY = "http://nom_utilisateur:mot_de_passe@proxy.example.com:8080"
$env:HTTPS_PROXY = "http://nom_utilisateur:mot_de_passe@proxy.example.com:8080"
insomnia

Notez le format de l'URL : même pour un proxy HTTPS, le schéma http:// est utilisé, et non https://. C'est une convention standard pour les variables d'environnement proxy. Si le proxy ne nécessite pas d'authentification, l'URL sera plus courte : http://proxy.example.com:8080.

Configuration du proxy SOCKS5

Pour les proxies SOCKS5, utilisez la variable d'environnement ALL_PROXY :

export ALL_PROXY="socks5://nom_utilisateur:mot_de_passe@proxy.example.com:1080"

Insomnia prend en charge SOCKS5, mais toutes les versions ne gèrent pas correctement l'authentification SOCKS5. Si vous rencontrez des problèmes avec un SOCKS5 authentifié, essayez d'utiliser un proxy HTTP ou mettez à jour Insomnia vers la dernière version.

Configuration via le fichier de configuration

Pour une configuration permanente du proxy, vous pouvez modifier le fichier de configuration d'Insomnia. L'emplacement du fichier dépend du système d'exploitation :

• Windows : %APPDATA%\Insomnia\config.json
• macOS : ~/Library/Application Support/Insomnia/config.json
• Linux : ~/.config/Insomnia/config.json

Ouvrez le fichier dans un éditeur de texte et ajoutez la section proxy :

{
  "proxy": {
    "http": "http://nom_utilisateur:mot_de_passe@proxy.example.com:8080",
    "https": "http://nom_utilisateur:mot_de_passe@proxy.example.com:8080"
  }
}

Après modification, redémarrez Insomnia. Les paramètres proxy s'appliqueront automatiquement à toutes les requêtes.

Utilisation du proxy dans cURL : exemples de commandes

cURL est un outil classique en ligne de commande pour travailler avec HTTP, installé sur presque tous les systèmes Unix et Windows 10+. Il prend en charge les proxies via le paramètre -x ou --proxy. Examinons différents scénarios d'utilisation.

Utilisation de base d'un proxy HTTP

Un exemple simple d'utilisation d'un proxy HTTP sans authentification :

curl -x http://proxy.example.com:8080 https://api.example.com/users

Le paramètre -x indique l'adresse et le port du serveur proxy. cURL déterminera automatiquement qu'il s'agit d'un proxy HTTP et configurera la connexion. Si vous souhaitez indiquer explicitement le protocole, utilisez l'URL complète :

curl --proxy http://proxy.example.com:8080 https://api.example.com/users

Proxy avec authentification

Si le proxy nécessite une authentification par identifiant et mot de passe, ajoutez-les à l'URL du proxy ou utilisez le paramètre -U :

# Méthode 1 : identifiant et mot de passe dans l'URL
curl -x http://nom_utilisateur:mot_de_passe@proxy.example.com:8080 https://api.example.com/users

# Méthode 2 : paramètre -U (plus sécurisé, ne s'enregistre pas dans l'historique des commandes)
curl -x http://proxy.example.com:8080 -U nom_utilisateur:mot_de_passe https://api.example.com/users

La deuxième méthode est préférable, car l'identifiant et le mot de passe ne seront pas enregistrés dans l'historique des commandes shell. Pour une sécurité encore plus grande, vous pouvez indiquer uniquement l'identifiant, et cURL demandera le mot de passe de manière interactive :

curl -x http://proxy.example.com:8080 -U nom_utilisateur https://api.example.com/users
# cURL demandera le mot de passe : Entrez le mot de passe du proxy pour l'utilisateur 'nom_utilisateur' :

Utilisation d'un proxy SOCKS5

Pour un proxy SOCKS5, indiquez explicitement le protocole dans l'URL :

# SOCKS5 sans authentification
curl -x socks5://proxy.example.com:1080 https://api.example.com/users

# SOCKS5 avec authentification
curl -x socks5://nom_utilisateur:mot_de_passe@proxy.example.com:1080 https://api.example.com/users

# SOCKS5h (résolution DNS via le proxy)
curl -x socks5h://proxy.example.com:1080 https://api.example.com/users

La différence entre socks5:// et socks5h:// : dans le premier cas, la résolution DNS se fait localement (sur votre machine), dans le second, via le serveur proxy. Utilisez socks5h:// si vous souhaitez cacher complètement les requêtes DNS de votre fournisseur.

Requêtes POST via un proxy

Le proxy fonctionne de la même manière pour toutes les méthodes HTTP. Exemple d'une requête POST avec des données JSON via un proxy :

curl -x http://proxy.example.com:8080 \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"name":"John","email":"john@example.com"}' \
  https://api.example.com/users

Pour envoyer des fichiers, utilisez le paramètre -F :

curl -x http://proxy.example.com:8080 \
  -X POST \
  -F "file=@document.pdf" \
  -F "description=Document important" \
  https://api.example.com/upload

Utilisation de variables d'environnement

Au lieu d'indiquer le proxy dans chaque commande, vous pouvez utiliser des variables d'environnement. cURL lit automatiquement http_proxy, https_proxy et all_proxy :

# Définir les variables d'environnement
export http_proxy="http://nom_utilisateur:mot_de_passe@proxy.example.com:8080"
export https_proxy="http://nom_utilisateur:mot_de_passe@proxy.example.com:8080"

# Maintenant, toutes les commandes cURL utilisent automatiquement le proxy
curl https://api.example.com/users

# Désactiver le proxy pour une commande spécifique
curl --noproxy "*" https://api.example.com/users

Le paramètre --noproxy permet d'exclure certains domaines du proxy. Par exemple, pour ne pas utiliser le proxy pour localhost et les domaines internes :

export no_proxy="localhost,127.0.0.1,.internal.company.com"

Configuration du proxy dans HTTPie

HTTPie est une alternative moderne à cURL avec une syntaxe lisible et une sortie colorée. Il est particulièrement pratique pour travailler de manière interactive avec des API dans le terminal. HTTPie prend en charge les proxies via le paramètre --proxy ou des variables d'environnement.

Utilisation de base d'un proxy

La syntaxe HTTPie pour le proxy est légèrement différente de celle de cURL. Vous devez indiquer le protocole et l'URL du proxy séparément :

# Proxy HTTP
http --proxy=http:http://proxy.example.com:8080 \
     --proxy=https:http://proxy.example.com:8080 \
     GET https://api.example.com/users

# Forme abrégée (si le proxy est identique pour HTTP et HTTPS)
http --proxy=all:http://proxy.example.com:8080 GET https://api.example.com/users

Format : --proxy=protocol:proxy_url. Pour les requêtes HTTPS, un proxy HTTP est généralement utilisé (pas HTTPS), c'est le comportement standard.

Proxy avec authentification

Pour l'authentification, ajoutez l'identifiant et le mot de passe à l'URL du proxy :

http --proxy=all:http://nom_utilisateur:mot_de_passe@proxy.example.com:8080 \
     GET https://api.example.com/users

HTTPie prend également en charge le paramètre --proxy-auth pour indiquer plus explicitement les identifiants, mais dans les dernières versions, ce paramètre est considéré comme obsolète, et il est recommandé d'inclure l'authentification dans l'URL.

Proxies SOCKS5 dans HTTPie

HTTPie prend en charge les proxies SOCKS5 à partir de la version 2.0.0. Assurez-vous que vous avez la version à jour :

# Vérifier la version de HTTPie
http --version

# Mettre à jour HTTPie via pip
pip install --upgrade httpie

# Utiliser un proxy SOCKS5
http --proxy=all:socks5://proxy.example.com:1080 GET https://api.example.com/users

Pour un SOCKS5 avec authentification, vous devrez installer une bibliothèque supplémentaire pysocks :

pip install pysocks
http --proxy=all:socks5://nom_utilisateur:mot_de_passe@proxy.example.com:1080 \
     GET https://api.example.com/users

Requêtes POST et envoi de données

HTTPie a une syntaxe pratique pour les requêtes POST. Exemple d'envoi de JSON via un proxy :

# POST avec JSON (HTTPie détermine automatiquement le Content-Type)
http --proxy=all:http://proxy.example.com:8080 \
     POST https://api.example.com/users \
     name="John Doe" \
     email="john@example.com" \
     age:=30

# Envoi de fichier
http --proxy=all:http://proxy.example.com:8080 \
     POST https://api.example.com/upload \
     file@document.pdf \
     description="Document important"

Notez la syntaxe : key=value pour les chaînes, key:=value pour les nombres et les valeurs booléennes, key@file pour les fichiers.

Utilisation de variables d'environnement

Comme cURL, HTTPie lit les variables d'environnement standard http_proxy et https_proxy :

export http_proxy="http://nom_utilisateur:mot_de_passe@proxy.example.com:8080"
export https_proxy="http://nom_utilisateur:mot_de_passe@proxy.example.com:8080"

# Maintenant, toutes les commandes utilisent automatiquement le proxy
http GET https://api.example.com/users

Pour désactiver temporairement le proxy, utilisez le paramètre --proxy= (valeur vide) :

http --proxy= GET https://api.example.com/users

Authentification du proxy : identifiant et mot de passe

La plupart des services de proxy commerciaux nécessitent une authentification pour se protéger contre une utilisation non autorisée. Il existe deux méthodes principales d'authentification : l'authentification de base (identifiant/mot de passe) et la liste blanche d'IP (liée à l'adresse IP). Examinons les particularités de chaque méthode et comment les configurer correctement dans les clients API.

Authentification de base (identifiant et mot de passe)

L'authentification de base est la méthode la plus courante. Le serveur proxy exige un identifiant et un mot de passe à chaque connexion. Les identifiants sont transmis dans l'en-tête Proxy-Authorization au format Base64. Tous les clients API modernes génèrent automatiquement cet en-tête si vous indiquez un identifiant et un mot de passe dans l'URL du proxy.

Format de l'URL avec authentification :

protocol://nom_utilisateur:mot_de_passe@proxy_host:proxy_port

Exemples pour différents protocoles :

# Proxy HTTP
http://user123:pass456@proxy.example.com:8080

# Proxy HTTPS (utilise le même format)
http://user123:pass456@proxy.example.com:8080

# Proxy SOCKS5
socks5://user123:pass456@proxy.example.com:1080

Liste blanche d'IP (liée à l'IP)

Certains fournisseurs de proxy proposent une authentification par adresse IP. Dans ce cas, vous ajoutez votre IP à la liste blanche dans le panneau de contrôle du proxy, et le serveur autorise les connexions uniquement à partir de cette IP sans identifiant ni mot de passe. C'est plus pratique et plus sûr, car il n'est pas nécessaire de transmettre des identifiants dans chaque requête.

Lors de l'utilisation de la liste blanche d'IP, le format de l'URL du proxy est simplifié :

# Sans identifiant ni mot de passe
http://proxy.example.com:8080

# Exemple dans cURL
curl -x http://proxy.example.com:8080 https://api.example.com/users

L'inconvénient de cette méthode est que si votre IP est dynamique (change lors de la reconnexion à Internet), vous devrez mettre à jour la liste blanche à chaque fois. Pour les serveurs avec une IP statique, c'est une option idéale.

Caractères spéciaux dans le mot de passe

Si le mot de passe du proxy contient des caractères spéciaux (@, :, /, ?), ils doivent être encodés au format URL encoding (percent encoding). Par exemple :

Exemple d'utilisation d'un mot de passe avec des caractères spéciaux :

# Mot de passe d'origine : P@ss:w0rd/123
# Mot de passe encodé : P%40ss%3Aw0rd%2F123

curl -x http://nom_utilisateur:P%40ss%3Aw0rd%2F123@proxy.example.com:8080 \
     https://api.example.com/users

Pour un encodage automatique, vous pouvez utiliser des outils en ligne d'URL encoder ou une commande en Python :

python3 -c "import urllib.parse; print(urllib.parse.quote('P@ss:w0rd/123'))"
# Sortie : P%40ss%3Aw0rd%2F123

Résolution des problèmes et erreurs courants

Lors de l'utilisation de proxies dans les clients API, des erreurs courantes surviennent souvent. Examinons les problèmes les plus fréquents et comment les résoudre.

Erreur "407 Proxy Authentication Required"

Cette erreur signifie que le serveur proxy exige une authentification, mais que les identifiants n'ont pas été fournis ou sont incorrects. Solutions :

• Vérifiez l'exactitude de l'identifiant et du mot de passe dans le panneau de contrôle du fournisseur de proxy
• Assurez-vous que les caractères spéciaux dans le mot de passe sont encodés (voir section ci-dessus)
• Vérifiez le format de l'URL : http://nom_utilisateur:mot_de_passe@hôte:port
• Si vous utilisez une liste blanche d'IP, assurez-vous que votre IP actuelle est ajoutée à la liste blanche

Exemple de diagnostic dans cURL avec sortie détaillée :

curl -v -x http://nom_utilisateur:mot_de_passe@proxy.example.com:8080 https://api.example.com/users
# Le drapeau -v (verbose) affichera tous les en-têtes et le processus d'authentification

Erreur "Connection timeout" ou "Failed to connect"

Cette erreur se produit lorsque le client API ne peut pas établir de connexion avec le serveur proxy. Causes possibles :

• Adresse ou port du serveur proxy incorrects — vérifiez les paramètres auprès du fournisseur
• Le serveur proxy est inaccessible ou surchargé — essayez un autre serveur de la liste
• Votre pare-feu bloque les connexions sortantes sur le port du proxy
• Le fournisseur de proxy a bloqué votre IP pour dépassement des limites

Pour le diagnostic, essayez de vous connecter directement au proxy via telnet ou nc :

# Vérifier la disponibilité du proxy
telnet proxy.example.com 8080
# ou
nc -zv proxy.example.com 8080

# Si la connexion ne s'établit pas, le problème vient du réseau ou le serveur proxy est inaccessible

Erreur "SSL certificate problem"

Lors de l'utilisation de proxies HTTPS, des problèmes peuvent survenir lors de la vérification des certificats SSL. Cela est particulièrement vrai pour les proxies MITM (Man-in-the-Middle) qui interceptent et déchiffrent le trafic HTTPS. Solutions :

• Dans cURL, utilisez le drapeau -k ou --insecure pour désactiver la vérification du certificat (uniquement pour les tests !)
• Dans Postman, désactivez "SSL certificate verification" dans Paramètres → Général
• Installez le certificat racine du proxy dans le système (pour l'environnement de production)

# Désactiver la vérification SSL dans cURL
curl -k -x http://proxy.example.com:8080 https://api.example.com/users

Meilleures pratiques pour travailler avec des proxies dans les clients API

Pour garantir une utilisation efficace et sécurisée des proxies dans les clients API, voici quelques meilleures pratiques à suivre :

• Utilisez toujours des proxies fiables et sécurisés pour protéger vos données.
• Évitez de stocker des identifiants et mots de passe en clair dans vos scripts.
• Testez toujours vos configurations de proxy avant de les utiliser en production.
• Surveillez les performances de votre proxy et ajustez les paramètres si nécessaire.
• Restez informé des mises à jour de sécurité et des meilleures pratiques de votre fournisseur de proxy.

Conclusion

La configuration d'un proxy dans les clients API REST est essentielle pour garantir la sécurité, l'anonymat et la flexibilité lors des tests et du développement. En suivant les étapes et recommandations présentées dans ce guide, vous serez en mesure de configurer efficacement des proxies dans Postman, Insomnia, cURL et HTTPie, tout en évitant les erreurs courantes.