5 ວິທີການເພື່ອຮັກສາໄລຍະ SSH ແລະໄລຍະການ ດຳ ເນີນງານທີ່ຫ່າງໄກຈາກການຕັດຂາດ

SSH ຫຼື Secure Shell ໃນເງື່ອນໄຂທີ່ງ່າຍດາຍແມ່ນວິທີການທີ່ບຸກຄົນໃດ ໜຶ່ງ ສາມາດເຂົ້າເຖິງຜູ້ໃຊ້ອື່ນໃນໄລຍະໄກຈາກລະບົບອື່ນໄດ້ແຕ່ໃນເສັ້ນ ຄຳ ສັ່ງ i.e. ຮູບແບບທີ່ບໍ່ແມ່ນ GUI. ໃນດ້ານວິຊາການຫລາຍກ່ວາ, ເມື່ອພວກເຮົາ ssh ຫາຜູ້ໃຊ້ອື່ນໃນບາງລະບົບອື່ນແລະ ດຳ ເນີນການ ຄຳ ສັ່ງໃນເຄື່ອງນັ້ນ, ຕົວຈິງແລ້ວມັນສ້າງ pseudo-terminal ແລະເອົາມັນເຂົ້າໄປໃນ shell login ຂອງຜູ້ໃຊ້ທີ່ເຂົ້າໃຊ້.

ໃນເວລາທີ່ພວກເຮົາອອກຈາກຊ່ວງເວລາຫລືຊ່ວງເວລາກອງປະຊຸມອອກໄປຫລັງຈາກທີ່ບໍ່ໄດ້ໃຊ້ເວລາຂ້ອນຂ້າງ, ສັນຍານ SIGHUP ຈະຖືກສົ່ງໄປທີ່ pseudo-terminal ແລະທຸກໆວຽກທີ່ໄດ້ແລ່ນຢູ່ປາຍນັ້ນ, ແມ່ນແຕ່ວຽກທີ່ມີວຽກພໍ່ແມ່ຂອງພວກເຂົາ. ການລິເລີ່ມໃນ pseudo-terminal ຍັງຖືກສົ່ງສັນຍານ SIGHUP ແລະຖືກບັງຄັບໃຫ້ຢຸດຕິ.

ມີພຽງແຕ່ວຽກທີ່ໄດ້ຮັບການຕັ້ງຄ່າໃຫ້ບໍ່ສົນໃຈສັນຍານນີ້ເທົ່ານັ້ນທີ່ເປັນວຽກງານທີ່ລອດຊີວິດຈາກການສິ້ນສຸດກອງປະຊຸມ. ໃນລະບົບ Linux, ພວກເຮົາສາມາດມີຫຼາຍວິທີທີ່ຈະເຮັດໃຫ້ວຽກເຫຼົ່ານີ້ເຮັດວຽກຢູ່ໃນ server ຫ່າງໄກສອກຫຼີກຫຼືເຄື່ອງຈັກໃດກໍ່ຕາມເຖິງແມ່ນວ່າຫຼັງຈາກການອອກຈາກລະບົບແລະການສິ້ນສຸດຂອງຜູ້ໃຊ້

ເຂົ້າໃຈຂັ້ນຕອນໃນ Linux

ຂະບວນການປົກກະຕິແມ່ນຜູ້ທີ່ມີອາຍຸການໃຊ້ງານຂອງການປະຊຸມ. ພວກມັນຖືກເລີ່ມຕົ້ນໃນລະຫວ່າງການປະຊຸມດັ່ງທີ່ເປັນຂັ້ນຕອນທາງ ໜ້າ ແລະສິ້ນສຸດໃນຊ່ວງເວລາທີ່ແນ່ນອນຫຼືເມື່ອເວລາເຂົ້າສູ່ລະບົບ. ຂະບວນການເຫຼົ່ານີ້ມີເຈົ້າຂອງຂອງພວກເຂົາເປັນຜູ້ໃຊ້ທີ່ຖືກຕ້ອງຂອງລະບົບ, ລວມທັງຮາກ.

