Di server Linux atau di dalam kontainer tidak ada dialog proxy sistem; ada tiga mekanisme, dan mana yang Anda butuhkan tergantung pada seberapa patuh perangkat lunak tersebut. Variabel lingkungan (http_proxy, https_proxy, no_proxy) dihormati oleh curl, wget, pip, apt, git, sebagian besar pustaka HTTP bahasa pemrograman, dan Docker itu sendiri — dan secara diam-diam diabaikan oleh beberapa alat. Pembungkus per-proses seperti proxychains memaksa satu program melalui proxy di tingkat pustaka. Pengalihan transparan dengan iptables dan pembantu seperti redsocks menangkap setiap koneksi TCP keluar dari host atau kontainer terlepas dari apa yang program pikir sedang dilakukannya. Panduan ini mencakup ketiganya, jebakan di masing-masing, dan cara memeriksa hasilnya.

Level 1: variabel lingkungan

Konvensi, lebih tua dari Linux: jika http_proxy / https_proxy disetel, gunakan; lewati host yang terdaftar di 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          # melewati proxy
curl http://localhost:9000/health   # langsung, berkat no_proxy

Poin yang menghabiskan waktu berjam-jam:

  • Huruf besar/kecil. Setel huruf kecil dan besar (HTTP_PROXY, HTTPS_PROXY, NO_PROXY); alat tidak setuju tentang mana yang mereka baca. Perhatikan bahwa https_proxy mengambil URL http:// — itu menamai proxy untuk target HTTPS, dan proxy itu sendiri biasanya HTTP biasa dengan CONNECT.
  • Karakter khusus dalam kata sandi harus di-encode persen.
  • Cakupan. Variabel berlaku untuk proses yang dimulai setelah disetel, di shell itu. Layanan yang dimulai oleh systemd tidak melihat shell Anda; letakkan di Environment= unit atau EnvironmentFile. Pekerjaan cron juga memiliki lingkungan yang kosong.
  • sudo menghapus lingkungan secara default; gunakan sudo -E atau konfigurasikan env_keep.
  • Siapa yang mengabaikannya. Program Go menghormatinya (melalui ProxyFromEnvironment dari net/http); requests Python menghormatinya; fetch bawaan Node dan banyak klien HTTP Node tidak kecuali menggunakan pembantu; Java memerlukan flag JVM -Dhttp.proxyHost; database dan protokol TCP khusus tidak pernah melihatnya. Jika lalu lintas program masih menunjukkan IP asli Anda setelah menyetel variabel, itu adalah salah satu dari ini — pindah ke level 2 atau 3.

Manajer paket memiliki kenop sendiri

# 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

Level 1b: Docker secara khusus

Docker memiliki dua cakupan proxy terpisah, dan membingungkan keduanya adalah kesalahan kontainer klasik.

Daemon (menarik gambar)

Penarikan gambar dilakukan oleh daemon Docker, layanan systemd — ia tidak melihat shell Anda. Konfigurasikan di 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

Kontainer (lalu lintas dari aplikasi Anda)

Proses di dalam kontainer memiliki lingkungan sendiri. Lewati variabel saat runtime:

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

atau setel default untuk semua kontainer yang Anda mulai dari klien ini di ~/.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" } } }

Klien menyuntikkan ini ke lingkungan setiap kontainer (dan ke build). Di dalam kontainer, peringatan yang sama berlaku: aplikasi harus menghormati variabel. Di Compose, gunakan blok environment: per layanan, dan ingat bahwa layanan yang berbicara satu sama lain dengan nama layanan harus ada di NO_PROXY atau setiap panggilan internal akan mencoba keluar melalui proxy dan gagal.

Build

docker build mendapatkan proxy dari ~/.docker/config.json atau dari --build-arg HTTP_PROXY=…. Jangan memanggang kredensial ke dalam gambar dengan ENV; mereka berakhir di riwayat lapisan untuk siapa pun yang menariknya.

Level 2: pembungkus per-proses

Untuk program yang mengabaikan lingkungan, proxychains (fork yang dipelihara adalah proxychains-ng, paket proxychains4) memuat pustaka bersama yang mencegat panggilan soket program dan merutekannya melalui rantai proxy yang Anda definisikan:

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

Setel proxy_dns di konfigurasi sehingga pencarian nama host juga melewati proxy (masalah kebocoran DNS dari Cara menguji proxy). Keterbatasan: ini hanya berfungsi pada biner yang ditautkan secara dinamis yang menggunakan pustaka soket standar — program Go yang ditautkan secara statis dan apa pun yang menggunakan soket mentah akan lolos. Ini adalah alat untuk satu proses pada satu waktu, ideal untuk pengujian dan untuk biner yang tidak patuh, bukan untuk seluruh host.

Alternatif di kelas yang sama: tsocks, graftcp (menggunakan ptrace, sehingga juga menangkap biner statis, dengan biaya kinerja), dan untuk kontainer yang menjalankan proses di bawah salah satu dari ini sebagai entrypoint.

Level 3: pengalihan transparan dengan iptables dan redsocks

Ketika Anda membutuhkan semuanya dari host atau kontainer untuk keluar melalui proxy — termasuk perangkat lunak yang tidak dapat Anda konfigurasikan — alihkan di kernel. iptables dapat menulis ulang koneksi TCP keluar ke port lokal; daemon kecil yang mendengarkan di sana membungkus setiap koneksi dalam protokol proxy dan meneruskannya. redsocks adalah daemon standar tersebut.

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;          # atau socks5
    login = "user"; password = "pass";
}
sudo systemctl restart redsocks

