SSD Nodes Learn Hosting plans →

Gluetun-ல் உள்ள Docker container-களுக்கு network அணுகல்

Gluetun-ன் network namespace-ல் இயங்கும் container-களுக்கு சொந்தமாக interfaces இருக்காது. Port-களை எவ்வாறு publish செய்வது மற்றும் firewall விதிகளை அமைப்பது என்பதை அறியுங்கள்.

container gluetun-ன் network-ல் இணைந்தால் என்ன நடக்கும்

network_mode: service:gluetun அமைக்கும் container-க்கு தனிப்பட்ட network interfaces எதுவும் இருக்காது. அது 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 அந்த படியைத் தவிர்த்து, ஏற்கனவே gluetun வைத்திருக்கும் namespace-க்குள் புதிய container-ஐ வைக்கிறது. Container தனது filesystem-ஐ வைத்திருக்கும். ஆனால் தனிப்பட்ட /etc/hosts அல்லது /etc/resolv.conf இருக்காது. Docker, gluetun பயன்படுத்தும் அதே files-ஐ அதற்கும் வழங்குகிறது. இது பின்னர் முக்கியமாகும்.

இதை நேரடியாகப் பார்க்கலாம்.

docker inspect -f '{{.HostConfig.NetworkMode}}' qbittorrent

இது container:-ஐ அடுத்து gluetun container ID-ஐ காட்டும். சாதாரண container-ல் bridge காட்டப்படும். இந்த வழிகாட்டி gluetun மூலம் Docker traffic-ஐ VPN வழியாக routing செய்தல் நிறுத்திய இடத்திலிருந்து தொடர்கிறது: tunnel செயல்படுகிறது. இப்போது container-உடன் எந்தவொரு தொடர்பும் ஏற்படாது.

gluetun-ல் port-ஐ publish செய்யவும்; application-ல் அல்ல

network_mode-ஐ அமைக்கும் service-ல் ports: block வைத்தால், Docker container-ஐ உருவாக்க மறுக்கும்:

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

இதற்கான காரணம் நேரடியானது. Port-ஐ publish செய்வது என்பது host port-இலிருந்து container-ன் சொந்த network namespace-க்கு traffic-ஐ forward செய்யும் NAT (network address translation) rule-ஐச் சேர்ப்பதாகும். ஆனால் இந்த container-க்கு தனிப்பட்ட network namespace இல்லை. Mapping-ஐ gluetun service-க்கு மாற்றவும். Application shared namespace-க்குள் அதே port-ல் listening செய்வதால், port number மாறாது.

services:
  gluetun:
    ports:
      - "8080:8080/tcp"   # qBittorrent web UI

  qbittorrent:
    network_mode: "service:gluetun"
    # no ports: block here

சார்ந்த service-ல் expose: block வைத்தாலும் இதேபோல் conflicting options: port exposing and the container type network mode உடன் தோல்வியடையும். அங்கு networks: block வைத்தாலும் Compose நிறுத்தப்படும்: service ஒன்றுக்கொன்று விலக்கான network_mode மற்றும் networks-ஐ அறிவிப்பதாக Compose தெரிவித்து, file-ஐ முழுமையாக load செய்ய மறுக்கும்.

இதன் ஒரு விளைவு பின்னர் தெரியவரும். அந்த namespace-ல் உள்ள அனைத்து containers-உம் ஒரே port space-ஐப் பகிர்கின்றன. ஆகவே, இயல்பாக 8080-ஐப் பயன்படுத்தும் இரண்டு applications மோதலை ஏற்படுத்தும். இரண்டாவதாக start ஆகும் application, address ஏற்கனவே பயன்படுத்தப்படுகிறது என்ற error-உடன் தோல்வியடையும். அவற்றில் ஒன்றின் சொந்த configuration-ல் port-ஐ மாற்றவும். உதாரணமாக, LinuxServer qBittorrent image-ல் உள்ள WEBUI_PORT variable-ஐ மாற்றி, புதிய எண்ணை gluetun-ல் publish செய்யவும்.

gluetun-க்கு பின்னால் உள்ள containers ஒன்றையொன்று எவ்வாறு அடைகின்றன?

அந்த namespace-க்குள் அவை ஏற்கனவே ஒரே loopback interface-ஐப் பகிர்கின்றன. gluetun-க்கு பின்னால் உள்ள ஒரு container, Docker network எதுவும் பயன்படுத்தாமல் 127.0.0.1:<port> மூலம் தனது sibling container-ஐ அடைகிறது.

