SSD Nodes Learn Hosting plans →

Docker కంటైనర్లను VPN ద్వారా రూట్ చేయడం ఎలా?

Gluetun సైడ్‌కార్‌ను ఉపయోగిస్తున్నప్పుడు కంటైనర్ పోర్టులు ఎందుకు పనిచేయవో తెలుసుకోండి. షేర్డ్ నెట్‌వర్క్ నేమ్‌స్పేస్ వల్ల కలిగే సమస్యలను పరిష్కరించే సరైన Docker Compose ఫైల్ ఇక్కడ ఉంది.

Docker containers ను VPN ద్వారా route చేసినప్పుడు ports ఎందుకు కనిపించకుండా పోతాయి

Docker containers ను VPN ద్వారా route చేయడానికి ఒక container కు tunnel అందించి, తరువాత network_mode: "service:gluetun" తో మిగతా containers ను దాని network namespace కు జతచేయాలి. ఈ attachment వల్లే చాలామందికి ఆశ్చర్యం కలుగుతుంది. జతచేసిన container కు ఇక ప్రత్యేక network ఉండదు. అందువల్ల దాని published ports మరియు Docker service name కూడా అందుబాటులో ఉండవు. Ports ను VPN container పైనే publish చేయాలి. అప్పుడు ఇతర containers VPN container name ద్వారా ఆ app ను చేరుకోగలవు.

జతచేసిన container లో ports: block ఉంచితే Docker దాన్ని అసలు create చేయదు:

Error response from daemon: conflicting options: port publishing and the container type network mode

ఇక్కడ ఉపయోగించిన tool Gluetun. ఇది WireGuard లేదా OpenVPN ద్వారా commercial VPN (virtual private network) provider కు connect అయి, తన స్వంత firewall ను నిర్వహించే container. October 2026 నాటికి Release v3.41.3 ప్రస్తుత version. ఉదాహరణల్లో WireGuard తో Mullvad ను ఉపయోగిస్తున్నాం. అందువల్ల మీ provider నుంచి account మరియు key అవసరం. మీరు tunnel ను మీ స్వంత hardware పై terminate చేయాలనుకుంటే, VPS పై మీ స్వంత WireGuard server ను నడపడం ద్వారా tunnel యొక్క మరో చివరను నిర్మించవచ్చు. Docker లో wg-easy దానికి web interface ను అందిస్తుంది.

network_mode: "service:gluetun" వాస్తవానికి ఏమి చేస్తుంది

ప్రతి Docker container సాధారణంగా తన సొంత network namespace ను కలిగి ఉంటుంది: అంటే దాని సొంత interfaces, routing table, firewall rules మరియు listening sockets ఉంటాయి. service: mode ఆ దశను దాటవేసి, gluetun యొక్క namespace లోపల container ను ప్రారంభిస్తుంది. ఒకే namespace అంటే ఒకే IP address అని అర్థం, ఇది ఆరు విషయాలను మారుస్తుంది.

  • అప్లికేషన్‌కు దాని సొంత address ఉండదు. దాని address gluetun యొక్క address అవుతుంది.
  • అప్లికేషన్ ఏ Docker network కు అనుసంధానించబడదు, కాబట్టి దాని service name ఎప్పటికీ register అవ్వదు మరియు resolve అవ్వదు. ఇతర containers తప్పనిసరిగా gluetun ను ఉపయోగించాలి.
  • namespace లోపల ఉన్న containers ఒకదానికొకటి localhost ద్వారా చేరుకుంటాయి.
  • ఒకే namespace లో ఉన్న రెండు containers ఒకే port పై వినలేవు (listen అవ్వలేవు). Gluetun డాక్యుమెంటేషన్ దీని గురించి స్పష్టంగా చెబుతోంది: దీనికి ఎటువంటి ప్రత్యామ్నాయం లేదు.
  • Capabilities అనేవి ఒక container కు చెందుతాయి, namespace కు కాదు. Gluetun tunnel interface ను సృష్టిస్తుంది కాబట్టి, అది NET_ADMIN మరియు /dev/net/tun లను కలిగి ఉంటుంది. అనుసంధానించబడిన container వాటిని వారసత్వంగా పొందదు.
  • ఒక service network_mode మరియు networks రెండింటినీ సెట్ చేసే ఫైల్‌ను Compose తిరస్కరిస్తుంది. Gluetun ను మీ networks కు అనుసంధానించండి, అప్పుడు అప్లికేషన్ దానితో పాటు పనిచేస్తుంది.

