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 แล้ว หากมีวิธีอื่นและมีประสิทธิภาพที่คุณสามารถนึกถึงได้ โปรดพูดถึงในความคิดเห็นของคุณ