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

วิธีติดตั้ง RustDesk Relay Server บน VPS ด้วยตัวเอง

เรียนรู้วิธีติดตั้ง hbbs และ hbbr บน VPS ของคุณเองให้ปลอดภัย ครอบคลุมการจัดการ Ed25519 key การกำหนดพอร์ตที่จำเป็น และการคำนวณแบนด์วิดท์เพื่อป้องกันค่าใช้จ่ายส่วนเกิน

RustDesk relay server แบบ self-hosted คืออะไร

RustDesk relay server แบบ self-hosted ประกอบด้วย daemon สองตัวที่ทำงานบน VPS เดียวกัน hbbs คือ ID และ rendezvous server ทำหน้าที่ลงทะเบียน ID ของไคลเอนต์ทุกตัวและเชื่อมต่อไคลเอนต์สองตัวเข้าหากัน hbbr คือ relay server ทำหน้าที่รับส่งข้อมูลเซสชันในกรณีที่ไม่สามารถเชื่อมต่อโดยตรงได้ คู่มือส่วนใหญ่จะแนะนำวิธีการติดตั้งทั้งสองตัวจนกระทั่งจับคู่สำเร็จแล้วจบลงเพียงเท่านั้น เนื้อหาต่อจากนี้คือส่วนที่เหลือของงาน ได้แก่ กุญแจสำหรับการควบคุมการเข้าถึง, พอร์ต, การอัปเกรด และการจัดการแบนด์วิดท์

daemon ทั้งสองตัวมาพร้อมกับอิมเมจเดียวกันคือ rustdesk/rustdesk-server และในการตั้งค่าด้านล่างนี้ ทั้งสองตัวจะอ่าน Ed25519 key pair ชุดเดียวกันจากไดเรกทอรีเดียวกัน ซึ่งเป็นสิ่งที่คุณต้องกำหนดค่าเอง ไม่ใช่ค่าเริ่มต้น โดย hbbs จะโหลดหรือสร้างกุญแจคู่ดังกล่าวขึ้นมาเอง แต่ hbbr จะไม่สนใจกุญแจเว้นแต่คุณจะระบุให้มันใช้งาน Ed25519 เป็นระบบลายเซ็นดิจิทัลแบบ public key กุญแจคู่นี้จะเป็นตัวตัดสินว่าเซิร์ฟเวอร์ของคุณจะสื่อสารกับไคลเอนต์ตัวใดบ้าง โดยไม่มีฐานข้อมูลผู้ใช้งานอยู่เบื้องหลัง

hbbs และ hbbr: daemon ตัวไหนที่ใช้แบนด์วิดท์ของคุณ

ทราฟฟิกของ hbbs มีขนาดเล็กและคงที่: เป็นการลงทะเบียน ID และการส่งสัญญาณ heartbeat รวมถึงการแลกเปลี่ยนข้อมูลสั้นๆ เพื่อแนะนำ peer สองฝั่งให้รู้จักกัน มันทำงานตลอดทั้งวันและแทบไม่กินทรัพยากรเลย

ทราฟฟิกของ hbbr คือตัวเซสชันการใช้งานจริง เฟรมภาพหน้าจอจะถูกส่งไปทางหนึ่ง ส่วนข้อมูลคีย์บอร์ดและเมาส์จะถูกส่งไปอีกทางหนึ่ง และทุกไบต์ที่ถูกส่งผ่าน relay จะเข้ามาที่ VPS ของคุณแล้วถูกส่งออกไปอีกครั้ง หากผู้ให้บริการของคุณคิดค่าบริการเฉพาะขาออก (egress) เซสชันที่ผ่าน relay จะมีค่าใช้จ่ายตามอัตราการใช้งานเซสชันนั้น แต่หากคิดค่าบริการจากปริมาณการถ่ายโอนข้อมูลรวม คุณจะต้องเสียค่าใช้จ่ายประมาณสองเท่าของปริมาณข้อมูลดังกล่าว

การทำ relay เป็นเพียงทางเลือกสำรอง ไม่ใช่เส้นทางปกติ hbbs จะพยายามเชื่อมต่อไคลเอนต์ทั้งสองฝั่งโดยตรงก่อน โดยใช้การทำ hole punching ผ่าน NAT (network address translation) ที่อยู่หน้าไคลเอนต์แต่ละฝั่ง เมื่อวิธีนี้สำเร็จ เซสชันจะไม่ผ่าน hbbr เลยและปริมาณการใช้งานของคุณก็จะไม่ถูกหัก แต่เมื่อฝั่งใดฝั่งหนึ่งอยู่หลัง NAT ที่กำหนดพอร์ตใหม่สำหรับทุกปลายทาง หรืออยู่หลังไฟร์วอลล์ที่บล็อกเส้นทางที่เจาะไว้ เซสชันจะเปลี่ยนไปใช้ hbbr และทุกเฟรมข้อมูลจะวิ่งผ่าน VPS ของคุณ