Gluetun ను restart చేయడం వల్ల దానికి అనుసంధానించబడినవన్నీ డిస్‌కనెక్ట్ అవుతాయి. ఇది డాక్యుమెంట్ చేయబడిన ప్రవర్తన, మరియు కనెక్షన్ విఫలమైనప్పుడు gluetun బయటకు వచ్చేయకుండా, container లోపల VPN ప్రాసెస్‌ను restart చేయడానికి ఇదే కారణం. మీరు gluetun ను స్వయంగా restart చేసినా లేదా మళ్ళీ సృష్టించినా, దానికి అనుసంధానించబడిన containers ను కూడా restart చేయండి.

పనిచేసే compose ఫైల్

services:
  gluetun:
    image: qmcgaw/gluetun:v3
    container_name: gluetun
    cap_add:
      - NET_ADMIN
    devices:
      - /dev/net/tun:/dev/net/tun
    environment:
      - VPN_SERVICE_PROVIDER=mullvad
      - VPN_TYPE=wireguard
      - SERVER_CITIES=Amsterdam
      - TZ=Europe/Amsterdam
    env_file:
      - ./gluetun.env
    volumes:
      - ./gluetun:/gluetun
    ports:
      - 127.0.0.1:8080:8080/tcp
    restart: unless-stopped

  qbittorrent:
    image: lscr.io/linuxserver/qbittorrent:latest
    container_name: qbittorrent
    network_mode: "service:gluetun"
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Amsterdam
      - WEBUI_PORT=8080
    volumes:
      - ./qbittorrent:/config
      - ./downloads:/downloads
    depends_on:
      gluetun:
        condition: service_healthy
    restart: unless-stopped

:v3 ట్యాగ్ v3 సిరీస్‌లో అత్యంత కొత్త స్థిరమైన (stable) విడుదల. :latest ట్యాగ్ మాస్టర్ బ్రాంచ్ యొక్క చివరి కమిట్‌ను సూచిస్తుంది, ఇది అభివృద్ధి దశలో ఉన్న వెర్షన్. కాబట్టి, మీరు మంగళవారం నాడు డీబగ్గింగ్ చేయకూడదనుకునే మెషీన్‌పై :v3 ని పిన్ (pin) చేయండి.

WEBUI_PORT=8080 పబ్లిష్ చేసిన పోర్ట్‌తో సరిపోలాలి, ఎందుకంటే qBittorrent అనేది gluetun యొక్క నేమ్‌స్పేస్ లోపల బైండ్ అవుతుంది మరియు పబ్లిష్ రూల్ హోస్ట్ ట్రాఫిక్‌ను అక్కడి 8080 పోర్ట్‌కు పంపుతుంది. ఒక నంబర్‌ను మార్చి మరొకటి మార్చకపోతే, ఆ పోర్ట్ ఏ సమాధానం ఇవ్వదు. 127.0.0.1:8080:8080 వెబ్ ఇంటర్‌ఫేస్‌ను హోస్ట్ లూప్‌బ్యాక్ అడ్రస్‌పై ఉంచుతుంది. కేవలం 8080:8080 అని ఇస్తే అది ప్రతి ఇంటర్‌ఫేస్‌పై పబ్లిష్ అవుతుంది మరియు దాని సొంత ఫైర్‌వాల్ రూల్‌ను రాస్తుంది, Docker పబ్లిష్ చేసిన పోర్ట్‌లు ufw ను ఎలా దాటి వెళ్తాయో ఇది చూపిస్తుంది.

దీనిని ప్రారంభించి, ఈ క్రమంలో తనిఖీ చేయండి:

docker compose up -d
docker compose ps
docker compose logs gluetun | tail -30

docker compose ps కమాండ్ gluetun ను healthy గా మరియు qbittorrent ను running గా చూపాలి. ఆ తర్వాత నేమ్‌స్పేస్ లోపల నుండి ఎగ్జిట్ అడ్రస్‌ను నిర్ధారించుకోండి, మిగిలినవన్నీ దీనిపైనే ఆధారపడి ఉంటాయి:

docker run --rm --network=container:gluetun alpine:3.22 sh -c "apk add wget && wget -qO- https://ipinfo.io"

ఆ JSON లోని ip ఫీల్డ్ మీ VPN ప్రొవైడర్ అడ్రస్‌ను కలిగి ఉండాలి. ఒకవేళ అది మీ సర్వర్ యొక్క సొంత అడ్రస్ అయితే, అప్లికేషన్ టన్నెల్ లోపల లేదు అని అర్థం, అప్పుడు కింద పేర్కొన్న ఏదీ వివరించినట్లుగా పనిచేయదు.

