วิธีใช้ SSH เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ระยะไกลใน Linux [รุ่น 2023]

โพสต์นี้มีไว้เพื่ออธิบายวิธีใช้ SSh เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ระยะไกลใน Linux นอกจากนี้เรายังกล่าวถึงวิธีการใช้ PuTTY เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ Linux ระยะไกลอีกด้วย แน่นอนว่า PuTTY ไม่ใช่ไคลเอ็นต์ SSH เดียวที่คุณสามารถใช้สำหรับการเชื่อมต่อระยะไกลได้ ลองดูที่นี่ การเปรียบเทียบไคลเอนต์ SSH ที่ดีที่สุดสำหรับ Windows ในปี 2022 และเลือกอันที่ตรงกับสิ่งที่คุณต้องการ การเข้าถึงอุปกรณ์จากระยะไกลกลายเป็นข้อกำหนดเมื่อนานมาแล้ว และเราแทบจะจินตนาการไม่ออกว่าจะเป็นอย่างไรหากเราไม่สามารถควบคุมคอมพิวเตอร์จากสถานที่ห่างไกลได้

มีหลายวิธีในการเชื่อมต่อกับเครื่องระยะไกล ขึ้นอยู่กับระบบปฏิบัติการที่คุณใช้ แต่โปรโตคอลที่ใช้กันอย่างแพร่หลายสองโปรโตคอลคือ:

1. Secure Shell (SSH) สำหรับอุปกรณ์ที่ใช้ Linux
2. Remote Desktop Protocol (RDP) สำหรับอุปกรณ์ Windows

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

SSH คืออะไรและย่อมาจากอะไร?

SSH (Secure Shell) หรือที่เรียกว่า “Secure Socket Shell” เป็นโปรโตคอลที่ช่วยให้คุณเชื่อมต่อกับอุปกรณ์ระยะไกลหรือเซิร์ฟเวอร์อย่างปลอดภัยโดยใช้อินเทอร์เฟซแบบข้อความ มีโปรโตคอลที่ใช้กันอย่างแพร่หลายสองประการในการเชื่อมต่อกับเครื่องระยะไกล: SSH และ RDP การสร้างการเชื่อมต่อ SSH ต้องใช้ทั้งไคลเอนต์และส่วนประกอบเซิร์ฟเวอร์

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

SSH ทำงานอย่างไร?

ในการสร้างการเชื่อมต่อ SSH คุณต้องมีสององค์ประกอบ:
ที่ ไคลเอ็นต์และส่วนฝั่งเซิร์ฟเวอร์ที่เกี่ยวข้อง. Tไคลเอ็นต์ SSH คือแอปพลิเคชันที่คุณใช้งานบนอุปกรณ์ที่คุณใช้เชื่อมต่อกับคอมพิวเตอร์หรือเซิร์ฟเวอร์เครื่องอื่น ไคลเอนต์ใช้ข้อมูลที่โฮสต์ระยะไกลให้มาเพื่อเริ่มต้นการเชื่อมต่อ เมื่อตรวจสอบข้อมูลรับรองแล้ว ไคลเอ็นต์จะสร้างการเชื่อมต่อที่เข้ารหัส

ทางฝั่งเซิร์ฟเวอร์มีส่วนที่เรียกว่า ภูต SSH (SSHD) ที่คอยรับฟังพอร์ต TCP/IP เฉพาะอย่างต่อเนื่องสำหรับคำขอลิงก์ไคลเอนต์ที่อาจเกิดขึ้น หากไคลเอนต์เริ่มการเชื่อมต่อ SSH daemon จะตอบกลับด้วยซอฟต์แวร์และเวอร์ชันโปรโตคอลที่รองรับ และทั้งสองจะแบ่งปันข้อมูลระบุตัวตนของพวกเขา