มี environment variable หนึ่งตัวที่ตัดทางเลือกนี้ออกไป ALWAYS_USE_RELAY=Y บน hbbs จะบังคับให้ทุกเซสชันต้องผ่าน hbbr เอกสารของ RustDesk แสดงค่านี้ไว้ในตัวอย่าง Compose ชุดหนึ่ง จึงมีการคัดลอกไปใช้กันบ่อยครั้ง มันทำให้การเชื่อมต่อคาดเดาได้ง่ายขึ้นและทำให้คุณต้องเสียค่าใช้จ่ายขาออกจริง ควรตั้งค่านี้ก็ต่อเมื่อคุณตัดสินใจเลือกเอง ไม่ใช่เพราะคุณคัดลอกมาวางเพียงอย่างเดียว

พอร์ตที่เซิร์ฟเวอร์ RustDesk แบบ self-hosted จำเป็นต้องใช้งาน

หมายเลขพอร์ตด้านล่างนี้ได้รับการตรวจสอบกับเอกสารประกอบของเซิร์ฟเวอร์ RustDesk และที่เก็บข้อมูล rustdesk-server เมื่อวันที่ 10 ตุลาคม 2026

  • TCP 21115 บน hbbs: สำหรับการทดสอบ NAT type
  • UDP 21116 บน hbbs: สำหรับการลงทะเบียน ID และ heartbeat นี่คือเส้นทางที่ไคลเอนต์ใช้งานเป็นค่าเริ่มต้น
  • TCP 21116 บน hbbs: สำหรับการลงทะเบียน ID ในกรณีที่ไคลเอนต์ตั้งค่าให้ใช้เฉพาะ TCP รวมถึงการทำ TCP hole punching และบริการเชื่อมต่อ
  • TCP 21117 บน hbbr: สำหรับ relay นี่คือพอร์ตที่ใช้รับส่งข้อมูลเซสชัน จึงเป็นพอร์ตที่มีผลต่อค่าใช้จ่ายในการรับส่งข้อมูลของคุณ
  • TCP 21118 บน hbbs และ TCP 21119 บน hbbr: สำหรับ WebSocket ซึ่งใช้โดยไคลเอนต์บนเบราว์เซอร์ ให้ปิดพอร์ตทั้งสองนี้ไว้หากคุณไม่ได้ใช้งาน
  • TCP 21114 คือเซิร์ฟเวอร์ HTTP API ใน RustDesk Server Pro สำหรับรุ่น open source จะไม่มีการเปิดใช้งานพอร์ตนี้

ติดตั้ง hbbs และ hbbr โดยระบุ image tag แบบเจาะจง

services:
  hbbs:
    container_name: hbbs
    image: rustdesk/rustdesk-server:1.1.16
    command: hbbs
    volumes:
      - ./data:/root
    network_mode: "host"
    depends_on:
      - hbbr
    restart: unless-stopped

  hbbr:
    container_name: hbbr
    image: rustdesk/rustdesk-server:1.1.16
    command: hbbr -k _
    volumes:
      - ./data:/root
    network_mode: "host"
    restart: unless-stopped
mkdir -p ~/rustdesk
cd ~/rustdesk
# save the block above as ~/rustdesk/compose.yml before this line
sudo docker compose up -d
sudo docker compose ps

บริการทั้งสองควรจะอ่านค่าจาก running ให้ตรวจสอบว่ามี listener ทำงานอยู่ก่อนที่จะไปตั้งค่า firewall

sudo ss -tlnp | grep -E ':2111[5-7]'
sudo ss -ulnp | grep ':21116'

คุณควรจะเห็น TCP listener บนพอร์ต 21115, 21116 และ 21117 รวมถึง UDP listener บนพอร์ต 21116 หากบรรทัด UDP หายไป แสดงว่า hbbs ไม่ได้ทำงานอยู่ เนื่องจาก hbbs จะเปิด listener ดังกล่าวเมื่อเริ่มต้นระบบ และเป็นพอร์ตที่ไคลเอนต์ใช้ลงทะเบียนตามค่าเริ่มต้น

สิ่งที่ระบุไว้ในไฟล์นั้นมี 4 ประการที่ตั้งใจให้เป็นเช่นนั้น: tag คือ 1.1.16 ซึ่งยังคงเป็น release ปัจจุบัน ณ เดือนตุลาคม 2026 แทนที่จะใช้ latest เพราะ latest หมายถึงเวอร์ชันใดก็ตามที่ถูก push ล่าสุด และ docker compose pull ในอีก 6 เดือนข้างหน้าอาจทำให้คุณได้เซิร์ฟเวอร์ที่คุณไม่เคยทดสอบมาก่อน network_mode: "host" เป็นการ bind host interface โดยตรง ซึ่งเป็นสิ่งที่เอกสารของ RustDesk แนะนำและเป็นตัวกำหนดพฤติกรรมของ firewall ของคุณ ./data:/root เป็นการ map working directory ของ image เข้ากับ host เพื่อให้ key pair ถูกจัดเก็บในที่ที่คุณสามารถสำรองข้อมูลได้ และ hbbr -k _ คือจุดเดียวที่ปรับเปลี่ยนจากตัวอย่างต้นฉบับ เนื่องจากค่าเริ่มต้นจะเปิด relay ของคุณให้ใครก็ได้เข้ามาใช้งาน หากคุณยังใหม่กับ Compose สามารถดู การรัน Docker Compose บน VPS ซึ่งครอบคลุมรูปแบบไฟล์และคำสั่งจัดการ lifecycle