namespace-க்கு வெளியிலிருந்து பார்க்கும்போது, அந்த container-க்கு பெயர் இல்லை. Docker-ன் embedded DNS, user defined network-ல் உள்ள service-ன் address-ஆக service name-ஐ resolve செய்யும். ஆனால் இந்த container எந்த network-லும் address வைத்திருக்காது. எனவே Sonarr போன்ற வழக்கமான container, http://qbittorrent:8080 மூலம் torrent client-ஐ அடையாது. அது http://gluetun:8080 மூலம் அதை அடையும். காரணம், socket gluetun-ன் namespace-ல், gluetun-ன் address-ல் listening நிலையில் உள்ளது. Docker Compose networks மற்றும் service names எவ்வாறு செயல்படுகின்றன என்பதை அறிந்தவர்களுக்கு, வழக்கமான naming இங்கும் பொருந்தும் என்று எதிர்பார்ப்பதால் இது ஆச்சரியமாக இருக்கும். இரண்டு containers-உம் ஒரே Compose network-ல் இருப்பதால், host-ல் எதையும் publish செய்யாமலும் இது செயல்படும்.

வேறு எதையும் debug செய்வதற்கு முன் DNS-ஐச் சரிபார்க்கவும். gluetun namespace-க்குள் தனது சொந்த DNS server-ஐ இயக்குகிறது. gluetun-க்கு பின்னால் உள்ள ஒவ்வொரு container-க்கும் Docker, gluetun-இல் உள்ள அதே /etc/resolv.conf file-ஐ வழங்குகிறது. எனவே உங்கள் application-ன் lookups, host-ன் resolver வழியாக அல்லாமல் gluetun-ன் resolver வழியாகச் செல்கின்றன. இயல்பாக, private addresses-ஐச் சுட்டிக்காட்டும் answers-ஐ அந்த resolver நிராகரிக்கும். அதனால் host-ல் resolve ஆகும் பெயர் container-க்குள் தோல்வியடையலாம். இத்தகைய hostnames-ஐ DNS_REBINDING_PROTECTION_EXEMPT_HOSTNAMES-ல் பட்டியலிட வேண்டும் என்று gluetun documentation கூறுகிறது.

docker exec qbittorrent cat /etc/resolv.conf

Docker host-ல் இயங்கும் service-ஐ எவ்வாறு அணுகுவது?

host.docker.internal-ஐ பயன்படுத்தவும். இதற்கு 2 settings தேவை. இரண்டு பிரச்சினைகள் இருப்பதால், அவை இரண்டும் gluetun service-ல் அமைக்கப்பட வேண்டும்.

முதலில் name-ஐ அமைக்க வேண்டும். gluetun-க்கு பின்னால் உள்ள container, gluetun-ன் /etc/hosts-ஐப் படிக்கும். மேலும், network_mode-ஐ conflicting options: custom host-to-IP mapping and the network mode உடன் அமைக்கும் service-ல் extra_hosts entry-ஐ Docker ஏற்காது. எனவே இந்த entry gluetun-ல் இருக்க வேண்டும். அந்த namespace-ல் உள்ள ஒவ்வொரு container-மும் இதைப் பார்க்கும்.

  gluetun:
    extra_hosts:
      - "host.docker.internal:host-gateway"

host-gateway என்பது Docker, host-ன் internal address-ஆக மாற்றும் special value ஆகும். சாதாரண Linux Docker installation-ல், இது docker0 bridge-ன் address ஆகும். பொதுவாக அது 172.17.0.1. VPS-ல் ip -4 addr show docker0 command மூலம் உங்கள் address-ஐ உறுதிப்படுத்தவும். Docker Desktop இந்த name-ஐ தானாக resolve செய்கிறது. அதனால் laptop-ல் எழுதப்பட்ட guides-ல் extra_hosts line இல்லாமல் இருக்கலாம். அதே file server-ல் தோல்வியடையும்.

அடுத்து route-ஐ அமைக்க வேண்டும். name-ஐ மட்டும் சேர்ப்பது, எந்த address-ஐ பயன்படுத்த வேண்டும் என்பதை container-க்கு மட்டும் தெரிவிக்கும். Packet இன்னும் gluetun-ன் default route வழியாகவே செல்லும். அது tunnel ஆகும். gluetun-ன் firewall அந்த packet-ஐ drop செய்யும். இதன் அறிகுறி, connection முதலில் நீண்ட நேரம் காத்திருந்து பின்னர் timeout ஆவது. Refusal என்றால் packet வந்து சேர்ந்தது, ஆனால் ஏதோ ஒன்று மறுப்புடன் பதிலளித்தது. Timeout என்றால் packet வந்து சேரவில்லை.

  gluetun:
    environment:
      - FIREWALL_OUTBOUND_SUBNETS=172.17.0.1/32

