Sur un serveur Linux ou dans un conteneur, il n'y a pas de dialogue de proxy système ; il existe trois mécanismes, et celui dont vous avez besoin dépend de la conformité du logiciel. Les variables d'environnement (http_proxy, https_proxy, no_proxy) sont respectées par curl, wget, pip, apt, git, la plupart des bibliothèques HTTP des langages et Docker lui-même — et silencieusement ignorées par certains outils. Les wrappers par processus tels que proxychains forcent un programme unique à passer par un proxy au niveau de la bibliothèque. La redirection transparente avec iptables et un assistant comme redsocks capture chaque connexion TCP sortante de l'hôte ou du conteneur, indépendamment de ce que le programme pense faire. Ce guide couvre les trois méthodes, les pièges de chacune et comment vérifier le résultat.
Niveau 1 : variables d'environnement
La convention, plus ancienne que Linux : si http_proxy / https_proxy sont définies, utilisez-les ; ignorez les hôtes listés dans no_proxy.
export http_proxy="http://user:pass@proxy.example.com:8080"
export https_proxy="http://user:pass@proxy.example.com:8080"
export no_proxy="localhost,127.0.0.1,::1,.internal,10.0.0.0/8"
curl https://api.ipify.org # passe par le proxy
curl http://localhost:9000/health # direct, grâce à no_proxy
Points qui coûtent des heures aux gens :
- Casse. Définissez à la fois les minuscules et les majuscules (
HTTP_PROXY,HTTPS_PROXY,NO_PROXY) ; les outils ne s'accordent pas sur celles qu'ils lisent. Notez quehttps_proxyprend une URLhttp://— elle nomme le proxy pour les cibles HTTPS, et le proxy lui-même est normalement en HTTP simple avecCONNECT. - Caractères spéciaux dans le mot de passe doivent être encodés en pourcentage.
- Portée. Les variables s'appliquent aux processus démarrés après leur définition, dans ce shell. Les services démarrés par systemd ne voient pas votre shell ; mettez-les dans
Environment=de l'unité ou dans unEnvironmentFile. Les tâches cron ont également un environnement nu. sudosupprime l'environnement par défaut ; utilisezsudo -Eou configurezenv_keep.- Qui les ignore. Les programmes Go les respectent (via
ProxyFromEnvironmentdenet/http) ; requests de Python les respecte ; lefetchintégré de Node et de nombreux clients HTTP Node ne les respectent pas à moins d'utiliser un assistant ; Java nécessite des drapeaux JVM-Dhttp.proxyHost; les bases de données et les protocoles TCP personnalisés ne les regardent jamais. Si le trafic d'un programme montre toujours votre IP réelle après avoir défini les variables, c'est l'un de ces cas — passez au niveau 2 ou 3.
Les gestionnaires de paquets ont leurs propres réglages
# apt
echo 'Acquire::http::Proxy "http://user:pass@proxy.example.com:8080";' | sudo tee /etc/apt/apt.conf.d/95proxy
echo 'Acquire::https::Proxy "http://user:pass@proxy.example.com:8080";' | sudo tee -a /etc/apt/apt.conf.d/95proxy
# pip
pip config set global.proxy http://user:pass@proxy.example.com:8080
# git
git config --global http.proxy http://user:pass@proxy.example.com:8080
# npm
npm config set proxy http://user:pass@proxy.example.com:8080
npm config set https-proxy http://user:pass@proxy.example.com:8080
Niveau 1b : Docker spécifiquement
Docker a deux portées de proxy distinctes, et les confondre est l'erreur classique des conteneurs.
Le démon (téléchargement des images)
Les téléchargements d'images sont effectués par le démon Docker, un service systemd — il ne voit pas votre shell. Configurez-le dans un drop-in :
sudo mkdir -p /etc/systemd/system/docker.service.d
cat <<'EOF' | sudo tee /etc/systemd/system/docker.service.d/http-proxy.conf
[Service]
Environment="HTTP_PROXY=http://user:pass@proxy.example.com:8080"
Environment="HTTPS_PROXY=http://user:pass@proxy.example.com:8080"
Environment="NO_PROXY=localhost,127.0.0.1,registry.internal"
EOF
sudo systemctl daemon-reload && sudo systemctl restart docker
Conteneurs (trafic de vos applications)
Les processus dans un conteneur ont leur propre environnement. Soit passez les variables au moment de l'exécution :
docker run -e HTTP_PROXY=http://user:pass@proxy.example.com:8080 \
-e HTTPS_PROXY=http://user:pass@proxy.example.com:8080 \
-e NO_PROXY=localhost,127.0.0.1 myimage
soit définissez des valeurs par défaut pour tous les conteneurs que vous démarrez depuis ce client dans ~/.docker/config.json :
{ "proxies": { "default": {
"httpProxy": "http://user:pass@proxy.example.com:8080",
"httpsProxy": "http://user:pass@proxy.example.com:8080",
"noProxy": "localhost,127.0.0.1" } } }
Le client injecte ces variables dans l'environnement de chaque conteneur (et dans les builds). À l'intérieur du conteneur, les mêmes mises en garde s'appliquent : l'application doit être celle qui respecte les variables. Dans Compose, utilisez le bloc environment: par service, et rappelez-vous que les services qui se parlent entre eux par nom de service doivent être dans NO_PROXY ou chaque appel interne tentera de sortir par le proxy et échouera.
Builds
docker build obtient le proxy depuis ~/.docker/config.json ou depuis --build-arg HTTP_PROXY=…. Ne pas intégrer les identifiants dans l'image avec ENV ; ils finissent dans l'historique des couches pour quiconque la tire.
Niveau 2 : wrappers par processus
Pour un programme qui ignore l'environnement, proxychains (le fork maintenu est proxychains-ng, paquet proxychains4) précharge une bibliothèque partagée qui intercepte les appels socket du programme et les route à travers une chaîne de proxys que vous définissez :
sudo apt install proxychains4
# /etc/proxychains4.conf, en bas :
# [ProxyList]
# http proxy.example.com 8080 user pass
# ou : socks5 proxy.example.com 1080 user pass
proxychains4 -q ./my-binary --that-ignores-env
Définissez proxy_dns dans la configuration pour que les résolutions de noms d'hôte passent aussi par le proxy (le problème de fuite DNS de Comment tester un proxy). Limites : cela ne fonctionne que sur les binaires liés dynamiquement qui utilisent la bibliothèque socket standard — les programmes Go liés statiquement et tout ce qui utilise des sockets bruts passent à travers. C'est un outil pour un processus à la fois, idéal pour les tests et pour un binaire récalcitrant occasionnel, pas pour tout un hôte.
Alternatives dans la même classe : tsocks, graftcp (utilise ptrace, donc attrape aussi les binaires statiques, au prix de performances), et pour les conteneurs exécutant le processus sous l'un de ces outils comme point d'entrée.
Niveau 3 : redirection transparente avec iptables et redsocks
Lorsque vous avez besoin que tout d'un hôte ou d'un conteneur sorte par un proxy — y compris les logiciels que vous ne pouvez pas configurer — redirigez au niveau du noyau. iptables peut réécrire les connexions TCP sortantes vers un port local ; un petit démon qui y écoute enveloppe chaque connexion dans le protocole proxy et la transmet. redsocks est le démon standard de ce type.
sudo apt install redsocks
# /etc/redsocks.conf
base { log_debug = off; log_info = on; daemon = on; redirector = iptables; }
redsocks {
local_ip = 127.0.0.1; local_port = 12345;
ip = PROXY_IP; port = 8080;
type = http-connect; # ou socks5
login = "user"; password = "pass";
}
sudo systemctl restart redsocks
# Rediriger tout le TCP sortant sauf le proxy lui-même et les plages locales/privées
sudo iptables -t nat -N REDSOCKS
sudo iptables -t nat -A REDSOCKS -d PROXY_IP -j RETURN
sudo iptables -t nat -A REDSOCKS -d 127.0.0.0/8 -j RETURN
sudo iptables -t nat -A REDSOCKS -d 10.0.0.0/8 -j RETURN
sudo iptables -t nat -A REDSOCKS -d 172.16.0.0/12 -j RETURN
sudo iptables -t nat -A REDSOCKS -d 192.168.0.0/16 -j RETURN
sudo iptables -t nat -A REDSOCKS -p tcp -j REDIRECT --to-ports 12345
sudo iptables -t nat -A OUTPUT -p tcp -j REDSOCKS # trafic propre de cet hôte
# pour le trafic des conteneurs/autres hôtes routé via cette machine, utilisez PREROUTING à la place
Trois choses à savoir avant de faire cela. La règle RETURN pour l'IP du proxy n'est pas optionnelle — sans elle, la connexion de redsocks au proxy est elle-même redirigée vers redsocks, et la machine boucle. UDP n'est pas redirigé par cette recette : le DNS ira toujours en direct à moins que vous ne redirigiez aussi le port 53 vers un résolveur de confiance ou utilisiez la section redudp de redsocks ; et QUIC/HTTP/3 ne fonctionnera tout simplement pas à travers le proxy (voir HTTP/3 à travers les proxies), ce qui est acceptable car les clients retombent sur TCP. Testez les règles avec un délai (sudo timeout 60 iptables … n'existe pas, mais gardez une deuxième session SSH ouverte et soyez prêt à faire iptables -t nat -F) — une mauvaise règle peut vous couper d'un serveur distant.
Le même schéma fonctionne pour un conteneur en exécutant les règles iptables à l'intérieur (nécessite --cap-add=NET_ADMIN) ou, plus proprement, sur l'hôte avec le trafic du conteneur routé via un espace de noms réseau dédié. Les utilisateurs de Kubernetes reconnaîtront cela comme exactement la façon dont les sidecars de service mesh capturent le trafic.
Quel niveau pour quelle situation
| Situation | Utiliser | Pourquoi |
|---|---|---|
| Scripts, outils CLI, gestionnaires de paquets, services bien comportés | Variables d'environnement (+ configuration spécifique à l'outil) | Simple, réversible, portée par processus |
| Téléchargements d'images Docker | Drop-in du démon | Le démon a son propre environnement |
| Applications dans les conteneurs | ~/.docker/config.json ou -e | Injecté dans l'environnement du conteneur |
| Un binaire qui ignore l'environnement | proxychains / graftcp | Intercepte au niveau socket ; pas de changement à l'échelle de l'hôte |
| Tout d'un hôte ou d'un espace de noms, sans condition | iptables + redsocks | Au niveau du noyau ; rien ne peut se désister |
| Différents proxies pour différentes destinations | Logique de type PAC : no_proxy dans l'environnement, ou règles iptables par plage de destination | Router par cible |
Vérifiez, toujours
curl -s https://api.ipify.org # respecte l'env : devrait montrer l'IP du proxy
curl -s --noproxy '*' https://api.ipify.org # contourne l'env : montre l'IP du proxy UNIQUEMENT si le niveau 3 est en place
python3 -c "import urllib.request;print(urllib.request.urlopen('https://api.ipify.org').read())"
dig +short myip.opendns.com @resolver1.opendns.com # de quelle IP le DNS vous voit-il ?
La deuxième ligne est l'astuce utile : avec --noproxy '*', curl ignore l'environnement, donc s'il rapporte toujours l'IP du proxy, la redirection transparente fonctionne ; s'il rapporte votre IP réelle, seul le niveau environnement est actif et les logiciels non conformes fuiront. Vérifiez aussi le DNS séparément — c'est la fuite la plus courante sur les serveurs, car les résolveurs sont configurés à l'échelle du système et rien dans les trois niveaux ci-dessus ne redirige UDP à moins que vous ne le fassiez.
Pour choisir le type de proxy derrière tout cela — datacenter pour la plupart des travaux serveur, ISP pour une identité stable, résidentiel là où la cible l'exige — voir la comparaison des types de proxies ; les notes côté fournisseur pour les charges de travail Linux sont dans notre classement des proxies Linux.
Questions fréquemment posées
Comment définir un proxy pour tout le serveur Linux ?
Pour les logiciels conformes, exportez http_proxy/https_proxy/no_proxy à l'échelle du système (par exemple /etc/environment) et configurez les services via systemd Environment=. Pour vraiment tout, utilisez la redirection iptables vers redsocks.
Comment faire en sorte que Docker utilise un proxy ?
Deux endroits : le démon (pour les téléchargements) via un drop-in systemd avec HTTP_PROXY, et les conteneurs via proxies dans ~/.docker/config.json ou les variables -e. Ils sont indépendants ; définissez les deux si vous avez besoin des deux.
Pourquoi mon programme ignore-t-il http_proxy ?
Tous les logiciels ne le lisent pas — le fetch de Node, Java, les bases de données et les protocoles personnalisés ne le font pas. Utilisez un paramètre spécifique à l'outil, un wrapper comme proxychains, ou la redirection transparente.
Qu'est-ce que redsocks ?
Un démon qui accepte les connexions TCP redirigées vers lui par iptables et les transmet via un proxy HTTP CONNECT ou SOCKS, vous donnant un proxy transparent pour toute application sans configurer l'application.
La redirection transparente gère-t-elle le DNS et l'UDP ?
Pas avec la recette de base — elle redirige le TCP. Redirigez le DNS explicitement (ou pointez le résolveur vers un serveur de confiance) et attendez-vous à ce que les protocoles basés sur UDP comme QUIC retombent sur TCP.
Les conteneurs doivent-ils utiliser des proxies SOCKS5 ou HTTP ?
HTTP avec CONNECT couvre les cibles HTTPS et c'est ce que les variables d'environnement attendent ; SOCKS5 n'est nécessaire que pour le trafic TCP non-HTTP, et alors via proxychains ou redsocks en mode socks5.