Docker पोर्ट को कैसे एक्सपोज़ करें

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

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

इस लेख के अंत तक, आपको Docker नेटवर्किंग कैसे काम करती है, पोर्ट्स को एक्सपोज़ करने के विभिन्न तरीके, और इन अवधारणाओं को अपने प्रोजेक्ट्स में लागू करने की व्यावहारिक तकनीकों की स्पष्ट समझ होगी।

यदि आप Docker में नए हैं, तो हमारे पाठ्यक्रम जैसे Introduction to Docker, Containerization and Virtualization with Docker and Kubernetes, Intermediate Docker, या Containerization and Virtualization Concepts लेने पर विचार करें।

Docker में पोर्ट एक्सपोज़ करना क्या होता है?

तकनीकी विवरण में जाने से पहले, यह समझना महत्वपूर्ण है कि Docker इकोसिस्टम में पोर्ट एक्सपोज़र का क्या मतलब है।

कंटेनर नेटवर्क आइसोलेशन के सिद्धांत

Docker कंटेनर आइसोलेशन को एक मुख्य सिद्धांत के रूप में डिज़ाइन किए गए हैं। यह आइसोलेशन Linux kernel की विशेषताओं जैसे namespaces और cgroups के माध्यम से प्राप्त होता है। Namespaces प्रक्रिया-स्तरीय आइसोलेशन प्रदान करते हैं, यह सुनिश्चित करते हुए कि किसी कंटेनर के अंदर की प्रक्रियाएँ अन्य कंटेनरों या होस्ट सिस्टम की प्रक्रियाएँ न देख सकें और न उनसे इंटरैक्ट कर सकें। दूसरी ओर, cgroups संसाधन आवंटन को नियंत्रित करते हैं, यह सीमित करते हुए कि कोई कंटेनर कितना CPU, मेमोरी और अन्य संसाधन उपयोग कर सकता है।

नेटवर्किंग परिप्रेक्ष्य से, प्रत्येक कंटेनर को अपना स्वयं का नेटवर्क namespace मिलता है, जिसमें एक वर्चुअल ईथरनेट इंटरफ़ेस (veth pair) शामिल होता है। यह इंटरफ़ेस डिफ़ॉल्ट रूप से Docker ब्रिज नेटवर्क से जुड़ता है, जो कंटेनरों के बीच संचार की अनुमति देता है जबकि होस्ट नेटवर्क से आइसोलेशन बनाए रखता है। इसे ऐसे समझें जैसे प्रत्येक कंटेनर के पास अपना निजी नेटवर्क पता होता है, जो बाहरी दुनिया के लिए अदृश्य है।

डिफ़ॉल्ट कॉन्फ़िगरेशन में, एक Docker कंटेनर पूर्णतः सैंडबॉक्स्ड होता है। अंदर चल रही सेवाएँ एक-दूसरे से बात कर सकती हैं, पर वे कंटेनर के बाहर से—यहाँ तक कि होस्ट मशीन से भी—पहुंच योग्य नहीं होतीं। यहीं पोर्ट एक्सपोज़र की आवश्यकता पड़ती है।

Expose बनाम Publish: अर्थगत अंतर

Docker पोर्ट कॉन्फ़िगरेशन के साथ काम करते समय, आपको दो संबंधित परंतु अलग अवधारणाएँ मिलेंगी: पोर्ट्स को एक्सपोज़ करना और पब्लिश करना।

पोर्ट्स को एक्सपोज़ करना मुख्यतः एक दस्तावेज़ीकरण सुविधा है। जब आप Docker में कोई पोर्ट एक्सपोज़ करते हैं, तो आप मूल रूप से अपने कंटेनर इमेज में मेटाडेटा जोड़ रहे होते हैं, जो दर्शाता है कि कंटेनराइज़्ड एप्लिकेशन किन पोर्ट्स पर सुनता है। 