அதன்பின் host service அந்த address-ல் உண்மையில் listening செய்கிறதா என்பதைச் சரிபார்க்கவும். 127.0.0.1-க்கு மட்டும் bind செய்யப்பட்ட PostgreSQL server-ஐ, தனக்கென network namespace கொண்ட எந்த container-லிருந்தும் அணுக முடியாது. இது gluetun-க்கு பின்னால் உள்ள அனைத்து container-களையும் உள்ளடக்கும்; 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-ல் திறக்காமல், container-களிலிருந்து வரும் connections-ஐ அது ஏற்றுக்கொள்ளும். Host-ல் ss -lntp | grep 5432 மூலம் இதை உறுதிப்படுத்தவும்.

FIREWALL_OUTBOUND_SUBNETS உண்மையில் எதை மாற்றுகிறது

Gluetun ஆவணங்கள் இதை, Gluetun மற்றும் அதன் network stack-ஐப் பகிரும் containers அணுக அனுமதிக்கப்பட்ட, கமாவால் பிரிக்கப்பட்ட subnets என்று விவரிக்கிறது. இது firewall மற்றும் routing மாற்றங்களை உள்ளடக்கியது என்பதையும் அது குறிப்பிடுகிறது. இவை இரண்டுமே முக்கியமானவை. பட்டியலிடப்பட்ட ஒவ்வொரு subnet-க்கும் Docker bridge gateway வழியாக ஒரு route-ஐ Gluetun சேர்க்கிறது. இதனால் அந்த முகவரிகளுக்கான packets, tunnel வழியாகச் செல்லாமல் eth0 வழியாக வெளியேறுகின்றன. இது அவற்றுக்கான firewall-ஐயும் திறந்துவிடுகிறது; ஏனெனில், VPN server-ஐ நோக்கிச் செல்லாத outbound traffic-ஐ Gluetun பொதுவாகத் தடுத்துவிடும் (drop).

மதிப்பை உள்ளிடும்போது கமாக்களுக்குப் பிறகு இடைவெளி (space) விட வேண்டாம்.

      - FIREWALL_OUTBOUND_SUBNETS=172.17.0.1/32,192.168.1.0/24,100.64.7.9/32

இரண்டு பண்புகளைக் கவனிக்கத் தவறுவது எளிது. இது ஒரு namespace அளவிலான அமைப்பு (setting), எனவே இது நீங்கள் கருத்தில் கொண்ட container-க்கு மட்டுமல்லாமல், Gluetun-க்கு பின்னால் உள்ள அனைத்து containers-க்கும் பொருந்தும். மேலும், இது outbound-க்கு மட்டுமே: ஒரு container தொடங்கும் இணைப்புகளை இது கட்டுப்படுத்துகிறது. ஒரு published port-க்கு வரும் இணைப்புகள் வேறு பாதையில் பயணிக்கும், அவற்றுக்கு இங்கே எந்த உள்ளீடும் தேவையில்லை.

Tailscale peer மூலம் web UI-ஐ அணுகுதல்

Tailscale ஒவ்வொரு இயந்திரத்திற்கும் 100.64.0.0/10-ல் ஒரு முகவரியை வழங்குகிறது, இது carrier grade NAT-க்காக ஒதுக்கப்பட்ட வரம்பாகும். தனிப்பட்ட tailnet-ல் இதற்கு கட்டணம் ஏதுமில்லை, இருப்பினும் இலவச திட்டத்தில் உள்ள ஆறு பயனர்கள் என்ற வரம்பு மற்றவர்கள் அதே UI-களை அணுக வேண்டியிருக்கும் போது இது தொடருமா என்பதை தீர்மானிக்கிறது. அனைத்து திட்டங்களிலும் பயனர் சாதனங்களுக்கு வரம்பு இல்லை. Servers மற்றும் பிற tagged சாதனங்கள் தனித்தனியாக கணக்கிடப்படுகின்றன: Tailscale-ன் விலை நிர்ணய பக்கத்தில் 50 tagged வளங்கள் சேர்க்கப்பட்டுள்ளன, அதற்கு மேல் ஒவ்வொன்றிற்கும் மாதம் $1 வசூலிக்கப்படுகிறது. பில்லிங் முறையில் இயந்திரங்களை விட பயனர்களே கணக்கிடப்படுவதால், ஒரு கட்டண tailnet-ன் உண்மையான செலவு நீங்கள் எத்தனை பேரை அழைக்கிறீர்கள் என்பதைப் பொறுத்தே அமையும், எத்தனை containers-ஐ அவர்களுக்கு வெளிப்படுத்துகிறீர்கள் என்பதைப் பொறுத்தல்ல. இந்த இரண்டு திசைகளுக்கும் வெவ்வேறு அணுகுமுறைகள் தேவை.

