SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor

Docker VPN: Bakit Nawawala ang Ports ng Containers

Alamin kung bakit lumalabas ang `conflicting options: port publishing and the container type network mode` at tingnan ang gumaganang Gluetun Compose setup.

Kapag nawawala ang ports kapag niruruta ang Docker containers sa VPN

Para iruta ang Docker containers sa VPN, ibigay ang tunnel sa isang container, pagkatapos ay i-attach ang iba sa network namespace nito gamit ang network_mode: "service:gluetun". Ang attachment na ito ang madalas nakalilito. Wala nang sariling network ang naka-attach na container, kaya nawawala rin ang mga published port nito at ang Docker service name nito. I-publish ang mga port sa VPN container sa halip, at maa-access ng ibang containers ang app gamit ang pangalan ng VPN container.

Mag-iwan ng ports: block sa naka-attach na container at tatanggihan ng Docker ang paggawa rito:

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

Ang tool dito ay Gluetun, isang container na kumokonekta sa isang commercial VPN (virtual private network) provider gamit ang WireGuard o OpenVPN at may sarili nitong firewall. Ang release v3.41.3 ang kasalukuyan noong October 2026. Ginagamit sa mga halimbawa ang Mullvad kasama ang WireGuard, kaya kailangan mo ng account at key mula sa iyong provider. Kung mas nais mong i-terminate ang tunnel sa hardware na pagmamay-ari mo, bubuuin ng pagpapatakbo ng sarili mong WireGuard server sa isang VPS ang kabilang dulo, at ibabalot iyon ng wg-easy sa Docker sa isang web interface.

Ano talaga ang ginagawa ng network_mode: "service:gluetun"

Karaniwang may sariling network namespace ang bawat Docker container: sarili nitong interfaces, routing table, firewall rules, at listening sockets. Nilalaktawan ng mode na service: ang hakbang na iyon at sinisimulan ang container sa loob ng namespace ng gluetun. Ibig sabihin, iisa ang namespace at iisa ang IP address. Dahil dito, nagbabago ang anim na bagay.

  • Walang sariling address ang app. Ang address nito ay address ng gluetun.
  • Hindi nakakonekta ang app sa anumang Docker network, kaya hindi nirerehistro at hindi nare-resolve ang service name nito. Dapat gamitin ng ibang container ang gluetun.
  • Nagkaka-access ang mga container sa loob ng namespace sa isa't isa gamit ang localhost.
  • Hindi maaaring makinig sa parehong port ang dalawang container na nasa iisang namespace. Malinaw ang Gluetun documentation tungkol dito: walang workaround.
  • Ang capabilities ay pagmamay-ari ng container, hindi ng namespace. Hawak ng Gluetun ang NET_ADMIN at /dev/net/tun dahil ito ang gumagawa ng tunnel interface. Hindi namamana ng naka-attach na container ang mga ito.
  • Tinatanggihan ng Compose ang anumang file kung nagse-set ang isang service ng parehong network_mode at networks. Ikonekta ang gluetun sa iyong mga network, at sasabay dito ang app.

Kapag nire-restart ang gluetun, nadidiskonekta ang lahat ng naka-attach dito. Dokumentado ang behavior na ito, at ito ang dahilan kung bakit nire-restart ng gluetun ang VPN process sa loob ng container sa halip na lumabas kapag nabigo ang connection. Pagkatapos mong i-restart o i-recreate ang gluetun, i-restart ang mga container na naka-attach dito.

Gumaganang compose file

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

Ang :v3 tag ang pinakabagong stable release sa v3 series. Ang :latest tag ay tumutukoy sa huling commit ng master branch, na development edge; kaya i-pin ang :v3 sa machine na ayaw mong i-debug sa hindi angkop na oras.

Dapat tumugma ang WEBUI_PORT=8080 sa published port, dahil nagbi-bind ang qBittorrent sa loob ng namespace ng gluetun at ipinapasa ng publish rule ang traffic mula sa host sa port 8080 doon. Kapag binago ang isang numero nang hindi binabago ang isa pa, walang sasagot sa port. Pinananatili ng 127.0.0.1:8080:8080 ang web interface sa loopback address ng host. Kapag bare na 8080:8080, ipa-publish nito ang port sa lahat ng interface at gagawa ito ng sarili nitong firewall rule. Ito ang dahilan kung bakit direktang nalalampasan ng Docker published ports ang ufw.