हालाँकि, कोई पोर्ट एक्सपोज़ करने से वह वास्तव में कंटेनर के बाहर से सुलभ नहीं हो जाता। यह आपकी इमेज के उपयोगकर्ताओं के लिए दस्तावेज़ के रूप में काम करता है।

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

कब कौन-सा तरीका अपनाएँ:

• जब आप ऐसी इमेज बना रहे हों जिन्हें अन्य Docker उपयोगकर्ता इस्तेमाल करेंगे, और आप बताना चाहते हों कि आपका एप्लिकेशन किन पोर्ट्स का उपयोग करता है, तो expose का उपयोग करें।
• जब आपको बाहरी सिस्टम्स (होस्ट सहित) को कंटेनर के अंदर चल रही सेवाओं तक पहुँच दिलानी हो, तब publish का उपयोग करें।
• उत्पादन वातावरण में विशेष रूप से, पूर्ण दस्तावेज़ीकरण और कार्यक्षमता के लिए दोनों का साथ में उपयोग करें।

Docker पोर्ट्स को कैसे एक्सपोज़ करें

अब जब हम अवधारणाएँ समझ चुके हैं, तो अलग-अलग संदर्भों में Docker पोर्ट्स को एक्सपोज़ करने के व्यावहारिक पहलुओं पर नज़र डालते हैं।

Dockerfile डिक्लेरेशन रणनीतियाँ

पोर्ट को एक्सपोज़ करने का सबसे बुनियादी तरीका है अपने Dockerfile में EXPOSE निर्देश का उपयोग करना। यह घोषित करता है कि कंटेनर किन पोर्ट्स का उपयोग करेगा।

FROM my-image:latest
EXPOSE 80
EXPOSE 443

इस उदाहरण में, मैंने निर्दिष्ट किया है कि कंटेनर 80 और 443 पोर्ट्स का उपयोग करेगा, जो HTTP (Hypertext Transfer Protocol) और HTTPS (Hypertext Transfer Protocol Secure) ट्रैफ़िक के लिए मानक हैं। आप इन्हें एक ही निर्देश में भी जोड़ सकते हैं:

EXPOSE 80 443

पोर्ट्स निर्दिष्ट करते समय, यदि आपका एप्लिकेशन किसी विशिष्ट प्रोटोकॉल का उपयोग करता है, तो TCP (Transmission Control Protocol) या UDP (User Datagram Protocol) शामिल करना अच्छा अभ्यास है:

EXPOSE 53/udp
EXPOSE 80/tcp

यदि कोई प्रोटोकॉल निर्दिष्ट नहीं किया गया, तो डिफ़ॉल्ट रूप से TCP माना जाता है। यह अधिकांश वेब एप्लिकेशनों के लिए उपयुक्त है, लेकिन DNS (Domain Name System) या गेमिंग सर्वर जैसी सेवाओं में अक्सर UDP की आवश्यकता होती है।

सुरक्षा परिप्रेक्ष्य से, मैं केवल उन्हीं पोर्ट्स को एक्सपोज़ करने की अनुशंसा करता हूँ जिनकी आपके एप्लिकेशन को वास्तव में आवश्यकता है। प्रत्येक एक्सपोज़्ड पोर्ट एक संभावित अटैक वेक्टर का प्रतिनिधित्व करता है, इसलिए एक्सपोज़्ड पोर्ट्स की संख्या को न्यूनतम रखना न्यूनतम विशेषाधिकार (principle of least privilege) के सिद्धांत का पालन करता है।

रनटाइम पोर्ट प्रबंधन

जहाँ EXPOSE निर्देश यह दस्तावेज़ करता है कि कोई कंटेनर किन पोर्ट्स का उपयोग करता है, वहीं इन पोर्ट्स को होस्ट या अन्य मशीनों से सुलभ बनाने के लिए आपको कंटेनर चलाते समय उन्हें पब्लिश करना पड़ता है।

यहाँ बताया गया है कि किसी कंटेनर पोर्ट को किसी विशिष्ट होस्ट पोर्ट से स्पष्ट रूप से कैसे बाँधें:

docker run -p 8081:80 my-image

-p (या --publish) फ़्लैग आपको कंटेनर में एकल पोर्ट या पोर्ट्स की रेंज को होस्ट से बाँधने देता है।

यह कमांड कंटेनर के अंदर पोर्ट 80 को होस्ट पर पोर्ट 8081 से मैप करता है। इस कमांड के बाद, आप अपने ब्राउज़र में http://localhost:8081 पर जाकर वेब सर्वर तक पहुँच सकते हैं।

डेवलपमेंट के दौरान सुविधा के लिए, Docker -P (कैपिटल P) या --publish-all फ़्लैग देता है, जो सभी एक्सपोज़्ड पोर्ट्स को स्वचालित रूप से होस्ट पर रैंडम उच्च-नंबर वाले पोर्ट्स पर पब्लिश कर देता है:

docker run -P my-image

कौन से होस्ट पोर्ट असाइन हुए हैं, यह जानने के लिए मैं docker ps कमांड का इस्तेमाल कर सकता हूँ:

docker ps

यह कुछ इस तरह का आउटपुट दिखाएगा:

CONTAINER ID   IMAGE  COMMAND    CREATED  STATUS  PORTS                                  NAMES
a7c53d9413bf   image  "/docker-.…"  10 s ago   Up 9 s    0.0.0.0:49153->80/tcp, :::49153->80/tcp   wizardl

यहाँ, कंटेनर के अंदर पोर्ट 80 होस्ट पर पोर्ट 49153 से मैप है।

ऐसी सेवाओं के साथ काम करते समय जो एक ही पोर्ट पर TCP और UDP दोनों का उपयोग करती हैं (जैसे DNS सर्वर), आपको पब्लिश करते समय प्रोटोकॉल निर्दिष्ट करना होगा:

docker run -p 53:53/tcp -p 53:53/udp dns-server

Docker Compose ऑर्केस्ट्रेशन

मल्टी-कंटेनर एप्लिकेशनों के लिए, Docker Compose नेटवर्किंग और पोर्ट्स को कॉन्फ़िगर करने का अधिक प्रबंधनीय तरीका प्रदान करता है।

Docker Compose की YAML फ़ाइल में, आप प्रत्येक सेवा के लिए ports कुंजी के तहत पोर्ट मैपिंग निर्दिष्ट कर सकते हैं:

services:
  web:
    image: my-image
    ports:
      - "8081:80"
      - "443:443"
  api:
    build: ./api
    ports:
      - "3000:3000"

Docker Compose ports और expose के बीच एक महत्वपूर्ण अंतर करता है। ports सेक्शन प्रकाशित पोर्ट मैपिंग बनाता है जिन्हें बाहर से एक्सेस किया जा सकता है, जबकि expose केवल उन्हीं पोर्ट्स को उपलब्ध कराता है जिन्हें उसी Compose नेटवर्क के भीतर लिंक की गई सेवाएँ उपयोग कर सकती हैं:

services:
  web:
    image: my-image
    ports:
      - "8081:80"
  database:
    image: postgres
    expose:
      - "5432"

इस उदाहरण में, web सेवा होस्ट पर पोर्ट 8081 से सुलभ है, लेकिन PostgreSQL डेटाबेस केवल Compose फ़ाइल के भीतर अन्य सेवाओं के लिए उपलब्ध है, सीधे होस्ट से नहीं।

लचीली कॉन्फ़िगरेशन के लिए, खासकर अलग-अलग वातावरणों में, मैं पोर्ट मैपिंग में environment variables का उपयोग कर सकता हूँ:

services:
  web:
    image: my-image
    ports:
      - "${WEB_PORT:-8081}:80"

यह सिंटैक्स मुझे environment variable (WEB_PORT) के माध्यम से होस्ट पोर्ट निर्दिष्ट करने देता है, और यदि सेट नहीं है तो 8081 डिफ़ॉल्ट रहता है।

Docker पोर्ट्स एक्सपोज़ करना - उदाहरण सहित