Inbound (உள்வரும் போக்குவரத்து) எளிதானது. gluetun-ல் 8080:8080-ஐ வெளியிடுவது அந்த port-ஐ host-ன் அனைத்து முகவரிகளிலும் பிணைக்கிறது, மேலும் host-ன் tailscale0 interface அவற்றில் ஒன்று என்பதால், ஒரு peer http://<machine-name>:8080-ஐத் திறந்து container-ஐ அடைய முடியும். Docker host-ல் NAT-ஐப் பயன்படுத்துகிறது, மேலும் gluetun-ன் firewall அதன் Docker subnet-க்கு வரும் போக்குவரத்தை அனுமதிக்கிறது.

UI-ஐ tailnet வழியாக மட்டுமே அணுகக்கூடியதாக மாற்ற, வெளியிடப்பட்ட port-ஐ அனைத்து முகவரிகளுக்கும் பதிலாக host-ன் Tailscale முகவரியுடன் பிணைக்கவும்.

    ports:
      - "100.101.102.103:8080:8080/tcp"

host-ல் tailscale ip -4 மூலம் அந்த முகவரியைக் கண்டறியவும். இங்கு firewall விதியை விட பிணைப்பு (binding) வலுவான கட்டுப்பாடாகும், ஏனெனில் public interface-ல் port திறக்கப்படுவதே இல்லை. host மற்றும் port-க்கு பதிலாக HTTPS பெயரில் UI-ஐ அணுக விரும்பினால், tailscale serve அந்த வெளியிடப்பட்ட port-க்கு முன்னால் செயல்படலாம், இருப்பினும் serve மற்றும் funnel ஆகியவற்றுக்கு இடையே UI-ஐ யார் அணுக முடியும் என்பதில் வேறுபாடு உள்ளது மற்றும் இரண்டில் ஒன்று மட்டுமே UI-ஐ tailnet-ல் வைத்திருக்கும். இது Docker ports-ஐ நேரடியாக ufw-ஐத் தாண்டி வெளியிடும் சிக்கலையும் தவிர்க்கிறது. Compose-க்கான Tailscale sidecar முறை இன்னும் ஒரு படி மேலே சென்று host port-ஐ முழுமையாக நீக்குகிறது, ஆனால் இது app-ஐ sidecar-ன் network namespace-க்குள் வைப்பதன் மூலம் செயல்படுகிறது, மேலும் gluetun-க்கு பின்னால் உள்ள container ஏற்கனவே அதன் ஒரு network_mode-ஐ gluetun-க்காகப் பயன்படுத்திவிட்டது.

Outbound (வெளிச்செல்லும் போக்குவரத்து) என்பது FIREWALL_OUTBOUND_SUBNETS மீண்டும் வரும் இடமாகும். ஒரு container ஒரு peer-ஐ அழைக்க வேண்டியிருந்தால், அந்த peer-ன் முகவரியைச் சேர்க்கவும், மேலும் முழு /10-க்கு பதிலாக ஒவ்வொரு peer-க்கும் ஒரு /32-ஐ முன்னுரிமைப்படுத்தவும். நீங்கள் அழைக்கும் இயந்திரம் உங்கள் tailnet-க்கு அந்த subnet-ஐ விளம்பரப்படுத்தும் VPS வழியாக அடையப்படும் ஒரு private network-ல் இருந்தால், router-ன் சொந்த 100.x முகவரிக்கு பதிலாக விளம்பரப்படுத்தப்பட்ட வரம்பைப் பட்டியலிடவும், மேலும் host அந்த வழிகளை ஏற்றுக்கொண்டதை உறுதிப்படுத்தவும். container இயல்பாகவே host-ன் resolver-க்கு பதிலாக gluetun-ன் DNS server-ஐப் பயன்படுத்துவதால், MagicDNS பெயர்கள் container-க்குள் resolve ஆகாது. எனவே, எண் சார்ந்த 100.x முகவரியைப் பயன்படுத்தவும் அல்லது gluetun service-ல் extra_hosts வரியுடன் பெயரைப் பொருத்தவும் (pin). Gluetun-ன் DNS_UPSTREAM_PLAIN_ADDRESSES விருப்பம் வினவல்களை மற்றொரு resolver-க்கு அனுப்பலாம், ஆனால் அது ஒவ்வொரு விவலையும் plaintext-ல் அனுப்புகிறது. VPN tunnel-லிருந்து private முகவரிக்குச் செல்லும் விவல்கள் கசிந்துவிடும் என்பதால், gluetun ஆவணங்கள் இதைத் தவிர்க்க அறிவுறுத்துகின்றன. உங்கள் சொந்த Tailscale control server-ஐ Headscale மூலம் இயக்கும்போதும் இதுவே பொருந்தும்.

