ຄວາມເຂົ້າໃຈແລະການຮຽນຮູ້ຂັ້ນພື້ນຖານຂອງການຂຽນແລະການແກ້ໄຂບັນຫາກ່ຽວກັບລະບົບແຟ້ມ Linux - ພາກທີ 10

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

ກວດເບິ່ງວິດີໂອຕໍ່ໄປນີ້ທີ່ ນຳ ພາທ່ານແນະ ນຳ ກ່ຽວກັບໂປແກຼມການຢັ້ງຢືນມູນນິທິ Linux.

ນີ້ແມ່ນບົດຂຽນສຸດທ້າຍ (ພາກທີ 10) ຂອງປື້ມຍາວ 10-tutorial ປະຈຸບັນ. ໃນບົດຄວາມນີ້ພວກເຮົາຈະສຸມໃສ່ພື້ນຖານການຂຽນ ໜັງ ສືຫອຍແລະການແກ້ໄຂບັນຫາລະບົບເອກະສານ Linux. ທັງສອງຫົວຂໍ້ແມ່ນມີຄວາມ ຈຳ ເປັນ ສຳ ລັບການສອບເສັງຢັ້ງຢືນ LFCS.

ເຂົ້າໃຈສະຖານີແລະຫອຍ

ໃຫ້ອະທິບາຍແນວຄວາມຄິດສອງສາມຢ່າງກ່ອນອື່ນ ໝົດ.

