En un servidor Linux o dentro de un contenedor no hay un diálogo de proxy del sistema; hay tres mecanismos, y cuál necesitas depende de lo bien que se comporte el software. Las variables de entorno (http_proxy, https_proxy, no_proxy) son respetadas por curl, wget, pip, apt, git, la mayoría de las bibliotecas HTTP de los lenguajes y el propio Docker — y silenciosamente ignoradas por algunas herramientas. Los envoltorios por proceso como proxychains fuerzan a un programa concreto a través de un proxy a nivel de biblioteca. La redirección transparente con iptables y una ayuda como redsocks captura cada conexión TCP saliente del host o contenedor, sin importar lo que el programa crea que está haciendo. Esta guía cubre las tres, las trampas de cada una y cómo comprobar el resultado.
Nivel 1: variables de entorno
La convención, más antigua que Linux: si http_proxy / https_proxy están definidas, úsalas; omite los hosts listados en 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 # pasa por el proxy
curl http://localhost:9000/health # directo, gracias a no_proxy
Puntos que cuestan horas a la gente:
- Mayúsculas/minúsculas. Define tanto en minúsculas como en mayúsculas (
HTTP_PROXY,HTTPS_PROXY,NO_PROXY); las herramientas no se ponen de acuerdo sobre cuál leen. Ten en cuenta quehttps_proxytoma una URLhttp://— nombra el proxy para destinos HTTPS y el proxy en sí normalmente es HTTP plano conCONNECT. - Caracteres especiales en la contraseña deben estar codificados en porcentaje.
- Alcance. Las variables se aplican a los procesos iniciados después de definirlas, en esa shell. Los servicios iniciados por systemd no ven tu shell; ponlas en
Environment=de la unidad o en unEnvironmentFile. Los trabajos cron también tienen un entorno mínimo. sudoelimina el entorno por defecto; usasudo -Eo configuraenv_keep.- Quién las ignora. Los programas Go las respetan (a través de
ProxyFromEnvironmentdenet/http); Python's requests las respeta; elfetchintegrado de Node y muchos clientes HTTP de Node no las respetan a menos que se use una ayuda; Java necesita flags JVM-Dhttp.proxyHost; las bases de datos y los protocolos TCP personalizados nunca las miran. Si el tráfico de un programa sigue mostrando tu IP real después de definir las variables, es uno de estos casos — pasa al nivel 2 o 3.
Los gestores de paquetes tienen sus propios ajustes
# 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
Nivel 1b: Docker específicamente
Docker tiene dos ámbitos de proxy separados, y confundirlos es el error clásico de los contenedores.
El daemon (descarga de imágenes)
Las descargas de imágenes las hace el daemon de Docker, un servicio systemd — no ve tu shell. Configúralo en 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
Contenedores (tráfico de tus aplicaciones)
Los procesos dentro de un contenedor tienen su propio entorno. O bien pasa las variables en tiempo de ejecución:
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
o define valores por defecto para todos los contenedores que inicies desde este cliente en ~/.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" } } }
El cliente inyecta estas variables en el entorno de cada contenedor (y en las builds). Dentro del contenedor se aplican las mismas advertencias: la aplicación debe ser de las que respetan las variables. En Compose, usa el bloque environment: por servicio, y recuerda que los servicios que se comunican entre sí por nombre de servicio deben estar en NO_PROXY o cada llamada interna intentará salir a través del proxy y fallará.
Builds
docker build obtiene el proxy de ~/.docker/config.json o de --build-arg HTTP_PROXY=…. No hornees credenciales en la imagen con ENV; acaban en el historial de capas para cualquiera que la descargue.
Nivel 2: envoltorios por proceso
Para un programa que ignora el entorno, proxychains (el fork mantenido es proxychains-ng, paquete proxychains4) precarga una biblioteca compartida que intercepta las llamadas de socket del programa y las enruta a través de una cadena de proxies que defines:
sudo apt install proxychains4
# /etc/proxychains4.conf, al final:
# [ProxyList]
# http proxy.example.com 8080 user pass
# o: socks5 proxy.example.com 1080 user pass
proxychains4 -q ./my-binary --that-ignores-env
Configura proxy_dns en el archivo de configuración para que las resoluciones de nombres también pasen por el proxy (el problema de fuga de DNS de Cómo probar un proxy). Límites: solo funciona con binarios enlazados dinámicamente que usen la biblioteca de sockets estándar — los programas Go enlazados estáticamente y cualquier cosa que use sockets crudos se escapan. Es una herramienta para un proceso a la vez, ideal para pruebas y para el binario raro que se porta mal, no para todo un host.
Alternativas en la misma clase: tsocks, graftcp (usa ptrace, así que también atrapa binarios estáticos, a costa de rendimiento), y para contenedores que ejecutan el proceso bajo uno de estos como entrypoint.
Nivel 3: redirección transparente con iptables y redsocks
Cuando necesitas que todo de un host o contenedor salga a través de un proxy — incluido software que no puedes configurar — redirige a nivel de kernel. iptables puede reescribir las conexiones TCP salientes a un puerto local; un pequeño daemon escuchando allí envuelve cada conexión en el protocolo del proxy y la reenvía. redsocks es el daemon estándar para esto.
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; # o socks5
login = "user"; password = "pass";
}
sudo systemctl restart redsocks
# Redirige todo el TCP saliente excepto el propio proxy y los rangos locales/privados
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 # tráfico propio de este host
# para tráfico de contenedores/otros hosts enrutado a través de esta máquina, usa PREROUTING en su lugar
Tres cosas que debes saber antes de hacer esto. La regla RETURN para la IP del propio proxy no es opcional — sin ella, la conexión de redsocks al proxy se redirige de vuelta a redsocks, y la máquina entra en bucle. UDP no se redirige con esta receta: el DNS seguirá yendo directo a menos que también redirijas el puerto 53 a un resolver de confianza o uses la sección redudp de redsocks; y QUIC/HTTP/3 simplemente no funcionará a través del proxy (ver HTTP/3 a través de proxies), lo cual está bien porque los clientes recurren a TCP. Prueba las reglas con un timeout (sudo timeout 60 iptables … no es una cosa, pero mantener una segunda sesión SSH abierta y estar listo para iptables -t nat -F sí lo es) — una regla incorrecta puede dejarte sin acceso a un servidor remoto.
El mismo patrón funciona para un contenedor ejecutando las reglas iptables dentro de él (necesita --cap-add=NET_ADMIN) o, más limpio, en el host con el tráfico del contenedor enrutado a través de un namespace de red dedicado. Los usuarios de Kubernetes reconocerán esto como exactamente cómo los sidecars de service mesh capturan el tráfico.
Qué nivel para cada situación
| Situación | Usa | Por qué |
|---|---|---|
| Scripts, herramientas CLI, gestores de paquetes, servicios bien comportados | Variables de entorno (+ configuración específica de la herramienta) | Simple, reversible, ámbito por proceso |
| Descargas de imágenes Docker | Drop-in del daemon | El daemon tiene su propio entorno |
| Aplicaciones dentro de contenedores | ~/.docker/config.json o -e | Se inyectan en el entorno del contenedor |
| Un binario que ignora el entorno | proxychains / graftcp | Intercepta a nivel de socket; sin cambios en todo el host |
| Todo desde un host o namespace, incondicionalmente | iptables + redsocks | A nivel de kernel; nada puede optar por no participar |
| Diferentes proxies para diferentes destinos | Lógica tipo PAC: no_proxy en entorno, o reglas iptables por rango de destino | Enruta según el destino |
Verifica, siempre
curl -s https://api.ipify.org # respeta el entorno: debería mostrar la IP del proxy
curl -s --noproxy '*' https://api.ipify.org # ignora el entorno: muestra la IP del proxy SOLO si el nivel 3 está activo
python3 -c "import urllib.request;print(urllib.request.urlopen('https://api.ipify.org').read())"
dig +short myip.opendns.com @resolver1.opendns.com # ¿desde qué IP te ve el DNS?
La segunda línea es el truco útil: con --noproxy '*' curl ignora el entorno, así que si aun así reporta la IP del proxy, la redirección transparente está funcionando; si reporta tu IP real, solo el nivel de entorno está activo y el software no conforme se filtrará. También verifica el DNS por separado — es la fuga más común en servidores, ya que los resolvers se configuran a nivel de sistema y nada en los tres niveles anteriores redirige UDP a menos que lo hagas tú.
Para elegir el tipo de proxy detrás de todo esto — datacenter para la mayoría del trabajo en servidores, ISP para una identidad estable, residencial donde el destino lo exija — ver la comparación de tipos de proxy; las notas del lado del proveedor para cargas de trabajo Linux están en nuestro ranking de proxies para Linux.
Preguntas frecuentes
¿Cómo configuro un proxy para todo el servidor Linux?
Para software conforme, exporta http_proxy/https_proxy/no_proxy a nivel de sistema (por ejemplo, /etc/environment) y configura los servicios mediante Environment= de systemd. Para absolutamente todo, usa redirección iptables a redsocks.
¿Cómo hago que Docker use un proxy?
Dos lugares: el daemon (para descargas) mediante un drop-in de systemd con HTTP_PROXY, y los contenedores mediante proxies en ~/.docker/config.json o variables -e. Son independientes; configura ambos si necesitas ambos.
¿Por qué mi programa ignora http_proxy?
No todo el software lo lee — el fetch de Node, Java, las bases de datos y los protocolos personalizados no lo hacen. Usa un ajuste específico de la herramienta, un envoltorio como proxychains, o redirección transparente.
¿Qué es redsocks?
Un daemon que acepta conexiones TCP redirigidas por iptables y las reenvía a través de un proxy HTTP CONNECT o SOCKS, dándote un proxy transparente para cualquier aplicación sin configurar la aplicación.
¿La redirección transparente maneja DNS y UDP?
No con la receta básica — redirige TCP. Redirige el DNS explícitamente (o apunta el resolver a un servidor de confianza) y espera que los protocolos basados en UDP como QUIC recurran a TCP.
¿Deben los contenedores usar proxies SOCKS5 o HTTP?
HTTP con CONNECT cubre destinos HTTPS y es lo que esperan las variables de entorno; SOCKS5 solo se necesita para tráfico TCP no HTTP, y entonces mediante proxychains o redsocks en modo socks5.