Claude Code Docker: कंटेनरों में AI एजेंट चलाना

स्वायत्त AI कोडिंग एजेंट शक्तिशाली होते हैं। वे आपके फाइल सिस्टम में नेविगेट करते हैं, शेल कमांड चलाते हैं, कमिट करते हैं, और फाइलें बदलते हैं—वह भी बिना आपके एक भी लाइन टाइप किए। लेकिन इसी शक्ति के साथ एक असली सवाल आता है: अगर कुछ गलत हो गया तो? अगर एजेंट ने किसी ऐसे कॉन्फ़िग फाइल को बदल दिया जिसे छूना नहीं चाहिए था, या ऐसा पैकेज इंस्टॉल कर दिया जो आपके सिस्टम से टकरा रहा है?

अधिकांश प्रोडक्शन-मानसिकता वाले डेवलपर्स का जवाब Docker होता है—और वही जवाब मेरे पास भी बार-बार लौटा, खासकर उस सेशन के बाद जब Claude Code ने मेरे प्रोजेक्ट की .env फाइल को "साफ" कर दिया क्योंकि वह बेकार लग रही थी। (वह बेकार नहीं थी।) 

कंटेनर एजेंट और आपके होस्ट मशीन के बीच एक सख्त सीमा बनाते हैं—और यही सीमा बिना निगरानी के एजेंट रन को चिंता के बजाय सुरक्षित महसूस कराती है। 

इस ट्यूटोरियल में, मैं आपको Docker के अंदर Claude Code चलाने की प्रक्रिया दिखाऊँगा: एक न्यूनतम बेसलाइन इमेज बनाने से लेकर Docker Compose के साथ मल्टी-सर्विस एप्लिकेशन ऑर्केस्ट्रेट करने तक। अंत तक, आपके पास एक दोहराने योग्य, सुरक्षित वर्कफ्लो होगा जिसे आप किसी भी प्रोजेक्ट पर उपयोग कर सकते हैं।

जो लोग नए Anthropic मॉडलों में रुचि रखते हैं, उन्हें मैं Claude Opus 4.6 और Claude Sonnet 4.6 पर हमारे गाइड पढ़ने की सलाह दूँगा।

Claude Code Docker के साथ कैसे एकीकृत होता है

समझने के लिए कि Docker Claude Code के लिए इतना स्वाभाविक फ़िट क्यों है, यह संक्षेप में जानना उपयोगी है कि हर टूल वास्तव में करता क्या है।

Claude Code Anthropic का कमांड-लाइन एजेंटिक कोडिंग टूल है, जो मई 2025 में सामान्य उपलब्धता के लिए जारी किया गया। यह आपके टर्मिनल में रहता है, आपके कोडबेस को पढ़ता है, और प्राकृतिक भाषा प्रॉम्प्ट्स के जरिए कार्य करता है (कोड का रिफैक्टरिंग, टेस्ट लिखना, git वर्कफ़्लोज़ प्रबंधित करना)। हमारा व्यापक Claude Code 2.1 ट्यूटोरियल वह सब कुछ कवर करता है जो आपको जानना चाहिए।

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

Claude Code को चलाने के लिए एक वातावरण चाहिए। Docker एक पुनरुत्पादनीय, डिस्पोज़ेबल वातावरण देता है। यह संयोजन शक्तिशाली है, लेकिन इसका भरपूर लाभ उठाने के लिए निष्पादन मॉडल, सुरक्षा डिफ़ॉल्ट्स, और आपकी स्थिति के अनुसार उपयुक्त डिप्लॉयमेंट दृष्टिकोण समझना ज़रूरी है।

कंटेनर आर्किटेक्चर और निष्पादन प्रवाह

आइए अनुरोध स्तर पर देखें कि कंटेनरीकृत Claude Code सत्र वास्तव में कैसे काम करता है।

1. आप अपने होस्ट टर्मिनल से एक प्रॉम्प्ट जारी करते हैं। 
2. Docker कंटेनर को Claude Code CLI प्री-इंस्टॉल्ड के साथ और आपके वर्कस्पेस को वॉल्यूम के रूप में माउंट करके शुरू करता है। 
3. Claude Code उस माउंट से फाइलें पढ़ता है, कोडबेस पर विचार करता है, कंटेनर के अलग-थलग प्रोसेस स्पेस में कमांड चलाता है, और आउटपुट वापस उसी माउंटेड वॉल्यूम पर लिखता है। 
4. सत्र समाप्त होने पर, कंटेनर का अस्थायी फाइल सिस्टम (जो माउंट के बाहर है) हटा दिया जाता है।

