Pengaturan Proxy di Kontainer Docker: Panduan Lengkap dengan Contoh Kode

Kontainer Docker sering membutuhkan akses ke sumber daya eksternal melalui proxy — untuk pengambilan data, pengujian dari berbagai wilayah, atau menghindari pembatasan. Pengaturan proxy yang salah dapat menyebabkan kesalahan koneksi, kebocoran IP asli, dan kegagalan dalam aplikasi. Dalam artikel ini, kita akan membahas semua cara untuk mengatur proxy di Docker: dari variabel lingkungan sederhana hingga skenario lanjutan dengan docker-compose dan jaringan kustom.

Mengapa perlu proxy dalam kontainer Docker

Kontainer Docker digunakan dalam berbagai skenario di mana proxy menjadi kebutuhan. Mari kita lihat tugas utama yang diselesaikan oleh proxy dalam aplikasi yang tercontainerisasi.

Pemrosesan dan pengumpulan data: Jika Anda menjalankan pemroses dalam kontainer Docker untuk mengumpulkan data dari marketplace (Wildberries, Ozon), media sosial, atau mesin pencari, proxy melindungi dari pemblokiran berdasarkan IP. Kontainer memungkinkan untuk menskalakan pemrosesan — menjalankan 10-50 instance secara bersamaan, masing-masing dengan proxy-nya sendiri.

Pengujian dari berbagai wilayah: Saat mengembangkan aplikasi web atau API mobile, sering kali perlu memeriksa bagaimana layanan berfungsi dari berbagai negara. Kontainer Docker dengan proxy dari berbagai geolokasi memungkinkan untuk mengotomatisasi pengujian semacam itu dalam pipeline CI/CD.

Automasi dan bot: Kontainer dengan Selenium, Puppeteer, atau Playwright untuk automasi browser memerlukan proxy untuk bekerja dengan banyak akun. Setiap kontainer mendapatkan proxy dan lingkungan terisolasi.

Menghindari pembatasan korporat: Dalam beberapa infrastruktur, kontainer Docker harus melewati proxy korporat untuk mengakses internet. Tanpa pengaturan yang benar, kontainer tidak akan dapat mengunduh paket atau mengakses API eksternal.

Pengaturan dasar melalui variabel lingkungan

Cara paling sederhana untuk mengatur proxy dalam kontainer Docker adalah dengan mengirimkan variabel lingkungan saat menjalankan. Metode ini bekerja untuk sebagian besar aplikasi yang menghormati variabel standar HTTP_PROXY, HTTPS_PROXY, dan NO_PROXY.

Menjalankan kontainer dengan proxy melalui docker run:

docker run -d \
  -e HTTP_PROXY="http://username:password@proxy.example.com:8080" \
  -e HTTPS_PROXY="http://username:password@proxy.example.com:8080" \
  -e NO_PROXY="localhost,127.0.0.1,.local" \
  your-image:latest

Penjelasan parameter:

• HTTP_PROXY — proxy untuk permintaan HTTP
• HTTPS_PROXY — proxy untuk permintaan HTTPS (gunakan http://, bukan https://)
• NO_PROXY — daftar alamat yang tidak boleh melalui proxy

Contoh dengan proxy SOCKS5:

docker run -d \
  -e HTTP_PROXY="socks5://username:password@proxy.example.com:1080" \
  -e HTTPS_PROXY="socks5://username:password@proxy.example.com:1080" \
  your-image:latest

Pengaturan proxy untuk daemon Docker (berpengaruh pada semua kontainer):

Jika Anda ingin semua kontainer secara default menggunakan proxy, atur daemon Docker. Buat file /etc/systemd/system/docker.service.d/http-proxy.conf:

[Service]
Environment="HTTP_PROXY=http://proxy.example.com:8080"
Environment="HTTPS_PROXY=http://proxy.example.com:8080"
Environment="NO_PROXY=localhost,127.0.0.1,.local"

Setelah perubahan, restart Docker:

sudo systemctl daemon-reload
sudo systemctl restart docker

Pengaturan proxy dalam Dockerfile

Ketika Anda membangun image Docker yang harus mengunduh paket melalui proxy (misalnya, apt-get, pip, npm), Anda perlu mengatur proxy pada tahap pembangunan. Docker mendukung argumen build-time untuk ini.

Contoh Dockerfile dengan dukungan proxy:

FROM python:3.11-slim

# Argumen untuk proxy (dikirim saat membangun)
ARG HTTP_PROXY
ARG HTTPS_PROXY
ARG NO_PROXY

# Mengatur variabel lingkungan untuk pembangunan
ENV HTTP_PROXY=${HTTP_PROXY}
ENV HTTPS_PROXY=${HTTPS_PROXY}
ENV NO_PROXY=${NO_PROXY}

# Menginstal dependensi melalui proxy
RUN apt-get update && apt-get install -y curl

# Menginstal paket Python
COPY requirements.txt .
RUN pip install --proxy ${HTTP_PROXY} -r requirements.txt

# Menyalin aplikasi
COPY . /app
WORKDIR /app

# Menghapus variabel proxy untuk runtime (opsional)
ENV HTTP_PROXY=
ENV HTTPS_PROXY=

CMD ["python", "app.py"]

Membangun image dengan mengirimkan proxy:

docker build \
  --build-arg HTTP_PROXY=http://proxy.example.com:8080 \
  --build-arg HTTPS_PROXY=http://proxy.example.com:8080 \
  --build-arg NO_PROXY=localhost,127.0.0.1 \
  -t my-app:latest .

Untuk aplikasi Node.js (npm melalui proxy):

FROM node:18-alpine

ARG HTTP_PROXY
ARG HTTPS_PROXY

# Mengatur npm untuk bekerja melalui proxy
RUN npm config set proxy ${HTTP_PROXY}
RUN npm config set https-proxy ${HTTPS_PROXY}

COPY package*.json ./
RUN npm install

# Menghapus pengaturan proxy untuk npm
RUN npm config delete proxy
RUN npm config delete https-proxy

COPY . .
CMD ["node", "server.js"]

Konfigurasi proxy dalam docker-compose.yml

Docker Compose menyederhanakan pengelolaan proxy untuk aplikasi multi-kontainer. Anda dapat mengatur proxy secara global atau untuk layanan tertentu.

Konfigurasi dasar dengan proxy untuk satu layanan:

version: '3.8'

services:
  parser:
    image: python:3.11-slim
    environment:
      - HTTP_PROXY=http://username:password@proxy.example.com:8080
      - HTTPS_PROXY=http://username:password@proxy.example.com:8080
      - NO_PROXY=localhost,127.0.0.1,db
    volumes:
      - ./app:/app
    working_dir: /app
    command: python parser.py
    
  db:
    image: postgres:15
    # Database tidak menggunakan proxy
    environment:
      - POSTGRES_PASSWORD=secret

Penggunaan file .env untuk penyimpanan kredensial yang aman:

Buat file .env di direktori dengan docker-compose.yml:

PROXY_URL=http://username:password@proxy.example.com:8080
NO_PROXY=localhost,127.0.0.1

Rujuk ke variabel dalam docker-compose.yml:

version: '3.8'

services:
  parser:
    image: python:3.11-slim
    environment:
      - HTTP_PROXY=${PROXY_URL}
      - HTTPS_PROXY=${PROXY_URL}
      - NO_PROXY=${NO_PROXY}
    volumes:
      - ./app:/app
    working_dir: /app
    command: python parser.py

Konfigurasi proxy untuk membangun image dalam docker-compose:

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        - HTTP_PROXY=${PROXY_URL}
        - HTTPS_PROXY=${PROXY_URL}
        - NO_PROXY=${NO_PROXY}
    environment:
      - HTTP_PROXY=${PROXY_URL}
      - HTTPS_PROXY=${PROXY_URL}
    ports:
      - "3000:3000"

Menskalakan dengan proxy yang berbeda untuk setiap instance:

Jika Anda perlu menjalankan beberapa pemroses, masing-masing dengan proxy-nya sendiri, gunakan layanan terpisah:

version: '3.8'

services:
  parser-1:
    image: my-parser:latest
    environment:
      - PROXY_URL=http://user:pass@proxy1.example.com:8080
    volumes:
      - ./data:/data
    
  parser-2:
    image: my-parser:latest
    environment:
      - PROXY_URL=http://user:pass@proxy2.example.com:8080
    volumes:
      - ./data:/data
    
  parser-3:
    image: my-parser:latest
    environment:
      - PROXY_URL=http://user:pass@proxy3.example.com:8080
    volumes:
      - ./data:/data

Pengaturan proxy pada tingkat aplikasi

Beberapa aplikasi tidak mendukung variabel lingkungan standar HTTP_PROXY. Dalam kasus seperti itu, Anda perlu mengatur proxy dalam kode aplikasi atau file konfigurasi.

Python (perpustakaan requests):

import os
import requests

# Mendapatkan proxy dari variabel lingkungan
proxy_url = os.getenv('PROXY_URL', 'http://proxy.example.com:8080')

proxies = {
    'http': proxy_url,
    'https': proxy_url
}

# Menggunakan proxy dalam permintaan
response = requests.get('https://api.example.com/data', proxies=proxies)
print(response.json())

# Untuk proxy SOCKS5, instal pip install requests[socks]
# proxies = {
#     'http': 'socks5://user:pass@proxy.example.com:1080',
#     'https': 'socks5://user:pass@proxy.example.com:1080'
# }

Python (aiohttp untuk permintaan asinkron):

import os
import aiohttp
import asyncio

async def fetch_with_proxy():
    proxy_url = os.getenv('PROXY_URL')
    
    async with aiohttp.ClientSession() as session:
        async with session.get(
            'https://api.example.com/data',
            proxy=proxy_url
        ) as response:
            data = await response.json()
            print(data)

asyncio.run(fetch_with_proxy())

Node.js (perpustakaan axios):

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');

const proxyUrl = process.env.PROXY_URL || 'http://proxy.example.com:8080';
const agent = new HttpsProxyAgent(proxyUrl);

axios.get('https://api.example.com/data', {
  httpsAgent: agent
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error('Error:', error.message);
});

Node.js (modul https bawaan):

const https = require('https');
const { HttpsProxyAgent } = require('https-proxy-agent');

const proxyUrl = process.env.PROXY_URL;
const agent = new HttpsProxyAgent(proxyUrl);

const options = {
  hostname: 'api.example.com',
  port: 443,
  path: '/data',
  method: 'GET',
  agent: agent
};

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => data += chunk);
  res.on('end', () => console.log(JSON.parse(data)));
});