หาก hbbr ย้ายไปอยู่บนเซิร์ฟเวอร์เครื่องที่สอง hbbs จะต้องได้รับแจ้งว่าย้ายไปที่ใด: ให้ส่งค่า -r relay.example.com:21117 หรือตั้งค่า environment variable RELAY-SERVERS สำหรับการใช้งานบนเครื่องเดียว คุณไม่จำเป็นต้องตั้งค่านี้

คู่กุญแจ Ed25519 คือการควบคุมการเข้าถึง

ในการเริ่มทำงานครั้งแรก hbbs จะสร้าง id_ed25519 และ id_ed25519.pub ไว้ในไดเรกทอรีการทำงาน หากใช้การ mount ตามที่ระบุไว้ข้างต้น ไฟล์ทั้งสองจะปรากฏอยู่บนโฮสต์

ls -l ~/rustdesk/data/
sudo cat ~/rustdesk/data/id_ed25519.pub

id_ed25519.pub จะเก็บสตริง base64 ไว้หนึ่งชุด สตริงนั้นจะต้องนำไปใส่ในช่อง Key บนไคลเอนต์ทุกเครื่อง ส่วน id_ed25519 คือส่วนที่เป็นกุญแจส่วนตัวและห้ามนำออกจากเซิร์ฟเวอร์โดยเด็ดขาด กุญแจสาธารณะไม่ใช่ความลับเพราะต้องคัดลอกไปไว้ในการตั้งค่าของไคลเอนต์ทุกเครื่องอยู่แล้ว แต่กุญแจส่วนตัวถือเป็นความลับ: ใครก็ตามที่ถือครองมันสามารถตั้งเซิร์ฟเวอร์ที่ไคลเอนต์ของคุณจะเชื่อถือได้

ให้สำรองไฟล์ทั้งสองนี้ไว้ทันที ก่อนที่คุณจะตั้งค่าไคลเอนต์ครบยี่สิบเครื่อง

sudo tar czf ~/rustdesk-keys.tgz -C ~/rustdesk/data id_ed25519 id_ed25519.pub
sudo chmod 600 ~/rustdesk-keys.tgz

คัดลอกไฟล์สำรองนั้นออกจากเครื่อง นี่คือเหตุผลว่าทำไมขั้นตอนนี้จึงสำคัญกว่าขั้นตอนอื่น หากลบ ~/rustdesk/data หรือสร้างเซิร์ฟเวอร์ใหม่บน VPS โดยไม่ได้คัดลอกไฟล์นี้ไป hbbs จะสร้างคู่กุญแจใหม่ขึ้นมาในการเริ่มทำงานครั้งถัดไป ไคลเอนต์ทุกเครื่องยังคงเก็บกุญแจสาธารณะชุดเก่าไว้ ทำให้คำขอเชื่อมต่อใหม่ล้มเหลวเนื่องจากกุญแจไม่ตรงกัน หากรัน sudo cat ~/rustdesk/data/id_ed25519.pub แล้วนำไปเปรียบเทียบกับช่อง Key บนไคลเอนต์เครื่องใดก็ตาม คุณจะพบว่าสตริงทั้งสองไม่ตรงกัน และความไม่ตรงกันนี้คือสาเหตุทั้งหมดของความล้มเหลว ให้กู้คืนคู่กุญแจเดิมจากไฟล์สำรองแล้วรีสตาร์ทบริการทั้งสอง หรืออัปเดตช่อง Key บนไคลเอนต์ทุกเครื่อง รวมถึงเครื่องที่คุณกำลังใช้งาน RustDesk เพื่อเข้าถึงด้วย

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

เหตุใดการทำ relay โดยไม่ตรวจสอบสิทธิ์จึงเป็นปัญหา

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

command: hbbr -k _ จะช่วยปิดช่องโหว่นี้ อาร์กิวเมนต์ _ จะสั่งให้ hbbr โหลดคู่กุญแจจากไดเรกทอรีทำงาน หรือสร้างขึ้นใหม่หากไม่มีอยู่ และเนื่องจากคอนเทนเนอร์ทั้งสองตัว mount ไปยัง ./data เดียวกัน จึงเป็นคู่กุญแจชุดเดียวกับที่ hbbs ใช้งาน ไม่จำเป็นต้องคัดลอกด้วยตนเอง ให้ยืนยันว่าบริการทั้งสองที่กำลังทำงานอยู่ได้โหลด public key เดียวกันใน log ตอนเริ่มต้นระบบแล้ว