I-start ito, pagkatapos ay suriin sa ganitong pagkakasunod-sunod:

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

Dapat ipakita ng docker compose ps ang gluetun bilang healthy at ang qbittorrent bilang running. Pagkatapos, kumpirmahin ang exit address mula sa loob ng namespace. Ito ang pagsusuring magpapasya sa lahat ng iba pa:

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

Dapat ang address ng VPN provider mo ang nasa ip field ng JSON na iyon. Kung sariling address ng server mo ang lumabas, wala ang app sa tunnel, kaya hindi gagana ayon sa inilalarawan ang mga sumusunod.

Huwag ilagay ang mga key sa compose file

Ang gluetun.env ang naglalaman ng credentials, at hindi ito isinasama sa git:

WIREGUARD_PRIVATE_KEY=wOEI9rqqbDwnN8/Bpp22sVz48T71vJ4fYmFWujulwUU=
WIREGUARD_ADDRESSES=10.64.222.21/32

Galing ang dalawang value sa WireGuard configuration file na ginagawa mo sa account area ng provider mo. Itakda ang file sa mode 600. Maging malinaw sa proteksiyong ibinibigay nito: hindi napupunta ang key sa repository mo, pero inililista pa rin ng docker inspect gluetun ang bawat environment variable sa sinumang makakaabot sa Docker socket. Saklaw ng Mga environment file at secret sa Docker Compose ang mas matibay na mga opsyon.

Paano nakikipag-ugnayan ang isang container na nasa labas ng tunnel sa container na nasa loob nito

Gumagana ang parehong direksyon, at magkaiba ang pangalan na ginagamit sa bawat isa. Kailangang nasa iisang shared Docker network ang dalawang container. Ibig sabihin, network ni Gluetun ito dahil walang sariling network ang naka-attach na container. Ipinaliliwanag sa Paano ikinokonekta ang mga network ng Docker Compose ang mga default na setting.

Mula sa labas papunta sa loob, gamitin ang pangalan ni Gluetun at ang port na ginagamit ng app. Maaabot ng reverse proxy container ang web interface ng qBittorrent sa gluetun:8080. Hindi kailangan ng ports: entry para rito dahil nananatili sa Docker network ang traffic sa pagitan ng mga container at hindi ito dumadaan sa host port.

Mula sa loob papunta sa labas, gamitin ang service name ng kabilang container, halimbawa ang postgres:5432. Nire-resolve na ni Gluetun ang mga pangalan ng ibang container mula sa loob ng namespace nito simula v3.41. Gumamit ng bersyong iyon o mas bago kung hindi ma-resolve ang isang pangalan.

Tinutukoy ng firewall ni Gluetun kung sino ang maaaring magbukas ng koneksyon dito. Pinapayagan ang traffic mula sa sariling Docker network ni Gluetun. Ang client na nasa ibang subnet, laptop na nasa LAN mo, o container na nasa hiwalay na bridge network ay nangangailangan ng return path na pinapayagan ng firewall at routing ni Gluetun:

FIREWALL_OUTBOUND_SUBNETS=192.168.1.0/24

Eksakto ang dokumentadong kahulugan: mga subnet na pinaghihiwalay ng kuwit na pinapayagang ma-access ni Gluetun at ng mga container na nakikibahagi sa network stack nito.

Hiwalay na problema ang mga inbound connection mula sa internet. Dumarating ang mga peer ng torrent client mula sa panig ng VPN, kaya walang magagawa ang pag-publish ng port 6881 sa host para sa kanila. Kailangan mo ng forwarded port mula sa provider, at dapat nakalista ang port na iyon sa FIREWALL_VPN_INPUT_PORTS, na nagpapahintulot ng mga port mula sa panig ng VPN server. Hindi sumusuporta ang Mullvad, na ginamit sa halimbawang ito, sa port forwarding. Kaya kailangan mo ng provider na sumusuporta rito. Ito ang bahaging kadalasang hindi naayos ng mga media stack na binuo gamit ang Docker Compose.