பொதுவாகப் பயன்படுத்தப்படும் அமைப்புக்கான முழுமையான compose file

VPN-க்கு பின்னால் இயங்கும் ஒரு download client, tailnet-ல் மட்டும் பதிலளிக்கும் இரண்டு web UIs, மேலும் host-ல் இயங்கும் PostgreSQL database-ஐப் படிக்கும் ஒரு container ஆகியவற்றுக்கான அமைப்பு இது.

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

Product names-ஐ விட, இந்த file-ல் பயன்படுத்தப்பட்டுள்ள pattern-ஐ கவனிக்கவும். இரண்டு UIs-மும் gluetun-ல் publish செய்யப்பட்டு, host-ன் tailnet address-க்கு bind செய்யப்பட்டுள்ளன. எனவே அவை Tailscale மூலம் மட்டுமே பதிலளிக்கும்; வேறு எந்த interface-லுமில்லை. extra_hosts line-உம் gluetun-ல் உள்ளது. ஏனெனில் host.docker.internal-ஐ resolve செய்யும்போது Prowlarr, gluetun-ன் /etc/hosts-ஐப் படிக்கிறது; Prowlarr-ல் அந்த line-ஐ நேரடியாக அமைக்க Docker அனுமதிக்காது. FIREWALL_OUTBOUND_SUBNETS இரண்டு தனிப்பட்ட addresses-ஐ குறிப்பிடுகிறது: Prowlarr database connection-ஐத் திறக்கப் பயன்படுத்தும் host-ன் Docker bridge address, மற்றும் ஒரு tailnet peer.

PostgreSQL server இந்த file-ல் நோக்கமுடன் சேர்க்கப்படவில்லை. அது VPS-ல் சாதாரண system service-ஆக இயங்கி, 172.17.0.1:5432-ல் listening செய்கிறது. இது Docker Compose-ல் இயங்கும் arr stack பயன்படுத்தும் அதே layering ஆகும்; database மட்டும் Docker-க்கு வெளியே வைக்கப்பட்டுள்ளது.

WireGuard private key-ஐ compose file-ல் வைக்க வேண்டாம். ${WIREGUARD_PRIVATE_KEY} அதற்கு அருகில் உள்ள .env file-லிருந்து அதைப் படிக்கிறது. இந்த pattern Docker Compose-க்கான env files மற்றும் secrets பகுதியில் விளக்கப்பட்டுள்ளது. condition: service_healthy clause, gluetun image-ல் ஏற்கனவே உள்ள healthcheck-ஐப் பயன்படுத்துகிறது. எனவே tunnel இயங்குவதாக report செய்யும் வரை எந்த service-உம் தொடங்காது. Compose healthchecks பகுதியில் பொதுவான syntax விளக்கப்பட்டுள்ளது.

tailnet-க்கு மட்டும் அல்லாமல் ஒவ்வொரு address-லும் publish செய்தல்

Address prefix-ஐ நீக்கவும். 0.0.0.0-ல் உள்ள port binds-ஐயும் நீக்கவும்; இதில் VPS public IP அடங்கும். நீங்கள் கட்டுப்படுத்தும் firewall-ன் பின்னால் மட்டுமே இதைச் செய்யவும். முதலில் மேலே உள்ள ufw குறிப்பு பகுதியைப் படிக்கவும்.

    ports:
      - "8080:8080/tcp"

Tunnel இன்னும் network traffic-ஐ எடுத்துச் செல்கிறதா என்பதை உறுதிப்படுத்தவும்