การใช้ volume ร่วมกันคือส่วนที่ผู้คนมักทำผิดพลาด หากคุณกำหนดไดเรกทอรีแยกให้ hbbr มันจะสร้างคู่กุญแจที่ แตกต่าง ออกไป ทำให้ hbbs และ hbbr ไม่ตรงกัน ส่งผลให้เซสชันที่ต้องผ่าน relay ล้มเหลวทั้งหมด แต่เซสชันแบบเชื่อมต่อตรงยังคงทำงานได้ อาการที่เกิดขึ้นจะสร้างความสับสน คือ RustDesk สามารถเชื่อมต่อกับ peer บางตัวได้แต่ไม่ใช่ทั้งหมด ขึ้นอยู่กับว่าการทำ hole punching ประสบความสำเร็จหรือไม่ การมี ls -l ~/rustdesk/data/ เพียงชุดเดียวที่แสดง id_ed25519 ไม่ได้การันตีว่าจะไม่มีปัญหาเรื่องกุญแจไม่ตรงกัน ให้เปรียบเทียบช่อง Key ของไคลเอนต์กับ public key และตรวจสอบ log ตอนเริ่มต้นของทั้งสองบริการ จากนั้นตรวจสอบว่ามีกระบวนการ hbbs อื่นๆ หรือเครื่องอื่นที่รัน RustDesk server อยู่หรือไม่ การดูรายการไฟล์ในไดเรกทอรีไม่ได้พิสูจน์ว่า relay มีการตรวจสอบกุญแจ เพราะ hbbr จะเพิกเฉยต่อไฟล์เหล่านั้นหากไม่ได้ถูกสั่งให้เริ่มทำงานด้วยคีย์ที่ไม่ว่างเปล่า ดังนั้นให้ตรวจสอบคำสั่งที่กำลังทำงานอยู่ด้วย:

ps -eo args | grep '[h]bbr'

คำสั่งดังกล่าวควรแสดงผลเป็น hbbr -k _ หากแสดงเพียง hbbr เปล่าๆ หมายความว่า relay ยังคงเปิดอยู่ เว้นแต่ว่าจะมีการระบุคีย์ที่ไม่ว่างเปล่าผ่าน environment หรือการกำหนดค่าของมัน

กำหนดค่าเครื่องลูกข่ายให้ชี้มายังเซิร์ฟเวอร์ของคุณ

บนเครื่องแต่ละเครื่อง ให้เปิด RustDesk ขึ้นมา จากนั้นไปที่ Settings แล้วเลือก Network และไปที่ ID/Relay Server

  • ID Server: ชื่อโฮสต์ของคุณ ตัวอย่างเช่น rustdesk.example.com โดยเครื่องลูกข่ายจะใช้พอร์ต 21116 เว้นแต่คุณจะระบุเป็นอย่างอื่น
  • Relay Server: ปล่อยว่างไว้หาก hbbr ทำงานอยู่บนโฮสต์เดียวกับ hbbs
  • API Server: ปล่อยว่างไว้ เนื่องจากเซิร์ฟเวอร์เวอร์ชันโอเพนซอร์สไม่มีฟีเจอร์นี้
  • Key: สตริง base64 จาก id_ed25519.pub ให้คัดลอกมาวางให้ถูกต้องแม่นยำ โดยต้องไม่มีช่องว่างต่อท้าย

หน้าต่างหลักควรจะแสดงสถานะว่าเครื่องลูกข่ายพร้อมใช้งาน หากไม่เป็นเช่นนั้นและเครื่องลูกข่ายใช้การตั้งค่าเริ่มต้น สาเหตุที่พบบ่อยคือ UDP 21116 ไม่สามารถเข้าถึง hbbs ได้ เนื่องจากเป็นพอร์ตที่เครื่องลูกข่ายเริ่มต้นใช้ลงทะเบียนและส่งสัญญาณ heartbeat อย่างไรก็ตาม สถานะ ID ออฟไลน์เพียงอย่างเดียวไม่ได้เป็นเครื่องพิสูจน์ปัญหาในส่วนนี้เสมอไป สำหรับเครื่องลูกข่ายที่ตั้งค่าตัวเลือก disable-udp เป็น Y จะเปลี่ยนไปลงทะเบียนผ่าน TCP 21116 แทนและไม่ใช้ UDP 21116 ดังนั้นสำหรับเครื่องลูกข่ายดังกล่าว ให้ตรวจสอบ TCP 21116 เป็นอันดับแรก

จำกัดพอร์ตเพื่อไม่ให้ relay กลายเป็นบริการแบบเปิด

เนื่องจากคอนเทนเนอร์ใช้ host networking จึงไม่มีกฎ Docker NAT อยู่เบื้องหน้า กฎของ ufw จึงทำงานตามที่คุณคาดหวัง

sudo ufw allow 22/tcp
sudo ufw allow 21115:21117/tcp
sudo ufw allow 21116/udp
sudo ufw enable
sudo ufw status numbered