หากข้อมูลรับรองที่ได้รับถูกต้อง SSH จะสร้างเซสชันใหม่สำหรับสภาพแวดล้อมที่เหมาะสม เวอร์ชันเริ่มต้นของโปรโตคอล SSH สำหรับเซิร์ฟเวอร์ SSH และการสื่อสารไคลเอ็นต์ SSH คือเวอร์ชัน 2

อ่านเพิ่มเติม:  ไคลเอนต์ SSH ที่ดีที่สุดสำหรับ Windows ในปี 2022

เทอร์มินัลคืออะไร?

หากคุณยังใหม่กับ Linux คุณต้องการทำความคุ้นเคยกับเทอร์มินัล คิดว่านี่เป็นฮับทางลัดคำสั่งขั้นสูงสุดซึ่งเป็นวิธีทั่วไปในการสื่อสารกับเซิร์ฟเวอร์ Linux

การใช้บรรทัดคำสั่งอาจดูเหมือนเป็นงานที่ท้าทาย แต่ก็ง่ายหากคุณเริ่มต้นด้วยพื้นฐาน — เช่นนี้ 15 คำสั่งพื้นฐานที่ผู้ใช้ทุกคนควรรู้.

เทอร์มินัลมีความสำคัญมากยิ่งขึ้นหากคุณวางแผนที่จะพัฒนาแอปพลิเคชัน (หรือเรียนรู้ที่จะพัฒนาแอปพลิเคชัน) โดยใช้ PHP หรือ Python แตกต่างจาก Windows ซึ่งทำให้ Python พยายามสร้างมันขึ้นมาใหม่ด้วย GUI แต่ Linux ได้รวม Python และภาษาการเขียนโปรแกรมอื่น ๆ เข้ากับเทอร์มินัล ดังนั้นแม้คุณจะต้องผ่านอะไรมาบ้าง ขั้นตอนในการติดตั้ง Python บน Windows เพียงเพื่อให้เกิดความยุ่งเหยิงที่ไม่มีประสิทธิภาพ Linux จึงมาพร้อมกับมันและสามารถเข้าถึงได้จากบรรทัดคำสั่ง

เอสเอสแอลคืออะไร?

SSH ใช้ SSL (Secure Socket Layer) เพื่อรักษาความปลอดภัยให้กับข้อมูลที่ถ่ายโอนระหว่างเว็บเบราว์เซอร์และเซิร์ฟเวอร์ การเข้ารหัสลิงก์ระหว่างเว็บเซิร์ฟเวอร์และเบราว์เซอร์ทำได้ด้วย SSL ทำให้มั่นใจได้ว่าข้อมูลทั้งหมดที่ส่งระหว่างกันยังคงเป็นส่วนตัวและปราศจากการโจมตี กล่าวอีกนัยหนึ่ง การสร้างคีย์สาธารณะและคีย์ส่วนตัวระหว่างเซิร์ฟเวอร์ระยะไกลและคอมพิวเตอร์เฉพาะที่ที่เชื่อมต่อผ่าน SSH เป็นส่วนหนึ่งของโปรโตคอลความปลอดภัย SSL การป้องกันอีกชั้นนี้มีประโยชน์ โดยเฉพาะในกรณีของการโจมตีด้วยรหัสผ่านแบบดุร้าย

จะสร้างการเชื่อมต่อ SSH ได้อย่างไร?

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

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

ขั้นตอนที่ 1: ติดตั้งไคลเอนต์ OpenSSH

ก่อนที่จะติดตั้งไคลเอนต์ SSH ตรวจสอบให้แน่ใจว่ายังไม่ได้ติดตั้งบนระบบของคุณ Linux จำนวนมากมีไคลเอนต์ SSH อยู่แล้ว

1. รันคำสั่งต่อไปนี้เพื่อติดตั้ง OpenSSH บนอุปกรณ์ของคุณ:

sudo apt-get install openssh-client

2. พิมพ์รหัสผ่าน superuser เมื่อจำเป็น
3. กด Enter เพื่อเสร็จสิ้นกระบวนการติดตั้ง

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