Ang kill switch: ano ang nangyayari kapag bumagsak ang tunnel

Nakukuha ng pattern na ito ang pagiging kumplikado nito kapag may failure. Ibinabahagi ng naka-attach na container ang mga interface at routing table ng Gluetun. Hinaharang ng firewall ng Gluetun ang karaniwang internet traffic sa labas ng tunnel, habang pinapayagan ang VPN server endpoint, lokal na Docker traffic, at mga naka-configure na exception. Ang firewall na ito ang pumipigil sa pag-fallback sa plain interface kapag bumagsak ang tunnel. Walang pagitan kung kailan maaaring lumabas ang mga packet sa plain interface habang muling kumokonekta ang client.

Binabantayan ng Gluetun ang sarili nitong koneksyon. Bawat minuto, nagpapadala ito ng ICMP echo (isang ping) sa mga address sa HEALTH_ICMP_TARGET_IPS, na ang default ay 1.1.1.1,8.8.8.8. Kung hindi pinapayagan ang ICMP, nagfa-fallback ang maliit na check na ito sa isang plaintext UDP DNS query. Bawat limang minuto, nagsasagawa ito ng kumpletong TCP at TLS (transport layer security) dial sa HEALTH_TARGET_ADDRESSES, na ang default ay cloudflare.com:443,github.com:443. Kapag nabigo ang mga ito, nire-restart nito ang VPN sa loob ng container at itinatala ito sa log:

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

Basahin ang logs ng naka-attach na container ayon sa pagkakasunod na ito. Ang mga linyang gaya ng connection refused, operation not permitted at i/o timeout sa loob ng app ay mga epekto ng dead tunnel, hindi mga sanhi. Tahasang sinasabi ito sa dokumentasyon ng Gluetun, dahil iniuulat ng mga tao ang epekto at ilang oras nila itong sinusubukang ayusin.

Ang HEALTH_RESTART_VPN=on ang default at dapat manatiling naka-on. I-off lamang ito habang nagde-debug ng isang partikular na failure, dahil kapag naka-off ito, mananatiling dead ang tunnel kapag bumagsak ito.

Pagkakasunud-sunod: pigilan ang pagsisimula ng stack bago maging aktibo ang tunnel

May Docker healthcheck ang image:

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

Ang command na iyon ay nagpapatakbo ng panibagong panandaliang kopya ng gluetun na kumokonsulta sa health server ng tumatakbong instance sa http://127.0.0.1:9999/. Nagbabalik ang gumaganang tunnel ng 200 OK. Ang sirang tunnel ay nagbabalik ng 500 Internal server error na may error string, at itinatakda ng Docker na unhealthy ang container matapos ang tatlong magkakasunod na nabigong check.

condition: service_healthy ang naghihintay para rito. Ang karaniwang depends_on: [gluetun] ay naghihintay lamang na magsimula ang container. Nangyayari iyon ilang segundo bago makumpleto ang handshake. Dahil dito, nagsisimula ang app na walang gumaganang network at madalas nitong isinusuko ang unang pagtatangkang kumonekta. Ipinaliliwanag ng Healthcheck sa Docker Compose ang syntax at mga timing field.

May isang limitasyong madalas hindi napapansin. Sinusuri ng Compose ang condition na iyon kapag sinisimulan nito ang stack. Hindi nito awtomatikong ihihinto o ire-restart ang app kung magiging unhealthy ang gluetun sa kalaunan. Ang internal auto-healing ng gluetun ang humahawak sa sitwasyong ito. Kaya ang nire-restart nito ay ang VPN process, hindi ang container.

Suriin ang DNS leak bago magtiwala sa setup

Ang DNS (domain name system) ang leak na nananatili kahit tama ang tunnel. Nagpapatakbo ang Gluetun ng sarili nitong resolver sa loob ng namespace at ipinapasa ang mga query sa pamamagitan ng DoT (DNS over TLS) sa Cloudflare bilang default: DNS_UPSTREAM_RESOLVER_TYPE=dot at DNS_UPSTREAM_RESOLVERS=cloudflare. Huwag galawin ang dalawang ito para manatiling encrypted ang iyong mga lookup at dumaan sa loob ng tunnel.