यहाँ मुख्य अंतर अस्थायी अवस्था और स्थायी अवस्था के बीच है। जो भी कंटेनर में लिखा गया है लेकिन माउंटेड वॉल्यूम के बाहर है, सफाई के दौरान मिटा दिया जाता है। आपका वर्कस्पेस, जो होस्ट पर रहता है और माउंट होता है, स्थायी रहता है। 

इसका मतलब है कि अस्थायी निर्भरताएँ, बिल्ड आर्टिफैक्ट्स और टूल इंस्टॉलेशन सब गायब हो जाते हैं, लेकिन आपकी वास्तविक प्रोजेक्ट फाइलें बिल्कुल वैसी ही रहती हैं जैसी Claude छोड़कर गया। यह विभाजन मुझे सचमुच आश्वस्त करता है: इसे समझने से पहले, मैं एजेंट सत्रों को घबराहट में बैठकर देखता था। अब मैं टास्क शुरू करता हूँ और कॉफी बनाने चला जाता हूँ।

सुरक्षा मॉडल और सुरक्षित डिफ़ॉल्ट्स

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

फाइल सिस्टम आइसोलेशन मुख्य सुरक्षा लाभ है। Claude Code केवल उन्हीं पाथ्स में फाइलें पढ़ और लिख सकता है जिन्हें आप स्पष्ट रूप से माउंट करते हैं। यदि आप उन्हें कंटेनर में माउंट नहीं करते, तो आपके SSH कीज़, ~/.aws क्रेडेंशियल्स, होस्ट एनवायरनमेंट वेरिएबल्स, और सिस्टम कॉन्फ़िग फाइलें एजेंट के लिए अदृश्य रहती हैं—जब तक कि आप जानबूझकर उन्हें एक्सपोज़ न करें। हालाँकि, यह सुरक्षा तभी कायम रहती है जब आप अपने माउंट्स सावधानी से कॉन्फ़िगर करें।

एक महत्वपूर्ण नियम: कभी भी Claude Code कंटेनर में होस्ट का Docker सॉकिट (/var/run/docker.sock) माउंट न करें। यदि एजेंट आपके होस्ट पर Docker डेमॉन से बात कर सकता है, तो वह संभवतः प्रिविलेज्ड कंटेनर चला सकता है, पूरी तरह सैंडबॉक्स से बाहर निकल सकता है, और आपकी मशीन पर रूट-स्तरीय एक्सेस प्राप्त कर सकता है। 

यह एक प्रसिद्ध प्रिविलेज एस्केलेशन पथ है जिसका कोई अच्छा औचित्य नहीं है। मैंने समुदाय के कुछ Dockerfiles में इसे "कंटेनर प्रबंधन" के लिए सुझाया देखा है, और हर बार मन करता है लेखक को कड़ी चेतावनी भेजूँ।

सही डिप्लॉयमेंट पथ चुनना

सुरक्षा डिफ़ॉल्ट्स से इतर, कोड लिखने से पहले एक और निर्णय लेना होता है: आपके उपयोग-केस के लिए कौन सा डिप्लॉयमेंट मॉडल उपयुक्त है? तीन मुख्य विकल्प हैं, और वे परस्पर विनिमेय नहीं हैं।

अधिकांश कार्यों के लिए (एकल रिपो पर एजेंट चलाना, स्क्रिप्ट डिबग करना, मॉड्यूल का रिफैक्टरिंग), साधारण Docker सैंडबॉक्स सबसे सुरक्षित डिफ़ॉल्ट है। 

जब Claude Code को किसी रनिंग डेटाबेस, API, या फ्रंटएंड सर्विस के साथ इंटरैक्ट करना हो, तब Docker Compose समझ आता है। 