<

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

    • ເມື່ອພວກເຮົາເລີ່ມແກະໂຕ ທຳ ອິດ, ມັນ ນຳ ສະ ເໜີ ຄຳ ສັ່ງ ຄຳ ສັ່ງ (ເຊິ່ງເອີ້ນວ່າເສັ້ນ ຄຳ ສັ່ງ) ເຊິ່ງບອກພວກເຮົາວ່າຫອຍກຽມພ້ອມທີ່ຈະເລີ່ມຮັບເອົາ ຄຳ ສັ່ງຈາກອຸປະກອນປ້ອນມາດຕະຖານຂອງມັນ, ເຊິ່ງປົກກະຕິແລ້ວແມ່ນແປ້ນພິມ.

    ທ່ານອາດຈະຕ້ອງການອ້າງອີງເຖິງບົດຂຽນອື່ນໃນຊຸດນີ້ (ໃຊ້ Command ເພື່ອສ້າງ, ແກ້ໄຂແລະປັບປຸງເອກະສານ - ພາກ 1) ເພື່ອທົບທວນ ຄຳ ສັ່ງບາງຢ່າງທີ່ເປັນປະໂຫຍດ.

    Linux ໃຫ້ຫລາຍໆທາງເລືອກ ສຳ ລັບຫອຍ, ສິ່ງຕໍ່ໄປນີ້ແມ່ນສິ່ງທີ່ພົບເລື້ອຍທີ່ສຸດ:

    Bash ໝາຍ ເຖິງ Bourne Again Shell ແລະແມ່ນຫອຍເລີ່ມຕົ້ນຂອງ GNU Project. ມັນປະກອບມີຄຸນລັກສະນະທີ່ເປັນປະໂຫຍດຈາກຫອຍ Korn (ksh) ແລະ C shell (csh), ເຊິ່ງສະ ເໜີ ການປັບປຸງຫຼາຍໆຄັ້ງໃນເວລາດຽວກັນ. ນີ້ແມ່ນເປືອກຫອຍທີ່ໃຊ້ໂດຍການແຈກຢາຍທີ່ຖືກປົກຄຸມໃນໃບຢັ້ງຢືນ LFCS, ແລະມັນແມ່ນຫອຍທີ່ພວກເຮົາຈະ ນຳ ໃຊ້ໃນບົດແນະ ນຳ ນີ້.

    The Bourne SHell ແມ່ນຫອຍທີ່ເກົ່າແກ່ທີ່ສຸດແລະດັ່ງນັ້ນຈິ່ງໄດ້ເປັນແກະສະຫຼັກຂອງລະບົບປະຕິບັດການທີ່ຄ້າຍຄືກັບ UNIX ເປັນເວລາຫຼາຍປີ.

    The Korn SHell ແມ່ນຫອຍ Unix ທີ່ຖືກພັດທະນາໂດຍ David Korn ທີ່ Bell Labs ໃນຕົ້ນຊຸມປີ 1980. ມັນແມ່ນດ້ານຫລັງກັບເຂົ້າກັນໄດ້ກັບເປືອກ Bourne ແລະປະກອບມີຫຼາຍລັກສະນະຂອງຫອຍ C.

    ສະຄິບຫອຍແມ່ນບໍ່ມີຫຍັງອີກແລະບໍ່ມີຫຍັງຫນ້ອຍກ່ວາເອກະສານຂໍ້ຄວາມທີ່ຫັນເປັນໂປແກຼມທີ່ສາມາດປະຕິບັດໄດ້ເຊິ່ງປະສົມປະສານກັບ ຄຳ ສັ່ງທີ່ຖືກປະຕິບັດໂດຍແກະພາຍຫຼັງ.

    Shell ຂັ້ນພື້ນຖານ

    ດັ່ງທີ່ໄດ້ກ່າວມາກ່ອນ ໜ້າ ນີ້, ໜັງ ສືແກະຈະເກີດເປັນເອກະສານຂໍ້ຄວາມ ທຳ ມະດາ. ດັ່ງນັ້ນ, ສາມາດສ້າງແລະແກ້ໄຂໂດຍໃຊ້ບັນນາທິການຕົວ ໜັງ ສືທີ່ເຮົາຕ້ອງການ. ທ່ານອາດຈະຕ້ອງການພິຈາລະນາໃຊ້ vi/m (ອ້າງເຖິງການ ນຳ ໃຊ້ vi Editor - ພາກທີ 2 ຂອງຊຸດນີ້), ເຊິ່ງມີການເນັ້ນໄວຍາກອນເພື່ອຄວາມສະດວກສະບາຍຂອງທ່ານ.

    ພິມ ຄຳ ສັ່ງຕໍ່ໄປນີ້ເພື່ອສ້າງແຟ້ມຊື່ myscript.sh ແລ້ວກົດ Enter.

    # vim myscript.sh

    ແຖວ ທຳ ອິດຂອງສະຄິບຫອຍຕ້ອງເປັນດັ່ງຕໍ່ໄປນີ້ (ທີ່ເອີ້ນວ່າ shebang ).

    #!/bin/bash

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

    ດຽວນີ້ເຖິງເວລາແລ້ວທີ່ຕ້ອງເພີ່ມ ຄຳ ສັ່ງຂອງພວກເຮົາ. ພວກເຮົາສາມາດຊີ້ແຈງຈຸດປະສົງຂອງ ຄຳ ສັ່ງແຕ່ລະ ຄຳ ຫລືອັກສອນທັງ ໝົດ ໂດຍການເພີ່ມ ຄຳ ເຫັນເຊັ່ນກັນ. ໃຫ້ສັງເກດວ່າຫອຍບໍ່ສົນໃຈສາຍເຫຼົ່ານັ້ນເລີ່ມຕົ້ນດ້ວຍເຄື່ອງ ໝາຍ ປອນ # (ມີ ຄຳ ເຫັນອະທິບາຍ).

    #!/bin/bash