ຂັ້ນຕອນຂອງເດັກ ກຳ ພ້າແມ່ນຜູ້ທີ່ມີພໍ່ແມ່ຜູ້ ທຳ ອິດທີ່ສ້າງຂະບວນການນີ້ແຕ່ຫລັງຈາກເວລາໃດ ໜຶ່ງ, ຂະບວນການຂອງພໍ່ແມ່ໄດ້ເສຍຊີວິດຫຼືລົ້ມເຫຼວໂດຍເຈດຕະນາ, ເຊິ່ງເຮັດໃຫ້ການເປັນພໍ່ແມ່ຂອງຂະບວນການນັ້ນ. ຂະບວນການດັ່ງກ່າວໄດ້ລິເລີ່ມເປັນພໍ່ແມ່ທັນທີທີ່ລໍຖ້າໃນຂັ້ນຕອນເຫຼົ່ານີ້ຈົນກວ່າພວກເຂົາຈະເສຍຊີວິດຫຼືສິ້ນສຸດລົງ.

ເຫຼົ່ານີ້ແມ່ນບາງຂະບວນການລ້ຽງເດັກ ກຳ ພ້າໂດຍເຈດຕະນາ, ຂະບວນການດັ່ງກ່າວທີ່ຖືກປະປ່ອຍໄວ້ໂດຍເຈດຕະນາໃນລະບົບຖືກເອີ້ນວ່າ daemon ຫຼືຂະບວນການ ກຳ ພ້າ ກຳ ພ້າໂດຍເຈດຕະນາ. ພວກມັນມັກຈະເປັນຂະບວນການທີ່ຍາວນານເຊິ່ງໄດ້ຖືກລິເລີ່ມຄັ້ງ ໜຶ່ງ ແລ້ວຖີ້ມອອກຈາກສະຖານີຄວບຄຸມໃດ ໜຶ່ງ ເພື່ອໃຫ້ພວກເຂົາສາມາດແລ່ນຢູ່ໃນພື້ນຫລັງຈົນກວ່າພວກເຂົາຈະບໍ່ ສຳ ເລັດ, ຫຼືສິ້ນສຸດການຖິ້ມຂໍ້ຜິດພາດ. ພໍ່ແມ່ຂອງຂະບວນການດັ່ງກ່າວໂດຍເຈດຕະນາເສຍຊີວິດເຮັດໃຫ້ການປະຕິບັດເດັກໃນພື້ນຖານ.

ເຕັກນິກເພື່ອຮັກສາລະບົບການເຮັດວຽກຂອງ SSH ພາຍຫຼັງການຕັດຂາດ

ມັນສາມາດມີຫລາຍວິທີທີ່ຈະອອກຈາກການເຮັດ ssh session ຫຼັງຈາກຕັດການເຊື່ອມຕໍ່ດັ່ງທີ່ໄດ້ອະທິບາຍຂ້າງລຸ່ມນີ້:

ໜ້າ ຈໍແມ່ນຕົວ ໜັງ ສື Windows Manager ສຳ ລັບ Linux ເຊິ່ງຊ່ວຍໃຫ້ຜູ້ໃຊ້ສາມາດຈັດການຫລາຍພາກສ່ວນ terminal ໃນເວລາດຽວກັນ, ປ່ຽນລະຫວ່າງ session, log session ສຳ ລັບ session ທີ່ ກຳ ລັງແລ່ນຢູ່ ໜ້າ ຈໍ, ແລະຍັງສາມາດຕໍ່ເຂົ້າ session ໄດ້ທຸກເວລາທີ່ເຮົາປາດຖະ ໜາ ໂດຍບໍ່ຕ້ອງກັງວົນກ່ຽວກັບ session ທີ່ຖືກ log. ອອກຫຼືຢູ່ປາຍທາງຖືກປິດ.

ກອງປະຊຸມ ໜ້າ ຈໍສາມາດເລີ່ມຕົ້ນໄດ້ແລະຫຼັງຈາກນັ້ນແຍກອອກຈາກສະຖານີຄວບຄຸມທີ່ເຮັດໃຫ້ພວກເຂົາແລ່ນຢູ່ໃນພື້ນຫລັງແລະຫຼັງຈາກນັ້ນຈະຖືກ ນຳ ໃຊ້ຄືນ ໃໝ່ ໃນທຸກເວລາແລະແມ່ນແຕ່ຢູ່ບ່ອນໃດກໍ່ຕາມ. ພຽງແຕ່ທ່ານຕ້ອງການເລີ່ມຕົ້ນການປະຊຸມຂອງທ່ານໃນ ໜ້າ ຈໍແລະເມື່ອທ່ານຕ້ອງການ, ຖອດມັນອອກຈາກ pseudo-terminal (ຫຼື terminal ຄວບຄຸມ) ແລະອອກຈາກລະບົບ. ເມື່ອທ່ານຮູ້ສຶກ, ທ່ານສາມາດເຂົ້າສູ່ລະບົບ ໃໝ່ ແລະສືບຕໍ່ການປະຊຸມ.

