Em um servidor Linux ou dentro de um contêiner não há diálogo de proxy do sistema; existem três mecanismos, e qual você precisa depende de quão bem-comportado é o software. Variáveis de ambiente (http_proxy, https_proxy, no_proxy) são respeitadas por curl, wget, pip, apt, git, a maioria das bibliotecas HTTP de linguagens e o próprio Docker — e silenciosamente ignoradas por algumas ferramentas. Wrappers por processo como proxychains forçam um único programa através de um proxy no nível da biblioteca. Redirecionamento transparente com iptables e um auxiliar como redsocks captura toda conexão TCP de saída do host ou contêiner, independentemente do que o programa pensa que está fazendo. Este guia cobre todos os três, as armadilhas em cada um e como verificar o resultado.

Nível 1: variáveis de ambiente

A convenção, mais antiga que o próprio Linux: se http_proxy / https_proxy estiverem definidas, use-as; pule hosts listados em 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          # passa pelo proxy
curl http://localhost:9000/health   # direto, graças ao no_proxy

Pontos que custam horas às pessoas:

  • Caixa. Defina tanto minúsculas quanto maiúsculas (HTTP_PROXY, HTTPS_PROXY, NO_PROXY); as ferramentas discordam sobre qual leem. Note que https_proxy recebe uma URL http:// — ela nomeia o proxy para alvos HTTPS, e o próprio proxy é normalmente HTTP simples com CONNECT.
  • Caracteres especiais na senha devem ser codificados em percent-encoding.
  • Escopo. As variáveis se aplicam a processos iniciados depois de serem definidas, naquele shell. Serviços iniciados pelo systemd não veem seu shell; coloque-as no Environment= da unidade ou em um EnvironmentFile. Trabalhos cron também têm um ambiente limpo.
  • sudo remove o ambiente por padrão; use sudo -E ou configure env_keep.
  • Quem as ignora. Programas Go as respeitam (via ProxyFromEnvironment do net/http); o requests do Python as respeita; o fetch embutido do Node e muitos clientes HTTP do Node não as respeitam, a menos que um auxiliar seja usado; Java precisa de flags JVM -Dhttp.proxyHost; bancos de dados e protocolos TCP personalizados nunca as olham. Se o tráfego de um programa ainda mostrar seu IP real após definir as variáveis, é um desses — vá para o nível 2 ou 3.

Gerenciadores de pacotes têm seus próprios controles

# 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

Nível 1b: Docker especificamente

O Docker tem dois escopos de proxy separados, e confundi-los é o erro clássico de contêiner.

O daemon (puxando imagens)

O pull de imagens é feito pelo daemon do Docker, um serviço systemd — ele não vê seu shell. Configure-o em um 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

Contêineres (tráfego dos seus aplicativos)

Processos dentro de um contêiner têm seu próprio ambiente. Ou passe as variáveis no momento da execução:

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

ou defina padrões para todos os contêineres que você iniciar a partir deste cliente em ~/.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" } } }

O cliente injeta essas variáveis no ambiente de cada contêiner (e em builds). Dentro do contêiner, as mesmas ressalvas se aplicam: o aplicativo deve ser um que respeite as variáveis. No Compose, use o bloco environment: por serviço, e lembre-se de que serviços que falam entre si pelo nome do serviço devem estar em NO_PROXY ou toda chamada interna tentará sair pelo proxy e falhará.

Builds

docker build obtém o proxy de ~/.docker/config.json ou de --build-arg HTTP_PROXY=…. Não coloque credenciais na imagem com ENV; elas acabam no histórico da camada para qualquer um que puxar a imagem.

Nível 2: wrappers por processo

Para um programa que ignora o ambiente, proxychains (o fork mantido é proxychains-ng, pacote proxychains4) pré-carrega uma biblioteca compartilhada que intercepta as chamadas de socket do programa e as roteia através de uma cadeia de proxies que você define:

sudo apt install proxychains4
# /etc/proxychains4.conf, no final:
#   [ProxyList]
#   http  proxy.example.com 8080 user pass
#   ou: socks5 proxy.example.com 1080 user pass
proxychains4 -q ./my-binary --that-ignores-env

Defina proxy_dns no config para que as consultas de hostname também passem pelo proxy (o problema de vazamento de DNS de Como testar um proxy). Limitações: funciona apenas com binários dinamicamente ligados que usam a biblioteca de socket padrão — programas Go estaticamente ligados e qualquer coisa que use sockets brutos escapam. É uma ferramenta para um processo por vez, ideal para testes e para o binário malcomportado ocasional, não para um host inteiro.

Alternativas na mesma classe: tsocks, graftcp (usa ptrace, então também captura binários estáticos, com custo de desempenho), e para contêineres executando o processo sob um destes como entrypoint.

Nível 3: redirecionamento transparente com iptables e redsocks

Quando você precisa que tudo de um host ou contêiner saia através de um proxy — incluindo software que você não pode configurar — redirecione no kernel. iptables pode reescrever conexões TCP de saída para uma porta local; um pequeno daemon escutando lá envolve cada conexão no protocolo de proxy e a encaminha. redsocks é o daemon padrão para isso.

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

