คนยังรู้เวลา ทำไมคอมพิวเตอร์จะรู้ไม่ได้ ด้วย NTP

เคยสงสัยกันมั้ยว่า ทำไมเวลาที่แสดงผลอยู่บนเครื่องคอมพิวเตอร์ของเรา ที่อยู่มุมบนสำหรับ macOS และ ล่างขวาสำหรับ Windows มันถึงบอกเวลาได้ตรง ทำไมนาฬิกาบนโทรศัพท์เราบอกเวลาได้ตรงจังเลย วันนี้เราจะพามารู้จักกับวิธีที่เครื่องคอมพิวเตอร์รู้จักเวลากันผ่านสิ่งที่เรียกว่า Network Time Protocol (NTP)

เมื่อก่อนเราทำยังไง

สำหรับเราเด็กในยุค 90's เมื่อก่อน เวลาเราใช้คอมพิวเตอร์ เราจะเจอกับอาการที่เครื่องบอกเวลาไม่ถูก สมัยนั้นเราใช้ Windows ME ไม่ก็ XP เลยมั้ง นาฬิกาของเครื่องคอมพิวเตอร์มันชอบตรงบ้างไม่ตรงบ้าง

สิ่งที่เราทำได้ ณ ตอนนั้นก็คือ การเข้าไปตั้งค่า วัน และ เวลาใน Settings ของระบบปฏิบัติการ หรือที่เมื่อก่อนดีกว่านั้นคือ การเข้าไปตั้งค่าใน BIOS ตรง ๆ เลย

แต่สิ่งที่ทำให้เวลามันเพี้ยน แบบ เพี้ยน ไปเลย คือ เมื่อถ่านกระดุมบน Mainboard หมด เมื่อเราเปิดเครื่องมา เครื่องมันจะบอกว่า เออ ถ่านหมดนะ ให้เราเปลี่ยนถ่าน หรือ เปลี่ยนแล้วมันจะให้เราตั้งเวลาใหม่ เป็นเพราะ การที่มีถ่านไว้ มันเอาไว้จ่ายไฟให้กับ Clock หรือนาฬิกาบนเครื่องคอมพิวเตอร์ นั่นแหละ เครื่องมันรู้เวลาด้วย การที่เราตั้งไว้ครั้งเดียว แล้วเครื่องมันก็จะนับไปเรื่อย ๆ เหมือนกับ นาฬิกาที่เราแขวนอยู่บนบ้านของเรานั่นเอง

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

ถามว่า แล้ว พวกโทรศัพท์ หรือ Laptop ละ มันก็เป็นเครื่องคอมพิวเตอร์เหมือนกัน ทำไมเราไม่ต้องมานั่งเปลี่ยนถ่าน ถ้าเป็น Laptop สมัยก่อน ถ้าเราจำไม่ผิด มันก็ต้องเปลี่ยนนะ แต่ปัจจุบันนี้ เราไม่ต้องทำแบบนั้นแล้ว เพราะสิ่งที่โทรศัพท์ และ Laptop มีเหมือนกันคือ มันมี Battery มันก็เอาไฟจาก Battery นั่นแหละ มาจ่ายให้กับนาฬิกา เมื่อเราปิดเครื่อง ซึ่งไฟที่ใช้มันน้อยมาก ๆ จนเราไม่รู้สึกหรอก ขนาดแบตก้อนกระดุม กว่าจะหมดคือนานมาก ๆ แล้วแบตคอมใหญ่กว่ากี่เท่า เรียกว่า เศษไฟ ได้เลย ดังนั้นไม่ต้องห่วงเรื่องอายุของ Battery เมื่อต้องเอามารันพวกนี้เลย ไม่ถึง 1W ด้วยซ้ำมั้งนะ

การรู้เวลาทำให้เราถ่ายภาพหลุมดำได้