அதே 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 provider-ன் exit address-ஐ காட்ட வேண்டும். இரண்டாவது request VPS address-ஐ காட்ட வேண்டும். இரண்டும் ஒரே address-ஐ காட்டினால், container-ன் traffic tunnel வழியாகச் செல்லவில்லை. அந்தச் சிக்கல் சரியாகும் வரை இந்த guide-ல் உள்ள மற்ற அனைத்து fixes-உம் பயனற்றவை.

Routing rules மற்றும் routing tables மூலம் எந்த traffic tunnel-ஐத் தவிர்க்கிறது, எது tunnel வழியாகச் செல்கிறது என்பதை அறியலாம்.

docker run --rm --network=container:gluetun alpine:3.22 sh -c 'ip rule show; ip route show table 51820; ip route show table 199'

இந்த guide-ல் உள்ள WireGuard அமைப்பில், gluetun tunnel interface-க்கு wg0 என்று பெயரிடுகிறது. tun0 என்பது அதன் OpenVPN default பெயர் மட்டுமே. gluetun tunnel-ன் default route-ஐ main routing table-க்கு வெளியிலும் வைத்திருக்கிறது. ip rule show-ல் WireGuard தானாக mark செய்யாத அனைத்து traffic-ஐ table 51820-க்கு அனுப்பும் rule இருக்க வேண்டும். அந்த table-ல் wg0 மீது default route இருக்க வேண்டும். Table 199-ல் FIREWALL_OUTBOUND_SUBNETS-இல் உள்ள ஒவ்வொரு entry-க்கும் ஒரு route இருக்கும். ஒவ்வொரு route-உம் eth0-ல் உள்ள Docker bridge gateway-ஐச் சுட்டிக்காட்டும். இந்த table-ன் rule, tunnel rule-க்கு உடனடியாக முன்பாகச் சரிபார்க்கப்படும். சாதாரண ip route show command இன்னும் eth0-ல் உள்ள Docker-ன் சொந்த default route-ஐக் காட்டும். இது எதிர்பார்க்கப்படும் நிலை. இது leak அல்ல, ஏனெனில் gluetun-ன் இரண்டு rules-உம் main table-க்கு முன்பாகச் சரிபார்க்கப்படுகின்றன. நீங்கள் பட்டியலிடாத table 199-ல் உள்ள எந்த route-உம் VPN-ஐத் தவிர்க்கும் traffic ஆகும்.

Gluetun-ன் control server port 8000-ல், /v1/publicip/ip என்ற path-ல், அதே public IP-ஐக் காட்ட முடியும். ஆனால் authentication-ஐ அமைத்த பிறகே இது இயல்பாகச் செயல்படும். அனைத்து control server routes-உம் இப்போது default-ஆக private நிலையில் உள்ளன என்று gluetun documentation குறிப்பிடுகிறது. எனவே அந்த path-க்கு அனுப்பும் plain request தோல்வியடையும். basic அல்லது apikey method-ஐப் பயன்படுத்தி /gluetun/auth/config.toml-ல் mount செய்யப்பட்ட auth file மூலம் இதை configure செய்யவும். பின்னர் gluetun-ஐ restart செய்யவும். மேலே உள்ள compose file ஏற்கனவே ./gluetun-ஐ /gluetun-ல் mount செய்கிறது. எனவே host-ல் அந்த file-ஐ ./gluetun/auth/config.toml-ல் வைக்க வேண்டும். HTTP_CONTROL_SERVER_AUTH_DEFAULT_ROLE variable-ஐப் பயன்படுத்துவது விரைவான வழியாகும். அதை {"auth":"none"} என அமைத்தால் authentication முழுமையாக முடக்கப்படும். இதை docs மிகவும் கடுமையாகத் தவிர்க்குமாறு குறிப்பிடுகின்றன. v3.39.1-க்கு முந்தைய release-ல் server இவ்வாறு lock down செய்யப்படாது. அதை அணுகக்கூடிய எந்த client-ஐயும் நம்புமாறு docs எச்சரிக்கின்றன.

தவறான subnet உருவாக்கும் கசிவு