echo This is Part 10 of the 10-article series about the LFCS certification
echo Today is $(date +%Y-%m-%d)

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

    # chmod 755 myscript.sh

    ກ່ອນທີ່ຈະ ດຳ ເນີນການສະຄິບຂອງພວກເຮົາ, ພວກເຮົາ ຈຳ ເປັນຕ້ອງເວົ້າສອງສາມ ຄຳ ກ່ຽວກັບຕົວປ່ຽນແປງສະພາບແວດລ້ອມ $PATH . ຖ້າພວກເຮົາແລ່ນ,

    echo $PATH

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

    ເມື່ອພວກເຮົາພິມ ຄຳ ສັ່ງແລະກົດ Enter, ຫອຍນາງຄົ້ນຫາໃນໄດເລກະທໍລີທັງ ໝົດ ທີ່ລະບຸໄວ້ໃນຕົວແປ $PATH ແລະປະຕິບັດຕົວຢ່າງ ທຳ ອິດທີ່ພົບ. ໃຫ້ເບິ່ງຕົວຢ່າງ,

    ຖ້າມີສອງແຟ້ມທີ່ສາມາດປະຕິບັດໄດ້ທີ່ມີຊື່ດຽວກັນ, ໜຶ່ງ ໃນ /usr/local/bin ແລະອີກອັນ ໜຶ່ງ ໃນ /usr/bin , ເອກະສານ ໜຶ່ງ ໃນໄດເລກະທໍລີ ທຳ ອິດຈະຖືກປະຕິບັດ ກ່ອນອື່ນ ໝົດ, ສ່ວນອີກຝ່າຍ ໜຶ່ງ ຈະບໍ່ເອົາໃຈໃສ່.

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

    # pwd
# ./myscript.sh
# cp myscript.sh ../bin
# cd ../bin
# pwd
# myscript.sh

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

    if CONDITION; then 
	COMMANDS;
else
	OTHER-COMMANDS 
fi

    ບ່ອນທີ່ CONDITION ສາມາດເປັນ ໜຶ່ງ ໃນບັນດາສິ່ງຕໍ່ໄປນີ້ (ພຽງແຕ່ມີເງື່ອນໄຂເລື້ອຍໆທີ່ກ່າວມານີ້) ແລະປະເມີນຄວາມຈິງເມື່ອ:

    <

  • [-a file] →ມີຢູ່ແລ້ວ.
  • [-d file] →ໄຟລ໌ມີຢູ່ແລະເປັນໄດເລກະທໍລີ.
  • [-f file] →ມີຢູ່ແລະເປັນເອກະສານປົກກະຕິ.
  • [-u file] →ເອກະສານມີຢູ່ແລ້ວແລະມັນ SUID (ຕັ້ງຊື່ຜູ້ໃຊ້ ID) ເລັກນ້ອຍຖືກຕັ້ງຄ່າ.
  • [-g file] →ມີເອກະສານແລະ SGID ບິດຂອງມັນຖືກຕັ້ງຄ່າ.
  • [-k file] →ມີຢູ່ແລ້ວແລະມັນຖືກ ກຳ ນົດໄວ້.
  • [-r file] →ມີຢູ່ແລະສາມາດອ່ານໄດ້.
  • [-s file] →ເອກະສານມີຢູ່ແລະບໍ່ແມ່ນຫວ່າງ.
  • [-w file] →ມີໄຟລ໌ແລະສາມາດຂຽນໄດ້.
  • [-x file] ແມ່ນຄວາມຈິງຖ້າມີເອກະສານຢູ່ແລະ ດຳ ເນີນການໄດ້.
  • [string1 = string2] str ສາຍເຊືອກແມ່ນເທົ່າກັນ.
  • [string1! = string2] →ສາຍເຊືອກບໍ່ເທົ່າກັນ.

    • [int1 op int2] ຄວນເປັນສ່ວນ ໜຶ່ງ ຂອງບັນຊີກ່ອນ ໜ້າ ນີ້, ໃນຂະນະທີ່ສິນຄ້າທີ່ຕິດຕາມ (ຕົວຢ່າງ, -eq -> ແມ່ນຄວາມຈິງຖ້າ int1 > ເທົ່າກັບ int2 .) ຄວນເປັນ " ເດັກ " ຂອງລາຍຊື່ [ int1 op int2 ] ບ່ອນທີ່ op ແມ່ນ ໜຶ່ງ ໃນຜູ້ປະຕິບັດການປຽບທຽບຕໍ່ໄປນີ້.

    <

  • -eq -> ແມ່ນຄວາມຈິງຖ້າ int1 ເທົ່າກັບ int2.
  • -ne -> ຄວາມຈິງຖ້າ int1 ບໍ່ເທົ່າກັບ int2.
  • -lt -> ທີ່ແທ້ຈິງຖ້າ int1 ໜ້ອຍ ກວ່າ int2.
  • -le -> ທີ່ແທ້ຈິງຖ້າ int1 ໜ້ອຍ ກວ່າຫຼືເທົ່າກັບ int2.
  • -gt -> ຄວາມຈິງຖ້າ int1 ໃຫຍ່ກວ່າ int2.
  • - - - ທີ່ແທ້ຈິງຖ້າ int1 ໃຫຍ່ກວ່າຫຼືເທົ່າກັບ int2.

    • loop ນີ້ອະນຸຍາດໃຫ້ປະຕິບັດ ຄຳ ສັ່ງ ໜຶ່ງ ຫຼືຫຼາຍ ຄຳ ສຳ ລັບແຕ່ລະຄ່າໃນບັນຊີຂອງຄ່າຕ່າງໆ. syntax ພື້ນຖານຂອງມັນແມ່ນ:

    for item in SEQUENCE; do 
		COMMANDS; 