ขั้นตอนที่ 2: ติดตั้งเซิร์ฟเวอร์ OpenSSH

ในการยอมรับการเชื่อมต่อ SSH จะต้องติดตั้งส่วนฝั่งเซิร์ฟเวอร์ของชุดเครื่องมือซอฟต์แวร์ SSH บนคอมพิวเตอร์ โดยคุณต้องทำตามขั้นตอนต่อไปนี้:

1. เปิดเทอร์มินัลบนเครื่องเซิร์ฟเวอร์ของคุณ คุณสามารถค้นหาเทอร์มินัลหรือคลิก CTRL + ALT + T บนแป้นพิมพ์ของคุณ
2. ป้อนคำสั่งต่อไปนี้เพื่อติดตั้งเซิร์ฟเวอร์ SSH ของคุณ:

sudo apt-get install openssh-server

3. พิมพ์รหัสผ่าน superuser เมื่อจำเป็น
4. กด เข้า และ Y เพื่อให้การติดตั้งดำเนินต่อไปหลังจากข้อความแจ้งพื้นที่ดิสก์

หลังจากทำตามขั้นตอนข้างต้นแล้ว คุณจะมีไฟล์สนับสนุนที่เหมาะสมติดตั้งสำหรับคุณ จากนั้นคุณสามารถตรวจสอบได้ว่าเซิร์ฟเวอร์ SSH ทำงานบนเครื่องหรือไม่โดยป้อนคำสั่งนี้:

sudo service ssh status

คำตอบของเทอร์มินัลควรมีลักษณะเหมือนกันหากบริการ SSH ทำงานอย่างถูกต้อง:

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

เอาล่ะ เข้าไป ใช่ or y เพื่อดำเนินการต่อ

เยี่ยมมาก! ขณะนี้เซิร์ฟเวอร์ของคุณพร้อมที่จะยอมรับคำขอการเชื่อมต่อระยะไกล SSH จากคอมพิวเตอร์เครื่องอื่นโดยใช้ไคลเอ็นต์ SSH

อ่าน

วิธีโฮสต์เซิร์ฟเวอร์ Git ของคุณเอง: คำแนะนำทีละขั้นตอนของ Linux

ฉันจะใช้ SSH เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ระยะไกลใน Linux ได้อย่างไร

ตอนนี้คุณได้ติดตั้งไคลเอนต์และเซิร์ฟเวอร์ OpenSSH ในทุกอุปกรณ์ที่คุณต้องการแล้ว คุณสามารถสร้างการเชื่อมต่อระยะไกล SSH ที่ปลอดภัยไปยังเซิร์ฟเวอร์ของคุณได้ผ่านขั้นตอนต่อไปนี้:

1. เปิดเทอร์มินัล SSH บนคอมพิวเตอร์ของคุณแล้วเปิดคำสั่งต่อไปนี้:

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

ssh your_username@host_ip_address

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

ssh host_ip_address

และกด เข้า.

2. ป้อนรหัสผ่านของคุณแล้วกด Enter โปรดทราบว่าคุณจะไม่ได้รับคำติชมใดๆ บนหน้าจอเมื่อคุณพิมพ์ หากคุณวางรหัสผ่าน ตรวจสอบให้แน่ใจว่ารหัสผ่านนั้นถูกเก็บไว้อย่างปลอดภัยและไม่ได้อยู่ในไฟล์ข้อความ
3. เมื่อคุณเชื่อมต่อกับเซิร์ฟเวอร์เป็นครั้งแรก คุณจะถูกถามว่าต้องการเชื่อมต่อต่อหรือไม่ เพียงพิมพ์ “ใช่” และกด เข้า. ข้อความนี้จะปรากฏขึ้นในเวลานี้เท่านั้นเนื่องจากไม่ได้ระบุเซิร์ฟเวอร์ระยะไกลบนเครื่องคอมพิวเตอร์ของคุณ
4. เพิ่มคีย์ลายนิ้วมือ ECDSA แล้ว และคุณเชื่อมต่อกับเซิร์ฟเวอร์ระยะไกลแล้ว

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