Devcontainers टीम-स्तरीय मानकीकृत वातावरणों के लिए सही विकल्प हैं, जिनमें प्री-कॉन्फ़िगर्ड IDE एक्सटेंशंस होते हैं। उल्लेखनीय रूप से, आधिकारिक Anthropic रेफ़रेंस devcontainer में एक बिल्ट-इन फ़ायरवॉल शामिल है जो आउटबाउंड कनेक्शनों को विश्वसनीय अलाउलिस्ट तक सीमित करता है—और यही आइसोलेशन Claude Code को पूर्णतः बिना निगरानी के चलाने हेतु --dangerously-skip-permissions का सुरक्षित उपयोग संभव बनाता है। 

इस ट्यूटोरियल में, हम सिंगल-कंटेनर सैंडबॉक्स और Compose सेटअप—दोनों को कवर करेंगे।

Claude Code के लिए Docker कंटेनर सेट करना

अब जब आर्किटेक्चर और डिप्लॉयमेंट विकल्प स्पष्ट हैं, तो कोड लिखने से पहले यह सुनिश्चित कर लें कि वातावरण ठीक तरह से कॉन्फ़िगर है। मैंने यह कदम अनगिनत बार छोड़ते देखा है—और ऐसे ही ट्यूटोरियल अक्सर बीच में फेल होते हैं।

सिस्टम और सॉफ्टवेयर आवश्यकताएँ

पहले docker build से पहले आपको ये सब चाहिए:

• Docker Desktop (macOS या Windows) या Docker Engine (Linux), और डेमॉन सक्रिय रूप से चल रहा हो। macOS और Windows पर, वर्चुअलाइज़ेशन आपके BIOS/फर्मवेयर सेटिंग्स में सक्षम होना चाहिए। Linux पर, अपने यूज़र को docker समूह में sudo usermod -aG docker $USER से जोड़ें, या हर Docker कमांड से पहले sudo लगाएँ।

• आपकी होस्ट मशीन पर Node.js v18 या बाद का, क्योंकि Claude Code CLI एक npm पैकेज है। node --version से पुष्टि करें।

• एक Anthropic API कुंजी, जिसे आप Claude Console में जनरेट कर सकते हैं।

आगे बढ़ने से पहले एक त्वरित सेनीटी चेक से सुनिश्चित करें कि Docker स्वयं स्वस्थ है:

docker run --rm hello-world

यदि आप Hello from Docker! देखते हैं, तो आपका डेमॉन सही ढंग से प्रतिक्रिया दे रहा है और आप आगे बढ़ने के लिए तैयार हैं।

प्रमाणीकरण और वातावरण वेरिएबल्स

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

यह मैंने कठिन तरीके से सीखा: इंटरैक्टिव लॉगिन क्रेडेंशियल्स को कंटेनर लेयर्स या शेल हिस्ट्री फाइलों में बेक कर सकते हैं, जो आपके भूल जाने के बहुत बाद तक डिस्क पर बने रहते हैं।

सही पैटर्न है कि रनटाइम पर -e का उपयोग करके कुंजी पास करें:

docker run --rm -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" my-claude-image

ध्यान दें कि मैं अपनी होस्ट शेल से $ANTHROPIC_API_KEY को संदर्भित कर रहा हूँ। कुंजी कभी भी Dockerfile में नहीं लिखी जाती, कभी वर्ज़न कंट्रोल में कमिट नहीं होती, और किसी भी इमेज लेयर में नहीं दिखती। इसे एक बार अपनी शेल प्रोफ़ाइल (~/.zshrc या ~/.bashrc) में सेट करें, और इसके बाद यह हर कंटेनर रन में साफ़-सुथरे तरीके से प्रवाहित होती है।

वर्कस्पेस इनिशियलाइज़ेशन

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

mkdir ~/claude-docker-tutorial
cd ~/claude-docker-tutorial
echo "# My Project" > README.md
echo "def hello(): return 'world'" > app.py

इस डायरेक्टरी को साफ़ रखें। अपनी वास्तविक .env फाइल या कोई भी क्रेडेंशियल इसमें कॉपी न करें। वर्कस्पेस में केवल वही कोड होना चाहिए जिस पर आप चाहते हैं कि एजेंट काम करे—और कुछ नहीं। यह सेट होने के बाद, हम बिल्ड के लिए तैयार हैं।

Docker में Claude Code चलाना

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