เพิ่ม 21118:21119/tcp เฉพาะในกรณีที่คุณใช้งาน browser client เท่านั้น ให้เปิด SSH session ทิ้งไว้อีกหนึ่งหน้าต่างในขณะที่คุณเปิดใช้งาน ufw เพื่อป้องกันไม่ให้คุณถูกตัดออกจากเซิร์ฟเวอร์หากตั้งค่ากฎ SSH ผิดพลาด พื้นฐานไฟร์วอลล์ ufw สำหรับ VPS ครอบคลุมถึงนโยบายเริ่มต้นและการเรียงลำดับกฎ

ข้อควรระวังคือ หากคุณเปลี่ยนไปใช้วิธีเผยแพร่พอร์ตด้วยบล็อก ports: ซึ่งเป็นวิธีที่ตัวอย่าง RustDesk แบบคอนเทนเนอร์เดี่ยวส่วนใหญ่ใช้ Docker จะเขียนกฎ DNAT ของตัวเองขึ้นมา และแพ็กเก็ตจะเข้าถึงคอนเทนเนอร์โดยไม่ผ่าน chain ที่กฎ ufw ของคุณอยู่ ดังนั้นการสั่ง ufw deny พอร์ต 21117 จะไม่มีผล และ relay จะเปิดรับการเชื่อมต่อจากอินเทอร์เน็ตแม้ว่า ufw status จะระบุไว้เป็นอย่างอื่นก็ตาม การเผยแพร่พอร์ตของ Docker ที่ข้ามการทำงานของ ufw อธิบายถึงลำดับของ chain ไว้ การใช้ host networking จะช่วยหลีกเลี่ยงปัญหานี้ได้ทั้งหมด หากคุณจำเป็นต้องเผยแพร่พอร์ต ให้ bind พอร์ตนั้นเข้ากับ address เดียว ดังเช่นใน "127.0.0.1:21118:21118" ที่อยู่หลัง reverse proxy

การจำกัดด้วย source address จะได้ผลก็ต่อเมื่อ client ของคุณมี address ที่คงที่เท่านั้น

sudo ufw allow from 203.0.113.0/24 to any port 21115:21117 proto tcp
sudo ufw allow from 203.0.113.0/24 to any port 21116 proto udp

แล็ปท็อปที่ใช้งานบนเครือข่ายโรงแรมไม่มี address ที่คงที่ ซึ่งเป็นเหตุผลว่าทำไมคีย์บน hbbr จึงทำหน้าที่ป้องกันได้จริงมากกว่าไฟร์วอลล์ในกรณีนี้

การอัปเกรด stack ที่เก็บคีย์ของคุณ

คีย์จะถูกเก็บไว้ใน bind mount ไม่ได้อยู่ใน container ดังนั้นการอัปเกรดจึงมีความปลอดภัยตราบใดที่คุณไม่ได้ไปยุ่งกับ ./data

  1. สำรองข้อมูลไดเรกทอรีข้อมูลก่อน: sudo tar czf ~/rustdesk-data-backup.tgz -C ~/rustdesk data
  2. อ่านบันทึกการเปลี่ยนแปลง (release notes) สำหรับ tag ใหม่ในหน้า rustdesk-server releases
  3. แก้ไขไฟล์ compose.yml และเปลี่ยนบรรทัด image: ทั้งสองบรรทัดให้เป็น tag ใหม่
  4. รันคำสั่ง sudo docker compose pull จากนั้นรัน sudo docker compose up -d
  5. รันคำสั่ง sudo cat ~/rustdesk/data/id_ed25519.pub และตรวจสอบว่าสตริงที่ได้เป็นสตริงเดียวกับที่ client ของคุณถืออยู่

ขั้นตอนที่ 5 คือการตรวจสอบที่สำคัญที่สุด เพราะหากคีย์เปลี่ยนไปจะทำให้การเชื่อมต่อใหม่จาก client ที่ยังถือคีย์เก่าอยู่ใช้งานไม่ได้ เซิร์ฟเวอร์เวอร์ชัน 1.1.16 ที่ถูกตรึงไว้จะบันทึก public key ที่ใช้งานอยู่ลงใน log เมื่อเริ่มทำงาน และจะบันทึกการปฏิเสธคำขอเชื่อมต่อที่มีคีย์ไม่ถูกต้องไว้ด้วย ดังนั้นควรตรวจสอบ log ของทั้งสองบริการด้วย การย้อนกลับ (rollback) ทำได้โดยการเปลี่ยนกลับไปใช้ tag เดิมแล้วรันคำสั่ง up -d อีกครั้ง ซึ่งวิธีนี้จะใช้ได้ผลก็ต่อเมื่อคุณได้ตรึงเวอร์ชันไว้แล้วเท่านั้น เพราะหากใช้ latest ตัว docker compose pull จะย้ายชื่อ tag ไปยัง image ใหม่ ทำให้ไม่มี tag ใดที่ระบุถึง image เก่าได้อีก