done

    ບ່ອນທີ່ ລາຍການ ແມ່ນຕົວແປທົ່ວໄປທີ່ເປັນຕົວແທນຂອງແຕ່ລະຄ່າໃນ SEQUENCE ໃນແຕ່ລະຄັ້ງ.

    loop ນີ້ອະນຸຍາດໃຫ້ປະຕິບັດຊຸດ ຄຳ ສັ່ງທີ່ຊ້ ຳ ແລ້ວຕາບໃດທີ່ ຄຳ ສັ່ງຄວບຄຸມ ດຳ ເນີນການດ້ວຍສະຖານະການອອກເທົ່າກັບເລກສູນ (ປະສົບຜົນ ສຳ ເລັດ). syntax ພື້ນຖານຂອງມັນແມ່ນ:

    while EVALUATION_COMMAND; do 
		EXECUTE_COMMANDS; 
done

    ບ່ອນທີ່ EVALUATION_COMMAND ສາມາດເປັນ ຄຳ ສັ່ງໃດໆທີ່ສາມາດອອກມາດ້ວຍຜົນ ສຳ ເລັດ ( 0 ) ຫຼືຄວາມລົ້ມເຫຼວ (ນອກ ເໜືອ ຈາກ 0) , ແລະ EXECUTE_COMMANDS ສາມາດເປັນໂປແກຼມໃດກໍ່ຕາມ, ສະຄິບຫລືໂຄງສ້າງແກະ, ລວມທັງວົງແຫວນທີ່ມີຮັງ.

    ພວກເຮົາຈະສະແດງໃຫ້ເຫັນການ ນຳ ໃຊ້ຂອງ if if construction ແລະ for loop ດ້ວຍຕົວຢ່າງຕໍ່ໄປນີ້.

    ສ້າງເອກະສານພ້ອມດ້ວຍລາຍການບໍລິການທີ່ພວກເຮົາຕ້ອງການຕິດຕາມເບິ່ງທັນທີ.

    # cat myservices.txt

sshd
mariadb
httpd
crond
firewalld

    ສະຄິບແກະຂອງພວກເຮົາຄວນເບິ່ງຄືວ່າ.

    #!/bin/bash

# This script iterates over a list of services and
# is used to determine whether they are running or not.

for service in $(cat myservices.txt); do
    	systemctl status $service | grep --quiet "running"
    	if [ $? -eq 0 ]; then
            	echo $service "is [ACTIVE]"
    	else
            	echo $service "is [INACTIVE or NOT INSTALLED]"
    	fi