1. बेसलाइन कंटेनर इमेज बनाना

इस सेक्शन की हर चीज़ पहले चर्चा किए गए सुरक्षा सिद्धांतों पर आधारित है। यहाँ एक न्यूनतम Dockerfile है जो उन सिद्धांतों को अमल में लाता है, एक स्लिम Node.js बेस इमेज पर Claude Code CLI इंस्टॉल करते हुए:

FROM node:20-slim

# Create a non-root user for safer execution
RUN useradd -m -u 1001 claude

# Install Claude Code CLI globally
RUN npm install -g @anthropic-ai/claude-code

# Set the working directory
WORKDIR /workspace

# Switch to non-root user
USER claude

ENTRYPOINT ["claude"]

कुछ डिज़ाइन निर्णय उल्लेखनीय हैं। मैं node:20-alpine के बजाय node:20-slim उपयोग कर रहा हूँ क्योंकि Alpine musl libc लाइब्रेरी का उपयोग करता है, जो कभी-कभी नैटिव npm पैकेजों के साथ संगतता समस्याएँ पैदा करता है। 

मुझे Alpine पर यही समस्या पहली कोशिश में मिली: Claude Code CLI ठीक से इंस्टॉल हुआ, लेकिन पहली रन पर एक रहस्यमयी लिंकिंग त्रुटि से क्रैश हो गया, जिसे musl तक ट्रेस करने में मुझे एक घंटा लगा। 

slim वेरिएंट Debian पर आधारित है: हल्का और भरोसेमंद, बिना उस ड्रामा के। साथ ही, मैं एक समर्पित claude यूज़र बना रहा हूँ और entrypoint से पहले उस पर स्विच कर रहा हूँ, जिसका मतलब है कि एजेंट प्रोसेस रूट विशेषाधिकार के बिना चलता है और उसकी क्षमताएँ कंटेनर के अंदर भी सीमित रहती हैं।

इमेज को इस कमांड से बिल्ड करें:

docker build -t claude-code:latest .

पहले बिल्ड पर Docker बेस इमेज पुल करेगा और CLI इंस्टॉल करेगा। बाद के बिल्ड्स में, जब Dockerfile में बदलाव न हो, तो हर लेयर के आगे “CACHED” दिखेगा, जिससे बेस स्थापित होने के बाद रिबिल्ड लगभग तात्कालिक हो जाते हैं।

2. एक अलग-थलग सैंडबॉक्स सत्र लॉन्च करना

इमेज तैयार है, अब पहला वास्तविक सत्र चलाने का समय है। 

रीड-ओनली ऑपरेशंस

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

docker run --rm \
  -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" \
  -v $(pwd):/workspace \
  claude-code:latest \
  "List the files in this workspace and describe what each one does."

-v $(pwd):/workspace आपके वर्तमान डायरेक्टरी को कंटेनर में माउंट करता है, इसलिए यह कमांड किसी भी प्रोजेक्ट डायरेक्टरी से काम करता है। --rm फ्लैग कंटेनर को एग्ज़िट के बाद स्वतः हटा देता है।

राइट ऑपरेशंस

राइट ऑपरेशंस के लिए दो अतिरिक्त फ्लैग चाहिए। 

-u $(id -u):$(id -g) फ्लैग आपके होस्ट यूज़र का UID और GID कंटेनर में पास करता है, जिससे claude प्रोसेस को आपके माउंटेड फाइलों पर लिखने की अनुमति मिलती है। इसके बिना, आपको रीड-ओनली फाइल सिस्टम त्रुटि मिलेगी क्योंकि कंटेनर का claude यूज़र आपके होस्ट फाइल ओनरशिप से मेल नहीं खाता। 

--dangerously-skip-permissions फ्लैग Claude Code के इंटरैक्टिव अप्रूवल प्रॉम्प्ट्स को स्किप करता है—जो कंटेनर के अंदर नॉन-इंटरैक्टिव रूप से चलाते समय आवश्यक होते हैं। Docker की सीमा ही इसे सुरक्षित बनाती है।

docker run --rm \
  -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" \
  -v $(pwd):/workspace \
  -u $(id -u):$(id -g) \
  claude-code:latest \
  --dangerously-skip-permissions \
  "Add a docstring to the hello function in app.py."

