Gluetun container से host और अन्य services तक कैसे पहुँचें
Gluetun के पीछे मौजूद container का अपना network interface नहीं होता है। इस गाइड में जानें कि कैसे Gluetun पर ports publish करें और केवल आवश्यक subnets को ही tunnel के बाहर खोलें।
जब कोई container gluetun के network से जुड़ता है तो क्या होता है
जो container network_mode: service:gluetun सेट करता है, उसका अपना कोई network interface नहीं होता। वह gluetun के network namespace में शामिल हो जाता है, इसलिए port publishing और firewall rules उस container की विशेषता न रहकर gluetun service की विशेषता बन जाते हैं। नीचे दिए गए सभी उत्तर इसी एक तथ्य पर आधारित हैं।
Network namespace, kernel के network stack की एक निजी प्रतिलिपि होती है: इसके अपने interfaces, अपनी routing table, अपने firewall rules और अपने listening sockets होते हैं। Docker डिफ़ॉल्ट रूप से प्रत्येक container को एक namespace देता है। जब आप network_mode: service:gluetun लिखते हैं, तो Docker उस चरण को छोड़ देता है और नए container को उस namespace के अंदर डाल देता है जिसका स्वामी पहले से ही gluetun है। container अपना filesystem तो रखता है, लेकिन अपना /etc/hosts या /etc/resolv.conf नहीं: Docker उसे वही files देता है जिनका उपयोग gluetun करता है, और यह बाद में महत्वपूर्ण हो जाता है।
आप इसे सीधे देख सकते हैं।
docker inspect -f '{{.HostConfig.NetworkMode}}' qbittorrentयह container: और उसके बाद gluetun container ID प्रिंट करता है, जबकि एक सामान्य container bridge प्रिंट करेगा। यह मार्गदर्शिका वहाँ से शुरू होती है जहाँ gluetun के साथ VPN के माध्यम से Docker traffic को route करना समाप्त होता है: tunnel काम कर रही है, और अब container से कोई भी संपर्क नहीं कर सकता।
पोर्ट को application पर नहीं, gluetun पर publish करें
service पर एक ports: block छोड़ दें जो network_mode सेट करता हो, तो Docker container बनाने से मना कर देगा:
Error response from daemon: conflicting options: port publishing and the container type network modeइसका कारण सीधा है। पोर्ट publish करने का अर्थ है एक NAT (network address translation) rule जोड़ना, जो host पोर्ट को container के अपने network namespace में forward करता है, और इस container का अपना कोई namespace नहीं होता। mapping को gluetun service पर ले जाएँ। पोर्ट नंबर नहीं बदलता, क्योंकि application अभी भी shared namespace के अंदर उसी पोर्ट पर listen कर रही है।
services:
gluetun:
ports:
- "8080:8080/tcp" # qBittorrent web UI
qbittorrent:
network_mode: "service:gluetun"
# no ports: block heredependent service पर एक expose: block भी इसी तरह विफल हो जाता है, जिसमें conflicting options: port exposing and the container type network mode आता है, और वहाँ एक networks: block भी एक hard stop है: Compose रिपोर्ट करता है कि service परस्पर विरोधी network_mode और networks घोषित करती है, और file को load करने से पूरी तरह मना कर देती है।
इसका एक परिणाम बाद में सामने आता है। namespace में प्रत्येक container एक ही पोर्ट space साझा करता है, इसलिए दो applications जो दोनों default रूप से 8080 पर चलती हैं, आपस में टकराती हैं, और दूसरी application जो start होती है, वह address already in use error के साथ विफल हो जाती है। उनमें से किसी एक को उसकी अपनी configuration में बदलें, उदाहरण के लिए LinuxServer qBittorrent image पर WEBUI_PORT variable, और फिर नए नंबर को gluetun पर publish करें।
Gluetun के पीछे स्थित containers एक-दूसरे तक कैसे पहुँचते हैं?
Namespace के अंदर वे पहले से ही एक loopback interface साझा करते हैं। Gluetun के पीछे स्थित एक container अपने sibling तक 127.0.0.1:<port> पर पहुँचता है, जिसमें किसी Docker network की आवश्यकता नहीं होती।
Namespace के बाहर से, container का कोई नाम नहीं होता। Docker का embedded DNS किसी service name को user-defined network पर उस service के address में resolve करता है, और इस container का किसी भी network पर कोई address नहीं होता। इसलिए Sonarr जैसा एक सामान्य container, torrent client तक http://qbittorrent:8080 पर नहीं पहुँचता। यह उस तक http://gluetun:8080 पर पहुँचता है, क्योंकि socket gluetun के namespace में, gluetun के address पर listen कर रहा होता है। यह उन लोगों को आश्चर्यचकित करता है जो Docker Compose networks और service names कैसे काम करते हैं जानते हैं और सामान्य naming लागू होने की अपेक्षा करते हैं। यह host पर कुछ भी publish किए बिना भी काम करता है, क्योंकि दोनों containers एक ही Compose network पर होते हैं।
किसी भी अन्य चीज़ को debug करने से पहले DNS की जाँच करें। Gluetun namespace के अंदर अपना स्वयं का DNS server चलाता है, और Docker gluetun के पीछे के प्रत्येक container को वही /etc/resolv.conf file देता है जो gluetun के पास होती है, इसलिए आपके application के lookups host के resolver के बजाय gluetun के resolver के माध्यम से जाते हैं। डिफ़ॉल्ट रूप से, वह resolver उन उत्तरों को भी अस्वीकार कर देता है जो private addresses की ओर इशारा करते हैं, यही कारण है कि जो नाम host पर resolve हो जाता है, वह container के अंदर विफल हो सकता है। Gluetun documentation का कहना है कि ऐसे hostnames को DNS_REBINDING_PROTECTION_EXEMPT_HOSTNAMES में सूचीबद्ध किया जाना चाहिए।
docker exec qbittorrent cat /etc/resolv.confDocker host पर चल रही service तक कैसे पहुँचें?
host.docker.internal का उपयोग करें। इसमें gluetun service पर दो settings की आवश्यकता होती है, क्योंकि दो अलग-अलग चीजें काम नहीं कर रही होती हैं।
नाम पहले आता है। gluetun के पीछे का एक container gluetun की /etc/hosts को पढ़ता है, और Docker उस service पर extra_hosts entry को अस्वीकार कर देता है जो conflicting options: custom host-to-IP mapping and the network mode के साथ network_mode सेट करती है। इसलिए यह entry gluetun पर होनी चाहिए, और namespace में मौजूद हर container इसे देख सकता है।
gluetun:
extra_hosts:
- "host.docker.internal:host-gateway"host-gateway एक विशेष मान है जिसे Docker host के आंतरिक पते (internal address) से बदल देता है। एक सामान्य Linux Docker install पर यह docker0 bridge का पता होता है, जो आमतौर पर 172.17.0.1 होता है। VPS पर ip -4 addr show docker0 के साथ अपने पते की पुष्टि करें। Docker Desktop इस नाम को स्वयं resolve कर लेता है, यही कारण है कि laptop पर लिखे गए guides extra_hosts line को छोड़ देते हैं और वही file फिर server पर विफल हो जाती है।
route दूसरे स्थान पर आता है। केवल नाम जोड़ने से container को यह पता चलता है कि किस पते का उपयोग करना है। packet अभी भी gluetun के default route, यानी tunnel के माध्यम से बाहर निकलता है, और gluetun का firewall उसे drop कर देता है। इसका लक्षण एक ऐसा connection है जो hang हो जाता है और फिर time out हो जाता है, न कि वह जिसे अस्वीकार (refuse) कर दिया गया हो। अस्वीकृति का मतलब है कि packet पहुँच गया और किसी ने 'नहीं' में उत्तर दिया। time out का मतलब है कि यह कभी पहुँचा ही नहीं।
gluetun:
environment:
- FIREWALL_OUTBOUND_SUBNETS=172.17.0.1/32फिर जाँचें कि host service वास्तव में उस पते पर listen कर रही है या नहीं। केवल 127.0.0.1 पर bound PostgreSQL server किसी भी ऐसे container से पहुँच योग्य नहीं है जिसका अपना network namespace है, जिसमें gluetun के पीछे के सभी containers शामिल हैं, चाहे tunnel हो या न हो, क्योंकि namespace के अंदर 127.0.0.1 उस namespace का अपना loopback होता है। केवल host networking पर मौजूद container ही host के loopback को साझा करता है, और gluetun के पीछे के container ने अपना network_mode पहले ही gluetun पर खर्च कर दिया है। इसके बजाय PostgreSQL को 172.17.0.1 पर bind करें: यह public interface से दूर रहते हुए containers से connection स्वीकार करता है। host पर ss -lntp | grep 5432 के साथ इसकी पुष्टि करें।
FIREWALL_OUTBOUND_SUBNETS वास्तव में क्या बदलता है
gluetun का documentation इसे उन comma-separated subnets के रूप में वर्णित करता है जिन्हें gluetun और इसके network stack को साझा करने वाले containers एक्सेस कर सकते हैं। यह नोट करता है कि इसमें firewall और routing में बदलाव शामिल हैं। दोनों हिस्से महत्वपूर्ण हैं। Gluetun प्रत्येक सूचीबद्ध subnet के लिए Docker bridge gateway के माध्यम से एक route जोड़ता है, ताकि उन addresses के लिए packets tunnel के बजाय eth0 पर बाहर निकलें। यह उनके लिए firewall भी खोलता है, क्योंकि अन्यथा gluetun उस outbound traffic को drop कर देता है जो VPN server के लिए नहीं होता है।
value को commas के बाद बिना किसी space के लिखें।
- FIREWALL_OUTBOUND_SUBNETS=172.17.0.1/32,192.168.1.0/24,100.64.7.9/32दो properties को अनदेखा करना आसान है। यह एक namespace level की setting है, इसलिए यह केवल आपके द्वारा सोचे गए container पर ही नहीं, बल्कि gluetun के पीछे के हर container पर लागू होती है। और यह केवल outbound है: यह उन connections को नियंत्रित करती है जिन्हें एक container शुरू करता है। published port पर आने वाले connections एक अलग रास्ते से आते हैं और उन्हें यहाँ किसी entry की आवश्यकता नहीं होती है।
Tailscale peer से web UI तक पहुँचना
Tailscale हर मशीन को 100.64.0.0/10 में एक पता देता है, जो carrier grade NAT के लिए आरक्षित रेंज है। व्यक्तिगत tailnet पर इसका कोई शुल्क नहीं लगता है, हालाँकि free plan की छह उपयोगकर्ताओं की सीमा यह तय करती है कि जब अन्य लोगों को उन्हीं UI तक पहुँच की आवश्यकता हो, तो क्या यह स्थिति बनी रहती है। हर plan पर उपयोगकर्ता उपकरणों की संख्या असीमित है। सर्वर और अन्य tagged उपकरणों की गणना अलग से की जाती है: Tailscale का pricing page 50 tagged संसाधनों को शामिल करता है, और उससे अधिक होने पर $1 प्रति माह का शुल्क लगता है। चूँकि बिलिंग में मशीनों के बजाय उपयोगकर्ताओं की गणना होती है, इसलिए paid tailnet की वास्तविक लागत मुख्य रूप से इस पर निर्भर करती है कि आप कितने लोगों को आमंत्रित करते हैं, न कि इस पर कि आप उनके लिए कितने containers expose करते हैं। दोनों दिशाओं के लिए अलग-अलग कार्य करने की आवश्यकता होती है।
Inbound (आने वाला) ट्रैफ़िक सरल है। gluetun पर 8080:8080 पब्लिश करने से वह port host के सभी पतों पर bind हो जाता है, और host का tailscale0 interface उनमें से एक है, इसलिए एक peer http://<machine-name>:8080 खोलता है और container तक पहुँच जाता है। Docker host पर NAT लागू करता है, और gluetun का firewall उसके Docker subnet पर आने वाले ट्रैफ़िक की अनुमति देता है।
UI को केवल tailnet पर ही सुलभ बनाने के लिए, पब्लिश किए गए port को हर पते के बजाय host के Tailscale पते पर bind करें।
ports:
- "100.101.102.103:8080:8080/tcp"host पर tailscale ip -4 के साथ वह पता ढूँढें। यहाँ firewall rule की तुलना में binding एक अधिक मजबूत नियंत्रण है, क्योंकि port public interface पर बिल्कुल भी नहीं खुलता है। यदि आप host और port के बजाय HTTPS नाम पर UI तक पहुँचना पसंद करते हैं, तो tailscale serve उस पब्लिश किए गए port के सामने रह सकता है, हालाँकि serve और funnel में यह अंतर है कि अंत में कौन उस तक पहुँच सकता है और दोनों में से केवल एक ही UI को tailnet पर रखता है। यह Docker द्वारा ufw के सीधे bypass होकर port पब्लिश करने की समस्या को भी टाल देता है। Compose के लिए Tailscale sidecar pattern और आगे जाता है और host port को पूरी तरह से हटा देता है, लेकिन यह app को sidecar के network namespace में रखकर काम करता है, और gluetun के पीछे का container अपना एकमात्र network_mode पहले ही gluetun पर खर्च कर चुका होता है।
Outbound (बाहर जाने वाला) ट्रैफ़िक वह जगह है जहाँ FIREWALL_OUTBOUND_SUBNETS वापस आता है। यदि किसी container को किसी peer को कॉल करना है, तो उस peer का पता जोड़ें, और पूरे /10 के बजाय प्रति peer एक /32 को प्राथमिकता दें। यदि आप जिस मशीन को कॉल कर रहे हैं वह एक private network पर स्थित है जिसे आपके tailnet पर उस subnet को advertise करने वाले VPS के माध्यम से एक्सेस किया जाता है, तो router के अपने 100.x पते के बजाय advertise की गई रेंज को सूचीबद्ध करें, और पुष्टि करें कि host ने स्वयं उन routes को स्वीकार कर लिया है। MagicDNS नाम डिफ़ॉल्ट रूप से container के अंदर resolve नहीं होते हैं, क्योंकि container host के resolver के बजाय gluetun के DNS सर्वर का उपयोग करता है, इसलिए संख्यात्मक 100.x पते का उपयोग करें या gluetun service पर extra_hosts लाइन के साथ नाम को पिन करें। Gluetun का DNS_UPSTREAM_PLAIN_ADDRESSES विकल्प इसके बजाय queries को किसी अन्य resolver पर forward कर सकता है, लेकिन यह हर query को plaintext में भेजता है, और gluetun documentation इसके खिलाफ सलाह देता है क्योंकि private पते पर की गई queries VPN tunnel से बाहर लीक हो जाती हैं। यही बात तब लागू होती है जब आप Headscale के साथ अपना स्वयं का Tailscale control server चलाते हैं।
सामान्य संरचना के लिए एक पूर्ण compose file
VPN के पीछे एक डाउनलोड क्लाइंट, केवल tailnet पर प्रतिक्रिया देने वाले दो वेब UI, और एक कंटेनर जो होस्ट पर चल रहे PostgreSQL डेटाबेस को पढ़ता है।
services:
gluetun:
image: qmcgaw/gluetun:latest
container_name: gluetun
cap_add:
- NET_ADMIN
devices:
- /dev/net/tun:/dev/net/tun
ports:
- "127.0.0.1:8000:8000/tcp" # gluetun control server, host only
- "100.101.102.103:8080:8080/tcp" # qBittorrent UI, tailnet only
- "100.101.102.103:9696:9696/tcp" # Prowlarr UI, tailnet only
extra_hosts:
- "host.docker.internal:host-gateway"
volumes:
- ./gluetun:/gluetun
environment:
- VPN_SERVICE_PROVIDER=mullvad
- VPN_TYPE=wireguard
- WIREGUARD_PRIVATE_KEY=${WIREGUARD_PRIVATE_KEY}
- WIREGUARD_ADDRESSES=${WIREGUARD_ADDRESSES}
- SERVER_CITIES=Amsterdam
- FIREWALL_OUTBOUND_SUBNETS=172.17.0.1/32,100.64.7.9/32
- TZ=Europe/Amsterdam
restart: unless-stopped
qbittorrent:
image: lscr.io/linuxserver/qbittorrent:latest
network_mode: "service:gluetun"
environment:
- PUID=1000
- PGID=1000
- TZ=Europe/Amsterdam
- WEBUI_PORT=8080
volumes:
- ./qbittorrent:/config
- /srv/downloads:/downloads
depends_on:
gluetun:
condition: service_healthy
restart: unless-stopped
prowlarr:
image: lscr.io/linuxserver/prowlarr:latest
network_mode: "service:gluetun"
environment:
- PUID=1000
- PGID=1000
- TZ=Europe/Amsterdam
- PROWLARR__POSTGRES__HOST=host.docker.internal
- PROWLARR__POSTGRES__PORT=5432
- PROWLARR__POSTGRES__USER=prowlarr
- PROWLARR__POSTGRES__PASSWORD=${PROWLARR_DB_PASSWORD}
- PROWLARR__POSTGRES__MAINDB=prowlarr-main
- PROWLARR__POSTGRES__LOGDB=prowlarr-log
volumes:
- ./prowlarr:/config
depends_on:
gluetun:
condition: service_healthy
restart: unless-stoppedउत्पाद के नामों के बजाय पैटर्न के लिए फ़ाइल को पढ़ें। दोनों UI gluetun पर पब्लिश किए गए हैं और होस्ट के tailnet पते से बंधे हैं, इसलिए वे केवल Tailscale पर प्रतिक्रिया देते हैं, कहीं और नहीं। extra_hosts लाइन भी gluetun पर स्थित है, क्योंकि जब Prowlarr host.docker.internal को रिज़ॉल्व करता है तो वह gluetun के /etc/hosts को पढ़ता है, और Docker स्वयं Prowlarr पर इस लाइन को अस्वीकार कर देगा। FIREWALL_OUTBOUND_SUBNETS दो एकल पतों को नामित करता है: होस्ट का Docker ब्रिज पता, ताकि Prowlarr डेटाबेस कनेक्शन खोल सके, और एक tailnet पीयर।
PostgreSQL सर्वर जानबूझकर फ़ाइल से अनुपस्थित है। यह VPS पर एक सामान्य सिस्टम सर्विस के रूप में चलता है जो 172.17.0.1:5432 पर लिसन करता है। यह Docker Compose पर एक arr स्टैक के समान लेयरिंग है, जिसमें डेटाबेस को Docker के बाहर रखा गया है।
WireGuard प्राइवेट की को compose फ़ाइल से बाहर रखें। ${WIREGUARD_PRIVATE_KEY} अपने बगल में स्थित एक .env फ़ाइल से पढ़ता है, यह पैटर्न Docker Compose के लिए env फ़ाइलें और सीक्रेट्स में कवर किया गया है। condition: service_healthy क्लॉज उस हेल्थचेक का उपयोग करता है जो gluetun इमेज में पहले से मौजूद है, इसलिए जब तक टनल चालू होने की रिपोर्ट नहीं देती, तब तक कुछ भी शुरू नहीं होता है। Compose हेल्थचेक्स सामान्य रूप को समझाते हैं।
केवल tailnet के बजाय हर पते पर पब्लिश करना
0.0.0.0 पर एड्रेस प्रीफिक्स और पोर्ट बाइंड्स को हटा दें, जिसमें VPS का पब्लिक IP शामिल है। ऐसा केवल उस फ़ायरवॉल के पीछे करें जिसे आप नियंत्रित करते हैं, और पहले ऊपर दिए गए ufw नोट को पढ़ें।
ports:
- "8080:8080/tcp"पुष्टि करें कि टनल अभी भी ट्रैफिक ले जा रही है
एक ही request को दो बार चलाएं, एक बार namespace के अंदर से और एक बार host से, और तुलना करें।
docker run --rm --network=container:gluetun curlimages/curl:latest -s https://api.ipify.org
curl -s https://api.ipify.orgपहली request को आपके VPN प्रदाता का exit address दिखाना चाहिए। दूसरी को VPS का address दिखाना चाहिए। यदि वे मेल खाते हैं, तो container का ट्रैफिक टनल से होकर नहीं जा रहा है, और इस गाइड का कोई भी समाधान तब तक व्यर्थ है जब तक इसे ठीक नहीं किया जाता।
Routing rules और tables दिखाती हैं कि क्या टनल से बाहर है और क्या नहीं।
docker run --rm --network=container:gluetun alpine:3.22 sh -c 'ip rule show; ip route show table 51820; ip route show table 199'इस गाइड में WireGuard सेटअप के साथ, gluetun टनल इंटरफ़ेस का नाम wg0 रखता है। tun0 नाम केवल इसका OpenVPN डिफ़ॉल्ट है। Gluetun टनल के डिफ़ॉल्ट रूट को main routing table से बाहर भी रखता है। ip rule show में एक rule शामिल होना चाहिए जो WireGuard द्वारा चिह्नित न किए गए सभी ट्रैफिक को table 51820 पर भेजता है, और उस table में wg0 पर एक डिफ़ॉल्ट रूट होना चाहिए। Table 199 में FIREWALL_OUTBOUND_SUBNETS की प्रत्येक प्रविष्टि के लिए एक रूट होता है, जो eth0 पर Docker bridge gateway की ओर इशारा करता है, और इसके rule की जाँच टनल के rule से ठीक पहले की जाती है। एक साधारण ip route show अभी भी eth0 पर Docker का अपना डिफ़ॉल्ट रूट दिखाता है। यह अपेक्षित है और यह कोई leak नहीं है, क्योंकि gluetun के दोनों rules की जाँच main table से पहले की जाती है। Table 199 में कोई भी रूट जिसे आपने सूचीबद्ध नहीं किया है, वह ऐसा ट्रैफिक है जो VPN को छोड़ देता है।
Gluetun का control server /v1/publicip/ip पर, port 8000 पर वही public IP रिपोर्ट कर सकता है, लेकिन डिफ़ॉल्ट रूप से केवल authentication सेट करने के बाद। Gluetun documentation बताता है कि सभी control server routes अब डिफ़ॉल्ट रूप से private हैं, इसलिए उस path पर एक साधारण request विफल हो जाती है। इसे basic या apikey विधि का उपयोग करके /gluetun/auth/config.toml पर bind mounted auth फ़ाइल के साथ कॉन्फ़िगर करें, फिर gluetun को पुनरारंभ करें। ऊपर दी गई compose फ़ाइल पहले से ही ./gluetun को /gluetun पर माउंट करती है, इसलिए फ़ाइल host पर ./gluetun/auth/config.toml पर जाती है। HTTP_CONTROL_SERVER_AUTH_DEFAULT_ROLE वेरिएबल एक तेज़ विकल्प है। इसे {"auth":"none"} पर सेट करने से authentication पूरी तरह से बंद हो जाता है, जिसे docs अत्यधिक असुरक्षित मानते हैं। v3.39.1 से पहले के release में सर्वर इस तरह से लॉक नहीं होता है, और docs आपको चेतावनी देते हैं कि जो भी उस तक पहुँच सकता है, उस पर भरोसा न करें।
गलत subnet से होने वाला leak
FIREWALL_OUTBOUND_SUBNETS एक ऐसा छेद है जिसे आप जानबूझकर firewall में करते हैं, इसलिए छेद का आकार ही जोखिम का आकार है। चार गलतियों से बचें:
0.0.0.0/0,outbound subnet has an unspecified address: 0.0.0.0/0के साथ configuration validation में विफल रहता है। Gluetun tunnel के बाहर सब कुछ route करने के बजाय इसे अस्वीकार कर देता है।- लक्ष्य से बड़ी रेंज।
10.0.1.7पर एक मशीन तक पहुँचने के लिए10.0.0.0/8खोलना उन सभी पतों को भी खोल देता है जिन्हें एक torrent peer उस रेंज में advertise कर सकता है।10.0.1.7/32लिखें। - ऐसी रेंज जो tunnel के अपने पतों के साथ ओवरलैप करती हो। Gluetun documentation चेतावनी देता है कि इससे gluetun VPN ट्रैफ़िक को bridge के माध्यम से बाहर भेज देता है, जिससे port forwarding टूट जाता है। किसी भी private रेंज को खोलने से पहले अपने
WIREGUARD_ADDRESSESमान की जाँच करें। - Tailscale के लिए
100.64.0.0/10। यह लगभग चालीस लाख खुले पते हैं ताकि एक peer तक पहुँचा जा सके। जिन peers की आपको आवश्यकता है उन्हें/32प्रविष्टियों के रूप में सूचीबद्ध करें।
याद रखें कि यह सेटिंग पूरे namespace को कवर करती है। एक subnet को खोलना ताकि indexer किसी host service तक पहुँच सके, उसी subnet को उस torrent client के लिए भी खोल देता है जो उस namespace को साझा कर रहा है। इस variable में हर बदलाव के बाद public IP जाँच को फिर से चलाएँ, क्योंकि यह एकमात्र परीक्षण है जो दिखाता है कि क्या बदलाव ने वही किया जो आप चाहते थे।
gluetun को restart करने पर क्या खराब होता है
gluetun namespace का स्वामी है, इसलिए gluetun का lifecycle ही namespace का lifecycle है। जब gluetun बंद हो, तो उस पर निर्भर container को start करने का प्रयास तुरंत विफल हो जाता है:
Error response from daemon: cannot join network namespace of a non running container: container <id> is exitedgluetun को उसी स्थान पर restart करना एक शांत विफलता (quieter failure) है। निर्भर containers चलते रहते हैं, जबकि जिस namespace से वे जुड़े थे, उसे उनके नीचे से ही फिर से बनाया (rebuild) जा रहा होता है। इस कारण docker ps सब कुछ ठीक होने की रिपोर्ट देता है, लेकिन कोई भी response नहीं मिलता। gluetun service में किसी भी बदलाव के बाद, किसी एक हिस्से को restart करने के बजाय पूरे group को recreate करें।
docker compose up -d --force-recreateयही बात image updates पर भी लागू होती है। gluetun की नई image pull करना और केवल उस एक service को recreate करना, बाकी services को एक ऐसे namespace की ओर इंगित करता है जो अब अस्तित्व में नहीं है।
FAQ
Docker यह क्यों कहता है कि "port publishing and the container type network mode" में समस्या है?
ऐसा इसलिए है क्योंकि एक ports: ब्लॉक अभी भी उस सर्विस पर है जो network_mode: service:gluetun को भी सेट करती है। पोर्ट पब्लिश करने से एक NAT नियम जुड़ जाता है जो होस्ट पोर्ट को कंटेनर के अपने नेटवर्क नेमस्पेस में फॉरवर्ड करता है, और इस मोड में कंटेनर के पास अपना नेमस्पेस नहीं होता है। उस सर्विस से ports: ब्लॉक को हटा दें और वही मैपिंग gluetun सर्विस में जोड़ दें। पोर्ट नंबर वही रहेगा, क्योंकि एप्लिकेशन अभी भी उसी साझा नेमस्पेस के अंदर उस पर लिसन कर रही है।
gluetun के पीछे स्थित सर्विस तक अन्य कंटेनर कैसे पहुँचते हैं?
एक ही नेमस्पेस के अंदर के कंटेनर एक-दूसरे तक 127.0.0.1 पर पहुँचते हैं। इसके बाहर के कंटेनर gluetun सर्विस के नाम का उपयोग करते हैं, इसलिए http://gluetun:8080 काम करता है जबकि http://qbittorrent:8080 नहीं। एप्लिकेशन कंटेनर के पास किसी भी Docker नेटवर्क पर कोई पता नहीं होता है, इसलिए एम्बेडेड DNS सर्वर के पास उसके नाम के लिए रिज़ॉल्व करने हेतु कुछ नहीं होता है। इसके लिए किसी पोर्ट पब्लिशिंग की आवश्यकता नहीं है, बशर्ते दोनों कंटेनर एक ही Compose नेटवर्क साझा करते हों।
मुझे FIREWALL_OUTBOUND_SUBNETS में क्या डालना चाहिए?
केवल वे पते जिनसे gluetun के पीछे के कंटेनर को कनेक्शन शुरू करना है, उन्हें जितना संभव हो उतना सटीक लिखें। एक सिंगल मशीन एक /32 है। दो सामान्य प्रविष्टियाँ 172.17.0.1/32 पर Docker होस्ट और आपके द्वारा कॉल किए जाने वाले प्रत्येक Tailscale पीयर के लिए एक /32 हैं। कभी भी 0.0.0.0/0 न जोड़ें, और कभी भी ऐसी रेंज न जोड़ें जो आपके VPN के अपने टनल पतों के साथ ओवरलैप हो। पब्लिश किए गए पोर्ट पर आने वाले इनबाउंड कनेक्शन के लिए यहाँ किसी प्रविष्टि की आवश्यकता नहीं है।
कंटेनर मेरे Tailscale MagicDNS नामों को रिज़ॉल्व क्यों नहीं कर पा रहा है?
MagicDNS होस्ट के रिज़ॉल्वर को Tailscale के DNS सर्वर पर पॉइंट करके काम करता है, और कंटेनर होस्ट के रिज़ॉल्वर का उपयोग नहीं करता है। यह उस /etc/resolv.conf का उपयोग करता है जिसे वह gluetun के साथ साझा करता है, जो gluetun के अपने DNS सर्वर पर पॉइंट करता है। docker exec <container> cat /etc/resolv.conf के साथ पुष्टि करें। पीयर के संख्यात्मक 100.x पते का उपयोग करें, या gluetun सर्विस पर extra_hosts प्रविष्टि के साथ नाम को पिन करें। Gluetun DNS_UPSTREAM_PLAIN_ADDRESSES के साथ क्वेरी को किसी अन्य रिज़ॉल्वर पर फॉरवर्ड कर सकता है, लेकिन यह उन्हें प्लेनटेक्स्ट में भेजता है और इसका डॉक्यूमेंटेशन ऐसा न करने की सलाह देता है।
मैं यह कैसे पुष्टि करूँ कि ट्रैफिक अभी भी VPN के माध्यम से जा रहा है?
नेमस्पेस के अंदर से एक रिक्वेस्ट चलाएँ और होस्ट से वही रिक्वेस्ट चलाएँ, फिर उत्तरों की तुलना करें। docker run --rm --network=container:gluetun curlimages/curl:latest -s https://api.ipify.org को आपके VPN प्रदाता का एग्जिट एड्रेस दिखाना चाहिए, जबकि VPS पर curl -s https://api.ipify.org को VPS का पता दिखाना चाहिए। दो मेल खाते उत्तरों का मतलब है कि टनल कंटेनर के ट्रैफिक को नहीं ले जा रहा है। FIREWALL_OUTBOUND_SUBNETS में हर बदलाव के बाद इस जाँच को फिर से चलाएँ।