डॉकर कंटेनरों में प्रॉक्सी सेटअप: कोड उदाहरणों के साथ पूर्ण मार्गदर्शिका

Docker कंटेनर अक्सर प्रॉक्सी के माध्यम से बाहरी संसाधनों तक पहुँच की आवश्यकता होती है - डेटा खींचने, विभिन्न क्षेत्रों से परीक्षण करने या प्रतिबंधों को बायपास करने के लिए। प्रॉक्सी का गलत सेटअप कनेक्शन त्रुटियों, वास्तविक IP लीक और अनुप्रयोगों में विफलताओं का कारण बनता है। इस लेख में, हम Docker में प्रॉक्सी सेटअप के सभी तरीकों पर चर्चा करेंगे: सरल पर्यावरण चर से लेकर docker-compose और कस्टम नेटवर्क के साथ उन्नत परिदृश्यों तक।

Docker कंटेनरों में प्रॉक्सी की आवश्यकता क्यों है

Docker कंटेनर विभिन्न परिदृश्यों में उपयोग किए जाते हैं, जहाँ प्रॉक्सी की आवश्यकता होती है। आइए उन मुख्य कार्यों पर ध्यान दें, जिन्हें कंटेनराइज्ड अनुप्रयोगों में प्रॉक्सी हल करते हैं।

डेटा खींचना और संग्रहण: यदि आप मार्केटप्लेस (Wildberries, Ozon), सोशल मीडिया या सर्च इंजनों से डेटा खींचने के लिए Docker कंटेनरों में पार्सर चला रहे हैं, तो प्रॉक्सी IP द्वारा ब्लॉक होने से सुरक्षा प्रदान करते हैं। कंटेनर डेटा खींचने को स्केल करने की अनुमति देते हैं - एक साथ 10-50 उदाहरण चलाना, प्रत्येक के पास अपना प्रॉक्सी होता है।

विभिन्न क्षेत्रों से परीक्षण: जब आप वेब अनुप्रयोगों या मोबाइल API का विकास कर रहे होते हैं, तो अक्सर यह जांचना आवश्यक होता है कि सेवा विभिन्न देशों से कैसे काम करती है। विभिन्न भू-स्थानिक प्रॉक्सी के साथ Docker कंटेनर CI/CD पाइपलाइन में ऐसे परीक्षणों को स्वचालित करने की अनुमति देते हैं।

स्वचालन और बॉट्स: Selenium, Puppeteer या Playwright के साथ ब्राउज़र स्वचालन के लिए कंटेनर को कई खातों के साथ काम करने के लिए प्रॉक्सी की आवश्यकता होती है। प्रत्येक कंटेनर को अपना प्रॉक्सी और अलग वातावरण मिलता है।

कॉर्पोरेट प्रतिबंधों को बायपास करना: कुछ बुनियादी ढांचों में, Docker कंटेनरों को इंटरनेट तक पहुँच के लिए कॉर्पोरेट प्रॉक्सी के माध्यम से जाना चाहिए। सही सेटअप के बिना, कंटेनर पैकेज डाउनलोड नहीं कर सकेंगे या बाहरी API से संपर्क नहीं कर सकेंगे।

पर्यावरण चर के माध्यम से बुनियादी सेटअप

Docker कंटेनर में प्रॉक्सी सेटअप करने का सबसे सरल तरीका लॉन्च करते समय पर्यावरण चर को पास करना है। यह विधि अधिकांश अनुप्रयोगों के लिए काम करती है जो मानक HTTP_PROXY, HTTPS_PROXY और NO_PROXY चर का सम्मान करते हैं।

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

पैरामीटर का स्पष्टीकरण:

• HTTP_PROXY — HTTP अनुरोधों के लिए प्रॉक्सी
• HTTPS_PROXY — HTTPS अनुरोधों के लिए प्रॉक्सी (http:// का उपयोग करें, https:// नहीं)
• NO_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

Docker डेमन के लिए प्रॉक्सी सेटअप (सभी कंटेनरों पर प्रभाव डालता है):

यदि आप चाहते हैं कि सभी कंटेनर डिफ़ॉल्ट रूप से प्रॉक्सी का उपयोग करें, तो Docker डेमन को सेटअप करें। /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"

परिवर्तनों के बाद Docker को पुनः चालू करें:

sudo systemctl daemon-reload
sudo systemctl restart docker

Dockerfile में प्रॉक्सी सेटअप

जब आप एक Docker छवि बना रहे होते हैं, जिसे प्रॉक्सी के माध्यम से पैकेज डाउनलोड करने की आवश्यकता होती है (जैसे, apt-get, pip, npm), तो निर्माण चरण में प्रॉक्सी को सेटअप करना आवश्यक है। Docker इसके लिए निर्माण-समय तर्कों का समर्थन करता है।

प्रॉक्सी का समर्थन करने वाला Dockerfile उदाहरण:

FROM python:3.11-slim

# प्रॉक्सी के लिए तर्क (निर्माण के समय पास किए जाते हैं)
ARG HTTP_PROXY
ARG HTTPS_PROXY
ARG NO_PROXY

# निर्माण के लिए पर्यावरण चर सेट करना
ENV HTTP_PROXY=${HTTP_PROXY}
ENV HTTPS_PROXY=${HTTPS_PROXY}
ENV NO_PROXY=${NO_PROXY}

# प्रॉक्सी के माध्यम से निर्भरताएँ स्थापित करना
RUN apt-get update && apt-get install -y curl

# Python पैकेज स्थापित करना
COPY requirements.txt .
RUN pip install --proxy ${HTTP_PROXY} -r requirements.txt

# अनुप्रयोग की कॉपी
COPY . /app
WORKDIR /app

# रनटाइम के लिए प्रॉक्सी चर हटाना (वैकल्पिक)
ENV HTTP_PROXY=
ENV HTTPS_PROXY=

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

प्रॉक्सी पास करते हुए छवि का निर्माण:

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 अनुप्रयोगों के लिए (npm के माध्यम से प्रॉक्सी):

FROM node:18-alpine

ARG HTTP_PROXY
ARG HTTPS_PROXY

# प्रॉक्सी के माध्यम से काम करने के लिए npm सेटअप करना
RUN npm config set proxy ${HTTP_PROXY}
RUN npm config set https-proxy ${HTTPS_PROXY}

COPY package*.json ./
RUN npm install

# npm के लिए प्रॉक्सी सेटिंग्स साफ करना
RUN npm config delete proxy
RUN npm config delete https-proxy

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

docker-compose.yml में प्रॉक्सी कॉन्फ़िगरेशन

Docker Compose कई कंटेनर अनुप्रयोगों के लिए प्रॉक्सी प्रबंधन को सरल बनाता है। आप प्रॉक्सी को वैश्विक रूप से या व्यक्तिगत सेवाओं के लिए सेटअप कर सकते हैं।

एक सेवा के लिए प्रॉक्सी के साथ बुनियादी कॉन्फ़िगरेशन:

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
    # डेटाबेस प्रॉक्सी का उपयोग नहीं करता
    environment:
      - POSTGRES_PASSWORD=secret

क्रेडेंशियल्स को सुरक्षित रूप से स्टोर करने के लिए .env फ़ाइल का उपयोग करना:

.env नामक फ़ाइल को docker-compose.yml के निर्देशिका में बनाएं:

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

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

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"

प्रत्येक उदाहरण के लिए विभिन्न प्रॉक्सी के साथ स्केलिंग:

यदि आपको कई पार्सर्स चलाने की आवश्यकता है, प्रत्येक के पास अपना प्रॉक्सी है, तो अलग-अलग सेवाओं का उपयोग करें:

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

अनुप्रयोग स्तर पर प्रॉक्सी सेटअप

कुछ अनुप्रयोग मानक HTTP_PROXY पर्यावरण चर का समर्थन नहीं करते हैं। ऐसे मामलों में, प्रॉक्सी को अनुप्रयोग कोड या कॉन्फ़िगरेशन फ़ाइलों में सेटअप करना आवश्यक है।

Python (requests पुस्तकालय):

import os
import requests

# पर्यावरण चर से प्रॉक्सी प्राप्त करना
proxy_url = os.getenv('PROXY_URL', 'http://proxy.example.com:8080')

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

# अनुरोधों में प्रॉक्सी का उपयोग करना
response = requests.get('https://api.example.com/data', proxies=proxies)
print(response.json())

# SOCKS5 प्रॉक्सी के लिए pip install requests[socks] स्थापित करें
# proxies = {
#     'http': 'socks5://user:pass@proxy.example.com:1080',
#     'https': 'socks5://user:pass@proxy.example.com:1080'
# }

Python (aiohttp के लिए असिंक्रोनस अनुरोध):

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 पुस्तकालय):

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 (इनबिल्ट https मॉड्यूल):

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();

Docker कंटेनर में प्रॉक्सी के साथ Selenium:

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 के लिए प्रॉक्सी सेटअप करना
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument(f'--proxy-server={proxy_url}')

