SSD Nodes Learn Hosting plans →
คู่มือ Matt Connorโดย Matt Connor

วิธีตั้งค่า Gluetun Port Forwarding สำหรับ Torrent

แก้ไขปัญหาดาวน์โหลดได้แต่ไม่มีการเชื่อมต่อขาเข้าด้วยการตั้งค่า Gluetun port forwarding พร้อมวิธีส่งพอร์ตใหม่ไปยังไคลเอนต์อัตโนมัติทุกครั้งที่เชื่อมต่อ VPN ใหม่

เหตุใดจึงไม่มีการเชื่อมต่อจากภายนอกหากไม่ได้ทำ port forwarding

Gluetun port forwarding จะร้องขอให้ผู้ให้บริการ VPN ทำการแมปพอร์ตสาธารณะหนึ่งพอร์ตบนแอดเดรสขาออก (exit address) กลับมายังคอนเทนเนอร์ของคุณ ซึ่งเป็นวิธีเดียวที่ peer อื่นจะสามารถเริ่มต้นการเชื่อมต่อมายังไคลเอนต์ torrent ของคุณได้ หากไม่มีการแมปดังกล่าว อุโมงค์ (tunnel) จะยังคงทำงานได้ปกติ การดาวน์โหลดจะดำเนินไป แต่จะไม่มีข้อมูลใดส่งเข้ามาได้ด้วยตัวเอง การเชื่อมต่อที่ใช้งานได้ทั้งหมดจะเป็นการเชื่อมต่อที่ไคลเอนต์ของคุณเป็นผู้เปิดก่อนเท่านั้น

กลไกที่เกี่ยวข้องคือ NAT (network address translation) คอนเทนเนอร์ของคุณใช้แอดเดรสขาออกร่วมกับลูกค้าคนอื่น ๆ ของผู้ให้บริการจำนวนมาก เมื่อไคลเอนต์ของคุณเปิดการเชื่อมต่อออกไปข้างนอก ผู้ให้บริการจะบันทึกกระแสข้อมูลนั้นไว้และส่งการตอบกลับกลับมาตามอุโมงค์ของคุณ แต่เมื่อมี peer อื่นพยายามเชื่อมต่อเข้ามาโดยไม่มีกระแสข้อมูลที่บันทึกไว้ แพ็กเก็ตจะไปถึงแอดเดรสขาออกแล้วถูกทิ้งไป ไคลเอนต์ของคุณยังคงเข้าถึง peer ทุกรายที่สามารถรับการเชื่อมต่อได้ด้วยตัวเอง ดังนั้นการดาวน์โหลดจึงเสร็จสิ้นและปัญหาจะยังคงไม่ปรากฏชัดเจน แต่จะเห็นผลชัดเจนในส่วนของการ seeding เนื่องจาก seeder คือเครื่องที่ผู้อื่นต้องเชื่อมต่อเข้ามาหา

การเปิดพอร์ตขาเข้าจะเปลี่ยนสถานะสองประการ คือคุณจะเข้าร่วม swarm ได้เร็วขึ้น เนื่องจาก peer ที่ไม่สามารถรับการเชื่อมต่อได้ด้วยตัวเองจะสามารถเข้าถึงคุณได้ และคุณจะสามารถอัปโหลดข้อมูลไปยัง peer เหล่านั้นได้ด้วย

เหตุผลที่ผู้ให้บริการ VPN ส่วนใหญ่ไม่เปิดให้ใช้งาน port forwarding

Port forwarding เป็นทรัพยากรที่มีจำกัดบน IP address แบบใช้ร่วมกัน ผู้ให้บริการต้องสำรองหมายเลขพอร์ตหนึ่งพอร์ตบน IP ขาออกหนึ่งหมายเลขให้กับลูกค้าหนึ่งราย และต้องรับผิดชอบต่อสิ่งที่ลูกค้าทำผ่านพอร์ตนั้น ผู้ให้บริการรายใหญ่หลายรายจึงยกเลิกฟีเจอร์นี้โดยอ้างเหตุผลเรื่องการจัดการการใช้งานในทางที่ผิด ให้มองว่าการรองรับฟีเจอร์นี้เป็นคำถามเชิงหมวดหมู่มากกว่าแค่การติ๊กเลือกในรายการ โดยให้สอบถามว่าผู้ให้บริการรองรับ port forwarding ในปัจจุบันหรือไม่ บนแพ็กเกจที่คุณเลือก และบนเซิร์ฟเวอร์ที่คุณสามารถเลือกใช้งานได้จริง