ย้อนกลับไปตอนเราเด็ก ๆ การที่เครื่องบอกเวลาได้ บอกเวลาได้ถูกต้อง คลาดเคลื่อนไปสัก 5 นาที มันดูจะไม่ได้เป็นอะไรมาก เราก็ยังใช้งานอะไรได้ปกติแทบทุกอย่าง แต่ถ้าเราลองตั้งเวลาให้ผิดในเครื่องของเราตอนนี้ดูสิ แค่เราเข้าเว็บสักเว็บ เช่น เว็บเราก็จะไม่ได้แล้ว มันจะขึ้น Warning มาเลยว่า เวลาเราผิด เพราะ มันมีบางอย่างที่ต้องใช้เวลาในการ Sync ด้วย มันก็เป็นเรื่องที่เราใช้งานทุกวันเนอะ

แต่เราอยากจะเล่าถึงเคสนึง ที่เวลา มันสำคัญมาก ๆ สำหรับเครื่อง ถ้าเราจำมีมด้านบนนี้ได้ เป็นรูปของ Dr. Katie Bouman ที่อยู่เบื้องหลังของการถ่ายรูปเจ้าหลุมดำ ที่เป็นข่าวใหญ่ในโลกของดาราศาสตร์เลยก็ว่าได้

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

ทำให้เกิด Event Horizon Telescope (EHT) ซึ่งก็คือ กลุ่มของกล้องโทรทรรศน์ ณ วันที่เราเขียนมีทั้งหมด 11 ตำแหน่งบนโลกด้วยกัน สิ่งที่เขาทำก็คือ การเก็บข้อมูลจากกล้องแต่ละตัว แล้วเอาข้อมูลตรงนั้นแหละ มาทำการประกอบเข้าด้วยกัน โอเค อ่านแล้วมันดูเป็นเรื่องที่ไม่น่ายากอะไร น่าจะเหมือนเราเอากล้อง 2 ตัวถ่ายพวกหนัง 3D ปะ

แต่ในความเป็นจริง ให้เรานึงถึงเวลาเราถ่ายรูป แล้วเราลาก Shutter Speed ช้า ๆ หน่อยสัก 1 วินาที ภาพที่เราได้ มันจะเกิดจาก ตั้งแต่เรากด Shutter จนไปถึงเวลาผ่านไปหลังจากนั้น 1 วินาทีเลย ทำให้ภาพที่เราได้มันก็จะเบลอ ๆ ไม่ชัด นี่ขนาดแค่กล้องเดียวนะ ETH มี 11 ตัว และ กระจายกันอยู่จุดต่าง ๆ บนโลก ทำให้ การ Sync เวลากัน เป็นเรื่องใหญ่มาก ๆ

สิ่งที่เขาทำก็คือ การเอา Atomic Clock หรือในภาษาไทยเรียกว่า นาฬิกาอะตอม (เป็นนาฬิกาที่เที่ยงตรงมาก ๆ แบบ มาก ๆ) ไปวางอยู่ตามกล้องทั้ง 11 ตัวเลย เมื่อกล้องแต่ละตัวมันเก็บข้อมูลมา มันจะ Tag เวลาจากนาฬิกาอะตอมไว้ด้วย เวลาได้ข้อมูลของทั้ง 11 ที่มาแล้ว เขาก็จะเอาข้อมูลที่เวลาเดียวกันมารวม ๆ กัน ทำให้เราได้ภาพออกมา อย่างที่เห็นนี่แหละ ยังไม่นับเรื่องของ ความไม่เรียบ และ การสั่นที่เป็น Noise ในระบบอีก เก็บไว้ให้เว็บที่เขาเขียนเรื่องพวกนี้เล่าเนอะ แต่สิ่งที่เราต้องการจะสื่อคือ การ Sync เวลามันเป็นเรื่องสำคัญมาก ๆ มันสำคัญตั้งแต่เรื่องธรรมดา อย่างเราจะเข้าเว็บสักเว็บ จนไปถึงการถ่ายภาพหลุมดำได้สำเร็จ

แล้วเราจะแก้ปัญหาได้ยังไง ?

ในเมื่อ การที่เครื่องมันรู้เวลามันสำคัญ แล้วเราจะทำยังไงถึงจะทำให้เครื่องรู้เวลาได้ โดยที่ไม่ต้องใช้ถ่านให้เจอปัญหาเหมือนที่เราคุยกันไป