# Alihkan semua TCP keluar kecuali proxy itu sendiri dan rentang lokal/pribadi
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        # lalu lintas host ini sendiri
# untuk lalu lintas dari kontainer/host lain yang dirutekan melalui kotak ini, gunakan PREROUTING sebagai gantinya

Tiga hal yang perlu diketahui sebelum Anda melakukan ini. Aturan RETURN untuk IP proxy itu sendiri tidak opsional — tanpanya, koneksi redsocks ke proxy akan dialihkan kembali ke redsocks, dan kotak akan berputar. UDP tidak dialihkan oleh resep ini: DNS akan tetap langsung kecuali Anda juga mengalihkan port 53 ke resolver yang Anda percayai atau menggunakan bagian redudp redsocks; dan QUIC/HTTP/3 tidak akan berfungsi melalui proxy (lihat HTTP/3 melalui proxy), yang tidak masalah karena klien akan kembali ke TCP. Uji aturan dengan batas waktu (sudo timeout 60 iptables … bukan hal yang nyata, tetapi menjaga sesi SSH kedua tetap terbuka dan siap untuk iptables -t nat -F adalah) — aturan yang salah dapat memutus Anda dari server jarak jauh.

Pola yang sama berlaku untuk kontainer dengan menjalankan aturan iptables di dalamnya (membutuhkan --cap-add=NET_ADMIN) atau, lebih bersih, di host dengan lalu lintas kontainer dirutekan melalui namespace jaringan khusus. Pengguna Kubernetes akan mengenali ini persis seperti cara sidecar service-mesh menangkap lalu lintas.

Level mana untuk situasi mana

SituasiGunakanMengapa
Skrip, alat CLI, manajer paket, layanan yang patuhVariabel lingkungan (+ konfigurasi khusus alat)Sederhana, dapat dibalik, cakupan per-proses
Penarikan gambar DockerDrop-in daemonDaemon memiliki lingkungan sendiri
Aplikasi di dalam kontainer~/.docker/config.json atau -eDisuntikkan ke env kontainer
Satu biner yang mengabaikan lingkunganproxychains / graftcpMencegat di tingkat soket; tidak ada perubahan seluruh host
Semuanya dari host atau namespace, tanpa syaratiptables + redsocksTingkat kernel; tidak ada yang bisa memilih keluar
Proxy berbeda untuk tujuan berbedaLogika seperti PAC: env no_proxy, atau aturan iptables per rentang tujuanRute berdasarkan target

Verifikasi, selalu

curl -s https://api.ipify.org          # menghormati env: harus menunjukkan IP proxy
curl -s --noproxy '*' https://api.ipify.org   # melewati env: menunjukkan IP proxy HANYA jika level 3 aktif
python3 -c "import urllib.request;print(urllib.request.urlopen('https://api.ipify.org').read())"
dig +short myip.opendns.com @resolver1.opendns.com   # dari IP mana DNS melihat Anda?

Baris kedua adalah trik yang berguna: dengan --noproxy '*' curl mengabaikan lingkungan, jadi jika masih melaporkan IP proxy, pengalihan transparan berfungsi; jika melaporkan IP asli Anda, hanya level lingkungan yang aktif dan perangkat lunak yang tidak patuh akan bocor. Juga periksa DNS secara terpisah — itu adalah kebocoran paling umum di server, karena resolver dikonfigurasi di seluruh sistem dan tidak ada yang di tiga level di atas yang mengalihkan UDP kecuali Anda membuatnya.

Untuk memilih jenis proxy di balik semua ini — datacenter untuk sebagian besar pekerjaan server, ISP untuk identitas yang stabil, residential di mana target menuntutnya — lihat perbandingan jenis proxy; catatan sisi penyedia untuk beban kerja Linux ada di peringkat proxy Linux kami.

Pertanyaan yang sering diajukan

Bagaimana cara mengatur proxy untuk seluruh server Linux?

Untuk perangkat lunak yang patuh, ekspor http_proxy/https_proxy/no_proxy di seluruh sistem (misalnya /etc/environment) dan konfigurasikan layanan melalui systemd Environment=. Untuk benar-benar semuanya, gunakan pengalihan iptables ke redsocks.

Bagaimana cara membuat Docker menggunakan proxy?

Dua tempat: daemon (untuk penarikan) melalui drop-in systemd dengan HTTP_PROXY, dan kontainer melalui proxies di ~/.docker/config.json atau variabel -e. Mereka independen; setel keduanya jika Anda membutuhkan keduanya.

Mengapa program saya mengabaikan http_proxy?

Tidak semua perangkat lunak membacanya — fetch Node, Java, database, dan protokol khusus tidak. Gunakan pengaturan khusus alat, pembungkus seperti proxychains, atau pengalihan transparan.

Apa itu redsocks?

Daemon yang menerima koneksi TCP yang dialihkan kepadanya oleh iptables dan meneruskannya melalui proxy HTTP CONNECT atau SOCKS, memberi Anda proxy transparan untuk aplikasi apa pun tanpa mengonfigurasi aplikasi.

Apakah pengalihan transparan menangani DNS dan UDP?

Tidak dengan resep dasar — ia mengalihkan TCP. Alihkan DNS secara eksplisit (atau arahkan resolver ke server tepercaya) dan harapkan protokol berbasis UDP seperti QUIC untuk kembali ke TCP.

Haruskah kontainer menggunakan proxy SOCKS5 atau HTTP?

HTTP dengan CONNECT mencakup target HTTPS dan itulah yang diharapkan variabel lingkungan; SOCKS5 hanya diperlukan untuk lalu lintas TCP non-HTTP, dan kemudian melalui proxychains atau redsocks dalam mode socks5.