ຫຼັງຈາກການພິມ ຄຳ ສັ່ງ ‘ໜ້າ ຈໍ’, ທ່ານຈະຢູ່ໃນກອງປະຊຸມ ໜ້າ ຈໍ ໃໝ່, ພາຍໃນກອງປະຊຸມນີ້ທ່ານສາມາດສ້າງປ່ອງຢ້ຽມ ໃໝ່, ຂ້າມຜ່ານ ໜ້າ ຕ່າງ, ລັອກ ໜ້າ ຈໍ, ແລະເຮັດອີກຫຼາຍໆຢ່າງທີ່ທ່ານສາມາດເຮັດໄດ້ຕາມສະຖານີ ທຳ ມະດາ.

$ screen

ເມື່ອກອງປະຊຸມ ໜ້າ ຈໍເລີ່ມຕົ້ນ, ທ່ານສາມາດ ດຳ ເນີນການ ຄຳ ສັ່ງໃດໆແລະເຮັດໃຫ້ການປະຊຸມ ດຳ ເນີນງານໂດຍການກັກຕົວເຊີ້ດ.

ພຽງແຕ່ໃນເວລາທີ່ທ່ານຕ້ອງການອອກຈາກກອງປະຊຸມໄລຍະໄກ, ແຕ່ທ່ານຕ້ອງການທີ່ຈະຮັກສາເຊດຊັນທີ່ທ່ານສ້າງຂື້ນໃນເຄື່ອງນັ້ນ, ຈາກນັ້ນສິ່ງທີ່ທ່ານຕ້ອງເຮັດຄືການຖອດ ໜ້າ ຈໍອອກຈາກປາຍທາງເພື່ອບໍ່ໃຫ້ມັນຄວບຄຸມຢູ່ປາຍຍອດ. ຫຼັງຈາກເຮັດສິ່ງນີ້ແລ້ວ, ທ່ານສາມາດອອກຈາກລະບົບໄດ້ຢ່າງປອດໄພ.

ເພື່ອຖອດ ໜ້າ ຈໍຈາກສະຖານີຫ່າງໄກສອກຫຼີກ, ພຽງແຕ່ກົດປຸ່ມ "Ctrl + a" ຕິດຕາມໂດຍທັນທີໂດຍໃສ່ລະຫັດ "d" ແລະທ່ານຈະກັບໄປທີ່ປາຍທາງທີ່ເຫັນຂໍ້ຄວາມວ່າ ໜ້າ ຈໍ ຖືກແຍກອອກ. ດຽວນີ້ທ່ານສາມາດອອກຈາກລະບົບໄດ້ຢ່າງປອດໄພແລະເວລາຂອງທ່ານຈະມີຊີວິດຢູ່.

ຖ້າທ່ານຕ້ອງການທີ່ຈະສືບຕໍ່ປະຊຸມ ໜ້າ ຈໍທີ່ແຍກອອກຈາກທີ່ທ່ານປະໄວ້ກ່ອນທີ່ຈະອອກຈາກລະບົບ, ທ່ານຕ້ອງເຂົ້າສູ່ລະບົບສະຖານີຫ່າງໄກສອກຫຼີກອີກຄັ້ງແລະພິມ “ ໜ້າ ຈໍ -r” ກອງປະຊຸມ ໜ້າ ຈໍຈະຖືກເປີດໃຊ້ງານ “ ໜ້າ ຈໍ -r ” .

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

ເພື່ອຮຽນຮູ້ເພີ່ມເຕີມກ່ຽວກັບ ຄຳ ສັ່ງ ໜ້າ ຈໍແລະວິທີການໃຊ້ມັນພຽງແຕ່ຕິດຕາມລິ້ງ: ໃຊ້ ຄຳ ສັ່ງ ໜ້າ ຈໍເພື່ອຈັດການ Linux Terminal Sessions

Tmux ແມ່ນໂປແກຼມອື່ນທີ່ຖືກສ້າງຂື້ນມາເພື່ອທົດແທນ ໜ້າ ຈໍ. ມັນມີຄວາມສາມາດສ່ວນໃຫຍ່ຂອງ ໜ້າ ຈໍ, ມີຄວາມສາມາດເພີ່ມເຕີມ ໜ້ອຍ ໜຶ່ງ ທີ່ເຮັດໃຫ້ມັນມີປະສິດທິພາບສູງກວ່າ ໜ້າ ຈໍ.