Claude Code Docker राइट ऑपरेशन

फिर अपनी लोकल फाइल जाँचें: cat app.py। यदि आपको docstring दिखे, तो वॉल्यूम माउंट दोनों दिशाओं में काम कर रहा है, और आप मल्टी-सर्विस सेटअप तक स्केल करने के लिए तैयार हैं।

3. मल्टी-सर्विस ऐप का ऑर्केस्ट्रेशन

सिंगल-कंटेनर सैंडबॉक्स अलग-थलग कार्यों के लिए अच्छा है, लेकिन वास्तविक विकास में अक्सर कई सेवाएँ साथ चलती हैं। यहीं Docker Compose की उपयोगिता सामने आती है।

नीचे दिया कॉन्फ़िगरेशन Claude Code एजेंट को एक वेब सर्विस और PostgreSQL डेटाबेस से जोड़ता है—कई बैकएंड प्रोजेक्ट्स के लिए प्रतिनिधि सेटअप:

services:
  claude:
    build: .
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    volumes:
      - ./workspace:/workspace
    depends_on:
      db:
        condition: service_healthy
    networks:
      - app-network

  web:
    image: python:3.12-slim
    working_dir: /app
    volumes:
      - ./workspace:/app
    command: python -m http.server 8080
    ports:
      - "8080:8080"
    networks:
      - app-network

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: appdb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user -d appdb"]
      interval: 5s
      timeout: 3s
      retries: 5
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

ध्यान दें कि version हटा दिया गया है, क्योंकि यह आधुनिक Docker Compose में अप्रचलित है और शामिल करने पर चेतावनी देगा। 

दो अन्य बातें उल्लेखनीय हैं:

पहला, claude सर्विस .:/workspace (वर्तमान डायरेक्टरी) माउंट करती है, न कि किसी सबडायरेक्टरी को। ./workspace का उपयोग करने पर एक अलग सबफोल्डर का अस्तित्व आवश्यक होगा, और एजेंट को खाली वर्कस्पेस दिखेगा। 

दूसरा, DATABASE_URL को स्पष्ट रूप से पास करना चाहिए ताकि एजेंट को पता हो कि Postgres तक कैसे पहुँचना है। इसके बिना, Claude के पास कनेक्शन स्ट्रिंग नहीं होगी और वह आपसे पूछेगा।

user: "${UID}:${GID}" लाइन वही होस्ट UID/GID ओवरराइड लागू करती है जो हमने स्टैंडअलोन docker run कमांड्स में उपयोग किया था, ताकि फाइल राइट्स सही से काम करें। रन करने से पहले दोनों एक्सपोर्ट करें:

export UID=$(id -u) GID=$(id -g)

claude सर्विस का कोई स्थायी command नहीं है, इसलिए web और db के विपरीत, इसे लगातार चलाने के लिए नहीं बनाया गया। पहले सपोर्टिंग सर्विसेज़ शुरू करें, फिर आवश्यकता पर docker compose run के साथ Claude को इनवोक करें:

# Start the database and web service
docker compose up -d web db

# Run a one-off Claude task
docker compose run --rm \
  claude \
  --dangerously-skip-permissions \
  "Check the database connection and summarize the schema in README.md."

Docker Compose के साथ Claude Code

पहले docker compose up -d web db से सपोर्टिंग सर्विसेज़ शुरू करें, फिर docker compose logs -f से उनके लॉग देखें। depends_on में condition: service_healthy नोट करें। 

मैंने इसे एक शुरुआती प्रोजेक्ट में छोड़ दिया था और 20 मिनट डेटाबेस कनेक्शन त्रुटियों का पीछा किया—फिर अहसास हुआ कि Claude Postgres के तैयार होने से पहले ही शुरू हो गया था। हेल्थ चेक की लागत नगण्य है और वही सिरदर्द बचा लेता है।

4. सत्र क्लीनअप प्रबंधन

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

यहाँ वे कमांड हैं जिनका आप सबसे अधिक उपयोग करेंगे—और कब करें:

The -v फ्लैग पर docker compose down सावधानी बरतें। यह नामित वॉल्यूम्स हटाता है—यानि Postgres में जमा किया गया कोई भी डेटाबेस डेटा चला जाएगा। मैं इसे तभी उपयोग करता हूँ जब सच में एक क्लीन स्लेट चाहिए। अन्यथा अकेला docker compose down पर्याप्त है।

