Docker Konteynerlerinde Proxy Ayarları: Örnek Kodlarla Tam Kılavuz

Docker konteynerleri genellikle dış kaynaklara proxy aracılığıyla erişim gerektirir — veri toplama, farklı bölgelerden test etme veya kısıtlamaları aşma için. Yanlış yapılandırılmış bir proxy, bağlantı hatalarına, gerçek IP sızıntılarına ve uygulama arızalarına yol açar. Bu makalede, Docker'da proxy ayarlamanın tüm yollarını inceleyeceğiz: basit ortam değişkenlerinden docker-compose ve özel ağlarla gelişmiş senaryolara kadar.

Docker konteynerlerinde proxy'ye neden ihtiyaç var

Docker konteynerleri, proxy'nin gerekli olduğu çeşitli senaryolar için kullanılır. Konteynerleştirilmiş uygulamalarda proxy'nin çözdüğü temel görevleri inceleyelim.

Veri toplama ve analiz: Eğer Docker konteynerlerinde veri toplamak için parser'lar çalıştırıyorsanız (Wildberries, Ozon gibi pazar yerlerinden), sosyal medya veya arama motorlarından veri topluyorsanız, proxy'ler IP engellemelerinden korur. Konteynerler, veri toplamayı ölçeklendirmeyi sağlar — aynı anda 10-50 örneği başlatabilir, her biri kendi proxy'si ile.

Farklı bölgelerden test etme: Web uygulamaları veya mobil API'ler geliştirirken, hizmetin farklı ülkelerden nasıl çalıştığını kontrol etmek sıkça gereklidir. Farklı coğrafi konumlara sahip proxy'ler ile Docker konteynerleri, CI/CD pipeline'ında bu tür testleri otomatikleştirmeyi sağlar.

Otomasyon ve botlar: Selenium, Puppeteer veya Playwright ile tarayıcı otomasyonu için konteynerler, birden fazla hesapla çalışmak için proxy gerektirir. Her konteyner kendi proxy'sini ve izole bir ortamı alır.

Kurumsal kısıtlamaları aşma: Bazı altyapılarda, Docker konteynerlerinin internete erişim için kurumsal proxy'den geçmesi gerekir. Doğru yapılandırma olmadan, konteynerler paket indiremeyecek veya dış API'lere erişemeyecektir.

Ortam değişkenleri aracılığıyla temel ayar

Docker konteynerinde proxy'yi ayarlamanın en basit yolu, başlatma sırasında ortam değişkenlerini geçirmektir. Bu yöntem, standart HTTP_PROXY, HTTPS_PROXY ve NO_PROXY ortam değişkenlerini dikkate alan çoğu uygulama için çalışır.

docker run ile proxy ile konteyner başlatma:

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

Parametrelerin açıklaması:

• HTTP_PROXY — HTTP istekleri için proxy
• HTTPS_PROXY — HTTPS istekleri için proxy (http:// kullanın, https:// değil)
• NO_PROXY — proxy'den geçmemesi gereken adreslerin listesi

SOCKS5 proxy ile örnek:

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

Docker daemon için proxy ayarı (tüm konteynerleri etkiler):

Tüm konteynerlerin varsayılan olarak proxy kullanmasını istiyorsanız, Docker daemon'u yapılandırın. /etc/systemd/system/docker.service.d/http-proxy.conf dosyasını oluşturun:

[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"

Değişikliklerden sonra Docker'ı yeniden başlatın:

sudo systemctl daemon-reload
sudo systemctl restart docker

Dockerfile'da proxy ayarı

Docker imajı oluştururken, proxy üzerinden paket indirmesi gereken bir imaj oluşturuyorsanız (örneğin, apt-get, pip, npm), proxy'yi yapılandırmak için inşa aşamasında ayarlamanız gerekir. Docker, bunun için build-time argümanlarını destekler.

Proxy desteği olan bir Dockerfile örneği:

FROM python:3.11-slim

# Proxy için argümanlar (inşa sırasında geçilir)
ARG HTTP_PROXY
ARG HTTPS_PROXY
ARG NO_PROXY

# İnşa için ortam değişkenlerini ayarlama
ENV HTTP_PROXY=${HTTP_PROXY}
ENV HTTPS_PROXY=${HTTPS_PROXY}
ENV NO_PROXY=${NO_PROXY}

# Proxy üzerinden bağımlılıkların kurulumu
RUN apt-get update && apt-get install -y curl

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

# Uygulamanın kopyalanması
COPY . /app
WORKDIR /app

# Çalışma zamanı için proxy değişkenlerinin silinmesi (isteğe bağlı)
ENV HTTP_PROXY=
ENV HTTPS_PROXY=

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

Proxy ile imaj oluşturma:

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 .

Node.js uygulamaları için (npm üzerinden proxy):

FROM node:18-alpine

ARG HTTP_PROXY
ARG HTTPS_PROXY

# Npm'i proxy üzerinden çalışacak şekilde ayarlama
RUN npm config set proxy ${HTTP_PROXY}
RUN npm config set https-proxy ${HTTPS_PROXY}

COPY package*.json ./
RUN npm install

# Npm için proxy ayarlarını temizleme
RUN npm config delete proxy
RUN npm config delete https-proxy

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

docker-compose.yml'de proxy yapılandırması

Docker Compose, çoklu konteyner uygulamaları için proxy yönetimini kolaylaştırır. Proxy'yi genel olarak veya belirli hizmetler için yapılandırabilirsiniz.

Tek bir hizmet için proxy ile temel yapılandırma:

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
    # Veritabanı proxy kullanmıyor
    environment:
      - POSTGRES_PASSWORD=secret

Kimlik bilgilerini güvenli bir şekilde saklamak için .env dosyası kullanma:

docker-compose.yml dosyasının bulunduğu dizinde bir .env dosyası oluşturun:

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

docker-compose.yml'de değişkenlere atıfta bulunun:

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

docker-compose'da imajın inşası için proxy yapılandırması:

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"

Her örnek için farklı proxy ile ölçeklendirme:

Eğer her biri kendi proxy'sine sahip birkaç parser başlatmanız gerekiyorsa, ayrı hizmetler kullanın:

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

Uygulama düzeyinde proxy ayarı

Bazı uygulamalar standart HTTP_PROXY ortam değişkenlerini desteklemez. Bu durumlarda, proxy'yi uygulama kodunda veya yapılandırma dosyalarında ayarlamak gerekir.

Python (requests kütüphanesi):

import os
import requests

# Ortam değişkeninden proxy'yi alma
proxy_url = os.getenv('PROXY_URL', 'http://proxy.example.com:8080')

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

# İsteklerde proxy kullanma
response = requests.get('https://api.example.com/data', proxies=proxies)
print(response.json())

# SOCKS5 proxy için pip install requests[socks] yükleyin
# proxies = {
#     'http': 'socks5://user:pass@proxy.example.com:1080',
#     'https': 'socks5://user:pass@proxy.example.com:1080'
# }

Python (aiohttp ile asenkron istekler):

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 (axios kütüphanesi):

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('Hata:', error.message);
});

Node.js (gömülü https modülü):

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 ile Docker konteynerinde proxy:

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

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

# Chrome için proxy ayarlama
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument(f'--proxy-server={proxy_url}')

# Kimlik doğrulama için uzantı veya SSH tüneli kullanın
driver = webdriver.Chrome(options=chrome_options)
driver.get('https://example.com')
print(driver.title)
driver.quit()

Puppeteer ile 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();
  
  // Proxy için kimlik doğrulama
  await page.authenticate({
    username: 'your-username',
    password: 'your-password'
  });
  
  await page.goto('https://example.com');
  console.log(await page.title());
  
  await browser.close();
})();

Docker için hangi proxy türünü seçmelisiniz

Proxy türünün seçimi, Docker konteynerinizdeki uygulamanızın çözmesi gereken göreve bağlıdır. Temel senaryoları ve önerileri inceleyelim.

Belirli görevler için seçim önerileri:

Pazar yerleri ve ürün katalogları için veri toplama: Eğer Docker konteynerleri aracılığıyla Wildberries, Ozon veya diğer pazar yerlerini topluyorsanız, ikametgah proxy'lerini kullanın. Bu platformlar, veri merkezi IP'lerini aktif olarak engelliyor. Farklı kullanıcıları taklit etmek için proxy'leri her 5-10 dakikada bir döndürmeyi ayarlayın.

API test etme ve geliştirme: Kendi API'lerinizi veya dış hizmetlerle entegrasyonları test etmek için veri merkezi proxy'lerini tercih edin. Yüksek hız ve bağlantı istikrarı sağladıkları için CI/CD'de otomatik testler için önemlidir.

Selenium/Puppeteer otomasyonu: Korunan sitelerle (sosyal medya, bankalar, karmaşık web uygulamaları) çalışmak için konteynerlerde tarayıcı otomasyonu başlatırken ikametgah proxy'lerini seçin. Bu, captcha ve engellemeler olasılığını azaltır.