ขั้นตอนเพิ่มเติมในการควบคุมระยะไกล SSH

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

ต่อไปนี้เป็นคำแนะนำบางส่วนสำหรับการปรับปรุงความปลอดภัย SSH ซึ่งคุณสามารถใช้ประโยชน์จากการแก้ไขไฟล์การกำหนดค่า sshd:

• แก้ไขพอร์ต TCP เริ่มต้นโดยที่ SSH daemon กำลังฟังอยู่ และเปลี่ยนจาก 22 เป็นค่าที่สูงกว่ามาก เช่น 245976 ระวังอย่าใช้หมายเลขพอร์ตที่เดาง่าย เช่น 222, 2222 หรือ 22222
• ใช้คู่คีย์ SSH เพื่อตรวจสอบสิทธิ์การเข้าสู่ระบบ SSH โดยไม่ต้องใช้รหัสผ่าน ปลอดภัยกว่าและอนุญาตให้เข้าสู่ระบบโดยไม่ต้องใช้รหัสผ่าน ทำให้คุณดำเนินการได้รวดเร็วและสะดวกยิ่งขึ้น
• ปิดการใช้งานการเข้าสู่ระบบด้วยรหัสผ่านบนเซิร์ฟเวอร์ของคุณ เพราะหากรหัสผ่านของคุณถูกถอดรหัส การปิดการใช้งานนี้จะช่วยลดความเป็นไปได้ในการใช้รหัสผ่านเพื่อเข้าสู่เซิร์ฟเวอร์ของคุณ ก่อนที่จะดำเนินการดังกล่าว จำเป็นอย่างยิ่งที่จะต้องแน่ใจว่าการรับรองความถูกต้องของคู่คีย์ทำงานอย่างถูกต้อง
• ปิดการใช้งานการเข้าถึงรูทไปยังเซิร์ฟเวอร์ของคุณและใช้บัญชีปกติด้วยคำสั่ง su – (เพื่อสลับไปใช้ผู้ใช้รูท)

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

PuTTY คืออะไร?

PuTTY เป็นโปรแกรมจำลองเทอร์มินัล Windows ยอดนิยมซึ่งไม่จำกัดเฉพาะระบบปฏิบัติการ Windows PuTTy เป็นบริการฟรีและเป็นโอเพ่นซอร์ส ดังนั้นจึงเป็นที่นิยมในหมู่ผู้ใช้ Linux และมีอินเทอร์เฟซผู้ใช้แบบข้อความสำหรับคอมพิวเตอร์ระยะไกลที่ใช้โปรโตคอลที่รองรับ รวมทั้ง SSH และเทลเน็ต.

