Proxy-Einrichtung in Docker-Containern: Vollständiger Leitfaden mit Codebeispielen

Docker-Container benötigen häufig Zugriff auf externe Ressourcen über Proxys – zum Parsen, Testen aus verschiedenen Regionen oder zum Umgehen von Einschränkungen. Eine falsche Proxy-Konfiguration führt zu Verbindungsfehlern, Leaks der echten IP-Adresse und Ausfällen von Anwendungen. In diesem Artikel werden wir alle Möglichkeiten zur Konfiguration von Proxys in Docker untersuchen: von einfachen Umgebungsvariablen bis hin zu fortgeschrittenen Szenarien mit docker-compose und benutzerdefinierten Netzwerken.

Warum Proxys in Docker-Containern benötigt werden

Docker-Container werden in verschiedenen Szenarien eingesetzt, in denen Proxys notwendig werden. Lassen Sie uns die Hauptaufgaben betrachten, die Proxys in containerisierten Anwendungen lösen.

Datenparsen und -sammlung: Wenn Sie Parser in Docker-Containern ausführen, um Daten von Marktplätzen (Wildberries, Ozon), sozialen Netzwerken oder Suchmaschinen zu sammeln, schützen Proxys vor IP-Sperren. Container ermöglichen das Skalieren des Parsens – starten Sie 10-50 Instanzen gleichzeitig, jede mit ihrem eigenen Proxy.

Testen aus verschiedenen Regionen: Bei der Entwicklung von Webanwendungen oder mobilen APIs muss häufig überprüft werden, wie der Dienst aus verschiedenen Ländern funktioniert. Docker-Container mit Proxys aus verschiedenen Geolokationen ermöglichen die Automatisierung solcher Tests im CI/CD-Pipeline.

Automatisierung und Bots: Container mit Selenium, Puppeteer oder Playwright zur Automatisierung von Browsern benötigen Proxys, um mit mehreren Konten zu arbeiten. Jeder Container erhält seinen eigenen Proxy und eine isolierte Umgebung.

Umgehung von Unternehmensbeschränkungen: In einigen Infrastrukturen müssen Docker-Container über einen Unternehmensproxy auf das Internet zugreifen. Ohne die richtige Konfiguration können Container keine Pakete herunterladen oder auf externe APIs zugreifen.

Grundlegende Konfiguration über Umgebungsvariablen

Der einfachste Weg, einen Proxy in einem Docker-Container zu konfigurieren, besteht darin, Umgebungsvariablen beim Start zu übergeben. Diese Methode funktioniert für die meisten Anwendungen, die die Standardvariablen HTTP_PROXY, HTTPS_PROXY und NO_PROXY respektieren.

Starten des Containers mit Proxy über 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

Erklärung der Parameter:

• HTTP_PROXY — Proxy für HTTP-Anfragen
• HTTPS_PROXY — Proxy für HTTPS-Anfragen (verwenden Sie http://, nicht https://)
• NO_PROXY — Liste von Adressen, die nicht über den Proxy geleitet werden sollen

Beispiel mit SOCKS5-Proxy:

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

Proxy-Konfiguration für den Docker-Daemon (wirkt sich auf alle Container aus):

Wenn Sie möchten, dass alle Container standardmäßig den Proxy verwenden, konfigurieren Sie den Docker-Daemon. Erstellen Sie die Datei /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"

Nach den Änderungen starten Sie Docker neu:

sudo systemctl daemon-reload
sudo systemctl restart docker

Proxy-Konfiguration in Dockerfile

Wenn Sie ein Docker-Image erstellen, das Pakete über einen Proxy herunterladen muss (z. B. apt-get, pip, npm), müssen Sie den Proxy während des Build-Vorgangs konfigurieren. Docker unterstützt dafür Build-Time-Argumente.

Beispiel Dockerfile mit Proxy-Unterstützung:

FROM python:3.11-slim

# Argumente für den Proxy (werden beim Build übergeben)
ARG HTTP_PROXY
ARG HTTPS_PROXY
ARG NO_PROXY

# Setzen von Umgebungsvariablen für den Build
ENV HTTP_PROXY=${HTTP_PROXY}
ENV HTTPS_PROXY=${HTTPS_PROXY}
ENV NO_PROXY=${NO_PROXY}

# Installation von Abhängigkeiten über den Proxy
RUN apt-get update && apt-get install -y curl

# Installation von Python-Paketen
COPY requirements.txt .
RUN pip install --proxy ${HTTP_PROXY} -r requirements.txt

# Kopieren der Anwendung
COPY . /app
WORKDIR /app

# Entfernen der Proxy-Variablen für die Laufzeit (optional)
ENV HTTP_PROXY=
ENV HTTPS_PROXY=

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

Build des Images mit Übergabe des Proxys:

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 .

Für Node.js-Anwendungen (npm über Proxy):

FROM node:18-alpine

ARG HTTP_PROXY
ARG HTTPS_PROXY

# Konfiguration von npm für den Betrieb über Proxy
RUN npm config set proxy ${HTTP_PROXY}
RUN npm config set https-proxy ${HTTPS_PROXY}

COPY package*.json ./
RUN npm install

# Bereinigung der Proxy-Einstellungen für npm
RUN npm config delete proxy
RUN npm config delete https-proxy

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

Proxy-Konfiguration in docker-compose.yml

Docker Compose vereinfacht die Verwaltung von Proxys für Multi-Container-Anwendungen. Sie können Proxys global oder für einzelne Dienste konfigurieren.

Grundlegende Konfiguration mit Proxy für einen Dienst:

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
    # Die Datenbank verwendet keinen Proxy
    environment:
      - POSTGRES_PASSWORD=secret

Verwendung einer .env-Datei zur sicheren Speicherung von Anmeldeinformationen:

Erstellen Sie eine Datei .env im Verzeichnis mit docker-compose.yml:

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

Verweisen Sie in docker-compose.yml auf die Variablen:

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

Proxy-Konfiguration für den Build des Images in 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"

Skalierung mit verschiedenen Proxys für jede Instanz:

Wenn Sie mehrere Parser starten müssen, jeder mit seinem eigenen Proxy, verwenden Sie separate Dienste:

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

Proxy-Konfiguration auf Anwendungsebene

Einige Anwendungen unterstützen die Standard-Umgebungsvariablen HTTP_PROXY nicht. In solchen Fällen müssen Sie den Proxy im Anwendungscode oder in Konfigurationsdateien einrichten.

Python (requests-Bibliothek):

import os
import requests

# Proxy aus der Umgebungsvariable abrufen
proxy_url = os.getenv('PROXY_URL', 'http://proxy.example.com:8080')

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

# Verwendung des Proxys in Anfragen
response = requests.get('https://api.example.com/data', proxies=proxies)
print(response.json())

# Für SOCKS5-Proxys installieren Sie pip install requests[socks]
# proxies = {
#     'http': 'socks5://user:pass@proxy.example.com:1080',
#     'https': 'socks5://user:pass@proxy.example.com:1080'
# }

Python (aiohttp für asynchrone Anfragen):

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-Bibliothek):

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 (eingebautes https-Modul):

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 mit Proxy im Docker-Container:

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

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

# Proxy für Chrome konfigurieren
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument(f'--proxy-server={proxy_url}')

# Für die Authentifizierung verwenden Sie eine Erweiterung oder ein SSH-Tunnel
driver = webdriver.Chrome(options=chrome_options)
driver.get('https://example.com')
print(driver.title)
driver.quit()

Puppeteer mit 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();
  
  // Authentifizierung für den Proxy
  await page.authenticate({
    username: 'your-username',
    password: 'your-password'
  });
  
  await page.goto('https://example.com');
  console.log(await page.title());
  
  await browser.close();
})();

Welchen Proxy-Typ für Docker wählen

Die Wahl des Proxy-Typs hängt von der Aufgabe ab, die Ihre Anwendung im Docker-Container lösen soll. Lassen Sie uns die Hauptszenarien und Empfehlungen betrachten.

Empfehlungen zur Auswahl für spezifische Aufgaben:

Parsing von Marktplätzen und Produktkatalogen: Wenn Sie Wildberries, Ozon oder andere Marktplätze über Docker-Container parsen, verwenden Sie residential Proxys. Diese Plattformen blockieren aktiv IPs aus Rechenzentren. Richten Sie eine Proxy-Rotation alle 5-10 Minuten ein, um verschiedene Benutzer zu simulieren.

API-Tests und -Entwicklung: Für Tests eigener APIs oder Integrationen mit externen Diensten eignen sich Datacenter-Proxys. Sie bieten hohe Geschwindigkeit und Stabilität der Verbindung, was für automatisierte Tests in CI/CD wichtig ist.

Selenium/Puppeteer-Automatisierung: Bei der Ausführung von browserbasierter Automatisierung in Containern für den Zugriff auf geschützte Websites (soziale Netzwerke, Banken, komplexe Webanwendungen) wählen Sie residential Proxys. Sie verringern die Wahrscheinlichkeit von Captchas und Blockierungen.