# प्रमाणीकरण के लिए एक्सटेंशन या SSH टनल का उपयोग करें
driver = webdriver.Chrome(options=chrome_options)
driver.get('https://example.com')
print(driver.title)
driver.quit()

प्रॉक्सी के साथ Puppeteer:

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();
  
  // प्रॉक्सी के लिए प्रमाणीकरण
  await page.authenticate({
    username: 'your-username',
    password: 'your-password'
  });
  
  await page.goto('https://example.com');
  console.log(await page.title());
  
  await browser.close();
})();

Docker के लिए कौन सा प्रॉक्सी प्रकार चुनें

प्रॉक्सी के प्रकार का चयन आपके अनुप्रयोग के Docker कंटेनर में हल किए जाने वाले कार्य पर निर्भर करता है। आइए मुख्य परिदृश्यों और सिफारिशों पर ध्यान दें।

विशिष्ट कार्यों के लिए चयन के लिए सिफारिशें:

मार्केटप्लेस और उत्पाद कैटलॉग का डेटा खींचना: यदि आप Docker कंटेनरों के माध्यम से Wildberries, Ozon या अन्य मार्केटप्लेस को खींचते हैं, तो रिज़िडेंट प्रॉक्सी का उपयोग करें। ये प्लेटफ़ॉर्म डेटा सेंटर IP को सक्रिय रूप से ब्लॉक करते हैं। विभिन्न उपयोगकर्ताओं का अनुकरण करने के लिए हर 5-10 मिनट में प्रॉक्सी का रोटेशन सेट करें।

API परीक्षण और विकास: अपने API या बाहरी सेवाओं के साथ एकीकरण का परीक्षण करने के लिए डेटा सेंटर प्रॉक्सी उपयुक्त हैं। वे उच्च गति और कनेक्शन की स्थिरता प्रदान करते हैं, जो CI/CD में स्वचालित परीक्षण के लिए महत्वपूर्ण है।

Selenium/Puppeteer स्वचालन: सुरक्षित साइटों (सोशल मीडिया, बैंक, जटिल वेब अनुप्रयोगों) के साथ काम करने के लिए कंटेनरों में ब्राउज़र स्वचालन चलाते समय रिज़िडेंट प्रॉक्सी चुनें। वे कैप्चा और ब्लॉकों की संभावना को कम करते हैं।

भौगोलिक रूप से वितरित परीक्षण: यदि आपको विभिन्न देशों से सेवा की उपलब्धता की जांच करने की आवश्यकता है, तो विशिष्ट भू-स्थान के साथ रिज़िडेंट प्रॉक्सी का उपयोग करें। कई Docker कंटेनरों को चलाएँ, प्रत्येक के पास अपने देश का प्रॉक्सी हो।

आम समस्याओं का समाधान

Docker कंटेनरों में प्रॉक्सी के साथ काम करते समय सामान्य समस्याएं उत्पन्न होती हैं। आइए सबसे सामान्य समस्याओं और उनके समाधान पर ध्यान दें।

समस्या 1: कंटेनर प्रॉक्सी से कनेक्ट नहीं कर सकता

लक्षण: "Connection refused", "Proxy connection failed" त्रुटियाँ, कंटेनर लॉन्च करते समय टाइमआउट।

समाधान:

• होस्ट से प्रॉक्सी की उपलब्धता की जाँच करें: curl -x http://proxy:port https://example.com
• सुनिश्चित करें कि प्रॉक्सी सर्वर Docker नेटवर्क से उपलब्ध है। यदि प्रॉक्सी होस्ट पर localhost है, तो host.docker.internal (Mac/Windows) या ब्रिज नेटवर्क में होस्ट का IP का उपयोग करें
• फायरवॉल नियमों की जाँच करें - Docker कंटेनरों को आउटगोइंग कनेक्शनों के लिए अवरुद्ध किया जा सकता है
• प्रॉक्सी के साथ प्रमाणीकरण के लिए, username और password की सहीता की जाँच करें, URL में विशेष वर्णों को एस्केप करें

होस्ट पर प्रॉक्सी तक पहुँच का उदाहरण:

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

# Linux (ब्रिज नेटवर्क में होस्ट का IP जानें)
ip addr show docker0  # आमतौर पर 172.17.0.1
docker run -e HTTP_PROXY=http://172.17.0.1:8080 my-image

समस्या 2: DNS प्रॉक्सी के माध्यम से रिज़ॉल्व नहीं हो रहा है