วิธีปกติที่ทำให้คีย์สูญหายไม่ใช่การใช้ docker compose down ซึ่งไม่ได้ไปยุ่งกับ bind mount แต่เป็นการย้ายไปยัง VPS ใหม่แล้วคัดลอกเฉพาะ compose.yml ไปด้วย ดังนั้นอย่าลืมคัดลอก ./data ไปพร้อมกันด้วย

การตรวจสอบปริมาณข้อมูลขาออกบนแผนบริการที่มีการจำกัดโควตาการรับส่งข้อมูล

hbbr ทำหน้าที่รับส่งข้อมูลเซสชัน ส่วน hbbs จะรับส่งข้อมูลการลงทะเบียนและ heartbeat ซึ่งทั้งหมดนี้ถูกนับรวมในโควตาการรับส่งข้อมูล (transfer allowance) คำถามที่พบบ่อยของ RustDesk ระบุว่าการเชื่อมต่อผ่าน relay บนหน้าจอความละเอียด 1920x1080 จะใช้แบนด์วิดท์ระหว่าง 30 KB/s ถึง 3 MB/s และการทำงานออฟฟิศทั่วไปจะใช้ประมาณ 100 KB/s ตัวเลขเหล่านี้เป็นค่าที่เผยแพร่สำหรับเซสชันเดียว ไม่ใช่การวัดผลจากระบบของคุณโดยตรง หากคำนวณจากการใช้งาน 60 ชั่วโมงต่อเดือน หรือวันละ 2 ชั่วโมง จะได้ผลลัพธ์ดังนี้

แผนภูมิVPS egress from one relayed RustDesk session, 60 hours per month
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "Low end, 30 KB/s",
    "gb_per_month": 6.5
  },
  {
    "label": "Office work, 100 KB/s",
    "gb_per_month": 21.6
  },
  {
    "label": "High end, 3 MB/s",
    "gb_per_month": 648
  }
]

ที่อัตราการทำงานออฟฟิศ หนึ่งเซสชันจะใช้ข้อมูลประมาณ 21.6 GB ต่อเดือน หากใช้งานที่ระดับสูงสุดตามช่วงที่เผยแพร่ การใช้งาน 60 ชั่วโมงเท่าเดิมจะใช้ข้อมูลถึง 648 GB และหากมีการเชื่อมต่อพร้อมกันสองเซสชันที่อัตราดังกล่าว ปริมาณข้อมูลจะเกินโควตา 1 TB ภายในหนึ่งเดือน ส่วนค่าต่ำสุดจะอยู่ที่ 6.5 GB โดยหน่วยกิกะไบต์ในที่นี้คิดที่ 1000 MB ซึ่งเป็นวิธีนับโควตาการรับส่งข้อมูลตามปกติ

docker stats ไม่สามารถแยกแยะข้อมูลส่วนนี้ให้คุณได้ เนื่องจากคอนเทนเนอร์ที่ใช้ host networking จะใช้ network namespace ร่วมกับโฮสต์ แต่มีเครื่องมืออื่นอีกสองตัวที่ใช้งานได้ โดย vnstat จะวัดผลทั้งเครื่อง:

sudo apt install -y vnstat
sudo systemctl enable --now vnstat
vnstat -m

การวัดทั้งเครื่องหมายถึงทั้งเครื่องจริงๆ หาก VPS นี้รันบริการอื่นที่รับส่งข้อมูลจำนวนมาก เช่น เซิร์ฟเวอร์เก็บรูปภาพแบบ self-hosted ที่ดึงข้อมูลจากคลังภาพในโทรศัพท์ทุกคืน ข้อมูลขาออกเหล่านั้นจะถูกนับรวมในยอดการใช้งานรายเดือนเดียวกับทราฟฟิกของ relay ของคุณ เซิร์ฟเวอร์สื่อก็เช่นเดียวกัน เนื่องจากบริการอย่าง Halcyon ซึ่งเปลี่ยนคลัง Jellyfin ให้เป็นร้านวิดีโอสไตล์ยุค 90 จะสตรีมข้อมูลออกไปยังผู้รับชม และข้อมูลขาออกนั้นก็จะดึงโควตาเดียวกับที่ relay ของคุณใช้งานอยู่

ตัวนับของ nftables สามารถวัดผลเฉพาะ relay ได้ดังนี้:

sudo nft add table inet relaymeter
sudo nft add chain inet relaymeter out '{ type filter hook output priority 0 ; }'
sudo nft add rule inet relaymeter out tcp sport 21117 counter
sudo nft list table inet relaymeter