ในเมื่อปัญหามันเกิดจากการที่แบตหมด หรือ ไม่ก็อะไรหลาย ๆ อย่าง แต่เรารู้ว่า ถ้าเราไม่ปิดเครื่อง เวลามันก็จะเดินไปเรื่อย ๆ แน่นอน เพราะเราเสียบไฟตลอดเวลา หรือ อาจจะมีไฟดับอะไรบ้าง เราก็ต่อ UPS เข้าไป มันก็น่าจะไม่มีปัญหาแน่นอน งั้นเราก็เปิดเครื่องสักเครื่องทิ้งไว้เป็น Server แล้วเขียน API เพื่อให้เครื่องอื่น ๆ ในระบบเข้ามาถามแล้วบอกเวลาปัจจุบันกลับไปได้ ซึ่งเราอาจจะเอา Atomic Clock มาเสียบเลยอะ แพงหน่อย น่ากลัวหน่อย แต่ก็บอกเวลาได้แม่นยำมาก ๆ

ทำให้เครื่องอื่น ๆ ในระบบ เมื่อต้องการอัพเดทเวลาภายในเครื่อง เขาก็ทำการเรียกหาเครื่อง Server ที่เราตั้งไว้ เครื่องที่ต้องการ ก็จะทำการส่ง Request เข้าไปบอก Server ว่า โอเค เราต้องการเวลา ขอหน่อย เมื่อเครื่อง Server ได้รับคำขอ (Request) แล้ว มันก็จะ Process และ โยนเวลากลับไป เครื่องที่ต้องการได้รับ ก็จะทำการ Update เวลาในเครื่องตัวเอง พูดง่าย ๆ คือ เราก็ใช้ Client-Server Model ทั่ว ๆ ไปเหมือนที่เราใช้งานกัน

เท่าที่อ่าน ก็ดูจะเป็นวิธีที่ อื้ม..... น่าจะไม่มีปัญหาอะไร น่าจะใช้งานได้ แต่..... เราลองคิดดูดี ๆ นะ การส่งข้อมูลมันมี เวลาของมันอยู่ มีแน่ ๆ คือ เวลาที่ข้อมูลผ่านตัวกลาง ไม่ว่าจะเป็น สาย Fibre Optics หรือจะเป็นทองแดง มันก็มีเวลาของมัน นอกจากนั้น ยังไม่นับพวก Overhead ของ Protocol ต่าง ๆ เช่นถ้าเราใช้ TCP/IP มันก็มีพวก Three-Ways Handshake อะไรอีก สุดท้าย เมื่อบวก ๆ กันไป มันก็จะมีเวลาที่เป็น Overhead เข้าไปอีก ทำให้จริง ๆ แล้ว Round-Trip Time (RTT) ระหว่างการส่งขอเวลาสักพักนึง อาจจะกดไปมากกว่า 10-20 ms เลยก็ได้

เรายกตัวอย่างง่าย ๆ เช่นเราขอเวลา ตอน 1:42:00:000 am  ตอนข้อมูลส่งไปถึง Server อาจจะเป็น 1:42:00:005 am เครื่องก็จะบอกเวลาไปเป็น 1:42:00:005 am เมื่อกลับไปถึงเครื่องที่ต้องการ เวลาจริง ๆ อาจจะเป็น 1:42:00:010 am แต่เวลาที่ได้รับมาเป็น 1:42:00:005 am นั่นแปลว่า เวลามันคลาดเคลื่อนไป 5 ms เลยนะ

สำหรับบาง Application อาจจะไม่ใช่เรื่องใหญ่อะไร แต่ในบาง Application ที่ต้องการความแม่นยำสูง ๆ อาจจะมีปัญหาเมื่อเราใช้วิธีนี้ได้ เรายกตัวอย่างง่าย ๆ เลยนะ เอาเป็นพวก เกม FPS หรือ MOBA ถ้ามันไม่ตรงระดับ Millisecond อาจจะทำให้เกมพังได้เลยนะ ยังไม่นับว่า ใน 1 เกม เราเล่นกันตั้งกี่คน แล้วจะหวังให้ทุกคนเวลาวิ่งตรงกันเป๊ะ ๆ ยากนะ งั้นเราจะทำยังไง ถึงจะบอกเวลาได้ตรงเป๊ะ ๆ