लक्षण: "Could not resolve host" त्रुटियाँ, DNS अनुरोध प्रॉक्सी के माध्यम से नहीं गुजरते।

समाधान:

• HTTP के बजाय SOCKS5 प्रॉक्सी का उपयोग करें - SOCKS5 DNS अनुरोधों को प्रॉक्सी करता है
• Docker में DNS सेट करें: कंटेनर लॉन्च करते समय --dns 8.8.8.8 जोड़ें
• ऐसे अनुप्रयोगों के लिए जो प्रॉक्सी के माध्यम से DNS का समर्थन नहीं करते, कंटेनर के अंदर proxychains का उपयोग करें

# Dockerfile के साथ proxychains
FROM python:3.11-slim

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

# proxychains का कॉन्फ़िगरेशन
RUN echo "strict_chain\nproxy_dns\n[ProxyList]\nsocks5 proxy.example.com 1080" > /etc/proxychains4.conf

# proxychains के माध्यम से अनुप्रयोग चलाना
CMD ["proxychains4", "python", "app.py"]

समस्या 3: कंटेनर का वास्तविक IP लीक हो रहा है

लक्षण: लक्षित सेवा होस्ट या कंटेनर का IP देखती है, प्रॉक्सी का IP नहीं।

समाधान:

• जाँच करें कि अनुप्रयोग वास्तव में प्रॉक्सी का उपयोग कर रहा है - https://api.ipify.org पर अनुरोध करें
• सुनिश्चित करें कि कोड में सभी HTTP क्लाइंट प्रॉक्सी का उपयोग करने के लिए सेट हैं
• WebRTC और WebSocket कनेक्शनों के लिए प्रॉक्सी काम नहीं कर सकता - ब्राउज़रों में WebRTC बंद करें
• अनुरोधों के हेडर की जाँच करें - कुछ पुस्तकालय वास्तविक IP के साथ X-Forwarded-For जोड़ते हैं

कंटेनर में IP लीक परीक्षण:

# बिना प्रॉक्सी
docker run --rm curlimages/curl:latest curl https://api.ipify.org

# प्रॉक्सी के साथ
docker run --rm \
  -e HTTPS_PROXY=http://proxy.example.com:8080 \
  curlimages/curl:latest curl https://api.ipify.org

समस्या 4: प्रॉक्सी के माध्यम से धीमी गति से काम करना

लक्षण: उच्च विलंबता, टाइमआउट, डेटा लोड करने में धीमी गति।

समाधान:

• होस्ट से सीधे प्रॉक्सी की गति की जाँच करें - समस्या स्वयं प्रॉक्सी में हो सकती है
• धीमी प्रॉक्सी के साथ काम करने के लिए अनुप्रयोग में टाइमआउट बढ़ाएँ
• TCP कनेक्शनों के पुन: उपयोग के लिए keep-alive कनेक्शन का उपयोग करें
• रिज़िडेंट प्रॉक्सी के लिए धीमी गति सामान्य है - अनुरोधों की संख्या को अनुकूलित करें
• समानांतर अनुरोधों के लिए HTTP क्लाइंट में कनेक्शन पूल सेट करें

समस्या 5: प्रॉक्सी HTTP के लिए काम करता है, लेकिन HTTPS के लिए नहीं

लक्षण: HTTP अनुरोध पास होते हैं, HTTPS SSL/TLS त्रुटियाँ लौटाते हैं।

समाधान:

• सुनिश्चित करें कि HTTPS_PROXY चर सेट है (केवल HTTP_PROXY नहीं)
• HTTPS_PROXY के लिए प्रॉक्सी URL में http:// का उपयोग करें, https:// नहीं
• जाँच करें कि प्रॉक्सी HTTPS टनलिंग के लिए CONNECT विधि का समर्थन करता है
• स्व-हस्ताक्षरित प्रमाणपत्रों वाले प्रॉक्सी के लिए SSL सत्यापन बंद करें (केवल परीक्षण के लिए!)

सुरक्षा और क्रेडेंशियल्स का प्रबंधन

Docker कंटेनरों में प्रॉक्सी क्रेडेंशियल्स को स्टोर करना सुरक्षा के लिए विशेष ध्यान देने की आवश्यकता है। पासवर्ड का गलत प्रबंधन लॉग, छवियों या रिपॉजिटरी में लीक का कारण बन सकता है।

उत्पादन के लिए Docker Secrets का उपयोग करें:

Docker Swarm पासवर्ड को सुरक्षित रूप से स्टोर करने के लिए secrets तंत्र का समर्थन करता है। एक सीक्रेट बनाएं:

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