Ang setting na sumisira nito kapag itinuro sa isang local resolver ay DNS_UPSTREAM_PLAIN_ADDRESSES. Ginagamit ito ng mga tao kapag hindi nag-resolve ang isang pangalan at gusto nilang ang router o resolver ng kanilang provider ang sumagot. Nagbabala ang dokumentasyon ng Gluetun na ang mga query na ipinapadala sa isang resolver sa iyong Docker bridge o LAN ay nagli-leak sa labas ng VPN tunnel. Ang isang public plaintext resolver ay tumatanggap pa rin ng mga query sa loob ng tunnel, pero mababasa at mababago pa rin ito ng VPN provider. Ang WireGuard version ng parehong pagkakamali ay tinalakay sa DNS na humihinto sa pag-resolve sa loob ng WireGuard tunnel.

Para subukan ito, i-set ang SHADOWSOCKS=on at SHADOWSOCKS_PASSWORD sa gluetun, i-publish ang 8388:8388/tcp at 8388:8388/udp, pagkatapos ay kumonekta gamit ang isang Shadowsocks client na naka-configure para i-tunnel ang UDP DNS at mag-load ng DNS leak test. Ang resulta ay dapat magpakita ng iyong provider o Cloudflare, hindi kailanman ang iyong home router. Nagbabala ang sariling dokumentasyon ng Gluetun na ang ilang leak test ay nagbibigay ng kakaibang resulta, dahil ang resolver sa loob ng namespace ay isang local caching intermediary at hindi ang server na mismong sumasagot. Ituring ang maling bansa o ang resolver ng iyong sariling ISP bilang totoong signal ng leak.

Pagdaragdag ng Tailscale sa tabi ng VPN sidecar, at kung alin ang mananaig

Ang Tailscale ay isang overlay network na nakabatay sa WireGuard para ma-access ang sarili mong mga machine. Ginagamit ito ng ilang tao kasabay ng provider VPN upang mapanatili ang admin path papasok sa stack. Ang pagbabahagi ng namespace ay nangangahulugan ding pagbabahagi ng firewall rules, kaya dapat magkatugma ang firewall at routing settings ng dalawa. Ayon sa dokumentasyon ng Tailscale, ito ang default: gumagana ito bilang overlay network, nagra-route lamang ito ng traffic sa pagitan ng mga device na nagpapatakbo ng Tailscale, at hindi nito ginagalaw ang public internet traffic mo.

Kaya nakadepende ang sagot sa isang setting.

  • Tailscale sa sarili nitong container, gamit ang default configuration: hindi nito kailanman nakikita ang outbound traffic ng app. Gluetun ang nagdadala ng lahat ng traffic na iyon. Nakaka-access ang isang process sa Tailscale container sa app sa gluetun:8080 sa pamamagitan ng shared Docker network; para ma-expose ang koneksyong iyon sa mga tailnet client, kailangan ng forwarding o proxy.
  • Naka-attach ang Tailscale sa namespace ng gluetun gamit ang network_mode: "service:gluetun": sa default userspace networking mode, naka-on ang TS_USERSPACE. Walang interface na ginagawa ang tailscaled at gumagana ito bilang SOCKS5 o HTTP proxy, kaya hindi nito mababago ang routing. Gluetun pa rin ang nagdadala ng ordinaryong outbound traffic maliban kung tahasang ginagamit ng isang app ang proxy na iyon.
  • Pareho ito, gamit ang TS_USERSPACE=false: kailangan ng Tailscale ng sarili nitong /dev/net/tun device at capabilities dahil hindi awtomatikong kasama ang mga iyon sa namespace. Gumagawa ang Tailscaled ng tunnel device at, sa Linux, karaniwang nag-i-install ng mga indibidwal na IPv4 peer /32 route sa halip na isang route para sa 100.64.0.0/10. Hindi sapat ang pagtatakda ng TS_USERSPACE=false para ma-enable ang aggregate route. Ini-install lamang nito ang subnet routes ng ibang node kung ipapasa mo ang --accept-routes sa pamamagitan ng TS_EXTRA_ARGS. Kabaligtaran ang gamit ng TS_ROUTES: ina-advertise nito sa iba pang bahagi ng tailnet ang mga subnet na maa-access ng container na ito. Katumbas ito ng tailscale set --advertise-routes= at wala itong idinadagdag na route dito. Sa gluetun pa rin lumalabas ang public traffic.
  • Kernel networking sa namespace ng gluetun na may napiling exit node, sudo tailscale set --exit-node=<exit-node-ip>: nag-i-install ang Tailscale ng default routes sa namespace na iyon, ngunit maaaring harangan ng firewall ng Gluetun ang path na iyon. Ang pagpili ng exit node sa hiwalay na container ay hindi nagbabago sa mga route ng app, at ang userspace mode ay nagdadala lamang ng traffic na tahasang ipinapadala sa proxy nito. Huwag pagsamahin ang magkakumpitensyang default route sa namespace ng gluetun. Isang default route at isang may-ari lamang.