Compose ఫైల్‌లో కీలను ఉంచవద్దు

gluetun.env క్రెడెన్షియల్స్‌ను కలిగి ఉంటుంది, ఇది git లో ఉండకూడదు:

WIREGUARD_PRIVATE_KEY=wOEI9rqqbDwnN8/Bpp22sVz48T71vJ4fYmFWujulwUU=
WIREGUARD_ADDRESSES=10.64.222.21/32

ఈ రెండు విలువలు మీ ప్రొవైడర్ ఖాతా ప్రాంతంలో మీరు రూపొందించే WireGuard కాన్ఫిగరేషన్ ఫైల్ నుండి వస్తాయి. ఈ ఫైల్‌ను 600 మోడ్‌కు సెట్ చేయండి. దీనివల్ల కలిగే ప్రయోజనం గురించి స్పష్టంగా ఉండండి: కీ మీ రిపోజిటరీలో ఉండదు, కానీ Docker socket ను యాక్సెస్ చేయగల ఎవరైనా docker inspect gluetun ద్వారా ప్రతి environment variable ను చూడగలరు. Docker Compose లో environment ఫైళ్లు మరియు secrets మరింత మెరుగైన పద్ధతులను వివరిస్తుంది.

టన్నెల్ వెలుపల ఉన్న container, టన్నెల్ లోపల ఉన్న containerతో ఎలా సంభాషిస్తుంది

రెండు దిశల్లోనూ ఇది పనిచేస్తుంది. ప్రతి దిశకు వేర్వేరు పేరు ఉపయోగించాలి. ఈ రెండు containers కు shared Docker network అవసరం. ఆ network gluetun యొక్క network అయి ఉండాలి, ఎందుకంటే అనుసంధానించిన container కు స్వంత network ఉండదు. Docker Compose networks ఎలా అనుసంధానించబడతాయి అనే విభాగంలో defaults వివరించబడ్డాయి.

వెలుపల నుంచి లోపలికి కనెక్ట్ కావడానికి gluetun పేరు మరియు app listening చేస్తున్న port ను ఉపయోగించాలి. ఒక reverse proxy container, qBittorrent web interface ను gluetun:8080 వద్ద చేరుకోగలదు. దీనికి ports: entry అవసరం లేదు, ఎందుకంటే container-to-container traffic Docker network లోనే ఉంటుంది. అది host port ను ఎప్పుడూ దాటదు.

లోపల నుంచి వెలుపలికి కనెక్ట్ కావడానికి ఇతర container యొక్క service name ను ఉపయోగించాలి. ఉదాహరణకు postgres:5432. v3.41 నుంచి gluetun తన namespace లోపల ఇతర container పేర్లను resolve చేస్తుంది. పేరు resolve కాకపోతే ఆ version లేదా దానికంటే కొత్త version ను pin చేయాలి.

దానికి ఎవరు connection open చేయవచ్చో gluetun యొక్క firewall నిర్ణయిస్తుంది. gluetun యొక్క స్వంత Docker network నుంచి వచ్చే traffic అనుమతించబడుతుంది. వేరే subnet లోని client, మీ LAN లోని laptop లేదా ప్రత్యేక bridge network లోని container కు gluetun firewall మరియు routing ద్వారా return path అనుమతించబడాలి:

FIREWALL_OUTBOUND_SUBNETS=192.168.1.0/24

Documentation లో పేర్కొన్న అర్థం ఖచ్చితమైనది: Gluetun మరియు దాని network stack ను పంచుకునే containers access చేయగల comma-separated subnets.

Internet నుంచి వచ్చే inbound connections వేరే సమస్య. Torrent client యొక్క peers VPN వైపు నుంచి వస్తారు. అందువల్ల host పై port 6881 publish చేయడం వారికి ఉపయోగపడదు. మీ provider నుంచి forwarded port అవసరం. ఆ port ను FIREWALL_VPN_INPUT_PORTS లో list చేయాలి. ఇది VPN server వైపు నుంచి వచ్చే ports ను అనుమతిస్తుంది. ఈ ఉదాహరణలో ఉపయోగించిన Mullvad port forwarding కు support ఇవ్వదు. అందువల్ల port forwarding అందించే provider అవసరం. Docker Compose తో నిర్మించిన media stacks లో సాధారణంగా సరిగా అమలు కాని భాగం ఇదే.

టన్నెల్ పడిపోయినప్పుడు ఏమవుతుంది