req.on('error', (error) => console.error(error));
req.end();

Selenium dengan proxy dalam kontainer Docker:

from selenium import webdriver
from selenium.webdriver.common.proxy import Proxy, ProxyType
import os

proxy_url = os.getenv('PROXY_URL', 'proxy.example.com:8080')

# Mengatur proxy untuk Chrome
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument(f'--proxy-server={proxy_url}')

# Untuk autentikasi, gunakan ekstensi atau SSH tunnel
driver = webdriver.Chrome(options=chrome_options)
driver.get('https://example.com')
print(driver.title)
driver.quit()

Puppeteer dengan proxy:

const puppeteer = require('puppeteer');

(async () => {
  const proxyUrl = process.env.PROXY_URL || 'proxy.example.com:8080';
  
  const browser = await puppeteer.launch({
    args: [`--proxy-server=${proxyUrl}`],
    headless: true
  });
  
  const page = await browser.newPage();
  
  // Autentikasi untuk proxy
  await page.authenticate({
    username: 'your-username',
    password: 'your-password'
  });
  
  await page.goto('https://example.com');
  console.log(await page.title());
  
  await browser.close();
})();

Jenis proxy apa yang dipilih untuk Docker

Pemilihan jenis proxy tergantung pada tugas yang diselesaikan aplikasi Anda dalam kontainer Docker. Mari kita bahas skenario utama dan rekomendasi.

Rekomendasi pemilihan untuk tugas tertentu:

Pemrosesan marketplace dan katalog produk: Jika Anda memproses Wildberries, Ozon, atau marketplace lainnya melalui kontainer Docker, gunakan proxy residensial. Platform-platform ini aktif memblokir IP datacenter. Atur rotasi proxy setiap 5-10 menit untuk meniru pengguna yang berbeda.

Pengujian dan pengembangan API: Untuk menguji API Anda sendiri atau integrasi dengan layanan eksternal, proxy datacenter cocok digunakan. Mereka menawarkan kecepatan tinggi dan stabilitas koneksi, yang penting untuk pengujian otomatis dalam CI/CD.

Automasi Selenium/Puppeteer: Saat menjalankan automasi browser dalam kontainer untuk bekerja dengan situs yang aman (media sosial, bank, aplikasi web yang kompleks), pilih proxy residensial. Mereka mengurangi kemungkinan captcha dan pemblokiran.

Pengujian geolokasi terdistribusi: Jika perlu memeriksa ketersediaan layanan dari berbagai negara, gunakan proxy residensial dengan pilihan geolokasi tertentu. Jalankan beberapa kontainer Docker, masing-masing dengan proxy dari negara mereka sendiri.