चलिए वेब एप्लिकेशन और डेटाबेस बैकएंड के लिए Docker पोर्ट्स को एक्सपोज़ करने का एक पूरा उदाहरण देखते हैं।

मान लीजिए हम एक सरल वेब एप्लिकेशन बना रहे हैं जिसमें एक Python Flask API सेवा और एक PostgreSQL डेटाबेस शामिल है। API सेवा 5000 पोर्ट पर सुनती है, और PostgreSQL अपना डिफ़ॉल्ट पोर्ट 5432 उपयोग करता है।

हमारा सरल Flask एप्लिकेशन (app.py) कुछ ऐसा दिख सकता है। यह एप्लिकेशन एक myapp डेटाबेस बनाएगा और जब इस डेटाबेस के भीतर items टेबल बना दी जाएगी, तो वहीं से डेटा फ़ेच करेगा।

from flask import Flask, jsonify
import os
import psycopg2

app = Flask(__name__)

# Database connection parameters from environment variables
DB_HOST = os.environ.get('DB_HOST', 'db')
DB_NAME = os.environ.get('DB_NAME', 'myapp')
DB_USER = os.environ.get('DB_USER', 'postgres')
DB_PASS = os.environ.get('DB_PASSWORD', 'postgres')

@app.route('/')
def index():
    return jsonify({'message': 'API is running'})

@app.route('/items')
def get_items():
    # Connect to the PostgreSQL database
    conn = psycopg2.connect(
        host=DB_HOST,
        database=DB_NAME,
        user=DB_USER,
        password=DB_PASS
    )
    
    # Create a cursor and execute a query
    cur = conn.cursor()
    cur.execute('SELECT id, name FROM items')
    
    # Fetch results and format as list of dictionaries
    items = [{'id': row[0], 'name': row[1]} for row in cur.fetchall()]
    
    # Close connections
    cur.close()
    conn.close()
    
    return jsonify(items)

if __name__ == '__main__':
    # Run the Flask app, binding to all interfaces (important for Docker)
    app.run(host='0.0.0.0', port=5000)

अगला कदम, मैं हमारा requirements.txt फ़ाइल बनाऊँगा:

flask
psycopg2-binary

अब, मुझे अपने Python API सर्विस के लिए एक Dockerfile बनाना है:

FROM python:3.9-slim
WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Expose the port Flask runs on
EXPOSE 5000

# Command to run the application
CMD ["python", "app.py"]

अंत में, मैं दोनों सेवाओं को ऑर्केस्ट्रेट करने के लिए एक Docker Compose फ़ाइल बनाऊँगा:

services:
  api:
    build:
      context: .
      dockerfile: Dockerfile
      tags:
        - "my-custom-image:latest"
    container_name: my-custom-api
    ports:
      - "5000:5000"
    environment:
      - DB_HOST=db
      - DB_NAME=myapp
      - DB_USER=postgres
      - DB_PASSWORD=postgres
    depends_on:
      - db
  
  db:
    container_name: my-custom-db
    image: postgres:13
    expose:
      - "5432"
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

इस कॉन्फ़िगरेशन में:

1. API सेवा हमारे Dockerfile से बिल्ड होती है और पोर्ट 5000 पब्लिश करती है, जिससे यह होस्ट मशीन से सुलभ हो जाती है।
2. PostgreSQL सेवा पोर्ट 5432 को एक्सपोज़ करती है लेकिन पब्लिश नहीं करती, जिससे यह केवल Compose नेटवर्क के भीतर अन्य सेवाओं के लिए सुलभ रहती है।
3. API सेवा db होस्टनेम (जो सेवा का नाम है) और पोर्ट 5432 का उपयोग करके डेटाबेस तक पहुँच सकती है।

इस एप्लिकेशन को चलाने के लिए, यह उपयोग करें:

docker-compose up