విఫలమైనప్పుడు ఈ విధానం తన అదనపు సంక్లిష్టతను సమర్థిస్తుంది. జతచేసిన container, Gluetun interfaces మరియు routing table ను పంచుకుంటుంది. tunnel వెలుపలికి వెళ్లే సాధారణ internet traffic ను Gluetun firewall నిరోధిస్తుంది. అయితే VPN server endpoint, local Docker traffic మరియు configured exceptions కు అనుమతి ఇస్తుంది. tunnel పడిపోయినప్పుడు plain interface కు fallback కాకుండా నిరోధించేది ఈ firewall. client మళ్లీ కనెక్ట్ అవుతున్న సమయంలో packets plain interface నుంచి బయటకు లీక్ అయ్యే వ్యవధి ఉండదు.

Gluetun తన connection ను పర్యవేక్షిస్తుంది. ప్రతి నిమిషం HEALTH_ICMP_TARGET_IPS లోని addresses కు ICMP echo (ping) పంపుతుంది. వీటి default విలువ 1.1.1.1,8.8.8.8. ICMP కు అనుమతి లేకపోతే, ఆ చిన్న check బదులుగా plaintext UDP DNS query ను ఉపయోగిస్తుంది. ప్రతి ఐదు నిమిషాలకు HEALTH_TARGET_ADDRESSES కు పూర్తి TCP మరియు TLS (transport layer security) connection ప్రయత్నిస్తుంది. దీని default విలువ cloudflare.com:443,github.com:443. ఇవి విఫలమైతే, container లోని VPN ను restart చేసి log నమోదు చేస్తుంది:

WARN [vpn] restarting VPN because it failed to pass the healthcheck: periodic check: dialing: dial tcp4: lookup cloudflare.com: i/o timeout

ఆ క్రమాన్ని దృష్టిలో ఉంచుకుని జతచేసిన container logs ను చదవండి. app లోని connection refused, operation not permitted మరియు i/o timeout వంటి lines, tunnel పనిచేయకపోవడం వల్ల ఏర్పడిన పరిణామాలు; అవి కారణాలు కావు. Gluetun documentation దీనిని స్పష్టంగా చెబుతుంది. ఎందుకంటే చాలామంది పరిణామాన్ని report చేసి, కారణాన్ని కనుగొనడానికి గంటల తరబడి ప్రయత్నిస్తారు.

HEALTH_RESTART_VPN=on default గా enabled ఉంటుంది. దీన్ని enabled గానే ఉంచాలి. ఒక నిర్దిష్ట failure ను debug చేస్తున్నప్పుడు మాత్రమే దీన్ని off చేయండి. ఇది off లో ఉంటే, పనిచేయని tunnel అలాగే పనిచేయదు.

Ordering: టన్నెల్ ప్రారంభం కావడానికి ముందు stack ఆగేలా చూడటం

ఈ image లో Docker healthcheck ఉంటుంది:

HEALTHCHECK --interval=5s --timeout=5s --start-period=10s --retries=3 CMD /gluetun-entrypoint healthcheck

ఆ command gluetun యొక్క తాత్కాలిక రెండవ copy ని నడుపుతుంది. ఇది http://127.0.0.1:9999/ వద్ద నడుస్తున్న gluetun health server ను query చేస్తుంది. టన్నెల్ సరిగ్గా పనిచేస్తే 200 OK సమాధానం వస్తుంది. టన్నెల్ పనిచేయకపోతే error string తో 500 Internal server error సమాధానం వస్తుంది. వరుసగా మూడు checks విఫలమైన తరువాత Docker container ను unhealthy గా గుర్తిస్తుంది.

దాని కోసం వేచి ఉండేది condition: service_healthy. సాధారణ depends_on: [gluetun] container start కావడం వరకు మాత్రమే వేచి ఉంటుంది. Handshake పూర్తయ్యేలోపే container start అవుతుంది. అందువల్ల app పనిచేయని network లో ప్రారంభమై, తన మొదటి connection attempt ను తరచుగా విరమించుకుంటుంది. Docker Compose లో Healthchecks syntax మరియు timing fields ను వివరిస్తుంది.

ఒక పరిమితి తరచుగా సమస్యగా మారుతుంది. Stack ప్రారంభించేటప్పుడు Compose ఆ condition ను evaluate చేస్తుంది. తరువాత gluetun unhealthy గా మారితే app ను ఆపదు లేదా restart చేయదు. ఆ పరిస్థితిని gluetun యొక్క అంతర్గత auto-healing నిర్వహిస్తుంది. అందుకే ఇది container ను కాకుండా VPN process ను restart చేస్తుంది.