# Redirecione todo TCP de saída exceto o próprio proxy e faixas locais/privadas
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áfego deste host
# para tráfego de contêineres/outros hosts roteados através desta máquina, use PREROUTING em vez disso

Três coisas para saber antes de fazer isso. A regra RETURN para o IP do próprio proxy não é opcional — sem ela, a conexão do redsocks ao proxy é redirecionada de volta para o redsocks, e a máquina entra em loop. UDP não é redirecionado por esta receita: o DNS ainda irá direto, a menos que você também redirecione a porta 53 para um resolvedor confiável ou use a seção redudp do redsocks; e QUIC/HTTP/3 simplesmente não funcionarão através do proxy (veja HTTP/3 através de proxies), o que é aceitável porque os clientes caem para TCP. Teste as regras com um timeout (sudo timeout 60 iptables … não é uma coisa, mas manter uma segunda sessão SSH aberta e estar pronto para iptables -t nat -F é) — uma regra errada pode cortar sua conexão com um servidor remoto.

O mesmo padrão funciona para um contêiner executando as regras iptables dentro dele (precisa de --cap-add=NET_ADMIN) ou, mais limpo, no host com o tráfego do contêiner roteado através de um namespace de rede dedicado. Usuários de Kubernetes reconhecerão isso como exatamente como os sidecars de service mesh capturam tráfego.

Qual nível para qual situação

SituaçãoUsePor quê
Scripts, ferramentas CLI, gerenciadores de pacotes, serviços bem-comportadosVariáveis de ambiente (+ config específica da ferramenta)Simples, reversível, escopo por processo
Pull de imagens DockerDrop-in do daemonO daemon tem seu próprio ambiente
Aplicativos dentro de contêineres~/.docker/config.json ou -eInjetado no ambiente do contêiner
Um binário que ignora o ambienteproxychains / graftcpIntercepta no nível de socket; sem mudança no host inteiro
Tudo de um host ou namespace, incondicionalmenteiptables + redsocksNível de kernel; nada pode optar por sair
Proxies diferentes para destinos diferentesLógica tipo PAC: env no_proxy, ou regras iptables por faixa de destinoRoteie por alvo

Verifique, sempre

curl -s https://api.ipify.org          # respeita env: deve mostrar o IP do proxy
curl -s --noproxy '*' https://api.ipify.org   # ignora env: mostra o IP do proxy SOMENTE se o nível 3 estiver ativo
python3 -c "import urllib.request;print(urllib.request.urlopen('https://api.ipify.org').read())"
dig +short myip.opendns.com @resolver1.opendns.com   # de qual IP o DNS te vê?

A segunda linha é o truque útil: com --noproxy '*' o curl ignora o ambiente, então se ele ainda reportar o IP do proxy, o redirecionamento transparente está funcionando; se reportar seu IP real, apenas o nível de ambiente está ativo e software não compatível vazará. Verifique também o DNS separadamente — é o vazamento mais comum em servidores, já que os resolvedores são configurados em todo o sistema e nada nos três níveis acima redireciona UDP, a menos que você faça.

Para escolher o tipo de proxy por trás de tudo isso — datacenter para a maioria dos trabalhos de servidor, ISP para uma identidade estável, residencial onde o alvo exige — veja a comparação de tipos de proxy; notas do lado do provedor para cargas de trabalho Linux estão em nosso ranking de proxies Linux.

Perguntas frequentes

Como defino um proxy para todo o servidor Linux?

Para software compatível, exporte http_proxy/https_proxy/no_proxy em todo o sistema (ex.: /etc/environment) e configure serviços via systemd Environment=. Para realmente tudo, use redirecionamento iptables para redsocks.

Como faço o Docker usar um proxy?

Dois lugares: o daemon (para pulls) via um drop-in systemd com HTTP_PROXY, e contêineres via proxies em ~/.docker/config.json ou variáveis -e. Eles são independentes; defina ambos se precisar de ambos.

Por que meu programa ignora http_proxy?

Nem todo software a lê — o fetch do Node, Java, bancos de dados e protocolos personalizados não. Use uma configuração específica da ferramenta, um wrapper como proxychains, ou redirecionamento transparente.

O que é redsocks?

Um daemon que aceita conexões TCP redirecionadas a ele pelo iptables e as encaminha através de um proxy HTTP CONNECT ou SOCKS, dando a você um proxy transparente para qualquer aplicativo sem configurar o aplicativo.

O redirecionamento transparente lida com DNS e UDP?

Não pela receita básica — ele redireciona TCP. Redirecione o DNS explicitamente (ou aponte o resolvedor para um servidor confiável) e espere que protocolos baseados em UDP como QUIC caiam para TCP.

Contêineres devem usar proxies SOCKS5 ou HTTP?

HTTP com CONNECT cobre alvos HTTPS e é o que as variáveis de ambiente esperam; SOCKS5 é necessário apenas para tráfego TCP não-HTTP, e então via proxychains ou redsocks no modo socks5.