Claude Code Docker इंटेग्रेशन और ट्रबलशूटिंग

कोर वर्कफ़्लो साफ़-सुथरा चलने के बाद, अब देखें कि इसे कैसे बढ़ाएँ और जब कुछ टूटे तो कैसे डिबग करें।

लोकल मॉडल्स और एक्सटेंशंस को इंटीग्रेट करना

Claude Code ANTHROPIC_BASE_URL के जरिए किसी भी Anthropic-कंपैटिबल लोकल एंडपॉइंट पर इंफरेंस रीडायरेक्ट करने का समर्थन करता है। Docker Desktop में बिल्ट-इन Docker Model Runner बिल्कुल ऐसा ही API एक्सपोज़ करता है, जिससे यह इंटेग्रेशन Docker इकोसिस्टम में नैटिव बनता है।

एक मॉडल पुल करें और Claude Code को लोकल एंडपॉइंट की ओर पॉइंट करें:

docker model pull ai/smollm2
ANTHROPIC_BASE_URL=http://localhost:12434 claude --model ai/smollm2 "List the files of the repository."

यह पैटर्न पहले कवर किए गए सैंडबॉक्स्ड कंटेनर एप्रोच से अलग है। यहाँ, Claude Code आपके होस्ट पर चलता है, और इंफरेंस Docker Model Runner के जरिए लोकल रहता है, इसलिए कोई API कॉल आपकी मशीन से बाहर नहीं जाती।

लोकल मॉडल्स से परे, आप MCP (Model Context Protocol) सर्वर के माध्यम से Claude Code की पहुँच बढ़ा सकते हैं। यदि आप इससे परिचित नहीं हैं, तो हमारा MCP गाइड शुरू करने के लिए बढ़िया संसाधन है।

Docker का MCP Toolkit GitHub, Jira, Supabase और अन्य के लिए 200 से अधिक प्री-बिल्ट, कंटेनरीकृत MCP सर्वर देता है—जिससे Claude Code को उन टूल्स तक अनुमति-आधारित पहुँच मिलती है, बिना कच्चे API क्रेडेंशियल्स एक्सपोज़ किए। 

साथ मिलकर, ये दो एक्सटेंशन पॉइंट आपको इस पर सार्थक नियंत्रण देते हैं कि इंफरेंस कहाँ होता है और एजेंट किन बाहरी सेवाओं तक पहुँच सकता है।

बिल्ड परफॉर्मेंस को ऑप्टिमाइज़ करना

जैसे-जैसे आपका Dockerfile बढ़ता है, बिल्ड समय बाधा बन सकता है। मल्टी-स्टेज बिल्ड्स इसे इंस्टॉलेशन को रनटाइम इमेज से अलग करके ठीक करते हैं:

# Build stage
FROM node:20-slim AS builder
RUN npm install -g @anthropic-ai/claude-code

# Runtime stage
FROM node:20-slim
COPY --from=builder /usr/local/lib/node_modules /usr/local/lib/node_modules
COPY --from=builder /usr/local/bin/claude /usr/local/bin/claude
RUN useradd -m -u 1001 claude
USER claude
WORKDIR /workspace
ENTRYPOINT ["claude"]

लेयर का क्रम संरचना जितना ही मायने रखता है—और यह बात मैंने जितना स्वीकार करना चाहूँ उससे ज्यादा देर तक गलत की। 

जो निर्देश शायद ही बदलते हैं (जैसे सिस्टम पैकेज इंस्टॉल करना) उन्हें ऊपर रखें। जो अक्सर बदलते हैं (जैसे सोर्स फाइलें कॉपी करना) उन्हें नीचे रखें। इससे कैश हिट्स अधिकतम होते हैं और 30-सेकंड के रिबिल्ड लगभग तात्कालिक बन जाते हैं।

आम इंटेग्रेशन विफलताओं को डिबग करना

एक अच्छी तरह संरचित सेटअप के बावजूद चीजें टूटती हैं। यहाँ मेरे सबसे आम मुद्दों के लिए दोहराने योग्य डिबगिंग लूप है—लक्षण पहले, फिर चलाने का कमांड:

• ब्लॉक्ड नेटवर्क इग्रेस: Claude Code Anthropic API तक नहीं पहुँच पा रहा। आउटबाउंड एक्सेस जाँचने के लिए docker run --rm alpine wget -qO- https://api.anthropic.com चलाएँ। यदि यह फेल हो, तो प्रॉक्सी सेटिंग्स के लिए docker network inspect bridge देखें।

• गलत वॉल्यूम माउंट्स: Claude Code रिपोर्ट करता है कि फाइलें नहीं मिल रहीं। docker run --rm -v $(pwd):/workspace alpine ls /workspace चलाएँ। खाली लिस्टिंग का मतलब आपका पाथ गलत है। सबसे पहले डायरेक्टरी के अस्तित्व की पुष्टि करें।

• स्टेल बिल्ड कैश: आपने Dockerfile अपडेट किया, पर व्यवहार नहीं बदला। पूर्ण रिबिल्ड फोर्स करने के लिए docker build --no-cache -t claude-code:latest . चलाएँ।

• Compose में सर्विस-टू-सर्विस कनेक्शन विफलताएँ: एक सर्विस दूसरी तक नहीं पहुँच पा रही। सर्विसेज़ अपने सर्विस नामों (db, web) से संचार करती हैं, localhost से नहीं। पहुँच की जाँच के लिए docker compose exec web ping db चलाएँ। असफल पिंग का मतलब सर्विसेज़ एक ही नेटवर्क पर नहीं हैं।

निष्कर्ष

Docker के अंदर Claude Code चलाने से आपको एक वास्तविक मूल्य मिलता है: एक स्वायत्त एजेंट को बेझिझक काम करने देने की स्वतंत्रता—यह जानते हुए कि वह जहाँ तक पहुँच सकता है, वह सख्ती से सीमाबद्ध है। 

इस ट्यूटोरियल में, मैंने एक न्यूनतम नॉन-रूट कंटेनर इमेज बनाना, वर्कस्पेस वॉल्यूम्स मैनेज करना, Docker Compose के साथ मल्टी-सर्विस एप्लिकेशन ऑर्केस्ट्रेट करना, और सबसे आम इंटेग्रेशन विफलताओं का निदान करना दिखाया। 

यह सेटअप मुझे सही करने में लगभग एक दोपहर लगी, और इसने एजेंट-असिस्टेड डेवलपमेंट के प्रति मेरा दृष्टिकोण बदल दिया। अब मैं हर कदम देखने के बजाय पूरे कार्य सौंपता हूँ—और यही Docker की सीमा संभव बनाती है।

यहाँ से, दो दिशाएँ खोजने लायक हैं:

पहला, अपनी टीम के लिए devcontainer टेम्पलेट्स पर नज़र डालें। GitHub पर Claude Code रेफ़रेंस devcontainer में एक प्री-कॉन्फ़िगर्ड फ़ायरवॉल शामिल है जो आउटबाउंड कनेक्शनों को विश्वसनीय डोमेन्स तक सीमित करता है। दूसरा, Docker MCP Toolkit के साथ प्रयोग करें ताकि Claude Code को आपके मौजूदा टूल्स—GitHub, डेटाबेस, प्रोजेक्ट मैनेजमेंट सिस्टम्स इत्यादि—तक संरचित पहुँच दी जा सके।

अंत में, अपने बेस इमेजेज़ को समय-समय पर अपडेट करने का रिमाइंडर सेट करें। Docker इमेजेज़ समय के साथ कमजोरियाँ इकट्ठा करती हैं, और docker pull node:20-slim के बाद एक रिबिल्ड में कुछ ही मिनट लगते हैं।

यदि आप AI एप्लिकेशन विकसित करने में रुचि रखते हैं, तो मैं हमारे AI Engineering with LangChain स्किल ट्रैक में नामांकन की पक्की सलाह दूँगा। इसमें शामिल कोर्स AI-नेटिव हैं, इसलिए आपको एक व्यक्तिगत शिक्षक मिलेगा जो आपके ठीक-ठीक स्तर से आपको पकड़कर आपकी गति पर आपके लक्ष्यों तक पहुँचने में मदद करेगा।