సెటప్‌పై నమ్మకం పెట్టుకునే ముందు DNS leak ను తనిఖీ చేయండి

DNS (domain name system) సరైన tunnel ఉన్నప్పటికీ బయటపడే leak. Gluetun namespace లోపల తన స్వంత resolver ను నడుపుతుంది. ఇది డిఫాల్ట్‌గా DoT (DNS over TLS) ద్వారా Cloudflare కు queries ను forward చేస్తుంది: DNS_UPSTREAM_RESOLVER_TYPE=dot మరియు DNS_UPSTREAM_RESOLVERS=cloudflare. ఈ రెండింటినీ అలాగే ఉంచితే మీ lookups encrypted గా ఉండి tunnel ద్వారా ప్రయాణిస్తాయి.

Local resolver కు చూపినప్పుడు ఈ ప్రవర్తనను భంగపరిచే setting DNS_UPSTREAM_PLAIN_ADDRESSES. ఏదైనా పేరు resolve కాకపోతే, తమ router లేదా provider resolver ద్వారా దానికి సమాధానం రావాలని కోరుకునే వారు దీన్ని ఉపయోగిస్తారు. Docker bridge లేదా LAN పై ఉన్న resolver కు పంపిన queries VPN tunnel వెలుపల leak అవుతాయని Gluetun documentation హెచ్చరిస్తుంది. Public plaintext resolver కు queries tunnel ద్వారా చేరినా, VPN provider వాటిని చదివి మార్చగలదు. WireGuard లో ఇదే పొరపాటు గురించి WireGuard tunnel ద్వారా DNS resolving ఆగిపోవడం లో వివరించారు.

దీన్ని పరీక్షించడానికి gluetun పై SHADOWSOCKS=on మరియు SHADOWSOCKS_PASSWORD సెట్ చేసి, 8388:8388/tcp మరియు 8388:8388/udp publish చేయండి. తరువాత UDP DNS ను tunnel చేసేలా configure చేసిన Shadowsocks client తో connect అయి DNS leak test ను load చేయండి. ఫలితంలో మీ provider లేదా Cloudflare పేరు రావాలి; మీ home router పేరు ఎప్పుడూ రాకూడదు. Namespace లోని resolver చివరికి సమాధానం ఇచ్చే server కాకుండా local caching intermediary కావడం వల్ల కొన్ని leak tests అసాధారణ ఫలితాలను చూపుతాయని Gluetun documentation హెచ్చరిస్తుంది. తప్పు దేశం లేదా మీ స్వంత ISP resolver కనిపించడాన్ని అసలు signal గా పరిగణించండి.

VPN sidecar పక్కన Tailscale ను జోడించడం మరియు ఏది ప్రాధాన్యత పొందుతుంది

Tailscale అనేది మీ స్వంత మెషీన్‌లను చేరుకోవడానికి WireGuard పై నిర్మించిన ఒక overlay నెట్‌వర్క్. స్టాక్‌లోకి అడ్మిన్ మార్గాన్ని ఉంచుకోవడానికి ప్రజలు దీనిని VPN ప్రొవైడర్‌తో పాటు నడుపుతారు. ఒకే namespace ను పంచుకోవడం అంటే firewall నియమాలను కూడా పంచుకోవడమే, కాబట్టి ఈ రెండింటికీ అనుకూలమైన firewall మరియు routing సెట్టింగ్‌లు అవసరం. Tailscale డాక్యుమెంటేషన్ దాని డిఫాల్ట్ ప్రవర్తనను ఇలా చెబుతుంది: ఇది overlay నెట్‌వర్క్‌గా పనిచేస్తుంది, Tailscale నడుస్తున్న పరికరాల మధ్య మాత్రమే ట్రాఫిక్‌ను రౌట్ చేస్తుంది మరియు ఇది మీ పబ్లిక్ ఇంటర్నెట్ ట్రాఫిక్‌ను తాకదు.