Memecahkan masalah umum

Saat bekerja dengan proxy dalam kontainer Docker, muncul masalah umum. Mari kita bahas masalah yang paling sering terjadi dan cara mengatasinya.

Masalah 1: Kontainer tidak dapat terhubung ke proxy

Gejala: Kesalahan "Connection refused", "Proxy connection failed", timeout saat menjalankan kontainer.

Solusi:

• Periksa ketersediaan proxy dari host: curl -x http://proxy:port https://example.com
• Pastikan server proxy dapat diakses dari jaringan Docker. Jika proxy berada di localhost host, gunakan host.docker.internal (Mac/Windows) atau IP host di jaringan bridge
• Periksa aturan firewall — kontainer Docker mungkin diblokir untuk koneksi keluar
• Untuk proxy dengan autentikasi, periksa keakuratan username dan password, dan escape karakter khusus dalam URL

Contoh akses ke proxy di host:

# Mac/Windows
docker run -e HTTP_PROXY=http://host.docker.internal:8080 my-image

# Linux (temukan IP host di jaringan bridge)
ip addr show docker0  # Biasanya 172.17.0.1
docker run -e HTTP_PROXY=http://172.17.0.1:8080 my-image

Masalah 2: DNS tidak teratasi melalui proxy

Gejala: Kesalahan "Could not resolve host", permintaan DNS tidak melewati proxy.

Solusi:

• Gunakan proxy SOCKS5 alih-alih HTTP — SOCKS5 meneruskan permintaan DNS
• Atur DNS di Docker: tambahkan --dns 8.8.8.8 saat menjalankan kontainer
• Untuk aplikasi yang tidak mendukung DNS melalui proxy, gunakan proxychains di dalam kontainer

# Dockerfile dengan proxychains
FROM python:3.11-slim

RUN apt-get update && apt-get install -y proxychains4

# Konfigurasi proxychains
RUN echo "strict_chain\nproxy_dns\n[ProxyList]\nsocks5 proxy.example.com 1080" > /etc/proxychains4.conf

# Menjalankan aplikasi melalui proxychains
CMD ["proxychains4", "python", "app.py"]

Masalah 3: Kebocoran IP asli kontainer

Gejala: Layanan target melihat IP host atau kontainer alih-alih IP proxy.

Solusi:

• Periksa apakah aplikasi benar-benar menggunakan proxy — lakukan permintaan ke https://api.ipify.org
• Pastikan semua klien HTTP dalam kode diatur untuk menggunakan proxy
• Untuk koneksi WebRTC dan WebSocket, proxy mungkin tidak berfungsi — matikan WebRTC di browser
• Periksa header permintaan — beberapa perpustakaan menambahkan X-Forwarded-For dengan IP asli

Uji kebocoran IP di kontainer:

# Tanpa proxy
docker run --rm curlimages/curl:latest curl https://api.ipify.org

# Dengan proxy
docker run --rm \
  -e HTTPS_PROXY=http://proxy.example.com:8080 \
  curlimages/curl:latest curl https://api.ipify.org

Masalah 4: Kinerja lambat melalui proxy

Gejala: Latensi tinggi, timeout, lambat dalam memuat data.

Solusi:

• Periksa kecepatan proxy secara langsung dari host — mungkin masalah ada pada proxy itu sendiri
• Perpanjang timeout dalam aplikasi untuk bekerja dengan proxy yang lambat
• Gunakan koneksi keep-alive untuk menggunakan kembali koneksi TCP
• Untuk proxy residensial, kecepatan lambat adalah hal yang normal, optimalkan jumlah permintaan
• Atur kumpulan koneksi dalam klien HTTP untuk permintaan paralel

Masalah 5: Proxy berfungsi untuk HTTP, tetapi tidak untuk HTTPS

Gejala: Permintaan HTTP berhasil, tetapi HTTPS mengembalikan kesalahan SSL/TLS.

Solusi:

• Pastikan variabel HTTPS_PROXY diatur (tidak hanya HTTP_PROXY)
• Gunakan http:// dalam URL proxy untuk HTTPS_PROXY, bukan https://
• Periksa apakah proxy mendukung metode CONNECT untuk tunneling HTTPS
• Untuk proxy dengan sertifikat self-signed, matikan verifikasi SSL (hanya untuk pengujian!)

Keamanan dan pengelolaan kredensial

