ค้นหาเว็บไซต์

5 วิธีในการทำให้เซสชันและกระบวนการ SSH ระยะไกลทำงานหลังจากขาดการเชื่อมต่อ


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

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

อย่าพลาด: 5 วิธีปฏิบัติที่เป็นประโยชน์เพื่อรักษาเซิร์ฟเวอร์ SSH ให้ปลอดภัยและได้รับการปกป้อง

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

ทำความเข้าใจกระบวนการบน Linux

กระบวนการปกติ

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

กระบวนการเด็กกำพร้า

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

กระบวนการภูต

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

เทคนิคในการทำให้เซสชัน SSH ทำงานหลังจากขาดการเชื่อมต่อ

มีหลายวิธีในการปล่อยให้เซสชัน ssh ทำงานหลังจากขาดการเชื่อมต่อตามที่อธิบายไว้ด้านล่าง:

1. การใช้คำสั่งหน้าจอเพื่อให้เซสชัน SSH ทำงานต่อไป

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

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

กำลังเริ่มเซสชันหน้าจอ

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

screen

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

การถอดหน้าจอ

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

หากต้องการแยกหน้าจอออกจากเทอร์มินัลระยะไกล เพียงกด “Ctrl+a ” ตามด้วย “d ” แล้วคุณจะกลับไปที่เทอร์มินัลโดยเห็นข้อความที่หน้าจอ ถูกแยกออก ตอนนี้คุณสามารถออกจากระบบได้อย่างปลอดภัย และเซสชั่นของคุณจะยังคงอยู่

ดำเนินเซสชันหน้าจอเดี่ยวต่อ

หากคุณต้องการดำเนินการต่อเซสชันหน้าจอเดี่ยวที่คุณทิ้งไว้ก่อนออกจากระบบ เพียงเข้าสู่ระบบเทอร์มินัลระยะไกลอีกครั้งแล้วพิมพ์ “screen -r ” ในกรณีที่เปิดหน้าจอเดียวเท่านั้น และหากมีหลายหน้าจอ เปิดเซสชันหน้าจอแล้วเรียกใช้ “screen -r

screen -r
screen -r <pid.tty.host>

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับคำสั่งหน้าจอและวิธีใช้งาน เพียงไปที่ลิงก์: ใช้คำสั่งหน้าจอเพื่อจัดการเซสชันเทอร์มินัล Linux

2. การใช้ Tmux (Terminal Multiplexer) เพื่อให้เซสชัน SSH ทำงานต่อไป

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

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

เริ่มเซสชัน Tmux

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

tmux

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

ถอดเซสชัน Tmux ออกจาก Terminal

คุณสามารถเรียกใช้ “tmux detach ” ในการรันเซสชัน tmux หรือคุณสามารถใช้ทางลัด (Ctrl+b แล้ว d) หลังจากนี้ เซสชันปัจจุบันของคุณจะถูกแยกออก และคุณจะกลับมาที่เทอร์มินัลของคุณ ซึ่งคุณสามารถออกจากระบบได้อย่างปลอดภัย

tmux detach

ดำเนินการเซสชัน Tmux ที่ปิดต่อ

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

tmux attach

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ tmux และวิธีใช้งาน เพียงไปที่ลิงก์: ใช้ Tmux Terminal Multiplexer เพื่อจัดการเทอร์มินัล Linux หลายตัว

3. การใช้คำสั่ง nohup เพื่อเรียกใช้เซสชัน SSH ต่อไป

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

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

การดำเนินการคำสั่งโดยใช้ nohup ในพื้นหลัง

นี่เป็นสถานการณ์ง่ายๆ โดยที่เราได้เรียกใช้คำสั่ง find เพื่อค้นหาไฟล์ในพื้นหลังบนเซสชัน ssh โดยใช้ nohup หลังจากนั้นงานจะถูกส่งไปยังพื้นหลังพร้อมทั้งพร้อมท์ที่ส่งคืนทันทีโดยให้ PID และงาน ID ของกระบวนการ ([JOBID] PID)

nohup find / -type f $gt; files_in_system.out 2>1 &

ดำเนินการเซสชันต่อเพื่อดูว่างานยังคงดำเนินอยู่หรือไม่

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

fg %JOBID

4. การใช้คำสั่ง disown เพื่อให้เซสชัน SSH ทำงานต่อไป

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

ปฏิเสธ ลบงานออกจากรายการงานกระบวนการของระบบ ดังนั้นกระบวนการจึงได้รับการปกป้องจากการถูกฆ่าระหว่างการตัดการเชื่อมต่อเซสชัน เนื่องจากมันจะไม่ได้รับ SIGHUP จากเชลล์เมื่อ คุณออกจากระบบ

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

การดำเนินการคำสั่งโดยใช้ disown ในพื้นหลัง

ด้านล่างนี้ เราได้ส่งคำสั่ง ping ไปที่พื้นหลัง เพื่อให้ทำงานต่อไปและถูกลบออกจากรายการงาน ตามที่เห็น งานถูกระงับในตอนแรก หลังจากนั้นงานยังคงอยู่ในรายการงานเป็น รหัสกระบวนการ: 15368

ping linux-console.net > pingout &
jobs -l
disown -h %1
ps -ef | grep ping

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

ps -ef | grep ping

5. การใช้คำสั่ง setsid เพื่อเรียกใช้เซสชัน SSH

ยูทิลิตี้อื่นเพื่อให้บรรลุลักษณะการทำงานที่ต้องการคือ setsid Nohup มีข้อเสียในแง่ที่ว่ากลุ่มกระบวนการของกระบวนการยังคงเหมือนเดิม ดังนั้นกระบวนการที่ทำงานด้วย nohup จึงเสี่ยงต่อสัญญาณใด ๆ ที่ส่งไปยังกลุ่มกระบวนการทั้งหมด (เช่น Ctrl + C)

ในทางกลับกัน setsid จะจัดสรรกลุ่มกระบวนการใหม่ให้กับกระบวนการที่กำลังดำเนินการ ดังนั้นกระบวนการที่สร้างขึ้นจึงอยู่ในกลุ่มกระบวนการที่ได้รับการจัดสรรใหม่ทั้งหมด และสามารถทำงานได้อย่างปลอดภัยโดยไม่ต้องกลัวว่าจะถูกฆ่าแม้หลังจากออกจากระบบเซสชันแล้ว

ดำเนินการคำสั่งใด ๆ โดยใช้ setsid

ในที่นี้ แสดงให้เห็นว่ากระบวนการ 'sleep 10m' ได้ถูกแยกออกจากเทอร์มินัลการควบคุม นับตั้งแต่เวลาที่ถูกสร้างขึ้น

setsid sleep 10m
ps -ef | grep sleep

ตอนนี้ เมื่อคุณจะเข้าสู่ระบบเซสชันอีกครั้ง คุณจะยังคงพบว่ากระบวนการนี้กำลังทำงานอยู่

ps -ef | grep [s]leep

บทสรุป

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