కాబట్టి సమాధానం ఒక సెట్టింగ్‌పై ఆధారపడి ఉంటుంది.

  • Tailscale దాని స్వంత కంటైనర్‌లో, డిఫాల్ట్ కాన్ఫిగరేషన్‌లో ఉన్నప్పుడు: ఇది అప్లికేషన్ యొక్క అవుట్‌బౌండ్ ట్రాఫిక్‌ను ఎప్పటికీ చూడదు. Gluetun దానిని పూర్తిగా నిర్వహిస్తుంది. Tailscale కంటైనర్‌లోని ఒక ప్రాసెస్, షేర్డ్ Docker నెట్‌వర్క్ ద్వారా gluetun:8080 వద్ద అప్లికేషన్‌ను చేరుకుంటుంది; ఆ కనెక్షన్‌ను tailnet క్లయింట్‌లకు ఎక్స్‌పోజ్ చేయడానికి ఫార్వార్డింగ్ లేదా ప్రాక్సీ అవసరం.
  • network_mode: "service:gluetun" తో gluetun యొక్క namespace కు Tailscale ను జత చేసినప్పుడు: డిఫాల్ట్ userspace నెట్‌వర్కింగ్ మోడ్‌లో, TS_USERSPACE ఆన్‌లో ఉన్నప్పుడు, tailscaled ఎటువంటి ఇంటర్‌ఫేస్‌ను సృష్టించదు మరియు SOCKS5 లేదా HTTP ప్రాక్సీగా పనిచేస్తుంది, కాబట్టి ఇది రూటింగ్‌ను మార్చలేదు. ఒక అప్లికేషన్ స్పష్టంగా ఆ ప్రాక్సీని ఉపయోగిస్తే తప్ప, Gluetun సాధారణ అవుట్‌బౌండ్ ట్రాఫిక్‌ను మోసుకెళ్తుంది.
  • అదే, TS_USERSPACE=false తో ఉన్నప్పుడు: Tailscale కు దాని స్వంత /dev/net/tun పరికరం మరియు సామర్థ్యాలు అవసరం, ఎందుకంటే అవి namespace తో రావు. Tailscaled ఒక టన్నెల్ పరికరాన్ని సృష్టిస్తుంది మరియు Linux లో, సాధారణంగా 100.64.0.0/10 కోసం ఒకే రూట్‌కు బదులుగా వ్యక్తిగత IPv4 peer /32 రూట్‌లను ఇన్‌స్టాల్ చేస్తుంది. కేవలం TS_USERSPACE=false ని సెట్ చేయడం వల్ల aggregate రూట్ ఎనేబుల్ అవ్వదు. మీరు TS_EXTRA_ARGS ద్వారా --accept-routes ని పంపితేనే ఇది ఇతర నోడ్ల సబ్‌నెట్ రూట్‌లను ఇన్‌స్టాల్ చేస్తుంది. TS_ROUTES వ్యతిరేక దిశలో పనిచేస్తుంది: ఇది ఈ కంటైనర్ చేరుకోగల సబ్‌నెట్‌లను మీ మిగిలిన tailnet కు ప్రకటిస్తుంది, ఇది tailscale set --advertise-routes= కి సమానం, మరియు ఇక్కడ ఎటువంటి రూట్‌లను జోడించదు. పబ్లిక్ ట్రాఫిక్ ఇప్పటికీ gluetun ద్వారానే వెళ్తుంది.
  • ఎగ్జిట్ నోడ్ ఎంపిక చేయబడిన gluetun యొక్క namespace లో Kernel నెట్‌వర్కింగ్, sudo tailscale set --exit-node=<exit-node-ip>: Tailscale ఆ namespace లో డిఫాల్ట్ రూట్‌లను ఇన్‌స్టాల్ చేస్తుంది, కానీ Gluetun యొక్క firewall ఆ మార్గాన్ని నిరోధించగలదు. వేరే కంటైనర్‌లో ఎగ్జిట్ నోడ్‌ను ఎంచుకోవడం వల్ల అప్లికేషన్ రూట్‌లు మారవు, మరియు userspace మోడ్ కేవలం దాని ప్రాక్సీ ద్వారా పంపిన ట్రాఫిక్‌ను మాత్రమే మోసుకెళ్తుంది. Gluetun యొక్క namespace లో పోటీ పడే డిఫాల్ట్ రూట్‌లను కలపవద్దు. ఒక డిఫాల్ట్ రూట్, ఒకే యజమాని ఉండాలి.

ప్రకటించిన ఆ రూట్‌లే ముఖ్యమైతే, మరియు కేవలం బాక్స్ మాత్రమే కాకుండా బాక్స్ వెనుక ఉన్న మొత్తం ప్రైవేట్ నెట్‌వర్క్ అందుబాటులో ఉండాలని మీరు కోరుకుంటే, VPS పై Tailscale సబ్‌నెట్ రౌటర్‌ను రన్ చేయడం అనే అంశం రూట్ ఆమోదం, IP ఫార్వార్డింగ్ మరియు TS_ROUTES స్వయంగా చేయలేని క్లయింట్ సైడ్ ఫ్లాగ్‌ను కవర్ చేస్తుంది.