Coğrafi dağıtım testi: Hizmetin farklı ülkelerden erişilebilirliğini kontrol etmeniz gerekiyorsa, belirli bir coğrafi konum seçimi ile ikametgah proxy'lerini kullanın. Her biri kendi ülkesinin proxy'si ile birkaç Docker konteyneri başlatın.

Sık karşılaşılan sorunların çözümü

Docker konteynerlerinde proxy ile çalışırken tipik sorunlar ortaya çıkabilir. En sık karşılaşılanları ve çözümlerini inceleyelim.

Sorun 1: Konteyner proxy'ye bağlanamıyor

Belirtiler: "Connection refused", "Proxy connection failed" hataları, konteyner başlatılırken zaman aşımı.

Çözümler:

• Proxy'nin ana makineden erişilebilirliğini kontrol edin: curl -x http://proxy:port https://example.com
• Proxy sunucusunun Docker ağı üzerinden erişilebilir olduğundan emin olun. Eğer proxy ana makinenin localhost'unda ise, host.docker.internal (Mac/Windows) veya bridge ağındaki ana makinenin IP'sini kullanın
• Firewall kurallarını kontrol edin — Docker konteynerleri çıkış bağlantıları için engellenmiş olabilir
• Kimlik doğrulamalı proxy'ler için kullanıcı adı ve şifrenin doğruluğunu kontrol edin, URL'deki özel karakterleri kaçırın

Proxy'ye ana makineden erişim örneği:

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

# Linux (bridge ağındaki ana makinenin IP'sini öğrenin)
ip addr show docker0  # Genellikle 172.17.0.1
docker run -e HTTP_PROXY=http://172.17.0.1:8080 my-image

Sorun 2: DNS proxy üzerinden çözülmüyor

Belirtiler: "Could not resolve host" hataları, DNS istekleri proxy üzerinden geçmiyor.

Çözümler:

• HTTP yerine SOCKS5 proxy kullanın — SOCKS5 DNS isteklerini proxy'ler
• Docker'da DNS ayarlayın: konteyner başlatırken --dns 8.8.8.8 ekleyin
• Proxy üzerinden DNS desteklemeyen uygulamalar için konteyner içinde proxychains kullanın

# Dockerfile ile proxychains
FROM python:3.11-slim

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

# Proxychains yapılandırması
RUN echo "strict_chain\nproxy_dns\n[ProxyList]\nsocks5 proxy.example.com 1080" > /etc/proxychains4.conf

# Uygulamayı proxychains ile başlatma
CMD ["proxychains4", "python", "app.py"]

Sorun 3: Konteynerin gerçek IP'sinin sızması

Belirtiler: Hedef hizmet, proxy IP'si yerine ana makinenin veya konteynerin IP'sini görüyor.

Çözümler:

• Uygulamanın gerçekten proxy'yi kullandığını kontrol edin — https://api.ipify.org adresine istek yapın
• Kodda tüm HTTP istemcilerinin proxy kullanacak şekilde ayarlandığından emin olun
• WebRTC ve WebSocket bağlantıları için proxy çalışmayabilir — tarayıcılarda WebRTC'yi devre dışı bırakın
• İstek başlıklarını kontrol edin — bazı kütüphaneler gerçek IP ile X-Forwarded-For ekler

Konteynerde IP sızıntısını test etme:

# Proxy olmadan
docker run --rm curlimages/curl:latest curl https://api.ipify.org

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

Sorun 4: Proxy üzerinden yavaş çalışma

Belirtiler: Yüksek gecikmeler, zaman aşımı, yavaş veri yükleme.

Çözümler:

• Proxy'nin ana makineden hızını kontrol edin — sorun proxy'de olabilir
• Yavaş proxy'ler ile çalışmak için uygulamadaki zaman aşımını artırın
• TCP bağlantılarını yeniden kullanmak için keep-alive bağlantılarını kullanın
• İkametgah proxy'leri için yavaş hız normaldir, istek sayısını optimize edin
• Paralel istekler için HTTP istemcilerinde bağlantı havuzunu ayarlayın

Sorun 5: Proxy HTTP için çalışıyor, ancak HTTPS için çalışmıyor

Belirtiler: HTTP istekleri geçiyor, HTTPS hataları SSL/TLS veriyor.

Çözümler:

• HTTPS_PROXY değişkeninin ayarlandığından emin olun (sadece HTTP_PROXY değil)
• HTTPS_PROXY için proxy URL'sinde http:// kullanın, https:// değil
• Proxy'nin HTTPS tünelleme için CONNECT yöntemini destekleyip desteklemediğini kontrol edin
• Kendi imzalı sertifikalara sahip proxy'ler için SSL doğrulamasını devre dışı bırakın (sadece testler için!)

Güvenlik ve kimlik bilgilerini yönetme

Docker konteynerlerinde proxy kimlik bilgilerini saklamak, güvenliğe özel bir dikkat gerektirir. Şifrelerin yanlış yönetimi, loglarda, imajlarda veya depolarda sızıntıya yol açabilir.

Üretim için Docker Secrets kullanın:

Docker Swarm, şifrelerin güvenli bir şekilde saklanması için secrets mekanizmasını destekler. Bir secret oluşturun:

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

Swarm için docker-compose'da kullanın:

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

Ortam değişkenlerini dosyalar (.env) aracılığıyla kullanın:

Geliştirme için .env dosyalarını kullanın, ancak ASLA bunları Git'e yüklemeyin. .gitignore'a ekleyin:

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

Gerçek kimlik bilgileri olmadan bir .env.example oluşturun:

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

İmajda kimlik bilgilerini hardcode etmekten kaçının:

# ❌ KÖTÜ - şifre imajda kalır
FROM python:3.11
ENV HTTP_PROXY=http://user:secretpass@proxy.com:8080
COPY . /app

# ✅ İYİ - inşa sırasında argümanlar veya çalışma zamanı değişkenleri ile geçirin
FROM python:3.11
ARG HTTP_PROXY
# Sadece inşa sırasında kullanılır, son imajda saklanmaz

Kimlik bilgilerini temizlemek için çok aşamalı inşaat kullanın:

# Proxy ile inşa aşaması
FROM python:3.11 AS builder
ARG HTTP_PROXY
ENV HTTP_PROXY=${HTTP_PROXY}
COPY requirements.txt .
RUN pip install -r requirements.txt

# Proxy değişkenleri olmadan son aşama
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"]

Proxy kimlik bilgilerini döndürme:

Eğer proxy sağlayıcınız geçici kimlik bilgileri oluşturmak için bir API destekliyorsa, bunları statik şifreler yerine kullanın. Konteynerde bir init script oluşturun:

#!/bin/bash
# entrypoint.sh

# API'den geçici kimlik bilgilerini alma
PROXY_CREDS=$(curl -s https://api.proxyservice.com/generate-temp-auth)
export HTTP_PROXY="http://${PROXY_CREDS}@proxy.example.com:8080"

# Uygulamayı başlatma
exec python app.py

Şifre sızıntısı olmadan loglama:

Kimlik bilgileri içeren değişkenlerin çıktıya düşmemesi için loglama ayarlarını yapın:

import os
import re

def safe_log_env():
    """Şifre olmadan ortam değişkenlerini loglama"""
    for key, value in os.environ.items():
        if 'PROXY' in key:
            # URL'deki şifreyi maskeleme
            safe_value = re.sub(r'://([^:]+):([^@]+)@', r'://\1:****@', value)
            print(f"{key}={safe_value}")
        else:
            print(f"{key}={value}")

safe_log_env()

Sonuç

Docker konteynerlerinde proxy ayarlamak, veri toplama, otomasyon ve dağıtık sistemlerle çalışan geliştiriciler için önemli bir beceridir. Ortam değişkenleri, Dockerfile ve docker-compose aracılığıyla proxy'yi nasıl ayarlayacağınızı, Python ve Node.js uygulama kodlarına proxy'yi nasıl entegre edeceğinizi ve bağlantı ve güvenlikle ilgili tipik sorunları nasıl çözeceğinizi öğrendiniz.

Docker'da proxy ile başarılı bir şekilde çalışmak için anahtar noktalar: esneklik için ortam değişkenlerini kullanın, kimlik bilgilerini secrets veya .env dosyaları aracılığıyla güvenli bir şekilde saklayın, görevinize bağlı olarak proxy türünü seçin ve üretime geçmeden önce gerçek IP sızıntısı olmadığını her zaman test edin.

Çoğu veri toplama ve otomasyon görevi için Docker konteynerlerinde ikametgah proxy'lerini kullanmanızı öneririz — bunlar korunan siteler ve API'lerle çalışırken yüksek anonimlik ve minimum engellenme riski sağlar. Eğer API test etme veya iç görevler için maksimum hız gerekiyorsa, veri merkezi proxy'lerine göz atın.