done

    1). The for loop ອ່ານ myservices.txt ຍື່ນ ໜຶ່ງ ສ່ວນຂອງ LIST ໃນແຕ່ລະຄັ້ງ. ອົງປະກອບດຽວນັ້ນຖືກສະແດງໂດຍຕົວປ່ຽນແປງທົ່ວໄປທີ່ມີຊື່ວ່າການບໍລິການ. The LIST ແມ່ນປະຊາກອນທີ່ມີຜົນຜະລິດຈາກ,

    # cat myservices.txt

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

    3). ສຳ ລັບແຕ່ລະອົງປະກອບຂອງ LIST (ໝາຍ ເຖິງທຸກໆຕົວຢ່າງຂອງຕົວແປບໍລິການ), ຄຳ ສັ່ງຕໍ່ໄປນີ້ຈະຖືກປະຕິບັດ.

    # systemctl status $service | grep --quiet "running"

    ເວລານີ້ພວກເຮົາ ຈຳ ເປັນຕ້ອງໄດ້ປ່ຽນແປງຕົວປ່ຽນແປງແບບ ທຳ ມະດາຂອງພວກເຮົາ (ເຊິ່ງເປັນຕົວແທນຂອງແຕ່ລະອົງປະກອບໃນ LIST ) ດ້ວຍສັນຍາລັກເງິນໂດລາເພື່ອສະແດງວ່າມັນມີຕົວແປແລະດັ່ງນັ້ນຄຸນຄ່າຂອງມັນໃນແຕ່ລະ iteration ຄວນຖືກ ນຳ ໃຊ້. ຜົນຜະລິດຫຼັງຈາກນັ້ນຖືກສົ່ງໄປ grep.

    ທຸງ quiet ຖືກໃຊ້ເພື່ອປ້ອງກັນ grep ຈາກການສະແດງຢູ່ ໜ້າ ຈໍຂອງສາຍທີ່ ຄຳ ວ່າແລ່ນຈະປາກົດ. ເມື່ອເປັນແນວນັ້ນ, ຄຳ ສັ່ງຂ້າງເທິງຈະກັບຄືນສະຖານະການທາງອອກຂອງ 0 (ເຊິ່ງສະແດງໂດຍ $? ໃນຖ້າສ້າງ), ດັ່ງນັ້ນການກວດສອບວ່າການບໍລິການ ກຳ ລັງ ດຳ ເນີນການຢູ່.

    ສະຖານະການອອກທີ່ແຕກຕ່າງຈາກ 0 (ໝາຍ ຄວາມວ່າການ ຄຳ ສັບ ທີ່ ກຳ ລັງແລ່ນຢູ່ບໍ່ພົບໃນຜົນຜະລິດຂອງ ລະບົບສະຖານະ $service ) ສະແດງວ່າການບໍລິການບໍ່ແມ່ນ ແລ່ນ.

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

    #!/bin/bash

# This script iterates over a list of services and
# is used to determine whether they are running or not.

if [ -f myservices.txt ]; then
    	for service in $(cat myservices.txt); do
            	systemctl status $service | grep --quiet "running"
            	if [ $? -eq 0 ]; then
                    	echo $service "is [ACTIVE]"
            	else
                    	echo $service "is [INACTIVE or NOT INSTALLED]"
            	fi
    	done
else
    	echo "myservices.txt is missing"
fi

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

    ຄຳ ສັ່ງທີ່ຂຽນໄວ້ໃນ shell ບອກໃນຂະນະທີ່ loop ອ່ານ myhosts ຕາມ ລຳ ດັບແລະ ກຳ ຫນົດເນື້ອຫາຂອງແຕ່ລະສາຍໃຫ້ເປັນ host host ເຊິ່ງຕໍ່ມາຈະຖືກສົ່ງໄປທີ່ ping .

    #!/bin/bash