Tailscale ఒక రూట్ కోసం కాకుండా అడ్మిన్ URL కోసం ఉంటే, tailscale serve మరియు tailscale funnel స్థానిక HTTP సేవ ముందు HTTPS ను ఉంచుతాయి, కేవలం funnel మాత్రమే దానిని పబ్లిక్ ఇంటర్నెట్‌కు తెరుస్తుంది. Tailscale Serve డాక్యుమెంటేషన్ http://127.0.0.1 ని మాత్రమే HTTP ప్రాక్సీ టార్గెట్‌గా సపోర్ట్ చేస్తుంది. షేర్డ్ Docker నెట్‌వర్క్ http://gluetun:8080 ని సపోర్ట్ చేసే టార్గెట్‌గా మార్చదు. Gluetun యొక్క నెట్‌వర్క్ namespace ను network_mode: "service:gluetun" తో షేర్ చేయండి మరియు http://127.0.0.1:8080 ని టార్గెట్ చేయండి.

Tailscale టన్నెల్ లోపల నడుస్తున్నప్పుడు ఒక దుష్ప్రభావం కనిపిస్తుంది. దీని peers VPN ప్రొవైడర్ యొక్క అడ్రస్‌ను చూస్తాయి, కాబట్టి ఇది తరచుగా రిలేలకు పడిపోయే అవకాశం ఉంది. అలా జరిగినప్పుడు tailscale status, direct కి బదులుగా peer పక్కన relay "..." ని చూపిస్తుంది. కనెక్షన్ పనిచేస్తుంది కానీ నెమ్మదిగా ఉంటుంది. మీకు నిజంగా కావలసింది కేవలం overlay మాత్రమే అయితే, సాధారణ WireGuard మరియు Tailscale మధ్య వ్యత్యాసం అనేది మెరుగైన ప్రారంభ స్థానం.

ఏవి విఫలమవుతాయి, మీరు చూసే సందేశం

Docker app container ను సృష్టించడానికి నిరాకరిస్తుంది. Error response from daemon: conflicting options: port publishing and the container type network mode అంటే జతచేయబడిన service పై ఇంకా ports: block ఉంది. దాన్ని gluetun కు తరలించండి.

Compose మొత్తం file ను అంగీకరించదు. ఒక service network_mode మరియు networks రెండింటినీ సెట్ చేయలేదు. networks ను gluetun పై ఉంచండి.

మరో container app ను resolve చేయలేకపోతుంది. curl: (6) Could not resolve host: qbittorrent సరైన ప్రవర్తనే, ఎందుకంటే జతచేయబడిన container ఏ network లోనూ చేరలేదు మరియు ఏ name ను register చేయలేదు. gluetun మరియు port ను ఉపయోగించండి.

రెండవ జతచేయబడిన container ప్రారంభం కాదు. ఒకే namespace లోని రెండు processes ఒకే port పై bind కాలేవు. ఓడిపోయిన process address ఇప్పటికే ఉపయోగంలో ఉందని నివేదిస్తుంది. app యొక్క internal port ను మార్చండి లేదా రెండవ gluetun ను నడపండి.

gluetun ను మార్చిన తర్వాత app కు network లేదు. gluetun ను restart చేయడం లేదా recreate చేయడం వల్ల దానికి జతచేయబడిన ప్రతిదాని connectivity కోల్పోతుంది. ఆ containers ను restart చేయండి.

చిన్న pages load అవుతాయి, పెద్దవి hang అవుతాయి. ఇది MTU (maximum transmission unit) సమస్య. tunnel అదనపు overhead ను జోడిస్తుంది. path లోని ఏదో భాగం పరిమాణం ఎక్కువగా ఉన్న packets ను error పంపకుండా drop చేస్తుంది. WIREGUARD_MTU ను పరిశీలించండి. v3.41.3 లో దాని default విలువ 1320. path కు ఇంకా చిన్న packets అవసరమైతే దాన్ని తగ్గించండి. ఈ setting unset గా ఉన్నప్పుడు development image path MTU discovery ను ఉపయోగిస్తుంది.

Gluetun ఎప్పటికీ healthy గా మారదు. startup check మొదట అనుమానించాల్సిన వాటిని సూచిస్తుంది: WARN [vpn] restarting VPN because it failed to pass the healthcheck: startup check: dialing: dial tcp4: lookup cloudflare.com: i/o timeout. key గడువు ముగిసిందో లేదో పరిశీలించండి. తరువాత server list పాతదైందో లేదో చూడండి. చివరగా మీ host firewall outbound UDP ను block చేస్తుందో లేదో తనిఖీ చేయండి.