Time Synchronisation Protocol

เพื่อเป็นการแก้ปัญหานี้ เลยทำให้เกิดสิ่งที่เรียกว่า Time Synchronisation Protocol ขึ้นมา โดยมันเป็นวิธีการที่เกิดมาสำหรับการปรับเวลาให้มันตรงกันบนระบบคอมพิวเตอร์ ไม่ว่าจะผ่านอะไรก็ตาม แต่วันนี้เราจะ Cover กันในส่วนของ การปรับเวลาผ่านระบบ Network กัน ซึ่งในปัจจุบัน มีหลาย ๆ Protocol ขึ้นมา แต่ตัวที่เราใช้งานกันเยอะ ๆ ก็น่าจะเป็น PTP (Precision Time Protocol) อันนี้ไว้ตอนหน้าเรามาคุยกัน และ NTP (Network Time Protocol) เราขอเล่าเฉพาะ NTP ละกัน เพราะเป็น Protocol ที่เราใช้กันแพร่หลายที่สุดแล้ว มันอยู่บน macOS, Windows และ Linux เป็น Default เลย

Network Time Protocol (NTP)

Network Time Protocol เกิดมานานมาก ๆ คือปี 1982 บนมาตรฐาน RFC958 ของ Version NTPv0 ถือว่าเป็นมาตรฐานในการปรับเวลาบนระบบ Network ที่เราเดาว่า น่าจะเก่าที่สุดแล้วละ ตั้งแต่วันนั้นถึงวันนี้ NTP ก็ยังคงได้รับการปรับปรุงอย่างต่อเนี่อง จนทุกวันนี้เราอยู่ใน ฮำพหรนื NTPv4 ที่ประกาศบนมาตรฐาน NTC5905 ในปี 2010 นี่เอง สำหรับคนที่พอจะเข้าใจ Network มันทำงานอยู่บน L7 ผ่าน Port 123 UDP

วิธีการทำงานของมัน คิดต่อจากสิ่งที่เราคุยกันก่อนหน้านี้ที่เรามี Server ตัวนึงขึ้นมา เราจะเรียกมันว่า Time Server ทำหน้าที่เดียวเลยคือ การบอกเวลา แต่เราเจอปัญหาว่า เวลาที่ Time Server บอก มันไม่ตรง เมื่อถึงปลายทาง หรือ Client แล้วอะสิ

สิ่งที่มันทำคือ เริ่มจาก Client จะเอาเวลาของตัวเองขึ้นมา เป็นเวลาที่ Client รู้ แปะไว้ เราเรียกว่า T0 แล้วส่งไปให้ Time Server จากนั้น Time Server จะแปะเวลาของตัวเองเข้าไป เป็น T1 ถ้าเราคิดเล่น ๆ ถ้าเราเอา T1 - T0 มันน่าจะเป็นเวลาที่ Packet หรือข้อมูลจาก Client ใช้ส่งถึง Server ใช่มั้ย จะบอกว่า มันไม่ได้เป็นแบบนั้น เพราะถ้าเกิด เครื่อง Client เข้าใจเวลาตัวเองผิด มันก็จะผิดไปหมดเลยใช่มั้ย แต่ถ้ามันถูก แล้วทำไมเราต้องขอเวลาด้วย

ในระหว่างนั้น Time Server อาจจะ Process อะไรบางอย่างอยู่ หรือมีคนเข้ามาต่อคิวขอเวลาอยู่ ทำให้มันอาจจะมี Processing Time เกิดขึ้น ทำให้เมื่อ Time Server มัน Process เสร็จเรียบร้อยแล้ว มันจะแปะเวลาเข้าไปอีกที คือ T2

จากนั้น ข้อมูลก็จะถูกส่งกลับมาที่ Client ละ เมื่อมันถึง Client ก็จะปั้มเวลาของตัวเองลงไป เป็น T3 ทำให้ตอนนี้ เราจะมี Timestamp อยู่ทั้งหมด 4 ตัวคือ T0 จากเครื่อง Client ก่อนส่ง, T1 เมื่อ Time Server ได้รับ Request, T2 เมื่อ Time Server ส่งเวลากลับไป และ T3 เวลาเมื่อ Client ได้รับข้อมูลจาก Time Server