Kung ang mga ina-advertise na route ang kailangan mo, at gusto mong ma-access ang buong private network sa likod ng box sa halip na ang box lamang, ipinapaliwanag ng pagpapatakbo ng Tailscale subnet router sa VPS ang route approval, IP forwarding, at client-side flag na hindi kayang gawin nang mag-isa ng TS_ROUTES.

Kung ang gamit ng Tailscale ay para magbigay ng admin URL sa halip na route, inilalagay ng tailscale serve at tailscale funnel ang HTTPS sa harap ng lokal na HTTP service. Ang funnel lamang ang nagbubukas nito sa public internet. Sinusuportahan ng dokumentasyon ng Tailscale Serve ang http://127.0.0.1 lamang bilang HTTP proxy target. Hindi nangangahulugang supported target ang http://gluetun:8080 dahil lamang nasa shared Docker network ito. Ibahagi ang network namespace ng gluetun sa network_mode: "service:gluetun" at gamitin ang http://127.0.0.1:8080 bilang target.

Makikita ang isang side effect kapag tumatakbo ang Tailscale sa loob ng tunnel. Nakikita ng mga peer nito ang address ng VPN provider, kaya mas madalas itong umaasa sa mga relay. Ipinapakita ng tailscale status ang relay "..." sa tabi ng peer sa halip na direct kapag nangyari ito. Gumagana ang koneksyon, ngunit mas mabagal. Kung overlay lamang ang kailangan mo, mas magandang panimulang punto ang pagkakaiba ng plain WireGuard at Tailscale.

Ano ang nasisira, at ang mensaheng makikita mo

Tumanggi ang Docker na gawin ang app container. Ang Error response from daemon: conflicting options: port publishing and the container type network mode ay nangangahulugang may ports: block pa na nakabitin sa attached service. Ilipat ito sa gluetun.

Tumanggi ang Compose sa buong file. Hindi maaaring magtakda ang isang service ng parehong network_mode at networks. Ilagay ang mga network sa gluetun.

Hindi ma-resolve ng ibang container ang app. Ang curl: (6) Could not resolve host: qbittorrent ay tamang behavior, dahil walang sinalihang network at walang ni-register na pangalan ang attached container. Gamitin ang gluetun at ang port.

Hindi magsisimula ang pangalawang attached container. Hindi maaaring mag-bind ng parehong port ang dalawang proseso sa iisang namespace, at ang matatalo ay mag-uulat na ang address ay ginagamit na. Baguhin ang internal port ng app, o magpatakbo ng pangalawang gluetun.

Walang network ang app matapos mong galawin ang gluetun. Ang pag-restart o pag-recreate sa gluetun ay nagpuputol ng koneksyon para sa lahat ng naka-attach dito. I-restart ang mga container na iyon.

Naglo-load ang maliliit na page pero nagha-hang ang malalaki. Iyan ay dahil sa MTU (maximum transmission unit). Nagdaragdag ng overhead ang tunnel, at may humaharang sa path na nagtatapon ng malalaking packet nang hindi nagpapadala ng error pabalik. Suriin ang WIREGUARD_MTU, na ang default sa v3.41.3 ay 1320, at babaan ito kung nangangailangan ang path ng mas maliliit na packet. Gumagamit ang development image ng path MTU discovery kapag hindi naka-set ang setting na ito.