FAQ

నా container యొక్క published ports Gluetun వెనుక పనిచేయడం ఎందుకు ఆగిపోయింది?

ఎందుకంటే network_mode: "service:gluetun" container ను gluetun యొక్క network namespace లో ఉంచుతుంది. ఒక namespace కు ఒక IP address మరియు listening ports యొక్క ఒక సమూహం మాత్రమే ఉంటాయి. App listening కొనసాగిస్తుంది. అయితే publish rule namespace ను కలిగి ఉన్న container లో ఉండాలి. ports: list ను gluetun service కు తరలించండి. దాన్ని attached service పై ఉంచితే Docker దాన్ని సృష్టించదు: Error response from daemon: conflicting options: port publishing and the container type network mode.

VPN tunnel లోపల ఉన్న container ను దాని వెలుపల ఉన్న container నుంచి ఎలా చేరుకోవాలి?

gluetun యొక్క service name మరియు app listening చేస్తున్న port ను ఉపయోగించండి. ఉదాహరణకు gluetun:8080. Attached container కు స్వంత Docker network ఉండదు. అందువల్ల దాని స్వంత name ఎప్పటికీ resolve కాదు. Container-to-container traffic కోసం ఏదీ publish చేయాల్సిన అవసరం లేదు. విరుద్ధ దిశలో, namespace లోపల ఉన్న container, Gluetun v3.41 మరియు తదుపరి versions లో, Gluetun వెలుపల ఉన్న container ను దాని service name ద్వారా, ఉదాహరణకు postgres:5432, చేరుకోగలదు. మీ LAN లోని laptop వంటి వేరే subnet లో ఉన్న client కు gluetun firewall మరియు routing అనుమతించే return path అవసరం. ఆ subnet ను FIREWALL_OUTBOUND_SUBNETS కు జోడించండి.

VPN disconnect అయినప్పుడు Gluetun kill switch గా పనిచేస్తుందా?

అవును, దాని firewall enabled గా ఉంటే. Attached container Gluetun యొక్క interfaces మరియు routes ను share చేస్తుంది. VPN tunnel వెలుపలికి వెళ్లే సాధారణ internet traffic ను firewall block చేస్తుంది. అదే సమయంలో VPN server endpoint, local Docker traffic మరియు configured exceptions ను అనుమతిస్తుంది. Gluetun VPN ను అంతర్గతంగా మళ్లీ ప్రారంభిస్తుంది మరియు WARN [vpn] restarting VPN because it failed to pass the healthcheck ను log చేస్తుంది. అది exit కాదు. ఎందుకంటే gluetun స్వయంగా restart అయితే ప్రతి attached container తన network ను కోల్పోతుంది.

ఒకే stack లో Tailscale మరియు Gluetun ఉంటే: outbound traffic ను ఏది నిర్వహిస్తుంది?

మీరు traffic ను Tailscale ద్వారా స్పష్టంగా పంపితే తప్ప, సాధారణ outbound traffic ను Gluetun నిర్వహిస్తుంది. Tailscale default గా మీ tailnet లోని devices మధ్య మాత్రమే traffic ను route చేస్తుంది. Public traffic ను అలాగే ఉంచుతుంది. Container image యొక్క default userspace mode లో ఇది interface ఏదీ సృష్టించదు. అందువల్ల routing పై ప్రభావం చూపదు. TS_USERSPACE=false తో Linux సాధారణంగా aggregate 100.64.0.0/10 route కు బదులుగా individual IPv4 peer /32 routes ను పొందుతుంది. అదనంగా, --accept-routes ను TS_EXTRA_ARGS ద్వారా జోడించినప్పుడు మాత్రమే ఇతర nodes యొక్క subnet routes వస్తాయి. TS_ROUTES ఈ container యొక్క subnets ను మీ tailnet కు advertise చేస్తుంది. ఇది local routes ఏవీ జోడించదు. sudo tailscale set --exit-node=<exit-node-ip> తో exit node ను ఎంచుకుంటే, Tailscale యొక్క kernel networking ఉపయోగించే namespace లో మాత్రమే default routes install అవుతాయి. Separate container app యొక్క routes ను మార్చదు. Userspace mode తన proxy ద్వారా పంపిన traffic ను మాత్రమే తీసుకువెళుతుంది. Default route పై నియంత్రణ కోసం రెండు products ను కలిపి ఉపయోగించకుండా, ఒక product ను ఎంచుకోండి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?