अब, मैं http://localhost:5000 पर API तक पहुँच सकता हूँ, लेकिन PostgreSQL इंस्टेंस Docker नेटवर्क के बाहर से सीधे सुलभ नहीं है, जो डेटाबेस सेवाओं के लिए एक अच्छी सुरक्षा प्रैक्टिस है। लेकिन आप चल रहे कंटेनर से PostgreSQL तक पहुँच सकते हैं:

docker compose exec db psql -U postgres -d myapp

यह कमांड PostgreSQL CLI तक पहुँच दिलाएगी, जहाँ मैं डेटाबेस देख सकता हूँ और एक items टेबल बना सकता हूँ। एक बार बनने के बाद, मैं http://localhost:5000/items पर डेटा देख सकता हूँ।

कई Docker पोर्ट्स को कैसे एक्सपोज़ करें

यदि मेरी Python एप्लिकेशन को कई पोर्ट्स एक्सपोज़ करने की ज़रूरत है, तो मैं उन्हें Dockerfile में सभी निर्दिष्ट कर सकता हूँ:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 5000 8081 9090
CMD ["python", "app.py"]

यह Dockerfile निम्न को एक्सपोज़ करता है:

• मुख्य Flask एप्लिकेशन के लिए पोर्ट 5000 (वर्तमान में सक्रिय)
• संभावित मॉनिटरिंग डैशबोर्ड के लिए पोर्ट 8081
• भविष्य के डीबगिंग इंटरफ़ेस के लिए पोर्ट 9090

यह ध्यान रखना महत्वपूर्ण है कि जबकि मैंने Dockerfile में दस्तावेज़ीकरण के रूप में 8081 और 9090 पोर्ट्स एक्सपोज़ किए हैं, मेरी वर्तमान Flask एप्लिकेशन केवल 5000 पोर्ट पर सुनने के लिए कॉन्फ़िगर है। अतिरिक्त एक्सपोज़्ड पोर्ट यह इंगित करते हैं कि भविष्य में कहाँ फ़ंक्शनैलिटी जोड़ी जा सकती है।

एक्सपोज़्ड पोर्ट्स को कैसे पब्लिश करें

Dockerfile में एक्सपोज़ किए गए पोर्ट्स को पब्लिश करने के लिए, मैं कंटेनर चलाते समय -p या -P फ़्लैग का उपयोग करता हूँ:

docker run -p 8081:5000  my-custom-image

यह कंटेनर में पोर्ट 5000 (जो Dockerfile में एक्सपोज़ है और जहाँ Flask सुन रहा है) को होस्ट पर पोर्ट 8081 से मैप करता है। इस कमांड को चलाने के बाद, मैं अपने ब्राउज़र में http://localhost:8081 पर जाकर अपनी Flask एप्लिकेशन तक पहुँच सकता हूँ।

मैं -P फ़्लैग का उपयोग करके सभी एक्सपोज़्ड पोर्ट्स को स्वचालित रूप से होस्ट पर रैंडम पोर्ट्स पर भी पब्लिश कर सकता हूँ:

docker run -P my-custom-image

कौन से पोर्ट्स पब्लिश हुए हैं, यह जाँचने के लिए मैं यह उपयोग कर सकता हूँ:

docker ps

अधिक विस्तृत जानकारी के लिए, मैं यह उपयोग कर सकता हूँ:

docker port [container_id]

5000/tcp -> 0.0.0.0:32768
8081/tcp -> 0.0.0.0:32769
9090/tcp -> 0.0.0.0:32770

यह कमांड किसी विशिष्ट कंटेनर के लिए सभी पोर्ट मैपिंग दिखाती है। उदाहरण के लिए, यदि मेरी Flask एप्लिकेशन केवल 5000 पोर्ट पर सुन रही है, लेकिन मैंने Dockerfile में कई पोर्ट्स एक्सपोज़ किए हैं, तो docker port बिल्कुल दिखाएगा कि कौन से होस्ट पोर्ट किस कंटेनर पोर्ट से मैप हैं। तो, यदि 5000 पोर्ट 32768 से मैप है, तो मैं अपनी Flask एप्लिकेशन http://localhost:32768 पर एक्सेस कर सकता हूँ।