Hindi nagiging healthy ang gluetun. Ipinapangalan ng startup check ang mga unang suspek: WARN [vpn] restarting VPN because it failed to pass the healthcheck: startup check: dialing: dial tcp4: lookup cloudflare.com: i/o timeout. Suriin kung expired na ang key, pagkatapos ay kung luma na ang server list, at panghuli kung hinaharangan ng host firewall mo ang outbound UDP.

FAQ

Bakit hindi na gumagana ang mga published port ng container ko kapag nasa likod ito ng Gluetun?

Dahil inilalagay ng network_mode: "service:gluetun" ang container sa network namespace ng gluetun, at ang isang namespace ay may isang IP address at isang set ng listening port. Patuloy na nakikinig ang app, pero kailangang nasa container na nagmamay-ari ng namespace ang publish rule. Ilipat ang listahan ng ports: sa gluetun service. Kung iniwan mo ito sa naka-attach na service, hindi man lang ito gagawin ng Docker: Error response from daemon: conflicting options: port publishing and the container type network mode.

Paano ko maa-access mula sa container na nasa labas ng VPN tunnel ang container na nasa loob nito?

Gamitin ang service name ng gluetun at ang port na ginagamit ng app, halimbawa gluetun:8080. Walang sariling Docker network ang naka-attach na container, kaya hindi nagre-resolve ang sarili nitong pangalan. Walang kailangang i-publish para sa container-to-container traffic. Sa kabilang direksyon, maa-access ng container na nasa loob ng namespace ang container sa labas gamit ang service name nito, gaya ng postgres:5432, sa Gluetun v3.41 at mas bago. Ang client na nasa ibang subnet, gaya ng laptop sa iyong LAN, ay nangangailangan ng return path na pinapayagan ng firewall at routing ng gluetun; idagdag ang subnet na iyon sa FIREWALL_OUTBOUND_SUBNETS.

Gumagana ba ang Gluetun bilang kill switch kapag bumaba ang VPN?

Oo, kapag naka-enable ang firewall nito. Ibinabahagi ng naka-attach na container ang mga interface at route ng Gluetun, at bina-block ng firewall ang karaniwang internet traffic sa labas ng tunnel habang pinapayagan ang VPN server endpoint, lokal na Docker traffic, at mga naka-configure na exception. Pagkatapos, nire-restart ng Gluetun ang VPN sa loob nito at nagla-log ng WARN [vpn] restarting VPN because it failed to pass the healthcheck sa halip na mag-exit, dahil nawawala ang network ng bawat naka-attach na container kapag mismong gluetun ang nag-restart.

Tailscale at Gluetun sa iisang stack: alin ang nagdadala ng outbound traffic?

Ang Gluetun ang nagdadala ng karaniwang outbound traffic maliban kung tahasan mo itong ipadala sa Tailscale. Bilang default, nagro-route lamang ang Tailscale ng traffic sa pagitan ng mga device sa iyong tailnet at iniiwan nitong hindi nagbabago ang public traffic. Sa default userspace mode ng container image, wala itong ginagawang interface, kaya hindi nito naaapektuhan ang routing. Kapag TS_USERSPACE=false, karaniwang nakakakuha ang Linux ng magkakahiwalay na IPv4 peer /32 route sa halip na pinagsama-samang 100.64.0.0/10 route, at nakakakuha lamang ito ng mga subnet route ng ibang node kapag idinagdag mo ang --accept-routes sa pamamagitan ng TS_EXTRA_ARGS. Ina-advertise ng TS_ROUTES ang mga subnet ng container na ito sa iyong tailnet at wala itong idinadagdag na lokal na route. Kapag pumili ka ng exit node gamit ang sudo tailscale set --exit-node=<exit-node-ip>, nag-i-install ito ng mga default route lamang sa namespace na gumagamit ng kernel networking ng Tailscale; hindi binabago ng hiwalay na container ang mga route ng app, at ang userspace mode ay nagdadala lamang ng traffic na ipinadala sa proxy nito. Pumili ng isang product na magmamay-ari ng default route sa halip na pagsabayin ang dalawa.

Nakatulong ba ang artikulong ito?