ในกรณีที่มีการเปิดให้ใช้งาน พอร์ตที่ได้จะเป็นแบบไดนามิก ซึ่งจะผูกอยู่กับเซสชัน VPN ไม่ใช่ผูกกับบัญชีผู้ใช้งานของคุณ ดังนั้นหมายเลขพอร์ตอาจเปลี่ยนไปทุกครั้งที่เชื่อมต่อใหม่ Private Internet Access จะออกพอร์ตที่ลงลายเซ็นดิจิทัลซึ่ง gluetun จะคอยรีเฟรชให้ โดยเอกสารประกอบของผู้ให้บริการระบุว่าคุณจะได้รับพอร์ตเดิมเป็นเวลา 60 วัน ตราบใดที่คุณทำ bind mount ไดเรกทอรี /gluetun เพื่อให้สถานะคงอยู่หลังการรีสตาร์ท ส่วน ProtonVPN จะกำหนดพอร์ตแบบสุ่มผ่าน NAT-PMP (NAT port mapping protocol) โดยมีระยะเวลาเช่าสั้นๆ ซึ่งต้องต่ออายุอย่างต่อเนื่อง นี่คือเหตุผลว่าทำไมการตั้งค่าพอร์ตในไคลเอนต์เพียงครั้งเดียวจึงไม่สามารถใช้งานได้ตลอดไป

ผู้ให้บริการรายใดบ้างที่ gluetun สามารถร้องขอพอร์ตได้

ณ gluetun v3.41.3 ซึ่งปล่อยออกมาเมื่อวันที่ 30 กรกฎาคม 2026 การเชื่อมต่อแบบเนทีฟรองรับการตรวจสอบกับชื่อผู้ให้บริการ 4 ราย ได้แก่ Private Internet Access, ProtonVPN, Perfect Privacy และ PrivateVPN โดยเปิดใช้งานด้วย VPN_PORT_FORWARDING=on ซึ่งมีค่าเริ่มต้นเป็น off คู่มือรุ่นเก่าจะใช้ PORT_FORWARDING หรือ PRIVATE_INTERNET_ACCESS_VPN_PORT_FORWARDING ซึ่งทั้งสองชื่อยังคงใช้งานได้ในเวอร์ชันนี้ในฐานะชื่อที่รองรับย้อนหลัง แต่กำลังจะถูกยกเลิกในอนาคต

รายละเอียดของผู้ให้บริการสองประการจะเป็นตัวตัดสินว่าการร้องขอจะสำเร็จหรือไม่ ProtonVPN จำเป็นต้องใช้แผนบริการแบบชำระเงินและต้องเปิดใช้งาน NAT-PMP: ให้เปิด NAT-PMP (Port Forwarding) ภายใต้ตัวเลือก VPN เมื่อคุณสร้างการตั้งค่า WireGuard หรือเพิ่ม +pmp ต่อท้ายชื่อผู้ใช้ของคุณเมื่อใช้ OpenVPN สำหรับ Private Internet Access บน OpenVPN จะมี PORT_FORWARD_ONLY ซึ่งจะจำกัดการเลือกเซิร์ฟเวอร์ให้เหลือเฉพาะเซิร์ฟเวอร์ที่รองรับการส่งต่อพอร์ต เพื่อป้องกันไม่ให้คุณเชื่อมต่อไปยังเซิร์ฟเวอร์ที่ไม่รองรับ WireGuard และ OpenVPN มีวิธีการร้องขอพอร์ตที่แตกต่างกัน ดังนั้นโปรดอ่านหน้าข้อมูลของผู้ให้บริการของคุณก่อนตัดสินใจเลือก

เมื่อ gluetun ทำงานด้วยการตั้งค่าแบบกำหนดเองแทนการใช้ผู้ให้บริการที่มีมาให้ในตัว VPN_PORT_FORWARDING_PROVIDER จะเป็นตัวระบุชื่อ API ที่ gluetun ควรเรียกใช้งาน หน้าข้อมูลของ Private Internet Access จะจับคู่ตัวแปรดังกล่าวกับ VPN_PORT_FORWARDING_USERNAME และ VPN_PORT_FORWARDING_PASSWORD ซึ่งใช้สำหรับส่งข้อมูลประจำตัวบัญชีที่จำเป็นต่อการร้องขอพอร์ต

การเปิดใช้งาน port forwarding ของ gluetun ใน docker compose

ส่วนนี้อนุมานว่าอุโมงค์เครือข่ายทำงานได้ปกติแล้ว หากยังไม่ทำงาน ให้เริ่มจากการ กำหนดเส้นทางทราฟฟิกของ Docker container ผ่าน gluetun และกลับมาดำเนินการต่อเมื่อดาวน์โหลดข้อมูลได้แล้ว

services:
  gluetun:
    image: qmcgaw/gluetun:v3.41.3
    container_name: gluetun
    cap_add:
      - NET_ADMIN
    devices:
      - /dev/net/tun:/dev/net/tun
    ports:
      - 8080:8080/tcp
      - 8000:8000/tcp
    volumes:
      - ./gluetun:/gluetun
    environment:
      - VPN_SERVICE_PROVIDER=protonvpn
      - VPN_TYPE=wireguard
      - WIREGUARD_PRIVATE_KEY=${WIREGUARD_PRIVATE_KEY}
      - VPN_PORT_FORWARDING=on
      - TZ=Etc/UTC
    restart: unless-stopped

  qbittorrent:
    image: lscr.io/linuxserver/qbittorrent:5.2.3
    container_name: qbittorrent
    network_mode: "service:gluetun"
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Etc/UTC
      - WEBUI_PORT=8080
    volumes:
      - ./qbittorrent:/config
      - ./downloads:/downloads
    depends_on:
      - gluetun
    restart: unless-stopped