Menyimpan kredensial proxy dalam kontainer Docker memerlukan perhatian khusus terhadap keamanan. Pengelolaan password yang tidak benar dapat menyebabkan kebocoran dalam log, image, atau repositori.

Gunakan Docker Secrets untuk produksi:

Docker Swarm mendukung mekanisme secrets untuk penyimpanan password yang aman. Buat secret:

echo "http://username:password@proxy.example.com:8080" | docker secret create proxy_url -

Gunakan dalam docker-compose untuk Swarm:

version: '3.8'

services:
  app:
    image: my-app:latest
    secrets:
      - proxy_url
    environment:
      - PROXY_URL_FILE=/run/secrets/proxy_url
    command: sh -c 'export HTTP_PROXY=$(cat $$PROXY_URL_FILE) && python app.py'

secrets:
  proxy_url:
    external: true

Variabel lingkungan melalui file (.env):

Untuk pengembangan, gunakan file .env, tetapi JANGAN pernah meng-commit-nya ke Git. Tambahkan ke .gitignore:

# .gitignore
.env
.env.local
*.env

Buat .env.example tanpa kredensial yang nyata:

# .env.example
PROXY_URL=http://username:password@proxy.example.com:8080
NO_PROXY=localhost,127.0.0.1

Hindari hardcoding kredensial dalam image:

# ❌ BURUK - password akan tetap ada dalam image
FROM python:3.11
ENV HTTP_PROXY=http://user:secretpass@proxy.com:8080
COPY . /app

# ✅ BAIK - kirim melalui argumen build atau variabel runtime
FROM python:3.11
ARG HTTP_PROXY
# Hanya digunakan selama pembangunan, tidak disimpan dalam image akhir

Gunakan multi-stage builds untuk membersihkan kredensial:

# Tahap pembangunan dengan proxy
FROM python:3.11 AS builder
ARG HTTP_PROXY
ENV HTTP_PROXY=${HTTP_PROXY}
COPY requirements.txt .
RUN pip install -r requirements.txt

# Tahap akhir tanpa variabel proxy
FROM python:3.11-slim
COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
COPY . /app
WORKDIR /app
CMD ["python", "app.py"]

Rotasi kredensial proxy:

Jika penyedia proxy Anda mendukung API untuk menghasilkan kredensial sementara, gunakan itu alih-alih password statis. Buat skrip init di dalam kontainer:

#!/bin/bash
# entrypoint.sh

# Mendapatkan kredensial sementara dari API
PROXY_CREDS=$(curl -s https://api.proxyservice.com/generate-temp-auth)
export HTTP_PROXY="http://${PROXY_CREDS}@proxy.example.com:8080"

# Menjalankan aplikasi
exec python app.py

Logging tanpa kebocoran password:

Atur logging sehingga variabel dengan proxy tidak muncul dalam output:

import os
import re

def safe_log_env():
    """Logging variabel lingkungan tanpa password"""
    for key, value in os.environ.items():
        if 'PROXY' in key:
            # Menyembunyikan password dalam URL
            safe_value = re.sub(r'://([^:]+):([^@]+)@', r'://\1:****@', value)
            print(f"{key}={safe_value}")
        else:
            print(f"{key}={value}")

safe_log_env()

Kesimpulan

Mengatur proxy dalam kontainer Docker adalah keterampilan penting bagi pengembang yang bekerja dengan pemrosesan data, automasi, dan sistem terdistribusi. Anda telah belajar bagaimana mengatur proxy melalui variabel lingkungan, Dockerfile, dan docker-compose, bagaimana mengintegrasikan proxy dalam kode aplikasi di Python dan Node.js, serta cara menyelesaikan masalah umum dengan koneksi dan keamanan.

Poin kunci untuk bekerja dengan sukses dengan proxy di Docker: gunakan variabel lingkungan untuk fleksibilitas, simpan kredensial dengan aman melalui secrets atau file .env, pilih jenis proxy sesuai dengan tugas, dan selalu uji untuk memastikan tidak ada kebocoran IP asli sebelum menjalankan di produksi.

Untuk sebagian besar tugas pemrosesan dan automasi dalam kontainer Docker, kami merekomendasikan menggunakan proxy residensial — mereka memberikan anonimitas tinggi dan risiko pemblokiran minimal saat bekerja dengan situs dan API yang aman. Namun, jika Anda memerlukan kecepatan maksimum untuk pengujian API atau tugas internal, pertimbangkan untuk menggunakan proxy datacenter.