Swarm के लिए docker-compose में उपयोग करें:

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

फाइलों के माध्यम से पर्यावरण चर (.env):

विकास के लिए .env फ़ाइलों का उपयोग करें, लेकिन इन्हें Git में कभी भी कमिट न करें। .gitignore में जोड़ें:

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

वास्तविक क्रेडेंशियल्स के बिना .env.example बनाएं:

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

छवियों में क्रेडेंशियल्स को हार्डकोड करने से बचें:

# ❌ बुरा - पासवर्ड छवि में रहेगा
FROM python:3.11
ENV HTTP_PROXY=http://user:secretpass@proxy.com:8080
COPY . /app

# ✅ अच्छा - निर्माण के तर्कों के माध्यम से या रनटाइम चर के रूप में पास करें
FROM python:3.11
ARG HTTP_PROXY
# केवल निर्माण के दौरान उपयोग किया जाता है, अंतिम छवि में सहेजा नहीं जाता

क्रेडेंशियल्स को साफ करने के लिए मल्टी-स्टेज बिल्ड का उपयोग करें:

# प्रॉक्सी के साथ निर्माण चरण
FROM python:3.11 AS builder
ARG HTTP_PROXY
ENV HTTP_PROXY=${HTTP_PROXY}
COPY requirements.txt .
RUN pip install -r requirements.txt

# प्रॉक्सी चर के बिना अंतिम चरण
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"]

प्रॉक्सी क्रेडेंशियल्स का रोटेशन:

यदि आपका प्रॉक्सी प्रदाता अस्थायी क्रेडेंशियल्स उत्पन्न करने के लिए API का समर्थन करता है, तो स्थिर पासवर्ड के बजाय उनका उपयोग करें। कंटेनर में एक init-script बनाएं:

#!/bin/bash
# entrypoint.sh

# API से अस्थायी क्रेडेंशियल्स प्राप्त करना
PROXY_CREDS=$(curl -s https://api.proxyservice.com/generate-temp-auth)
export HTTP_PROXY="http://${PROXY_CREDS}@proxy.example.com:8080"

# अनुप्रयोग चलाना
exec python app.py

पासवर्ड लीक के बिना लॉगिंग:

सुनिश्चित करें कि प्रॉक्सी के साथ चर लॉगिंग में नहीं आते हैं:

import os
import re

def safe_log_env():
    """पासवर्ड के बिना पर्यावरण चर लॉगिंग"""
    for key, value in os.environ.items():
        if 'PROXY' in key:
            # URL में पासवर्ड को छुपाना
            safe_value = re.sub(r'://([^:]+):([^@]+)@', r'://\1:****@', value)
            print(f"{key}={safe_value}")
        else:
            print(f"{key}={value}")

safe_log_env()

निष्कर्ष

Docker कंटेनरों में प्रॉक्सी सेटअप करना एक महत्वपूर्ण कौशल है उन डेवलपर्स के लिए जो डेटा खींचने, स्वचालन और वितरित प्रणालियों के साथ काम करते हैं। आपने सीखा कि प्रॉक्सी को पर्यावरण चर, Dockerfile और docker-compose के माध्यम से कैसे सेटअप करें, Python और Node.js में अनुप्रयोगों के कोड में प्रॉक्सी को कैसे एकीकृत करें, और कनेक्शन और सुरक्षा से संबंधित सामान्य समस्याओं को कैसे हल करें।

Docker में प्रॉक्सी के साथ सफलतापूर्वक काम करने के लिए प्रमुख बिंदु: लचीलापन के लिए पर्यावरण चर का उपयोग करें, क्रेडेंशियल्स को secrets या .env फ़ाइलों के माध्यम से सुरक्षित रूप से स्टोर करें, कार्य के आधार पर प्रॉक्सी का प्रकार चुनें, और उत्पादन में लॉन्च करने से पहले वास्तविक IP के लीक की अनुपस्थिति का परीक्षण करें।

डेटा खींचने और स्वचालन के लिए अधिकांश कार्यों के लिए Docker कंटेनरों में रिज़िडेंट प्रॉक्सी का उपयोग करने की सिफारिश की जाती है - वे सुरक्षित साइटों और API के साथ काम करते समय उच्च गुमनामी और न्यूनतम ब्लॉकिंग जोखिम प्रदान करते हैं। यदि आपको API परीक्षण या आंतरिक कार्यों के लिए अधिकतम गति की आवश्यकता है, तो डेटा सेंटर प्रॉक्सी पर ध्यान दें।