ให้ระบุเวอร์ชันของ image ไว้ (pin the tag) เนื่องจาก qmcgaw/gluetun:latest ติดตาม branch master ซึ่งมีการเปลี่ยนแปลงโครงสร้างภายในของ port forwarding สำหรับ v4 ดังนั้น image ที่ไม่ได้ระบุเวอร์ชันอาจเปลี่ยนพฤติกรรมในการทำ docker compose pull ครั้งถัดไป ควรเก็บ private key ไว้นอกไฟล์ compose โดยใช้ ไฟล์ env สำหรับจัดการความลับใน compose

ตำแหน่งที่ gluetun เขียนพอร์ตที่ส่งต่อ (forwarded port)

Gluetun จะเปิดเผยหมายเลขพอร์ตไว้ใน 3 ตำแหน่ง ซึ่งทั้งหมดจะมีค่าเดียวกัน

ระบบจะบันทึกพอร์ตลงใน log หนึ่งครั้งเมื่อได้รับค่า โดยบรรทัดดังกล่าวจะแสดงเป็น port forwarded is 45678 และแสดงเป็น no port forwarded ในกรณีที่คำขอไม่ส่งค่าใดๆ กลับมา

docker logs gluetun 2>&1 | grep -i "port forwarded"

ระบบจะเขียนหมายเลขพอร์ตลงในไฟล์ที่ระบุโดย VPN_PORT_FORWARDING_STATUS_FILE ซึ่งค่าเริ่มต้นคือ /tmp/gluetun/forwarded_port ไฟล์นี้จะเก็บพอร์ตไว้หนึ่งรายการต่อหนึ่งบรรทัด โดยเขียนด้วยโหมด 0644 และเปลี่ยนเจ้าของ (chown) เป็น PUID และ PGID ของคอนเทนเนอร์ เมื่อการส่งต่อพอร์ตสิ้นสุดลง gluetun จะล้างข้อมูลในไฟล์แทนการลบไฟล์ทิ้ง เพื่อให้โปรแกรมอื่นที่มาอ่านไฟล์สามารถอ่านไฟล์ว่างได้แทนที่จะพบข้อผิดพลาดว่าไม่พบไฟล์

docker exec gluetun cat /tmp/gluetun/forwarded_port

ระบบจะให้บริการค่าพอร์ตผ่าน control server ซึ่งโดยปกติจะฟังอยู่ที่ :8000 และสามารถกำหนดค่าได้ผ่าน HTTP_CONTROL_SERVER_ADDRESS

curl -s http://127.0.0.1:8000/v1/portforward
{"port":45678,"ports":[45678]}

นอกจากนี้ gluetun ยังเปิดพอร์ตดังกล่าวใน firewall ของตนเองบน VPN interface ดังนั้นจึงไม่จำเป็นต้องใช้ FIREWALL_VPN_INPUT_PORTS ในขณะที่การทำงานร่วมกันแบบ native กำลังดำเนินการอยู่ ตัวแปรดังกล่าวมีไว้สำหรับกรณีอื่น คือกรณีที่ผู้ให้บริการไม่รองรับการสอบถามจาก gluetun ซึ่งคุณได้รับพอร์ตแบบ static มาจากช่องทางอื่นและจำเป็นต้องอนุญาตพอร์ตนั้นด้วยตนเอง

ใน 3 ตำแหน่งนี้ มีเพียงตำแหน่งเดียวที่เป็นแบบถาวร ส่วนอีกสองตำแหน่งไม่ใช่ เอกสารประกอบของ upstream ได้ระบุว่าไฟล์สถานะ (status file) จะถูกเลิกใช้งานใน v4.0.0 และ GET /v1/openvpn/portforwarded ได้ตอบกลับด้วย 301 Moved Permanently ซึ่งชี้ไปยัง /v1/portforward แล้ว ดังนั้นการพัฒนาใหม่ควรเลือกอ่านค่าจาก control server แทน

เหตุผลที่ต้องแจ้งพอร์ตให้ไคลเอนต์ทราบทุกครั้งที่มีการเชื่อมต่อใหม่