กฎดังกล่าวไม่มีการตัดสิน (verdict) จึงทำหน้าที่นับจำนวนแพ็กเก็ตและไบต์โดยไม่เปลี่ยนแปลงสิทธิ์การเข้าถึง และวางอยู่ในตารางของตัวเองเพื่อไม่ให้รบกวน ufw กฎนี้ไม่คงอยู่ถาวร (not persistent) ตัวนับจะรวมแพ็กเก็ต TCP ขาออกทั้งหมดจากพอร์ต 21117 รวมถึงการทำ handshake, คำขอที่ถูกปฏิเสธ และการสแกนพอร์ต ดังนั้นการที่ตัวเลขเพิ่มขึ้นเพียงอย่างเดียวไม่ได้พิสูจน์ว่ามีผู้อื่นกำลังใช้ relay ผ่านเซิร์ฟเวอร์ของคุณ เนื่องจากคุณคงไม่มานั่งอ่าน nft list ทุกเช้า ให้ตั้งค่า cron job เพื่อเปรียบเทียบจำนวนไบต์กับเกณฑ์ที่กำหนด และส่งการแจ้งเตือนแบบ push เมื่อเกินกำหนด ซึ่งเป็นงานที่เหมาะสำหรับ เซิร์ฟเวอร์ ntfy ของคุณเอง

hbbr ยังมีตัวจำกัดอัตรา (rate limits) ที่คุณสามารถปรับลดลงได้ โดย SINGLE_BANDWIDTH มีค่าเริ่มต้นที่ 128 Mb/s ต่อการเชื่อมต่อ relay หนึ่งรายการ และ TOTAL_BANDWIDTH อยู่ที่ 1024 Mb/s สำหรับการเชื่อมต่อทั้งหมด การตั้งค่า SINGLE_BANDWIDTH=8 จะกำหนดขีดจำกัดเริ่มต้นไว้ที่ประมาณ 1 MB/s ในเวอร์ชัน 1.1.16 หลังจากผ่านไป 1,800 วินาที หากการเชื่อมต่อใดมีค่าเฉลี่ยสูงกว่า 66% ของ SINGLE_BANDWIDTH ระบบจะสลับไปใช้ LIMIT_SPEED ซึ่งมีค่าเริ่มต้นที่ 32 × 1024 × 1024 bit/s หรือประมาณ 4.19 MB/s ให้ตั้งค่า LIMIT_SPEED=8 ไว้ด้วยเพื่อคุมตัวจำกัดทั้งสองให้ใกล้เคียง 1 MB/s การตั้งค่านี้เป็นการจำกัดความเร็ว ไม่ใช่ยอดรวมรายเดือน ดังนั้นให้มองว่าเป็นวิธีป้องกันไม่ให้เซสชันเดียวใช้งานลิงก์จนเต็ม มากกว่าที่จะเป็นเครื่องมือควบคุมงบประมาณการใช้งาน

เมื่อคุณไม่จำเป็นต้องใช้ relay เลย

สำหรับการใช้งานส่วนตัว คำตอบที่ตรงไปตรงมาคือคุณอาจไม่จำเป็นต้องทำสิ่งเหล่านี้เลย ให้ติดตั้งเครื่องทั้งสองเครื่องไว้บน mesh VPN แล้วเชื่อมต่อตรงไปยังที่อยู่ของ tunnel โดยวิธีนี้จะไม่มี hbbs, ไม่มี hbbr, ไม่มีการใช้ RustDesk relay egress และไม่ต้องคอยอัปเกรด RustDesk container บน VPS

บนเครื่องที่คุณต้องการควบคุม ให้เปิดใช้งานการเข้าถึงด้วย IP โดยตรงในการตั้งค่าความปลอดภัยของ RustDesk ช่องพอร์ตจะถูกตั้งค่าเริ่มต้นไว้ที่ 21118 ให้ตรวจสอบว่าพอร์ตดังกล่าวเปิดใช้งานอยู่ก่อนที่จะพยายามเชื่อมต่อ:

ss -tlnp | grep 21118

จากนั้นให้เชื่อมต่อโดยใช้ที่อยู่ VPN ของ peer นั้นแทนการใช้ ID ใน FAQ ของ RustDesk ระบุว่าโหมดนี้การเชื่อมต่อจะไม่มีการเข้ารหัส ดังนั้นควรใช้งานภายใน tunnel เท่านั้นและห้ามใช้งานผ่านอินเทอร์เน็ตสาธารณะโดยเด็ดขาด เพราะตัว tunnel จะเป็นสิ่งที่ทำหน้าที่เข้ารหัสให้

ให้เลือกตามความเป็นเจ้าของเครื่อง การใช้ hbbs และ hbbr แบบ self-hosted นั้นเหมาะสมเมื่อคุณต้องดูแลเครื่องที่ไม่ใช่ของคุณ หรือดูแลผู้ใช้งานที่ไม่สามารถติดตั้ง VPN client ได้ เพราะฝั่งของผู้ใช้งานจะใช้เพียง ID และรหัสผ่านเท่านั้น ส่วนการใช้ mesh VPN ร่วมกับการเข้าถึงด้วย IP โดยตรงจะเหมาะสมเมื่อทุกเครื่องเป็นของคุณและสามารถติดตั้งกุญแจ (key) ได้ การเปรียบเทียบ WireGuard กับ Tailscale ครอบคลุมวิธีการทั่วไปสองวิธีในการสร้าง mesh ดังกล่าว และ การใช้งาน remote desktop บน Linux VPS ครอบคลุมกรณีอื่น ๆ ซึ่งเป็นกรณีที่เครื่องที่คุณต้องการเข้าถึงหน้าจอคือตัวเซิร์ฟเวอร์เอง