ມັນອະນຸຍາດໃຫ້, ນອກຈາກຕົວເລືອກທັງ ໝົດ ທີ່ສະ ເໜີ ໂດຍ ໜ້າ ຈໍ, ການແບ່ງປັນແຖບແຕກອອກທາງນອນຫຼືແນວຕັ້ງລະຫວ່າງຫລາຍໆປ່ອງ, ການປັບຂະ ໜາດ ຂອງປ່ອງຢ້ຽມ, ການກວດສອບກິດຈະ ກຳ ຂອງກອງປະຊຸມ, ການຕິດຕາມດ້ວຍການ ນຳ ໃຊ້ຮູບແບບເສັ້ນ ຄຳ ສັ່ງແລະອື່ນໆ. ການແຈກຢາຍທັງ ໝົດ ຂອງ Unix ແລະແມ່ນແຕ່ມັນໄດ້ຖືກລວມເຂົ້າໃນລະບົບຖານຂອງ OpenBSD.

ຫຼັງຈາກເຮັດ ssh ໃສ່ host ຫ່າງໄກສອກຫຼີກແລະພິມ tmux, ທ່ານຈະເຂົ້າໄປໃນກອງປະຊຸມ ໃໝ່ ດ້ວຍການເປີດ ໜ້າ ຕ່າງ ໃໝ່ ຢູ່ທາງ ໜ້າ ຂອງທ່ານ, ເຊິ່ງທ່ານສາມາດເຮັດທຸກຢ່າງທີ່ທ່ານເຮັດໃນສະຖານີ ທຳ ມະດາ.

$ tmux

ຫຼັງຈາກປະຕິບັດການປະຕິບັດງານຂອງທ່ານຢູ່ສະ ໜາມ ບິນ, ທ່ານສາມາດຖອດກອງປະຊຸມນັ້ນອອກຈາກສະຖານີຄວບຄຸມເພື່ອໃຫ້ມັນເຂົ້າໄປໃນພື້ນຫລັງແລະທ່ານສາມາດອອກຈາກລະບົບໄດ້ຢ່າງປອດໄພ.

ທ່ານສາມາດ ດຳ ເນີນການ “ tmux detach” ໃນການແລ່ນ tmux session ຫຼືທ່ານສາມາດໃຊ້ລະຫັດທາງລັດ (Ctrl + b ແລ້ວ d) . ຫຼັງຈາກນີ້ກອງປະຊຸມປະຈຸບັນຂອງທ່ານຈະຖືກກັກຂັງແລະທ່ານຈະກັບຄືນມາຢູ່ສະຖານີຂອງທ່ານຈາກບ່ອນທີ່ທ່ານສາມາດອອກຈາກລະບົບໄດ້ຢ່າງປອດໄພ.

$ tmux detach

ເພື່ອເປີດກອງປະຊຸມ ໃໝ່ ທີ່ທ່ານໄດ້ແຍກອອກແລະປະໄວ້ຄືກັບເວລາທີ່ທ່ານອອກຈາກລະບົບ, ພຽງແຕ່ເຂົ້າລະບົບ ໃໝ່ ຈາກເຄື່ອງຫ່າງໄກສອກຫຼີກແລ້ວພິມ ຄຳ ວ່າ“ tmux ແນບ” ເພື່ອຕິດກັບກອງປະຊຸມທີ່ປິດແລ້ວແລະມັນຈະຍັງຢູ່ແລະແລ່ນຢູ່ .

$ tmux attach

ເພື່ອຮຽນຮູ້ເພີ່ມເຕີມກ່ຽວກັບ tmux ແລະວິທີການ ນຳ ໃຊ້ມັນພຽງແຕ່ຕິດຕາມລິ້ງ: ໃຊ້ Tmux Terminal Multiplexer ເພື່ອຈັດການກັບ Linux Linux Terminals.

ຖ້າທ່ານບໍ່ຄຸ້ນເຄີຍກັບ ໜ້າ ຈໍຫລື tmux, ທ່ານສາມາດໃຊ້ nohup ແລະສົ່ງ ຄຳ ສັ່ງທີ່ເຮັດວຽກຍາວໆໄປສູ່ພື້ນຫລັງເພື່ອໃຫ້ທ່ານສາມາດ ດຳ ເນີນການຕໍ່ໄປໃນຂະນະທີ່ ຄຳ ສັ່ງຈະ ດຳ ເນີນການຢູ່ເບື້ອງຫຼັງ. ຫລັງຈາກນັ້ນທ່ານສາມາດອອກຈາກລະບົບໄດ້ຢ່າງປອດໄພ.