ในเมื่อเวลา T0 และ T3 มันคือเวลาที่ได้จากเครื่องเดียวกัน ถ้าเราเอามาลบกัน เราก็จะรู้ว่า เวลาทั้งหมดที่ใช้ในการเรียกเวลามันเป็นเท่าไหร่ เช่น 10 วินาที เราก็จะรู้ว่า การที่เราเชื่อมต่อ เรียกเวลา และ ส่งข้อมูลกลับมา เราใช้เวลา 10 วินาทีด้วยกัน

แล้วยังไงต่อ เราอยากรู้เวลาปัจจุบันนิ แต่เวลา T3-T0 มันบวกเวลาในการเรียกภายในเครื่องต่อคิวอะไรอีก เลยทำให้ T1 และ T2 เข้ามา มันก็คือเวลาที่ Time Server ใช้ในการ Process นั่นเอง เราก็เอา T2 - T1 เราก็จะได้ Processing Time ออกมา แล้วเอาไปลบออกจากผลลัพธ์ของ T3-T0 เราก็จะได้เวลาในการรับส่งข้อมูลเฉย ๆ

เมื่อเรารู้เวลาที่ใช้ในการส่งข้อมูลกลับมาแล้ว เรามี T2 ที่เป็นเวลาก่อนออกจาก Time Server นิ เราก็เอาผลลัพธ์เมื่อครู่ที่พึ่งคำนวณไป บวก เพื่อให้ได้เวลาปัจจุบันกลับออกมา นั่นทำให้ NTP สามารถปรับเวลาได้ ในระดับที่แม่นยำกว่าวิธีแรกที่เราคิดกันมาก เพราะมันมีการชดเชยเวลาที่เกิดขึ้นระหว่างการรับ-ส่งข้อมูลนั่นเอง

ถ้าเราทำแบบนี้ไปเรื่อย ๆ หลาย ๆ รอบ เราจะเห็นว่า เวลามันจะค่อย ๆ ตรงขึ้นเรื่อย ๆ เรารู้ได้ยังไง ก็คือเอา T1-T0 เหมือนที่เราคุยกันตอนแรกใช่มะ ถ้าลบกันออกมาแล้วมันได้ 0 ก็แปลว่า เวลาที่เราปรับไปมันตรงละ นอกจากนั้น มันจะทำให้เครื่องรู้ด้วยว่า เวลาที่มันกำลังเดินอยู่ มันเดินเร็วไป หรือช้าไป ทำให้เครื่องสามารถปรับ Clock ของตัวเองให้ตรงกับเวลาจริงได้มากที่สุด ทำให้นาฬิกาบนเครื่องมันก็จะตรงมากขึ้นไปอีก

หรือ บางครั้ง เครื่องมันก็จะพยายามปรับเวลาจากหลาย ๆ Time Server เพื่อให้มั่นใจจริง ๆ ว่าเวลามันตรงจริง ๆ นะ ซึ่งวิธีการอย่าง NTP นี้ ถ้าเราสังเกตดี ๆ มันทนทานต่อเรื่องของเวลาในการรับ-ส่งข้อมูลมาก ๆ ทำให้มันไม่ค่อยมีปัญหาว่า Server ที่ 1 ช้า Server ที่ 2 ส่งได้เร็วกว่าอะไรแบบนั้น เพราะเรามีการเช็คตรงนี้ตลอดทุกครั้งอยู่แล้ว แล้วยังทำให้เครื่องบอกได้อีกว่า Server ไหนดี หรือไม่ดี ทำให้มัน Ranking แล้วเลือกอันที่ตรงที่สุดให้กับเราได้ เพราะบางครั้ง ต้องยอมรับว่า เวลาเรารับส่งข้อมูลกัน เวลาในการรับส่งมันอาจจะมีการรวน ๆ ช้าบ้าง เร็วบ้างในถึงมันจะทนทาน แต่เราก็ควรจะเลือกตัวที่มันนิ่งที่สุดแหละ