FAQ

ทุกเซสชันของ RustDesk ต้องผ่าน relay ของฉันหรือไม่?

ไม่จำเป็น hbbs จะพยายามเชื่อมต่อไคลเอนต์ทั้งสองฝั่งโดยตรงก่อน โดยใช้เทคนิค hole punching ผ่าน NAT ที่อยู่หน้าไคลเอนต์แต่ละฝั่ง เฉพาะเซสชันที่การเชื่อมต่อโดยตรงล้มเหลวเท่านั้นที่จะถอยกลับไปใช้ hbbr และมีเพียงเซสชันเหล่านั้นที่จะใช้แบนด์วิดท์ของคุณ ข้อยกเว้นคือ ALWAYS_USE_RELAY=Y บน hbbs ซึ่งจะบังคับให้ทุกเซสชันผ่าน hbbr โดยไม่คำนึงว่าจะมีเส้นทางเชื่อมต่อโดยตรงหรือไม่ หากมีการตั้งค่าตัวแปรนี้ไว้ในไฟล์ Compose ของคุณ ข้อมูลทุกไบต์ของทุกเซสชันจะถูกนำไปคำนวณในค่าใช้จ่ายการรับส่งข้อมูลของคุณ

เซิร์ฟเวอร์คีย์ของ RustDesk ถูกเก็บไว้ที่ไหน และถ้าทำหายจะเป็นอย่างไร?

hbbs จะสร้าง id_ed25519 และ id_ed25519.pub ไว้ในไดเรกทอรีทำงานเมื่อเริ่มการทำงานครั้งแรก ไดเรกทอรีดังกล่าวคือ /root ภายในอิมเมจมาตรฐาน ดังนั้นหากมีการทำ volume mount ตามที่แสดงไว้ข้างต้น ไฟล์จะปรากฏอยู่ใน ./data บนโฮสต์ ให้สำรองไฟล์ทั้งสองไว้นอกเซิร์ฟเวอร์ หากไฟล์สูญหาย hbbs จะสร้างคู่คีย์ใหม่ในการเริ่มการทำงานครั้งถัดไป และคำขอเชื่อมต่อใหม่จากไคลเอนต์ที่ยังถือ public key เดิมอยู่จะล้มเหลวเนื่องจากคีย์ไม่ตรงกัน ให้กู้คืนคู่คีย์เดิมจากไฟล์สำรองแล้วรีสตาร์ททั้งสองบริการ หรืออัปเดตฟิลด์ Key บนไคลเอนต์ทุกเครื่อง

ฉันต้องเปิดพอร์ตใดบ้างสำหรับเซิร์ฟเวอร์ RustDesk ที่โฮสต์เอง?

TCP 21115, 21116 และ 21117 รวมถึง UDP 21116 โดย hbbs ใช้ 21115 สำหรับการทดสอบประเภท NAT, ใช้ 21116 สำหรับการลงทะเบียน ID และ heartbeat ผ่าน UDP รวมถึงการลงทะเบียนและทำ hole punching ผ่าน TCP ส่วน hbbr ใช้ 21117 สำหรับการทำ relay สำหรับ TCP 21118 และ 21119 เป็นพอร์ต WebSocket สำหรับไคลเอนต์บนเบราว์เซอร์ หากคุณไม่ได้ใช้งานให้ปิดพอร์ตเหล่านี้ไว้ ส่วน TCP 21114 เป็นของ Pro HTTP API server ซึ่งรุ่น open source ไม่จำเป็นต้องใช้งาน

คนแปลกหน้าสามารถใช้ RustDesk relay ที่ฉันโฮสต์เองได้หรือไม่?

ได้ หากคุณรัน hbbr ด้วยการตั้งค่าเริ่มต้น เอกสารของ RustDesk ระบุว่าการปล่อยคีย์ว่างไว้จะอนุญาตให้ไคลเอนต์ที่ไม่มีคีย์ที่ตรงกันสามารถใช้ relay ได้ ดังนั้นใครก็ตามที่ทราบชื่อโฮสต์และพอร์ต 21117 ของคุณจะสามารถส่งทราฟฟิกผ่านเซิร์ฟเวอร์ของคุณได้ ให้รัน hbbr ด้วย -k _ เพื่อให้โหลดคู่คีย์เดียวกับที่ hbbs ใช้จาก volume ./data ที่แชร์กัน หลังจากนั้นจะมีเพียงไคลเอนต์ที่กำหนดค่าด้วย public key ของคุณเท่านั้นที่จะสามารถใช้งาน relay ผ่านเซิร์ฟเวอร์ของคุณได้

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