# This script is used to demonstrate the use of a while loop

while read host; do
    	ping -c 2 $host
done < myhosts

    ອ່ານຍັງ :

    <

  • ຮຽນຮູ້ Shell Scripting: ຄູ່ມືຈາກ Newbies ກັບຜູ້ເບິ່ງແຍງລະບົບ
  • 5 ສະຄິບ Shell ເພື່ອຮຽນຮູ້ການຂຽນໂປແກຼມ Shell

    • ການແກ້ໄຂບັນຫາຂອງລະບົບແຟ້ມ

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

    ນອກຈາກນັ້ນ, ໃນແຕ່ລະຄັ້ງທີ່ລະບົບເລີ່ມຕົ້ນໃນຊ່ວງເກີບປົກກະຕິ, ມັນຈະກວດສອບຄວາມສົມບູນຂອງລະບົບແຟ້ມກ່ອນທີ່ຈະຕິດຕັ້ງມັນ. ໃນທັງສອງກໍລະນີນີ້ແມ່ນປະຕິບັດໂດຍໃຊ້ເຄື່ອງມືທີ່ມີຊື່ວ່າ fsck (“ ກວດສອບລະບົບແຟ້ມເອກະສານ ”).

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

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

    syntax ພື້ນຖານຂອງ fsck ແມ່ນດັ່ງຕໍ່ໄປນີ້:

    # fsck [options] filesystem

    ເພື່ອກວດກາລະບົບແຟ້ມເອກະສານດ້ວຍ fsck, ກ່ອນອື່ນ ໝົດ ພວກເຮົາຕ້ອງຖອດມັນອອກ.

    # mount | grep sdg1
# umount /mnt
# fsck -y /dev/sdg1

    ນອກ ເໜືອ ຈາກທຸງ -y , ພວກເຮົາສາມາດໃຊ້ຕົວເລືອກ -a ເພື່ອແກ້ໄຂລະບົບແຟ້ມເອກະສານໂດຍອັດຕະໂນມັດໂດຍບໍ່ຕ້ອງຖາມ ຄຳ ຖາມໃດໆ, ແລະບັງຄັບໃຫ້ມີການກວດກາເຖິງແມ່ນວ່າລະບົບແຟ້ມເອກະສານເບິ່ງຄືວ່າສະອາດ.

    # fsck -af /dev/sdg1

    ຖ້າພວກເຮົາສົນໃຈພຽງແຕ່ຊອກຫາສິ່ງທີ່ຜິດພາດ (ໂດຍບໍ່ຕ້ອງພະຍາຍາມແກ້ໄຂຫຍັງໃນເວລານີ້) ພວກເຮົາສາມາດແລ່ນ fsck ດ້ວຍຕົວເລືອກ -n ເຊິ່ງຈະສົ່ງຜົນໃຫ້ບັນຫາຂອງລະບົບແຟ້ມຂໍ້ມູນໃຫ້ຜົນຜະລິດຕາມມາດຕະຖານ.

    # fsck -n /dev/sdg1

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

    ບົດສະຫຼຸບ

    ພວກເຮົາໄດ້ມາຮອດຕອນທ້າຍຂອງຊຸດ 10-Article ນີ້ເຊິ່ງໄດ້ພະຍາຍາມປົກປິດຄວາມສາມາດພື້ນຖານຂອງໂດເມນທີ່ຕ້ອງການເພື່ອສອບເສັງ LFCS .

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

    ຖ້າທ່ານມີ ຄຳ ຖາມຫຼື ຄຳ ເຫັນໃດໆ, ພວກເຂົາຍິນດີຕ້ອນຮັບສະ ເໝີ - ສະນັ້ນຢ່າລັງເລໃຈທີ່ຈະຖີ້ມສາຍຂອງພວກເຮົາຜ່ານແບບຟອມລຸ່ມນີ້!