डायग्नोस्टिक और ट्रबलशूटिंग तकनीकें

सावधानीपूर्वक कॉन्फ़िगरेशन के बावजूद, Docker पोर्ट मैपिंग के साथ समस्याएँ आ सकती हैं। यहाँ कुछ तकनीकें हैं जिनका मैं आम समस्याओं के निदान और समाधान के लिए उपयोग करता हूँ।

पोर्ट मैपिंग निरीक्षण

पोर्ट-संबंधित समस्याओं का निदान करने का पहला कदम यह सत्यापित करना है कि मैपिंग सही ढंग से सेट हैं। मैं ये कमांड्स उपयोग करता हूँ:

चल रहे सभी कंटेनरों को उनकी पोर्ट मैपिंग के साथ सूचीबद्ध करें:

docker ps

किसी विशिष्ट कंटेनर के बारे में विस्तृत जानकारी प्राप्त करें:

docker inspect [container_id]

किसी विशिष्ट कंटेनर के पोर्ट मैपिंग जाँचें:

docker port [container_id]

docker inspect कमांड विस्तृत जानकारी देता है, जिसमें नेटवर्क सेटिंग्स भी शामिल हैं। केवल नेटवर्क-संबंधित विवरण पर ध्यान केंद्रित करने के लिए, यह उपयोग करें:

docker inspect --format='{{json .NetworkSettings.Ports}}' [container_id] | jq

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

docker exec -u root -it f5c6cac71492 bash -c "apt-get update && apt-get install -y net-tools tcpdump"

कंटेनर के अंदर एप्लिकेशन किन पोर्ट्स पर सुन रहा है, यह देखने के लिए:

docker exec -it [container_id] netstat -tuln

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 0.0.0.0:5000            0.0.0.0:*               LISTEN
tcp        0      0 127.0.0.11:42265        0.0.0.0:*               LISTEN
udp        0      0 127.0.0.11:34267        0.0.0.0:*

यह दिखाता है, उदाहरण के लिए, कि Flask ऐप सभी इंटरफ़ेस पर पोर्ट 5000 पर सुन रहा है।

कंटेनर के मुख्य नेटवर्क इंटरफ़ेस (आम तौर पर eth0) पर आने-जाने वाले ट्रैफ़िक की निगरानी करने के लिए:

docker exec -it [container_id] tcpdump -i eth0

listening on eth0, link-type EN10MB (Ethernet), snapshot length 262144 bytes

यह कमांड आपको ट्रैफ़िक ट्रेस करने देता है और यह पहचानने में मदद करता है कि अनुरोध कंटेनर तक पहुँच रहे हैं या पैकेट ड्रॉप/गलत रूट हो रहे हैं।

Iptables नियम विश्लेषण

Docker, Network Address Translation (NAT) को प्रबंधित करने और होस्ट व कंटेनरों के बीच ट्रैफ़िक प्रवाह नियंत्रित करने के लिए iptables का उपयोग करता है। यह स्वचालित रूप से ऐसे नियम जोड़ता है जो होस्ट पोर्ट्स को उपयुक्त कंटेनर IPs और पोर्ट्स तक फ़ॉरवर्ड करते हैं, जिससे कंटेनराइज़्ड सेवाओं तक निर्बाध पहुँच संभव होती है।

नेटिव Linux होस्ट्स पर, आप इन नियमों का निरीक्षण निम्न कमांड जैसे आदेशों से कर सकते हैं:

sudo iptables -t nat -L DOCKER -n -v

यह दिखाता है कि Docker किस प्रकार विशिष्ट होस्ट पोर्ट्स पर आने वाले ट्रैफ़िक को कंटेनर एंडपॉइंट्स तक मैप करता है। पहले वाले Docker Compose फ़ाइल के आधार पर, आपको फ़ॉरवर्ड किए गए पोर्ट्स दिखेंगे:

Chain DOCKER (2 references)
 pkts bytes target     prot opt in     out     source               destination
   50  3000 RETURN     all  --  docker0 *       0.0.0.0/0            0.0.0.0/0
  100  6000 RETURN     all  --  br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0
  500 30000 DNAT       tcp  --  !br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0            tcp dpt:5000 to:172.18.0.2:5000
  400 24000 DNAT       tcp  --  !br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0            tcp dpt:8081 to:172.18.0.2:5000
  300 18000 DNAT       tcp  --  !br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0            tcp dpt:9090 to:172.18.0.2:5000

यहाँ:

• DNAT नियम ट्रैफ़िक को होस्ट से कंटेनर की ओर रीडायरेक्ट करते हैं।
• RETURN नियम Docker के आंतरिक नेटवर्क ट्रैफ़िक के उचित रूटिंग को सुनिश्चित करते हैं।

हालाँकि, आपके वातावरण (उदाहरण के लिए, Windows पर Docker Desktop या WSL2) पर निर्भर करते हुए, Docker पोर्ट फ़ॉरवर्डिंग को अलग तरीके से संभाल सकता है, और सिस्टम के अंदर से iptables नियम दिखाई या परिवर्तनीय न हों। ऐसे में आप निम्न कमांड से पोर्ट फ़ॉरवर्डिंग जाँच सकते हैं:

sudo ss -tulnp

Netid    State       Recv-Q      Send-Q            Local Address:Port         Peer Address:Port 
tcp        LISTEN     0                 4096                                          *:5000           	        *:*           
tcp        LISTEN     0                 4096                          		   *:8081                               *:*    
tcp        LISTEN     0                 4096                          		   *:9090                              *:*    

ट्रबलशूटिंग टिप्स:

• docker ps और docker port [container] से पोर्ट मैपिंग की पुष्टि करें।
• जाँचें कि होस्ट सिस्टम का फ़ायरवॉल या सुरक्षा सॉफ़्टवेयर पोर्ट्स को ब्लॉक तो नहीं कर रहा।
• कंटेनर लॉग्स और netstat, tcpdump जैसे नेटवर्क टूल्स का उपयोग करके अपने एप्लिकेशन के नेटवर्क व्यवहार को सत्यापित करें।

निष्कर्ष

Docker पोर्ट्स को एक्सपोज़ करना एक बुनियादी कौशल है जो कंटेनराइज़्ड आइसोलेशन और व्यावहारिक उपयोगिता के बीच की खाई को पाटता है। इस लेख के दौरान, मैंने समझाया कि Docker का नेटवर्किंग मॉडल कैसे काम करता है, पोर्ट्स को एक्सपोज़ और पब्लिश करने में क्या अंतर है, और विभिन्न परिदृश्यों के लिए व्यावहारिक उदाहरण दिए।

इन मुख्य बिंदुओं को ध्यान में रखें:

• EXPOSE का उपयोग Dockerfiles में करें ताकि यह दस्तावेज़ रहे कि आपका एप्लिकेशन किन पोर्ट्स का उपयोग करता है
• -p या -P का उपयोग कंटेनर चलाते समय करें ताकि वे पोर्ट्स बाहर से सुलभ हों
• जटिल मल्टी-कंटेनर एप्लिकेशन प्रबंधन के लिए Docker Compose का लाभ उठाएँ
• समस्याएँ आने पर निदान के लिए डायग्नोस्टिक टूल्स का उपयोग करें

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

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

सीखना जारी रखने के लिए, निम्न संसाधनों को अवश्य देखें:

• Docker का उपयोग करके LLM एप्लिकेशन कैसे डिप्लॉय करें: चरण-दर-चरण गाइड
• 2025 के लिए संपूर्ण Docker Certification (DCA) गाइड
• 2025 के लिए शीर्ष 26 Docker इंटरव्यू प्रश्न और उत्तर 
• 10 Docker प्रोजेक्ट आइडियाज़: शुरुआती से उन्नत तक