ດ້ວຍ ຄຳ ສັ່ງ nohup ພວກເຮົາບອກຂັ້ນຕອນທີ່ຈະບໍ່ສົນໃຈສັນຍານ SIGHUP ເຊິ່ງຖືກສົ່ງໂດຍ session ssh ໃນການຢຸດ, ດັ່ງນັ້ນເຮັດໃຫ້ ຄຳ ສັ່ງດັ່ງກ່າວຍັງຄົງຢູ່ຕໍ່ໄປເຖິງແມ່ນວ່າຫຼັງຈາກເຂົ້າສູ່ລະບົບ. ໃນການອອກຈາກລະບົບການສັ່ງ ຄຳ ສັ່ງຈະຖືກກວດພົບຈາກການຄວບຄຸມຢູ່ປາຍຍອດແລະສືບຕໍ່ເຮັດວຽກໃນພື້ນຫລັງຄືກັບຂັ້ນຕອນຂອງ daemon.

ນີ້ແມ່ນສະຖານະການທີ່ງ່າຍດາຍເຊິ່ງພວກເຮົາໄດ້ ດຳ ເນີນການຊອກຫາ ຄຳ ສັ່ງເພື່ອຄົ້ນຫາເອກະສານໃນພື້ນຫລັງກ່ຽວກັບ ssh session ໂດຍໃຊ້ nohup, ຫຼັງຈາກນັ້ນວຽກໄດ້ຖືກສົ່ງໄປຫາພື້ນຫລັງດ້ວຍການກັບຄືນທັນທີໃຫ້ PID ແລະ ID ວຽກຂອງຂັ້ນຕອນ ([[ JOBID] PID) .

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

ເມື່ອທ່ານເຂົ້າສູ່ລະບົບອີກຄັ້ງ, ທ່ານສາມາດກວດເບິ່ງສະຖານະຂອງ ຄຳ ສັ່ງ, ນຳ ກັບໄປທີ່ພື້ນເຮືອນໂດຍໃຊ້ fg% JOBID ເພື່ອຕິດຕາມຄວາມຄືບ ໜ້າ ຂອງມັນແລະອື່ນໆ. ຂ້າງລຸ່ມນີ້, ຜົນໄດ້ຮັບສະແດງໃຫ້ເຫັນວ່າວຽກໄດ້ ສຳ ເລັດສົມບູນຍ້ອນວ່າມັນບໍ່ສະແດງໃນການເຂົ້າສູ່ລະບົບຄືນ ໃໝ່, ແລະໄດ້ໃຫ້ຜົນຜະລິດທີ່ສະແດງອອກມາ.

# fg %JOBID

ອີກວິທີ ໜຶ່ງ ທີ່ສະຫງ່າງາມໃນການປ່ອຍໃຫ້ ຄຳ ສັ່ງຂອງທ່ານຫລື ໜ້າ ທີ່ດຽວເຮັດວຽກຢູ່ໃນພື້ນຫລັງແລະຍັງມີຊີວິດຢູ່ເຖິງແມ່ນວ່າຫລັງຈາກການອອກຈາກລະບົບຫລືການຕັດການ ນຳ ໃຊ້ແມ່ນການໃຊ້ປະຕິເສດ.

ປະຕິເສດ, ເອົາວຽກອອກຈາກບັນຊີລາຍຊື່ວຽກງານຂອງລະບົບ, ສະນັ້ນຂັ້ນຕອນດັ່ງກ່າວຈະຖືກປ້ອງກັນຈາກການຖືກຂ້າໃນລະຫວ່າງການຕັດຕໍ່ກອງປະຊຸມເພາະວ່າມັນຈະບໍ່ໄດ້ຮັບ SIGHUP ໂດຍຫອຍເມື່ອທ່ານອອກຈາກລະບົບ.

ຂໍ້ເສຍປຽບຂອງວິທີການນີ້ແມ່ນວ່າ, ມັນຄວນຈະຖືກ ນຳ ໃຊ້ ສຳ ລັບວຽກທີ່ບໍ່ ຈຳ ເປັນຕ້ອງມີການປ້ອນຂໍ້ມູນໃດໆຈາກ stdin ແລະບໍ່ ຈຳ ເປັນຕ້ອງຂຽນເຖິງ stdout, ເວັ້ນເສຍແຕ່ວ່າທ່ານຈະປ່ຽນເສັ້ນທາງເຂົ້າແລະຜົນງານໂດຍສະເພາະເພາະວ່າໃນເວລາທີ່ວຽກຈະພະຍາຍາມພົວພັນກັບ stdin ຫຼື stdout, ມັນຈະຢຸດ.

ຂ້າງລຸ່ມນີ້, ພວກເຮົາໄດ້ສົ່ງ ຄຳ ສັ່ງ ping ໄປຍັງພື້ນຖານເພື່ອໃຫ້ທ່ານສືບຕໍ່ເຮັດວຽກແລະຖືກລຶບອອກຈາກລາຍຊື່ວຽກ. ດັ່ງທີ່ເຫັນ, ວຽກໄດ້ຖືກໂຈະເປັນຄັ້ງ ທຳ ອິດ, ຫລັງຈາກນັ້ນມັນກໍ່ຍັງຢູ່ໃນບັນຊີວຽກເຮັດງານ ທຳ ຄື ID ປະມວນຜົນ: 15368.

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

ຫຼັງຈາກສັນຍານທີ່ປະຕິເສດນັ້ນໄດ້ຖືກສົ່ງໄປຫາວຽກ, ແລະມັນຖືກລຶບອອກຈາກລາຍຊື່ວຽກ, ເຖິງແມ່ນວ່າມັນຍັງແລ່ນຢູ່ໃນພື້ນຫລັງ. ວຽກຍັງຈະເຮັດວຽກຢູ່ໃນເວລາທີ່ທ່ານຈະເຂົ້າສູ່ລະບົບກັບເຊີບເວີ ໃໝ່ ຄືກັບທີ່ເຫັນຢູ່ທາງລຸ່ມ.

$ ps -ef | grep ping

ຜົນປະໂຫຍດອີກອັນ ໜຶ່ງ ເພື່ອບັນລຸພຶດຕິ ກຳ ທີ່ ຈຳ ເປັນແມ່ນຊຸດໂຊມ. Nohup ມີຂໍ້ເສຍປຽບໃນແງ່ທີ່ວ່າກຸ່ມການເຮັດວຽກຂອງຂະບວນການຍັງຄືເກົ່າດັ່ງນັ້ນຂັ້ນຕອນທີ່ແລ່ນກັບ nohup ແມ່ນມີຄວາມສ່ຽງຕໍ່ສັນຍານໃດໆທີ່ຖືກສົ່ງໄປຫາກຸ່ມຂະບວນການທັງ ໝົດ (ເຊັ່ນ Ctrl + C ).

setid ໃນອີກດ້ານ ໜຶ່ງ ຈັດສັນກຸ່ມຂະບວນການ ໃໝ່ ໃຫ້ແກ່ຂະບວນການທີ່ຖືກປະຕິບັດແລະເພາະສະນັ້ນ, ຂະບວນການທີ່ສ້າງຂື້ນແມ່ນທັງ ໝົດ ໃນກຸ່ມຂະບວນການທີ່ຈັດສັນ ໃໝ່ ແລະສາມາດປະຕິບັດໄດ້ຢ່າງປອດໄພໂດຍບໍ່ຕ້ອງຢ້ານວ່າຈະຖືກຂ້າຕາຍເຖິງແມ່ນວ່າຫຼັງຈາກເຂົ້າສູ່ລະບົບ.

ໃນນີ້, ມັນສະແດງໃຫ້ເຫັນວ່າຂະບວນການ ‘ນອນ 10m code ຖືກແຍກອອກຈາກທ່າຄວບຄຸມ, ຕັ້ງແຕ່ເວລາສ້າງ.

$ setsid sleep 10m
$ ps -ef | grep sleep

ດຽວນີ້, ເມື່ອທ່ານເຂົ້າສູ່ລະບົບ ໃໝ່, ທ່ານຈະຍັງພົບວ່າຂະບວນການນີ້ ກຳ ລັງ ດຳ ເນີນຢູ່.

$ ps -ef | grep [s]leep

ສະຫຼຸບ

ມີວິທີໃດແດ່ທີ່ທ່ານສາມາດຄິດເພື່ອເຮັດໃຫ້ຂະບວນການຂອງທ່ານ ດຳ ເນີນການໄດ້ເຖິງແມ່ນວ່າຫລັງຈາກທ່ານອອກຈາກລະບົບ SSH? ຖ້າມີວິທີອື່ນໃດທີ່ມີປະສິດຕິພາບແລະມີປະສິດຕິພາບທີ່ທ່ານສາມາດຄິດ, ໃຫ້ເວົ້າໃນ ຄຳ ເຫັນຂອງທ່ານ.