Geodistribuierte Tests: Wenn Sie die Verfügbarkeit eines Dienstes aus verschiedenen Ländern überprüfen müssen, verwenden Sie residential Proxys mit Auswahl einer bestimmten Geolokation. Starten Sie mehrere Docker-Container, jeder mit einem Proxy aus seinem Land.

Lösung häufiger Probleme

Bei der Arbeit mit Proxys in Docker-Containern treten typische Probleme auf. Lassen Sie uns die häufigsten und deren Lösungen betrachten.

Problem 1: Container kann sich nicht mit dem Proxy verbinden

Symptome: Fehler "Connection refused", "Proxy connection failed", Timeouts beim Starten des Containers.

Lösungen:

• Überprüfen Sie die Erreichbarkeit des Proxys vom Host aus: curl -x http://proxy:port https://example.com
• Stellen Sie sicher, dass der Proxy-Server aus dem Docker-Netzwerk erreichbar ist. Wenn der Proxy auf localhost des Hosts läuft, verwenden Sie host.docker.internal (Mac/Windows) oder die IP des Hosts im Bridge-Netzwerk
• Überprüfen Sie die Firewall-Regeln – Docker-Container können für ausgehende Verbindungen blockiert sein
• Für Proxys mit Authentifizierung überprüfen Sie die Richtigkeit von Benutzername und Passwort, escapen Sie Sonderzeichen in der URL

Beispiel für den Zugriff auf den Proxy auf dem Host:

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

# Linux (erfahren Sie die IP des Hosts im Bridge-Netzwerk)
ip addr show docker0  # Normalerweise 172.17.0.1
docker run -e HTTP_PROXY=http://172.17.0.1:8080 my-image

Problem 2: DNS wird über den Proxy nicht aufgelöst

Symptome: Fehler "Could not resolve host", DNS-Anfragen werden nicht über den Proxy geleitet.

Lösungen:

• Verwenden Sie SOCKS5-Proxys anstelle von HTTP – SOCKS5 leitet DNS-Anfragen weiter
• Konfigurieren Sie DNS in Docker: Fügen Sie --dns 8.8.8.8 beim Starten des Containers hinzu
• Für Anwendungen, die DNS über den Proxy nicht unterstützen, verwenden Sie proxychains innerhalb des Containers

# Dockerfile mit proxychains
FROM python:3.11-slim

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

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

# Anwendung über proxychains starten
CMD ["proxychains4", "python", "app.py"]

Problem 3: Leck der echten IP-Adresse des Containers

Symptome: Der Zielservice sieht die IP des Hosts oder des Containers anstelle der IP des Proxys.

Lösungen:

• Überprüfen Sie, ob die Anwendung tatsächlich den Proxy verwendet – machen Sie eine Anfrage an https://api.ipify.org
• Stellen Sie sicher, dass alle HTTP-Clients im Code so konfiguriert sind, dass sie den Proxy verwenden
• Für WebRTC- und WebSocket-Verbindungen funktioniert der Proxy möglicherweise nicht – deaktivieren Sie WebRTC in den Browsern
• Überprüfen Sie die Header der Anfragen – einige Bibliotheken fügen X-Forwarded-For mit der echten IP hinzu

Test auf IP-Leck im Container:

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

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

Problem 4: Langsame Leistung über den Proxy

Symptome: Hohe Latenzen, Timeouts, langsame Datenübertragung.

Lösungen:

• Überprüfen Sie die Geschwindigkeit des Proxys direkt vom Host aus – möglicherweise liegt das Problem am Proxy selbst
• Erhöhen Sie die Timeouts in der Anwendung für die Arbeit mit langsamen Proxys
• Verwenden Sie Keep-Alive-Verbindungen zur Wiederverwendung von TCP-Verbindungen
• Für residential Proxys ist eine langsame Geschwindigkeit normal, optimieren Sie die Anzahl der Anfragen
• Konfigurieren Sie einen Verbindungs-Pool in HTTP-Clients für parallele Anfragen

Problem 5: Proxy funktioniert für HTTP, aber nicht für HTTPS

Symptome: HTTP-Anfragen funktionieren, HTTPS geben SSL/TLS-Fehler zurück.

Lösungen:

• Stellen Sie sicher, dass die Variable HTTPS_PROXY gesetzt ist (nicht nur HTTP_PROXY)
• Verwenden Sie http:// in der Proxy-URL für HTTPS_PROXY, nicht https://
• Überprüfen Sie, ob der Proxy die CONNECT-Methode für HTTPS-Tunneling unterstützt
• Für Proxys mit selbstsignierten Zertifikaten deaktivieren Sie die SSL-Überprüfung (nur für Tests!)

Sicherheit und Verwaltung von Anmeldeinformationen

Die Speicherung von Anmeldeinformationen für Proxys in Docker-Containern erfordert besondere Aufmerksamkeit für die Sicherheit. Eine falsche Verwaltung von Passwörtern kann zu deren Leckage in Logs, Images oder Repositories führen.

Verwenden Sie Docker Secrets für die Produktion:

Docker Swarm unterstützt einen Mechanismus für Secrets zur sicheren Speicherung von Passwörtern. Erstellen Sie ein Secret:

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

Verwenden Sie es in docker-compose für 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

Umgebungsvariablen über Dateien (.env):

Verwenden Sie für die Entwicklung .env-Dateien, aber KOMMEN SIE NIEMALS IN GIT. Fügen Sie sie zu .gitignore hinzu:

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

Erstellen Sie .env.example ohne echte Anmeldeinformationen:

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

Vermeiden Sie Hardcoding von Anmeldeinformationen in Images:

# ❌ SCHLECHT - Passwort bleibt im Image
FROM python:3.11
ENV HTTP_PROXY=http://user:secretpass@proxy.com:8080
COPY . /app

# ✅ GUT - über Build-Argumente oder Runtime-Variablen übergeben
FROM python:3.11
ARG HTTP_PROXY
# Wird nur während des Builds verwendet, nicht im finalen Image gespeichert

Verwenden Sie Multi-Stage-Builds zur Bereinigung von Anmeldeinformationen:

# Build-Phase mit Proxy
FROM python:3.11 AS builder
ARG HTTP_PROXY
ENV HTTP_PROXY=${HTTP_PROXY}
COPY requirements.txt .
RUN pip install -r requirements.txt

# Endphase ohne Proxy-Variablen
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"]

Rotation von Proxy-Anmeldeinformationen:

Wenn Ihr Proxy-Anbieter eine API zur Generierung temporärer Anmeldeinformationen unterstützt, verwenden Sie diese anstelle von statischen Passwörtern. Erstellen Sie ein Init-Skript im Container:

#!/bin/bash
# entrypoint.sh

# Abrufen temporärer Anmeldeinformationen von der API
PROXY_CREDS=$(curl -s https://api.proxyservice.com/generate-temp-auth)
export HTTP_PROXY="http://${PROXY_CREDS}@proxy.example.com:8080"

# Anwendung starten
exec python app.py

Protokollierung ohne Leckage von Passwörtern:

Konfigurieren Sie die Protokollierung so, dass Variablen mit Proxys nicht in die Ausgabe gelangen:

import os
import re

def safe_log_env():
    """Protokollierung von Umgebungsvariablen ohne Passwörter"""
    for key, value in os.environ.items():
        if 'PROXY' in key:
            # Passwort in der URL maskieren
            safe_value = re.sub(r'://([^:]+):([^@]+)@', r'://\1:****@', value)
            print(f"{key}={safe_value}")
        else:
            print(f"{key}={value}")

safe_log_env()

Fazit

Die Konfiguration von Proxys in Docker-Containern ist eine wichtige Fähigkeit für Entwickler, die mit Parsing, Automatisierung und verteilten Systemen arbeiten. Sie haben gelernt, wie man Proxys über Umgebungsvariablen, Dockerfile und docker-compose konfiguriert, wie man Proxys in den Anwendungscode in Python und Node.js integriert und wie man typische Probleme mit Verbindungen und Sicherheit löst.

Wichtige Punkte für eine erfolgreiche Arbeit mit Proxys in Docker: Verwenden Sie Umgebungsvariablen für Flexibilität, speichern Sie Anmeldeinformationen sicher über Secrets oder .env-Dateien, wählen Sie den Proxy-Typ je nach Aufgabe und testen Sie immer auf das Fehlen von Lecks der echten IP, bevor Sie in die Produktion gehen.

Für die meisten Aufgaben im Parsing und in der Automatisierung in Docker-Containern empfehlen wir die Verwendung von residential Proxys – sie bieten hohe Anonymität und minimales Risiko von Blockierungen beim Zugriff auf geschützte Websites und APIs. Wenn Sie jedoch maximale Geschwindigkeit für API-Tests oder interne Aufgaben benötigen, achten Sie auf Datacenter-Proxys.