[su_button url=”https://www.putty.org/” target=”blank” style=”soft” size=”5″]ดาวน์โหลด Putty[/su_button]

บันทึก: PuTTY สามารถดาวน์โหลดซอฟต์แวร์ได้ฟรี และนำเสนอวิธีง่ายๆ ในการเข้าถึงสภาพแวดล้อมเชลล์ Unix จากระบบ Windows ของคุณ ต่างจาก Unix ตรงที่ Windows ไม่มีเซิร์ฟเวอร์หรือไคลเอนต์ SSH ที่ติดตั้งไว้ล่วงหน้า นั่นคือเหตุผลที่โปรแกรมถ่ายโอนไฟล์ผ่านเครือข่ายรองรับโปรโตคอลที่หลากหลาย รวมถึงไคลเอนต์ Telnet

อ่านเพิ่มเติม: สร้างคีย์ SSH ใน Windows 10

จะดาวน์โหลดและติดตั้ง Putty บน Ubuntu Linux ได้อย่างไร

PuTTY เวอร์ชัน Linux เป็นแอปพลิเคชันเทอร์มินัลแบบกราฟิกที่ไม่ได้ติดตั้งไว้ล่วงหน้าใน Linux เวอร์ชันส่วนใหญ่ แม้ว่าคุณจะสามารถติดตั้ง puTTY ได้อย่างง่ายดายผ่านเทอร์มินัลบนอุปกรณ์ที่ใช้ Linux

หากคุณไม่ได้ติดตั้ง PuTTY โปรดไปที่ ดาวน์โหลด PuTTY.dll และดาวน์โหลดตัวติดตั้ง Linux จากส่วน Package Files ของเพจ

ข่าวดีสำหรับผู้ใช้ Linux ก็คือ PuTTY มีอยู่ในที่เก็บจักรวาลของ Ubuntu หากต้องการติดตั้ง PuTTY บน Linux Ubuntu คุณควรตรวจสอบให้แน่ใจก่อนว่าได้เปิดใช้งานที่เก็บจักรวาลแล้ว ใช้คำสั่งนี้:

sudo add-apt-repository universe

เมื่อเปิดใช้งานพื้นที่เก็บข้อมูลจักรวาลแล้ว คุณสามารถอัปเดต Ubuntu ด้วยคำสั่งนี้:

sudo apt update

จากนั้นติดตั้ง PuTTY ด้วยคำสั่งนี้:

sudo apt install putty

เมื่อการติดตั้ง PuTTY เสร็จสิ้น คุณสามารถเริ่ม PuTTY ได้โดยค้นหาจากเมนู PuTTY เวอร์ชัน Linux มีลักษณะเกือบจะเหมือนกับเวอร์ชัน Windows ดังนั้น คุณจะไม่มีปัญหาในการค้นหาเส้นทางผ่านการตั้งค่าใหม่และการตั้งค่าที่เปลี่ยนแปลง

วิธีเชื่อมต่อกับเซิร์ฟเวอร์ Linux โดยใช้ PuTTY

หากคุณต้องการเชื่อมต่อกับเซิร์ฟเวอร์ Linux โดยใช้ PuTTY หลังจากติดตั้งแล้ว คุณต้องทำตามขั้นตอนเหล่านี้:

ขั้นตอนที่ 1: กำหนดค่า PuTTY

หน้าจอการกำหนดค่าเซสชันหลักจะปรากฏขึ้นเมื่อคุณเปิด PuTTY เริ่มต้นด้วยการเข้าสู่. ชื่อโฮสต์ (หรือที่อยู่ IP) ของเซิร์ฟเวอร์ที่คุณพยายามเชื่อมต่อ

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

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

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

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

อ่านเพิ่มเติม: ติดตั้ง MikroTik CHR บน VPS (ใช้ PuTTY)

ขั้นตอนที่ 2: บันทึกการกำหนดค่า PuTTY สำหรับครั้งถัดไป 

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

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

จะตั้งค่าการตรวจสอบสิทธิ์คีย์สาธารณะ SSH บน Linux ได้อย่างไร

PuTTY อาจได้รับการกำหนดค่าให้ใช้คีย์ SSH วิธีการตรวจสอบสิทธิ์คีย์ SSH ปลอดภัยกว่าและบางครั้งก็สะดวกกว่า คุณสามารถใช้ PuTTY เพื่อสร้างคีย์เหล่านั้นได้ นี่คือของเรา คำแนะนำในการสร้างคีย์ SSH โดยใช้ PuTTY บน Windows. คุณสามารถใช้มันเพื่อเพิ่มความปลอดภัย SSH ของคุณได้อย่างรวดเร็ว

คุณต้องทำตามขั้นตอนสองสามขั้นตอนเพื่อตั้งค่าการตรวจสอบสิทธิ์คีย์สาธารณะผ่าน SSH บน Linux (หรือคอมพิวเตอร์ macOS):

ขั้นตอนที่ 1: สร้างคู่คีย์

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

ssh-keygen -t rsa

ขั้นตอนที่ 2: ระบุชื่อไฟล์และรหัสผ่าน

คุณจะต้องตั้งชื่อไฟล์เพื่อบันทึกคู่คีย์และรหัสผ่านเพื่อป้องกันคีย์ส่วนตัวของคุณ หากคุณต้องการใช้ชื่อไฟล์และตำแหน่งเริ่มต้นสำหรับคู่คีย์ของคุณต่อ ให้คลิก Enter หรือ Return โดยไม่ต้องป้อนชื่อไฟล์ หรือคุณสามารถป้อนชื่อไฟล์เช่น My_ssh_key ที่พรอมต์แล้วกด Enter หรือ Return โปรดทราบว่าโฮสต์ระยะไกลจำนวนมากได้รับการกำหนดค่าให้ยอมรับคีย์ส่วนตัวด้วยชื่อไฟล์และเส้นทางเริ่มต้น ดังนั้น คุณต้องเรียกใช้สิ่งนี้อย่างชัดเจนบนบรรทัดคำสั่ง SSH หรือในไฟล์การกำหนดค่าไคลเอนต์ SSH (~/.ssh/config)

คุณต้องป้อนรหัสผ่านที่มีอักขระอย่างน้อยห้าตัวแล้วคลิก Enter หรือ Return หากคุณคลิกที่ Enter โดยไม่มีรหัสผ่าน มันจะสร้างรหัสส่วนตัวของคุณ โดยไม่มีการป้องกันด้วยรหัสผ่าน.

ขั้นตอนที่ 3: คัดลอกรหัสสาธารณะ

 ใช้ SFTP หรือ SCP เพื่อคัดลอกไฟล์กุญแจสาธารณะไปยังบัญชีของคุณบนระบบระยะไกล

ขั้นตอนที่ 4: ป้อนข้อมูลรับรองบัญชีของคุณ

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

ขั้นตอนที่ 5: เข้าสู่ระบบระยะไกล

เข้าสู่ระบบระยะไกลด้วยชื่อผู้ใช้และรหัสผ่านบัญชีของคุณ

ขั้นตอนที่ 6: สร้างไฟล์ที่จำเป็นในบัญชีของคุณ

ในกรณีที่บัญชีของคุณบนระบบระยะไกลยังไม่มีไฟล์ ~/.ssh/authorized_keys ให้สร้างขึ้นใหม่โดยพิมพ์คำสั่งต่อไปนี้:

mkdir -p ~/.ssh

touch ~/.ssh/authorized_keys

ขั้นตอนที่ 7: เพิ่มเนื้อหาของไฟล์กุญแจสาธารณะลงในไฟล์ ไฟล์คีย์ที่ได้รับอนุญาต

บนระบบรีโมต ให้เพิ่มเนื้อหาของไฟล์พับลิกคีย์ของคุณ เช่น ~/id_rsa.pub ไปยังบรรทัดใหม่ในไฟล์ ~/.ssh/authorized_keys ของคุณโดยใช้คำสั่งต่อไปนี้:

cat ~/id_rsa.pub >> ~/.ssh/authorized_keys

คุณอาจต้องการตรวจสอบเนื้อหาของ ~/.ssh/authorized_keys เพื่อให้แน่ใจว่ากุญแจสาธารณะของคุณถูกเพิ่มอย่างถูกต้องผ่านคำสั่งด้านล่าง:

more ~/.ssh/authorized_keys

ขั้นตอนที่ 8: ลบไฟล์กุญแจสาธารณะ

ตอนนี้คุณสามารถลบไฟล์กุญแจสาธารณะออกจากบัญชีของคุณบนระบบระยะไกลได้อย่างปลอดภัยโดยใช้รหัสต่อไปนี้บนบรรทัดคำสั่ง:

rm ~/id_rsa.pub

หรือหากคุณต้องการเก็บสำเนาคีย์สาธารณะของคุณไว้ในระบบระยะไกล ให้ย้ายคีย์นั้นไปยังไดเร็กทอรี .ssh ของคุณโดยใช้คำสั่งนี้:

mv ~/id_rsa.pub ~/.ssh/

ขั้นตอนที่ 9: เพิ่มกุญแจสาธารณะของคุณไปยังระบบอื่น (ไม่บังคับ)

ณ จุดนี้ของการตั้งค่าการตรวจสอบสิทธิ์คีย์สาธารณะ SSH คุณสามารถทำซ้ำขั้นตอนเหล่านี้เพื่อเพิ่มคีย์สาธารณะของคุณไปยังระบบระยะไกลอื่นๆ ที่คุณต้องการเข้าถึงจากคอมพิวเตอร์ด้วยคีย์ส่วนตัวของคุณโดยใช้การตรวจสอบสิทธิ์คีย์สาธารณะ SSH

ขั้นตอนที่ 10: SSH ไปยังบัญชีของคุณบนระบบระยะไกล

ตอนนี้ คุณควรจะสามารถใช้ประโยชน์จากการเชื่อมต่อระยะไกล SSH โดยใช้บัญชีของคุณบนระบบระยะไกลที่มีรหัสส่วนตัวของคุณ หากคีย์ส่วนตัวของคุณมีการป้องกันด้วยรหัสผ่าน ระบบระยะไกลจะถามรหัสผ่านหรือข้อความรหัสผ่านจากคุณ (ดังภาพด้านล่าง) โปรดทราบว่ารหัสผ่านคีย์ส่วนตัวหรือข้อความรหัสผ่านของคุณไม่ได้ถูกส่งไปยังระบบระยะไกล

ในกรณีที่คีย์ส่วนตัวของคุณไม่ได้รับการป้องกันด้วยรหัสผ่าน ระบบระยะไกลจะนำคุณไปยังบรรทัดคำสั่งในโฮมไดเร็กตอรี่ของคุณโดยไม่ต้องขอรหัสผ่านหรือข้อความรหัสผ่าน และคุณจะเห็นผลลัพธ์ที่คล้ายกับสิ่งนี้:

คลิกที่ เปิด ป้อนรหัสผ่านและเชื่อมต่อ

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

อ่านเพิ่มเติม: ทุกสิ่งที่คุณต้องการรู้เกี่ยวกับพร็อกซี SSH SOCKS5

มาตรฐานเดสก์ท็อประยะไกลที่สำคัญ

VNC และ RDP เป็นโปรโตคอลเดสก์ท็อประยะไกลสองตัว เทคโนโลยีทั้งสองนี้มีเป้าหมายคล้ายกัน แต่วิธีการต่างกัน

VNC คืออะไร?

บางครั้ง VNC (การประมวลผลเครือข่ายเสมือน) อาจสับสนกับ VPN (Virtual Private Network) โดยไม่ได้ตั้งใจ ทั้งสองทำงานเหมือนกันในสภาพแวดล้อมเครือข่ายแบบเพียร์ทูเพียร์ ทำให้สามารถเข้าถึงคอมพิวเตอร์จากระยะไกลได้ อย่างไรก็ตาม พวกมันไม่เหมือนกันโดยพื้นฐานแล้ว 

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

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

อุโมงค์ VNC บน SSH

หากคุณเชื่อมต่อกับเดสก์ท็อประยะไกลโดยใช้โปรโตคอล Virtual Network Computing (VNC) การเชื่อมต่อของคุณจะไม่ปลอดภัย ไคลเอนต์ VNC บางตัวไม่ปกป้องการเชื่อมต่อของคุณเกินกว่าจุดลงชื่อเข้าใช้เริ่มต้น คุณสามารถทันเนลการเชื่อมต่อ VNC ผ่านช่องทาง Safe Shell (SSH) เพื่อแก้ไขปัญหา  อุโมงค์ SSH ให้การเชื่อมต่อที่ปลอดภัยสำหรับ VNC ทำให้คุณสามารถใช้การเชื่อมต่อ VNC เมื่อพอร์ต VNC ปกติ (พอร์ต 5901) ถูกบล็อก

เครือข่ายองค์กรบางแห่งจะบล็อกพอร์ตมาตรฐาน เช่น พอร์ต 5901 เพื่อการป้องกันเพิ่มเติม ดังนั้นการทันเนล VNC บน SSH จะช่วยให้คุณสามารถแก้ไขปัญหานี้ได้

RDP คืออะไร?

RDP (Remote Desktop Protocol) เป็นโปรโตคอลการสื่อสารเครือข่ายที่สร้างขึ้นโดย Microsoft ซึ่งอนุญาตให้ผู้ใช้เชื่อมโยงจากระยะไกลไปยังอุปกรณ์อื่น  Remote Desktop Protocol เป็นส่วนขยายของโปรโตคอล T.120 (โปรโตคอลปกติ) ซึ่งเป็นส่วนหนึ่งของ ITU (International Telecommunications Union)

ความคิดสุดท้าย: การเชื่อมต่อระยะไกล SSH

หากต้องการสร้างการเชื่อมต่อระยะไกล SSH และใช้เพื่อเชื่อมต่อเซิร์ฟเวอร์ใน Linux คุณต้องมีไคลเอ็นต์และส่วนฝั่งเซิร์ฟเวอร์ที่เกี่ยวข้องเป็นสององค์ประกอบ บทความแนวปฏิบัตินี้อธิบายวิธีเข้าถึง SSH จากระยะไกลและใช้ประโยชน์จากมัน เรายังภูมิใจนำเสนอต่างๆ แผน Linux VPS เพื่อช่วยให้คุณใช้คุณสมบัติที่ยอดเยี่ยมได้มากที่สุด ที่ cloudzy เราพยายามอย่างเต็มที่เพื่อมอบโซลูชั่น Linux VPS ที่โดดเด่นให้กับคุณ เพื่อให้บริการที่คุณเลือกมีความปลอดภัยและประสิทธิภาพที่ยอดเยี่ยม มอบประสบการณ์โฮสติ้งที่ยอดเยี่ยมแก่คุณ

คำถามที่พบบ่อย

 

SSH คืออะไร?

SSH เป็นโปรโตคอลที่ใช้เพื่อความปลอดภัยขณะเชื่อมต่อกับเซิร์ฟเวอร์ระยะไกล คำสั่ง ssh ใช้โปรโตคอลนี้เพื่อถ่ายโอนข้อมูลระหว่างไคลเอ็นต์และโฮสต์ในรูปแบบที่เข้ารหัส

วิธีการตั้งค่าคีย์ SSH

1. สร้างคีย์ SSH
2. ตั้งชื่อคีย์ SSH ของคุณ
3. ป้อนรหัสผ่าน (ไม่จำเป็น)
4. ย้ายกุญแจสาธารณะไปยังระบบระยะไกล
5. ทดสอบการเชื่อมต่อของคุณ

คู่คีย์ SSH คืออะไร

คู่คีย์ SSH แต่ละคู่ประกอบด้วยสองคีย์ที่เรียกว่า: คีย์สาธารณะและคีย์ส่วนตัว ใครก็ตามที่มีสำเนาของกุญแจสาธารณะสามารถเข้ารหัสข้อมูลได้ แต่เฉพาะบุคคลที่ถือกุญแจส่วนตัวที่เกี่ยวข้องเท่านั้นที่สามารถอ่านข้อมูลนี้ได้

รหัสส่วนตัว SSH อยู่ที่ไหน

หากคุณใช้ชื่อเริ่มต้น คีย์ส่วนตัวของคุณจะถูกจัดเก็บไว้ใน “/root/.ssh/id_rsa”