FIREWALL_OUTBOUND_SUBNETS என்பது நீங்கள் வேண்டுமென்றே firewall-ல் துளையிடும் ஒரு ஓட்டையாகும், எனவே அந்த ஓட்டையின் அளவுதான் ஆபத்தின் அளவும். தவிர்க்க வேண்டிய நான்கு தவறுகள்:

  • 0.0.0.0/0, outbound subnet has an unspecified address: 0.0.0.0/0 உடன் configuration சரிபார்ப்பில் தோல்வியடைகிறது. tunnel-க்கு வெளியே அனைத்தையும் routing செய்வதற்குப் பதிலாக gluetun அதை நிராகரிக்கிறது.
  • இலக்கை விட அகலமான வரம்பு. 10.0.1.7-ல் உள்ள ஒரு இயந்திரத்தை அடைய 10.0.0.0/8-ஐத் திறப்பது, ஒரு torrent peer அந்த வரம்பில் விளம்பரப்படுத்தக்கூடிய அனைத்து முகவரிகளையும் திறந்துவிடும். 10.0.1.7/32 என்று எழுதவும்.
  • tunnel-ன் சொந்த முகவரிகளுடன் மேலெழும்பும் (overlap) வரம்பு. இது gluetun-ஐ VPN போக்குவரத்தை bridge வழியாக வெளியே அனுப்பச் செய்யும் என்று gluetun ஆவணங்கள் எச்சரிக்கின்றன, இது port forwarding-ஐப் பாதிக்கும். ஏதேனும் private வரம்பைத் திறக்கும் முன் உங்கள் WIREGUARD_ADDRESSES மதிப்பைச் சரிபார்க்கவும்.
  • Tailscale-க்கான 100.64.0.0/10. ஒரு peer-ஐ அடைய நான்கு மில்லியன் முகவரிகளைத் திறப்பது இதற்குச் சமம். உங்களுக்குத் தேவையான peer-களை /32 உள்ளீடுகளாகப் பட்டியலிடவும்.

இந்த அமைப்பு முழு namespace-க்கும் பொருந்தும் என்பதை நினைவில் கொள்ளவும். ஒரு indexer ஒரு host service-ஐ அடைய ஒரு subnet-ஐத் திறப்பது, அதே namespace-ஐப் பயன்படுத்தும் torrent client-க்கும் அந்த subnet-ஐத் திறந்துவிடும். இந்த variable-ல் ஒவ்வொரு மாற்றத்திற்குப் பிறகும் public IP சோதனையை மீண்டும் செய்யவும், ஏனெனில் நீங்கள் செய்த மாற்றம் நீங்கள் எதிர்பார்த்ததைச் செய்ததா என்பதைத் தெரிவிக்கும் ஒரே சோதனை அதுதான்.

gluetun-ஐ restart செய்யும்போது என்ன பாதிக்கிறது

Gluetun network namespace-ஐ நிர்வகிக்கிறது. எனவே gluetun-ன் lifecycle-ம் அந்த namespace-ன் lifecycle-ம் ஒன்றே. gluetun நிறுத்தப்பட்டிருக்கும் போது அதை சார்ந்த container-ஐ தொடங்கினால் உடனடியாக தோல்வியடையும்:

Error response from daemon: cannot join network namespace of a non running container: container <id> is exited

gluetun-ஐ இயங்கிக்கொண்டிருக்கும் நிலையில் restart செய்வது வெளிப்படையாகத் தெரியாத தோல்வியை ஏற்படுத்தும். Dependent containers தொடர்ந்து இயங்கும்; ஆனால் அவை இணைக்கப்பட்டிருந்த namespace பின்னணியில் மீண்டும் உருவாக்கப்படும். இதனால் docker ps அனைத்தும் healthy எனக் காட்டும், ஆனால் எந்த service-மும் பதிலளிக்காது. gluetun service-ல் ஏதேனும் மாற்றம் செய்த பிறகு, ஒரு பகுதியை மட்டும் restart செய்யாமல் முழு group-ஐ மீண்டும் உருவாக்கவும்.

docker compose up -d --force-recreate

Image updates-க்கும் இதே விதி பொருந்தும். புதிய gluetun image-ஐ pull செய்து அந்த service-ஐ மட்டும் மீண்டும் உருவாக்கினால், மற்ற containers இனி இல்லாத namespace-ஐ நோக்கி இணைந்திருக்கும்.

FAQ

Docker ஏன் "port publishing and the container type network mode" என்று கூறுகிறது?

ports: block, network_mode: service:gluetun-ஐ அமைக்கும் service-ல் இன்னும் இருப்பதே இதற்குக் காரணம். Port-ஐ publish செய்வது, host port-இலிருந்து container-ன் சொந்த network namespace-க்கு traffic-ஐ forward செய்யும் NAT rule-ஐச் சேர்க்கிறது. ஆனால் இந்த mode-ல் இயங்கும் container-க்கு தனிப்பட்ட network namespace இருப்பதில்லை. அந்த service-இலிருந்து ports: block-ஐ நீக்கி, அதே mapping-ஐ gluetun service-க்கு சேர்க்கவும். Application shared namespace-க்குள் அதே port-ல் listening செய்வதால், port number மாறாது.