Stratum เข้ามาช่วย

ใน NTP มันจะมีสิ่งที่เรียกว่า Stratum เข้ามา ยิ่งเลขน้อย ๆ มันยิ่งจะเป็นนาฬิกาที่เที่ยงตรงมาก ๆ เช่น Stratum 0 อาจจะเป็นพวกเครื่องที่ต่อเข้ากับ Atomic Clock แล้วเครื่องต่อไปที่ต่อกับเครื่อง Stratum 0 ก็คือ Stratum 1 แบบนี้ลงไปเรื่อย ๆ ดูเผิน ๆ การทำแบบนี้ ก็ทำให้เราไม่จำเป็นต้องมีพวก Atomic Clock หรือเครื่องที่ต่อเพื่อขอเวลาจากดาวเทียมวางอยู่เยอะ ๆ ใช่ม่ะ มันแพงงงง เราก็ปรับเวลาลงไปเรื่อย ๆ ดูจะไม่มีปัญหาอะไร แต่อย่างที่เราเล่าไปก่อนหน้า มันก็อาจจะมีความคลาดเคลี่อนอยู่เหมือนกัน และยิ่งเรา ปรับกันลงมาเรื่อย ๆ ด้วย เหมือนกับตอนที่เราเล่นเกมวาดรูปที่หลังเพื่อน แล้ววาดต่อไปเรื่อย ๆ ตอนแรกเป็นกวาง จนถึงคนสุดท้าย อาจจะเป็นหอยทากก็ได้ใช่ป่ะ เหมือนกัน

แต่สิ่งที่ดีสำหรับการทำแบบนี้คือ เราจะมีจุดอ้างอิงเวลาที่ค่อนข้างมั่นคงมาก ๆ เพราะจุดที่เราใช้อ้างอิงก็คือ Stratum ก่อนหน้า มันอาจจะมีหลายเครื่องก็ได้ เช่น อาจจะมี 10 เครื่อง โอกาสที่ทั้ง 10 เครื่อง ล่มไปพร้อม ๆ กันมันก็น้อยกว่า โอกาสที่เครื่องเดียวจะล่มแน่นอน

เราจะรู้ได้ยังไงว่า เครื่องเราใช้ NTP หรือไม่ ?

ในเครื่องคอมพิวเตอร์ส่วนใหญ่ เราก็จะใช้ NTP ในการปรับเวลากันอยู่แล้ว สำหรับฝั่ง macOS ที่เราใช้งานอยู่ก็เหมือนกัน ถ้าเราเข้าไปที่ Date & Time เราจะเห็นตัวเลือกที่เขียนว่า Set date & time automantically ถ้าเราเปิด ก็คือ เราเลือกใช้การปรับเวลาจาก Server และถ้าเราดูที่การตั้งค่าต่อไปมันจะเป็น Source ที่โดยเริ่มต้น มันจะตั้งเป็น time.apple.com หรือก็คือ Time Server ของ Apple เอง

โดยถ้าเรามี Time Server ที่คิดว่า แม่นยำ และ ใกล้ตัวเรามากกว่า เราก็สามารถเข้าไปปรับได้ เช่นกัน แค่นี้เอง เครื่องเราก็ทำการปรับเวลาโดย Protocol ที่เราเล่าไป

สรุป

Network Time Protocol หรือ NTP เป็น Protocol ที่ทำให้เครื่องคอมพิวเตอร์ของเราสามารถปรับเวลาให้ตรงกับที่อื่น ๆ ได้ ทำให้เราสามารถส่งข้อมูลกันไปมา และ ตรวจสอบได้อย่างมั่นใจ ผ่าน Network ที่เราใช้งานได้เลย โดยที่เราไม่ต้องใช้ Hardware พิเศษอะไรเลย เพียงแค่เราต่อ Network ได้เท่านั้นเอง และ เป็น Protocol ที่เราก็ใช้งานกันอยู่ในเครื่องคอมพิวเตอร์ทั่ว ๆ ไป อย่างเครื่องที่เราใช้เอง มันก็มี Feature นี้เช่นกัน ลองเข้าไปหาดูกันได้