Torrent client จะจัดเก็บพอร์ตที่ใช้รับฟัง (listening port) ไว้ในการตั้งค่าของตัวเองและใช้หมายเลขเดิมเสมอหลังจากรีสตาร์ท แต่พอร์ตที่ทำ port forwarding นั้นเป็นคุณสมบัติของเซสชัน VPN เมื่อมีการเชื่อมต่อใหม่ หมายเลขทั้งสองจะไม่ตรงกัน ส่งผลให้ผู้ให้บริการแมปพอร์ตไปยังจุดที่ไม่มีบริการใดรับฟังอยู่ ในขณะที่ไคลเอนต์ก็รับฟังบนพอร์ตที่ไม่มีการแมปไว้ การเชื่อมต่อใหม่เกิดขึ้นได้บ่อยครั้ง เช่น การรีสตาร์ทคอนเทนเนอร์, การเปลี่ยนเซิร์ฟเวอร์, การที่ tunnel หลุดจน gluetun ต้องรีสตาร์ท health check หรือการที่ lease ไม่สามารถต่ออายุได้ ผลลัพธ์ที่ได้คือระบบที่เคยเข้าถึงได้เมื่อวานกลับเข้าถึงไม่ได้ในวันนี้โดยไม่มีข้อความแจ้งเตือนความผิดพลาดใน log ของทั้งสองฝั่ง

ดังนั้น จึงจำเป็นต้องกำหนดค่าพอร์ตในขณะที่ gluetun ได้รับพอร์ตนั้นมา วิธีการเชื่อมต่อข้อมูลนี้มี 2 รูปแบบ ซึ่งแตกต่างกันที่กระบวนการทำงานของแต่ละวิธี

ทางเลือกที่ 1: gluetun ส่งต่อพอร์ตด้วยคำสั่ง up

VPN_PORT_FORWARDING_UP_COMMAND จะทำงานเมื่อการส่งต่อพอร์ต (port forwarding) เริ่มต้นขึ้น และ VPN_PORT_FORWARDING_DOWN_COMMAND จะทำงานเมื่อการส่งต่อพอร์ตสิ้นสุดลง Gluetun จะแทนที่ {{PORT}} (พอร์ตแรก), {{PORTS}} (พอร์ตทั้งหมดที่คั่นด้วยเครื่องหมายจุลภาค) และ {{VPN_INTERFACE}} (ชื่ออินเทอร์เฟซของอุโมงค์ ซึ่งค่าเริ่มต้นคือ tun0) ก่อนที่จะรันคำสั่ง ไวยากรณ์ของเชลล์จำเป็นต้องมีตัวครอบ /bin/sh -c อย่างชัดเจน นี่คือตัวอย่างการตั้งค่าสำหรับ qBittorrent ต้นทาง ซึ่งเขียนเป็นรายการ environment ใน compose สองรายการ:

      - VPN_PORT_FORWARDING_UP_COMMAND=/bin/sh -c 'wget -O- -nv --retry-connrefused --post-data "json={\"listen_port\":{{PORT}},\"current_network_interface\":\"{{VPN_INTERFACE}}\",\"random_port\":false,\"upnp\":false}" http://127.0.0.1:8080/api/v2/app/setPreferences'
      - VPN_PORT_FORWARDING_DOWN_COMMAND=/bin/sh -c 'wget -O- -nv --retry-connrefused --post-data "json={\"listen_port\":0,\"current_network_interface\":\"lo\"}" http://127.0.0.1:8080/api/v2/app/setPreferences'

แต่ละฟิลด์ในการเรียกใช้งานนี้มีหน้าที่เฉพาะ listen_port คือพอร์ตใหม่ current_network_interface ทำหน้าที่ผูก qBittorrent เข้ากับอุโมงค์ random_port ที่ตั้งค่าเป็น false จะป้องกันไม่ให้ qBittorrent เลือกพอร์ตของตนเองในการเริ่มทำงานครั้งถัดไป upnp ที่ตั้งค่าเป็น false จะป้องกันไม่ให้พยายามทำ port mapping ผ่านเราเตอร์ที่ไม่มีอยู่จริง

แนวทางนี้มีข้อกำหนดสองประการ ประการแรก Web UI ของ qBittorrent ต้องเปิดใช้งานและฟังที่พอร์ต 8080 และการแชร์ network namespace ของ gluetun คือสิ่งที่ทำให้ qBittorrent สามารถตอบสนองที่ 127.0.0.1:8080 จากภายในคอนเทนเนอร์ gluetun ได้ ประการที่สอง Bypass authentication for clients on localhost (bypass_local_auth) ต้องเปิดใช้งานอยู่ เนื่องจากคำสั่งดังกล่าวไม่ได้ส่งข้อมูลรับรอง (credentials) ไปด้วย คำสั่ง down มีไว้เนื่องจาก qBittorrent ไม่ได้สร้างพอร์ตขึ้นใหม่เสมอไปหลังจากตัดการเชื่อมต่อ

คำสั่งจะทำงานภายในคอนเทนเนอร์ gluetun ซึ่งสร้างบน Alpine และมาพร้อมกับ wget ในอิมเมจนั้นไม่มี curl คำสั่งที่ระบุชื่อไบนารีที่ไม่มีอยู่ในอิมเมจจะล้มเหลวทุกครั้งที่มีการส่งต่อพอร์ตเกิดขึ้น

ทางเลือกที่ 2: กระบวนการภายนอก gluetun อ่านพอร์ต

รูปแบบอีกอย่างหนึ่งคือการรันกระบวนการขนาดเล็กควบคู่ไปกับ gluetun เพื่อดึงค่าพอร์ตและส่งต่อไปยังไคลเอนต์ผ่าน API ของไคลเอนต์เอง โดยอ่านค่าจาก control server ดังนี้:

port=$(curl -s http://127.0.0.1:8000/v1/portforward | jq -r .port)

หรืออ่านจากไฟล์หากกระบวนการนั้นสามารถเข้าถึงได้ /tmp/gluetun/forwarded_port อยู่ภายในคอนเทนเนอร์ gluetun ดังนั้น sidecar จำเป็นต้องใช้ shared volume ที่ mount ไว้ที่ /tmp/gluetun ในทั้งสองคอนเทนเนอร์ หรือคุณอาจชี้ VPN_PORT_FORWARDING_STATUS_FILE ไปยัง path ภายใต้ volume ที่คุณ mount ไว้แล้ว

การยืนยันตัวตนมีความสำคัญในส่วนนี้ ในเวอร์ชัน v3.41.3 เส้นทาง GET /v1/portforward อยู่ภายใต้บทบาทเริ่มต้นที่ชื่อ public พร้อมด้วย auth = "none" จึงสามารถตอบสนองได้โดยไม่ต้องใช้ข้อมูลประจำตัว และ gluetun จะบันทึกคำเตือนที่ขึ้นต้นด้วย route GET /v1/portforward is unprotected by default, please set up authentication ทางต้นน้ำกำลังจะปิดช่องทางนี้ในรุ่นถัดไป และเอกสารประกอบของ control server ในปัจจุบันได้ระบุให้ทุกเส้นทางเป็นส่วนตัวโดยค่าเริ่มต้นแล้ว ให้กำหนดบทบาททันทีในไฟล์ที่ bind mount ไว้ที่ /gluetun/auth/config.toml:

roles = [
  { name = "qbittorrent", routes = ["GET /v1/portforward"], auth = "apikey", apikey = "myapikey" }
]

สร้างคีย์ด้วย docker run --rm qmcgaw/gluetun:v3.41.3 genkey และส่งใน header X-API-Key ส่วน HTTP_CONTROL_SERVER_AUTH_DEFAULT_ROLE จะกำหนดบทบาทเริ่มต้นเป็นตัวแปรสภาพแวดล้อมที่เข้ารหัส JSON สำหรับทุกเส้นทางที่ไม่ได้ครอบคลุมโดยบทบาทในไฟล์ เมื่อคุณกำหนดบทบาทใดๆ แล้ว v3.41.3 จะหยุดใช้บทบาท public ที่มีมาให้ ดังนั้นทุกเส้นทางที่คุณเรียกหลังจากนั้นจำเป็นต้องมีบทบาทที่ระบุเส้นทางนั้นไว้หรือใช้บทบาทเริ่มต้นที่กำหนดค่าไว้ หากไม่มีบทบาทใดๆ บทบาท public ที่มีมาให้จะครอบคลุมถึง PUT /v1/vpn/status ด้วย ดังนั้นพอร์ต 8000 ที่เปิดใช้งานโดยไม่มีการตั้งค่าการยืนยันตัวตนจะทำให้ทุกคนที่เข้าถึงได้สามารถควบคุมสถานะ VPN ได้ โปรดตัดสินใจอย่างรอบคอบว่าข้อมูลนี้จะถูกส่งไปไกลแค่ไหนเมื่อคุณศึกษา วิธีการเข้าถึง gluetun จากโฮสต์และคอนเทนเนอร์อื่น

เลือกใช้คำสั่ง up เมื่อไคลเอนต์เปิดเผย API ที่การเรียก wget เพียงครั้งเดียวสามารถจัดการได้ เพราะคำสั่งนี้จะทำงานเพียงครั้งเดียวต่อเหตุการณ์และไม่ต้องใช้ทรัพยากรในการรันค้างไว้ เลือกใช้กระบวนการภายนอกเมื่อไคลเอนต์ต้องการขั้นตอนการล็อกอิน การเขียนไฟล์ config ใหม่ หรือการรีสตาร์ท ใน arr stack ที่อยู่หลังคอนเทนเนอร์ gluetun เดียว มักจะจบลงด้วยการใช้ poller ขนาดเล็ก เนื่องจากมีเพียง torrent client เท่านั้นที่สนใจค่าพอร์ตนี้

กับดัก: การแชร์ namespace ไม่ได้เป็นการตั้งค่าพอร์ตสำหรับรับฟัง (listening port)

ความผิดพลาดนี้ทำให้เสียเวลามากที่สุด network_mode: "service:gluetun" จะนำ client เข้าไปอยู่ใน network namespace ของ gluetun ทำให้ client ได้รับ IP address ของ VPN, เส้นทาง routing ของ tunnel และกฎ firewall ของ gluetun แต่สิ่งเหล่านี้ไม่ได้เป็นการตั้งค่าพอร์ตสำหรับรับฟังของ client แต่อย่างใด gluetun จะเปิดพอร์ตที่ถูก forward ไว้บน interface ของ VPN ซึ่งแพ็กเก็ตจะเข้ามาถึงใน namespace นั้น แต่หาก client ไปรับฟังที่พอร์ตอื่น เคอร์เนลก็ไม่มีปลายทางที่จะส่งแพ็กเก็ตเหล่านั้นไปให้ ผลที่ตามมาคือการเชื่อมต่อถูกปฏิเสธหรือหมดเวลา (timeout) ในขณะที่การตรวจสอบขาออกทุกอย่างดูปกติ พอร์ตที่ถูก forward และพอร์ตที่ client รับฟังนั้นเป็นคนละหมายเลขกัน และหน้าที่หลักคือการทำให้ทั้งสองค่านี้ตรงกัน

ให้ใช้วิธีเปรียบเทียบค่าแทนการคาดเดา โดยรันคำสั่งทั้งสองนี้กับ namespace เดียวกัน:

docker exec gluetun cat /tmp/gluetun/forwarded_port
docker exec gluetun wget -qO- http://127.0.0.1:8080/api/v2/app/preferences | grep -o '"listen_port":[0-9]*'

มีการตั้งค่าอีกหนึ่งอย่างที่ทำให้ผู้ใช้งานเข้าใจผิด คือ VPN_PORT_FORWARDING_LISTENING_PORT ซึ่งจะเปลี่ยนเส้นทาง (redirect) ทราฟฟิกขาเข้าจากพอร์ตที่ถูก forward ไปยังพอร์ตภายในที่กำหนดไว้ตายตัวโดยใช้ iptables ทางผู้พัฒนาต้นทางแนะนำว่าไม่ควรใช้ร่วมกับโปรแกรม torrent เนื่องจาก client จะประกาศพอร์ตที่ตนเองรับฟังไปยัง tracker และ peer ทำให้ swarm ได้รับหมายเลขพอร์ตที่ไม่ถูกต้องไปใช้งาน

วิธีพิสูจน์ว่าพอร์ตที่ส่งต่อสามารถเข้าถึงได้

ตัวบ่งชี้สถานะการเชื่อมต่อของไคลเอนต์จะแสดงการเชื่อมต่อขาออกไปยัง tracker จึงอาจแสดงสถานะเป็นสีเขียวทั้งที่ไม่มีใครสามารถเชื่อมต่อเข้ามาหาคุณได้ ให้ทดสอบด้วย listener ที่คุณควบคุมจากเครือข่ายภายนอกอุโมงค์ ผู้พัฒนาต้นทางได้เผยแพร่เครื่องมือขนาดเล็กสำหรับงานนี้ ให้หยุดการทำงานของ torrent client ก่อน เนื่องจากสองกระบวนการไม่สามารถ bind พอร์ตเดียวกันได้

docker stop qbittorrent
docker exec -it gluetun /bin/sh

ภายในคอนเทนเนอร์ ให้เปลี่ยน amd64 เป็นสถาปัตยกรรม CPU ของคุณ และ 4567 เป็นพอร์ตที่คุณส่งต่อ:

wget -qO port-checker https://github.com/qdm12/port-checker/releases/download/v0.4.0/port-checker_0.4.0_linux_amd64
chmod +x port-checker
./port-checker --listening-address=":4567"

จากนั้นค้นหา exit address ที่ gluetun กำลังใช้งานอยู่ การตอบกลับจะเป็นรูปแบบ JSON และที่อยู่จะอยู่ในฟิลด์ public_ip

curl -s http://127.0.0.1:8000/v1/publicip/ip

คำขอดังกล่าวจะตอบกลับโดยไม่ต้องใช้ข้อมูลรับรองใน 3 กรณี ได้แก่ เวอร์ชัน v3.41.3 ที่ทำงานโดยไม่มีการตั้งค่า auth ซึ่งบทบาท public ที่มีมาให้จะครอบคลุมส่วนนี้, การตั้งค่า auth ที่ระบุ GET /v1/publicip/ip ไว้ในบทบาทที่มี auth = "none", หรือ HTTP_CONTROL_SERVER_AUTH_DEFAULT_ROLE='{"auth":"none"}' ในกรณีที่ไม่มีบทบาทใดในไฟล์ครอบคลุมเส้นทางดังกล่าว เอกสารประกอบต้นทางกำหนดให้ none หมายถึงไม่ต้องมีการตรวจสอบสิทธิ์ หากคุณกำหนดบทบาท apikey ไว้ตามตัวเลือกที่ 2 แทน ให้เพิ่ม GET /v1/publicip/ip ลงใน routes ของบทบาทนั้น แล้วส่งคีย์ของมัน เช่น curl -s -H "X-API-Key: myapikey" http://127.0.0.1:8000/v1/publicip/ip

เปิด http://<that address>:4567 จากอุปกรณ์ที่ไม่ได้อยู่บน VPN เดียวกัน การใช้โทรศัพท์ผ่านเครือข่ายมือถือสามารถทำได้ หากหน้าเว็บแสดง IP address และ user agent ของเบราว์เซอร์คุณ พร้อมกับมีการบันทึกคำขอที่ตรงกันโดย port-checker แสดงว่า TCP ขาเข้าสามารถเข้าถึง namespace ได้ หากเกิด timeout แสดงว่าเข้าถึงไม่ได้และสาเหตุอยู่ที่เหนือระดับไคลเอนต์ ให้หยุดเครื่องมือด้วย CTRL+C ออกจาก shell ด้วย exit แล้วเริ่มการทำงานของไคลเอนต์ใหม่อีกครั้ง การตรวจสอบนี้ทดสอบเฉพาะ TCP เท่านั้น ส่วน DHT (distributed hash table) และทราฟฟิก uTP จะใช้ UDP บนหมายเลขพอร์ตเดียวกัน ซึ่งการทดสอบนี้ไม่ครอบคลุมถึง

รูปแบบความล้มเหลวและข้อความที่คุณจะพบ

ไม่มีบรรทัดระบุพอร์ตใน log เลย ไม่มีการร้องขอพอร์ตเกิดขึ้น ให้ยืนยันว่าตัวแปรถูกส่งไปยังคอนเทนเนอร์จริงด้วย docker exec gluetun printenv | grep PORT_FORWARDING เนื่องจากสาเหตุที่พบบ่อยคือการตั้งค่าตัวแปรผิด service ในไฟล์ compose

Gluetun ปฏิเสธที่จะเริ่มทำงานและแจ้งเตือนเกี่ยวกับผู้ให้บริการ VPN_PORT_FORWARDING_PROVIDER จะถูกตรวจสอบกับชื่อที่รองรับทั้งสี่ชื่อ ดังนั้นหากพิมพ์ผิดจะทำให้คอนเทนเนอร์หยุดทำงานแทนที่จะรันไปโดยไม่มีการส่งต่อข้อมูล

log แสดงข้อความ no port forwarded Gluetun ได้ร้องขอไปแล้วแต่ผู้ให้บริการไม่ตอบกลับข้อมูลใดๆ ในกรณีของ ProtonVPN มักหมายความว่าไม่ได้เปิดใช้งาน NAT-PMP ในการตั้งค่าที่คุณสร้างขึ้น หรือแพ็กเกจของคุณไม่รองรับการส่งต่อพอร์ต สำหรับ Private Internet Access มักหมายความว่าเซิร์ฟเวอร์ที่เลือกไม่รองรับฟีเจอร์นี้

ได้รับพอร์ตแล้ว แต่ไม่มีการเชื่อมต่อเข้ามา ให้เปรียบเทียบพอร์ตที่ส่งต่อกับพอร์ตที่ client กำลังฟังอยู่โดยใช้สองคำสั่งด้านบน หากพอร์ตตรงกัน ให้ตรวจสอบว่า client ถูกผูกไว้กับอินเทอร์เฟซ tunnel และปิดตัวเลือก random-port แล้ว เนื่องจากตัวเลือกดังกล่าวจะเขียนทับพอร์ตที่ฟังอยู่ทุกครั้งที่เริ่มทำงานใหม่

คำสั่ง up ดูเหมือนไม่ทำงาน ให้รันคำสั่งนั้นโดยตรงภายในคอนเทนเนอร์เพื่อดูข้อผิดพลาด: docker exec gluetun /bin/sh -c '<your command>' โดยปกติผลลัพธ์ที่ได้คือ curl: not found เนื่องจากอิมเมจมาพร้อมกับ wget เท่านั้น

401 Unauthorized จากเซิร์ฟเวอร์ควบคุม ไม่มีบทบาทใดครอบคลุมเส้นทางที่คุณเรียกใช้ หรือบทบาทที่ตรงกันทั้งหมดปฏิเสธคำขอเนื่องจากข้อมูลประจำตัวไม่ถูกต้องหรือขาดหายไป โดย HTTP_CONTROL_SERVER_AUTH_DEFAULT_ROLE ที่กำหนดค่าไว้จะครอบคลุมเส้นทางที่ไม่ได้ระบุไว้ในไฟล์ แต่ละเส้นทางจะเขียนด้วย method ตามด้วย path เช่น GET /v1/portforward หากเขียนเส้นทางเป็น /v1/portforward เพียงอย่างเดียวจะไม่ทำให้เกิดข้อผิดพลาด 401 แต่จะทำให้ gluetun ล้มเหลวตั้งแต่ตอนเริ่มทำงานแทน

พอร์ตเปลี่ยนไปทุกครั้งที่รีสตาร์ทบน Private Internet Access ให้ทำ bind mount ที่ /gluetun เพื่อให้สถานะพอร์ตที่บันทึกไว้คงอยู่หลังการรีสตาร์ท หากไม่มี volume นี้ gluetun จะร้องขอพอร์ตใหม่ทุกครั้ง

FAQ

ทำไม torrent ของฉันถึงดาวน์โหลดได้แต่ไม่เคยมีการเชื่อมต่อขาเข้าเลย?

หากไม่มีการทำ port forwarding ผู้ให้บริการ VPN จะไม่มีกฎ NAT สำหรับส่งแพ็กเก็ตขาเข้าผ่านพอร์ตใดๆ มายังอุโมงค์ของคุณ ดังนั้นการเชื่อมต่อที่คุณไม่ได้เป็นผู้เริ่มจึงถูกปฏิเสธที่ที่อยู่ขาออก การดาวน์โหลดจึงยังคงทำงานได้เพราะไคลเอนต์ของคุณเป็นผู้เริ่มการเชื่อมต่อเหล่านั้นเอง และสามารถเข้าถึง peer ใดก็ตามที่สามารถเชื่อมต่อได้ แต่การปล่อยไฟล์ (seeding) และการเข้าร่วม swarm จะได้รับผลกระทบเนื่องจากทั้งสองอย่างต้องอาศัยให้ผู้อื่นเชื่อมต่อเข้ามาหาคุณ วิธีแก้ไขคือการใช้ผู้ให้บริการที่รองรับ port forwarding, เปิดใช้งาน VPN_PORT_FORWARDING=on ใน gluetun และนำพอร์ตที่ได้ไปตั้งค่าเป็นพอร์ตรับฟังของไคลเอนต์

gluetun รองรับ port forwarding ของผู้ให้บริการ VPN ทุกรายหรือไม่?

ไม่ gluetun v3.41.3 มีการรวมระบบ (integration) สำหรับผู้ให้บริการ 4 ราย ได้แก่ Private Internet Access, ProtonVPN, Perfect Privacy และ PrivateVPN หากอยู่นอกเหนือจากรายการนี้ การตรวจสอบสำหรับ VPN_PORT_FORWARDING_PROVIDER จะล้มเหลวและคอนเทนเนอร์จะหยุดทำงานตั้งแต่เริ่ม หากผู้ให้บริการของคุณออกพอร์ตแบบคงที่ผ่านแผงควบคุมของตนเอง gluetun จะไม่สามารถร้องขอพอร์ตนั้นให้คุณได้ แต่ FIREWALL_VPN_INPUT_PORTS จะอนุญาตให้พอร์ตคงที่นั้นผ่าน firewall ของ gluetun ได้ นโยบายของผู้ให้บริการมีการเปลี่ยนแปลงอยู่เสมอ ดังนั้นควรตรวจสอบหน้าข้อมูลของผู้ให้บริการปัจจุบันก่อนตัดสินใจซื้อแผนบริการ

ฉันต้องอัปเดตพอร์ตทุกครั้งที่เชื่อมต่อใหม่หรือไม่?

ใช่ และการอัปเดตนั้นควรเป็นไปโดยอัตโนมัติ พอร์ตที่ทำ forward ไว้เป็นส่วนหนึ่งของเซสชัน VPN ดังนั้นการรีสตาร์ทคอนเทนเนอร์ การเปลี่ยนเซิร์ฟเวอร์ หรือการต่ออายุสัญญาเช่าพอร์ตที่ล้มเหลวอาจทำให้ได้หมายเลขพอร์ตใหม่ ในขณะที่ไคลเอนต์ยังคงใช้พอร์ตเดิมที่บันทึกไว้ในการตั้งค่า คุณควรปล่อยให้ gluetun ทำการ push พอร์ตด้วย VPN_PORT_FORWARDING_UP_COMMAND ซึ่งจะทำงานทันทีที่การ forwarding พร้อมใช้งาน หรือรันกระบวนการขนาดเล็กเพื่ออ่านค่า GET /v1/portforward จากเซิร์ฟเวอร์ควบคุมแล้วเขียนค่าลงในไคลเอนต์ผ่าน API

ฉันจะตรวจสอบได้อย่างไรว่าพอร์ตที่ทำ forward ไว้เปิดใช้งานอยู่จริง?

ให้รันโปรแกรมรับฟังบนพอร์ตนั้นภายใน network namespace ของ gluetun แล้วเชื่อมต่อเข้ามาจากภายนอก VPN ให้หยุด torrent client ก่อนเพื่อให้พอร์ตว่าง จากนั้นรัน binary ของ port-checker จากต้นทางภายในคอนเทนเนอร์ gluetun ด้วย --listening-address=":<port>" รับที่อยู่ขาออกจาก curl -s http://127.0.0.1:8000/v1/publicip/ip โดยเพิ่ม -H "X-API-Key: <key>" หากบทบาทที่ระบุ GET /v1/publicip/ip มีการใช้ auth = "apikey" และเปิด http://<address>:<port> จากโทรศัพท์ที่ใช้เครือข่ายมือถือ หากมีคำขอปรากฏใน log ของ port-checker แสดงว่า TCP ขาเข้าเข้ามาถึงจริง หากเกิด timeout แสดงว่าเข้าถึงไม่ได้ ไม่ว่าไอคอนสถานะของไคลเอนต์จะแสดงอย่างไรก็ตาม

บทความนี้มีประโยชน์หรือไม่

#gluetun#vpn#port-forwarding#docker#torrenting