gluetun-ன் பின்னால் இருக்கும் service-ஐ மற்ற containers எவ்வாறு அணுகும்?

அதே namespace-க்குள் உள்ள containers, 127.0.0.1 மூலம் ஒன்றையொன்று அணுகும். அதற்கு வெளியே உள்ள containers, gluetun service name-ஐ பயன்படுத்த வேண்டும். எனவே http://gluetun:8080 செயல்படும்; http://qbittorrent:8080 செயல்படாது. Application container-க்கு எந்த Docker network-லும் address இருப்பதில்லை. ஆகவே embedded DNS server-ஆல் அதன் பெயரை resolve செய்ய முடியாது. இரண்டு containers-உம் ஒரே Compose network-ஐப் பகிரும் வரை, இதற்காக port publishing தேவையில்லை.

FIREWALL_OUTBOUND_SUBNETS-ல் என்ன சேர்க்க வேண்டும்?

gluetun-ன் பின்னால் இருக்கும் container connection-ஐ தொடங்க வேண்டிய addresses-ஐ மட்டும், முடிந்தவரை குறுகிய range-ஆக எழுதவும். ஒரு தனி machine-க்கு /32 ஆகும். பொதுவாக சேர்க்கப்படும் இரண்டு entries, Docker host-க்கான 172.17.0.1/32 மற்றும் நீங்கள் அணுகும் ஒவ்வொரு Tailscale peer-க்குமான ஒரு /32 ஆகும். ஒருபோதும் 0.0.0.0/0-ஐ சேர்க்க வேண்டாம். உங்கள் VPN-ன் சொந்த tunnel addresses-ஐ overlap செய்யும் range-ஐயும் சேர்க்க வேண்டாம். Published port-க்கு வரும் inbound connections-க்கு இங்கு entry தேவையில்லை.

Container-ஆல் எனது Tailscale MagicDNS names-ஐ ஏன் resolve செய்ய முடியவில்லை?

MagicDNS, host-ன் resolver-ஐ Tailscale-ன் DNS server-க்கு சுட்டிக்காட்டி இயங்குகிறது. ஆனால் container, host-ன் resolver-ஐ பயன்படுத்துவதில்லை. அது gluetun உடன் பகிரும் /etc/resolv.conf-ஐப் பயன்படுத்துகிறது. இது gluetun-ன் சொந்த DNS server-ஐ சுட்டிக்காட்டுகிறது. docker exec <container> cat /etc/resolv.conf மூலம் இதை உறுதிப்படுத்தவும். Peer-ன் numeric 100.x address-ஐ பயன்படுத்தவும் அல்லது gluetun service-ல் extra_hosts entry மூலம் name-ஐ நிலையாக அமைக்கவும். DNS_UPSTREAM_PLAIN_ADDRESSES மூலம் gluetun queries-ஐ வேறு resolver-க்கு forward செய்ய முடியும். ஆனால் அவை plaintext-ஆக அனுப்பப்படும்; இதைத் தவிர்க்க வேண்டும் என்று அதன் documentation குறிப்பிடுகிறது.

Traffic இன்னும் VPN வழியாகச் செல்கிறது என்பதை எவ்வாறு உறுதிப்படுத்துவது?

Namespace-க்குள் இருந்து ஒரு request-ஐ இயக்கி, அதே request-ஐ host-லிருந்தும் இயக்கவும். பின்னர் கிடைக்கும் answers-ஐ ஒப்பிடவும். docker run --rm --network=container:gluetun curlimages/curl:latest -s https://api.ipify.org, உங்கள் VPN provider-ன் exit address-ஐத் திருப்பித் தர வேண்டும். VPS-ல் curl -s https://api.ipify.org, VPS address-ஐத் திருப்பித் தர வேண்டும். இரண்டு answers-உம் ஒரே மாதிரியாக இருந்தால், container-ன் traffic tunnel வழியாகச் செல்லவில்லை. FIREWALL_OUTBOUND_SUBNETS-ல் ஒவ்வொரு மாற்றத்திற்குப் பிறகும் இந்தச் சோதனையை மீண்டும் இயக்கவும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?