അടിസ്ഥാന ഷെൽ സ്ക്രിപ്റ്റിംഗും ലിനക്സ് ഫയൽസിസ്റ്റം ട്രബിൾഷൂട്ടിംഗും മനസ്സിലാക്കുകയും പഠിക്കുകയും ചെയ്യുക - ഭാഗം 10

ലിനക്സ് ഫൗണ്ടേഷൻ LFCS സർട്ടിഫിക്കേഷൻ (Linux Foundation Certified Sysadmin) സമാരംഭിച്ചു. ലിനക്സ് സിസ്റ്റങ്ങൾക്കുള്ള പ്രവർത്തന പിന്തുണ, അതിൽ റണ്ണിംഗ് സിസ്റ്റങ്ങളെയും സേവനങ്ങളെയും പിന്തുണയ്ക്കുന്നു, മൊത്തത്തിലുള്ള നിരീക്ഷണത്തിനും വിശകലനത്തിനും ഒപ്പം ഉയർന്ന പിന്തുണാ ടീമുകൾക്ക് പ്രശ്uനങ്ങൾ ഉന്നയിക്കുമ്പോൾ മികച്ച തീരുമാനമെടുക്കൽ എന്നിവയും ഉൾപ്പെടുന്നു.

ലിനക്സ് ഫൗണ്ടേഷൻ സർട്ടിഫിക്കേഷൻ പ്രോഗ്രാമിലേക്കുള്ള ഒരു ആമുഖം നിങ്ങളെ നയിക്കുന്ന വീഡിയോ പരിശോധിക്കുക.

നിലവിലെ 10-ട്യൂട്ടോറിയൽ ദൈർഘ്യമേറിയ പരമ്പരയുടെ അവസാന ലേഖനമാണിത് (ഭാഗം 10). ഈ ലേഖനത്തിൽ ഞങ്ങൾ അടിസ്ഥാന ഷെൽ സ്ക്രിപ്റ്റിംഗിലും ലിനക്സ് ഫയൽ സിസ്റ്റങ്ങളുടെ ട്രബിൾഷൂട്ടിംഗിലും ശ്രദ്ധ കേന്ദ്രീകരിക്കും. LFCS സർട്ടിഫിക്കേഷൻ പരീക്ഷയ്ക്ക് രണ്ട് വിഷയങ്ങളും ആവശ്യമാണ്.

ടെർമിനലുകളും ഷെല്ലുകളും മനസ്സിലാക്കുന്നു

ആദ്യം കുറച്ച് ആശയങ്ങൾ വ്യക്തമാക്കാം.

1. കമാൻഡുകൾ എടുത്ത് അവ പ്രവർത്തിപ്പിക്കേണ്ട ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന് നൽകുന്ന ഒരു പ്രോഗ്രാമാണ് ഷെൽ.
2. അവസാന ഉപയോക്താക്കളായ ഞങ്ങളെ ഷെല്ലുമായി സംവദിക്കാൻ അനുവദിക്കുന്ന ഒരു പ്രോഗ്രാമാണ് ടെർമിനൽ. ഒരു ടെർമിനലിന്റെ ഒരു ഉദാഹരണം ഗ്നോം ടെർമിനലാണ്, ചുവടെയുള്ള ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നത്.

നമ്മൾ ആദ്യം ഒരു ഷെൽ ആരംഭിക്കുമ്പോൾ, അത് ഒരു കമാൻഡ് പ്രോംപ്റ്റ് (കമാൻഡ് ലൈൻ എന്നും അറിയപ്പെടുന്നു) അവതരിപ്പിക്കുന്നു, ഇത് സാധാരണയായി കീബോർഡായ അതിന്റെ സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് ഉപകരണത്തിൽ നിന്ന് കമാൻഡുകൾ സ്വീകരിക്കാൻ ഷെൽ തയ്യാറാണെന്ന് നമ്മോട് പറയുന്നു.

ചില ഉപയോഗപ്രദമായ കമാൻഡുകൾ അവലോകനം ചെയ്യുന്നതിന് ഈ പരമ്പരയിലെ മറ്റൊരു ലേഖനം (ഫയലുകൾ സൃഷ്uടിക്കാനും എഡിറ്റ് ചെയ്യാനും കൈകാര്യം ചെയ്യാനും കമാൻഡ് ഉപയോഗിക്കുക - ഭാഗം 1) നിങ്ങൾക്ക് റഫർ ചെയ്യാൻ താൽപ്പര്യമുണ്ടാകാം.

Linux ഷെല്ലുകൾക്കായി നിരവധി ഓപ്ഷനുകൾ നൽകുന്നു, ഇനിപ്പറയുന്നവയാണ് ഏറ്റവും സാധാരണമായത്:

Bash എന്നത് Bourne Again SHell എന്നതിന്റെ ചുരുക്കപ്പേരാണ്, ഇത് GNU പ്രോജക്റ്റിന്റെ സ്ഥിരസ്ഥിതി ഷെല്ലാണ്. ഒരേ സമയം നിരവധി മെച്ചപ്പെടുത്തലുകൾ വാഗ്ദാനം ചെയ്യുന്ന കോർൺ ഷെൽ (ksh), C ഷെൽ (csh) എന്നിവയിൽ നിന്നുള്ള ഉപയോഗപ്രദമായ സവിശേഷതകൾ ഇത് ഉൾക്കൊള്ളുന്നു. ഇത് LFCS സർട്ടിഫിക്കേഷനിൽ ഉൾപ്പെടുത്തിയിട്ടുള്ള വിതരണങ്ങൾ ഉപയോഗിക്കുന്ന ഡിഫോൾട്ട് ഷെല്ലാണ്, ഈ ട്യൂട്ടോറിയലിൽ ഞങ്ങൾ ഉപയോഗിക്കുന്ന ഷെല്ലാണിത്.

Bourne SHell ഏറ്റവും പഴയ ഷെല്ലാണ്, അതിനാൽ നിരവധി UNIX പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ ഡിഫോൾട്ട് ഷെല്ലാണ് വർഷങ്ങളായി.

1980-കളുടെ തുടക്കത്തിൽ ബെൽ ലാബിൽ ഡേവിഡ് കോർൺ വികസിപ്പിച്ചെടുത്ത ഒരു യുണിക്സ് ഷെല്ലാണ് കോൺ ഷെൽ. ഇത് ബോൺ ഷെല്ലുമായി പിന്നിലേക്ക്-അനുയോജ്യമാണ് കൂടാതെ സി ഷെല്ലിന്റെ നിരവധി സവിശേഷതകൾ ഉൾക്കൊള്ളുന്നു.

ഷെൽ സ്uക്രിപ്റ്റ് മറ്റൊന്നുമല്ല, ഷെൽ എക്uസിക്യൂട്ട് ചെയ്യുന്ന കമാൻഡുകൾ ഒന്നിന് പുറകെ ഒന്നായി സംയോജിപ്പിക്കുന്ന ഒരു എക്uസിക്യൂട്ടബിൾ പ്രോഗ്രാമായി മാറിയ ഒരു ടെക്uസ്uറ്റ് ഫയലിൽ കുറവല്ല.

അടിസ്ഥാന ഷെൽ സ്ക്രിപ്റ്റിംഗ്

നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, ഒരു ഷെൽ സ്ക്രിപ്റ്റ് ഒരു പ്ലെയിൻ ടെക്സ്റ്റ് ഫയലായി ജനിക്കുന്നു. അതിനാൽ, ഞങ്ങൾ തിരഞ്ഞെടുത്ത ടെക്സ്റ്റ് എഡിറ്റർ ഉപയോഗിച്ച് സൃഷ്ടിക്കാനും എഡിറ്റുചെയ്യാനും കഴിയും. നിങ്ങളുടെ സൗകര്യാർത്ഥം സിന്റാക്സ് ഹൈലൈറ്റിംഗ് ഫീച്ചർ ചെയ്യുന്ന vi/m (വി എഡിറ്ററിന്റെ ഉപയോഗം - ഈ സീരീസിന്റെ ഭാഗം 2 കാണുക) ഉപയോഗിക്കുന്നത് നിങ്ങൾക്ക് പരിഗണിക്കാവുന്നതാണ്.

myscript.sh എന്ന പേരിൽ ഒരു ഫയൽ ഉണ്ടാക്കാൻ താഴെ പറയുന്ന കമാൻഡ് ടൈപ്പ് ചെയ്ത് എന്റർ അമർത്തുക.

# vim myscript.sh

ഒരു ഷെൽ സ്uക്രിപ്റ്റിന്റെ ആദ്യ വരി ഇനിപ്പറയുന്നതായിരിക്കണം (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: ഡയറക്uടറികളുടെ കോളൺ-വേർതിരിക്കപ്പെട്ട ലിസ്റ്റ് കാണും. ഷെൽ പരിസ്ഥിതിയുടെ ഭാഗമായതിനാൽ ഇതിനെ പരിസ്ഥിതി വേരിയബിൾ എന്ന് വിളിക്കുന്നു - ഷെൽ ആദ്യം ആരംഭിക്കുമ്പോൾ ഷെല്ലിനും അതിന്റെ ചൈൽഡ് പ്രോസസ്സുകൾക്കും ലഭ്യമാകുന്ന ഒരു കൂട്ടം വിവരങ്ങൾ.

നമ്മൾ ഒരു കമാൻഡ് ടൈപ്പ് ചെയ്uത് എന്റർ അമർത്തുമ്പോൾ, PATH വേരിയബിളിൽ ലിസ്റ്റുചെയ്തിരിക്കുന്ന എല്ലാ ഡയറക്uടറികളിലും ഷെൽ തിരയുകയും ആദ്യം കണ്ടെത്തിയ ഉദാഹരണം നടപ്പിലാക്കുകയും ചെയ്യുന്നു. ഒരു ഉദാഹരണം നോക്കാം,

ഒരേ പേരിൽ രണ്ട് എക്സിക്യൂട്ടബിൾ ഫയലുകൾ ഉണ്ടെങ്കിൽ, ഒന്ന് /usr/local/bin ലും മറ്റൊന്ന് /usr/bin ലും, ആദ്യത്തെ ഡയറക്uടറിയിലുള്ളത് എക്uസിക്യൂട്ട് ചെയ്യപ്പെടും. ആദ്യം, മറ്റൊന്ന് അവഗണിക്കപ്പെടും.

PATH വേരിയബിളിൽ ലിസ്uറ്റ് ചെയ്uതിരിക്കുന്ന ഡയറക്uടറികളിലൊന്നിൽ സ്uക്രിപ്റ്റ് ഞങ്ങൾ സംരക്ഷിച്ചിട്ടില്ലെങ്കിൽ, അത് എക്uസിക്യൂട്ട് ചെയ്യുന്നതിന് ഞങ്ങൾ ഫയലിന്റെ പേരിൽ ./ ചേർക്കേണ്ടതുണ്ട്. അല്ലാത്തപക്ഷം, ഒരു സാധാരണ കമാൻഡ് ഉപയോഗിച്ച് നമുക്ക് അത് പ്രവർത്തിപ്പിക്കാൻ കഴിയും.

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

ഒരു കമാൻഡിന്റെ വിജയമോ പരാജയമോ കാരണം, ഒരു ഷെൽ സ്ക്രിപ്റ്റിൽ എടുക്കേണ്ട വിവിധ പ്രവർത്തന കോഴ്uസുകൾ നിങ്ങൾക്ക് വ്യക്തമാക്കേണ്ടിവരുമ്പോൾ, അത്തരം വ്യവസ്ഥകൾ നിർവചിക്കുന്നതിന് നിങ്ങൾ if നിർമ്മിതി ഉപയോഗിക്കും. അതിന്റെ അടിസ്ഥാന വാക്യഘടന ഇതാണ്:

if CONDITION; then 
	COMMANDS;
else
	OTHER-COMMANDS 
fi

CONDITION ഇനിപ്പറയുന്നവയിൽ ഒന്നാകാൻ കഴിയുന്നിടത്ത് (ഏറ്റവും പതിവ് വ്യവസ്ഥകൾ മാത്രം ഇവിടെ ഉദ്ധരിക്കുന്നു) കൂടാതെ എപ്പോൾ ശരിയാണെന്ന് വിലയിരുത്തുന്നു:

1. [ -a ഫയൽ ] → ഫയൽ നിലവിലുണ്ട്.
2. [ -d ഫയൽ ] → ഫയൽ നിലവിലുണ്ട്, അത് ഒരു ഡയറക്uടറിയാണ്.
3. [ -f ഫയൽ ] → ഫയൽ നിലവിലുണ്ട്, ഇത് ഒരു സാധാരണ ഫയലാണ്.
4. [ -u ഫയൽ ] →ഫയൽ നിലവിലുണ്ട്, അതിന്റെ SUID (സെറ്റ് യൂസർ ഐഡി) ബിറ്റ് സജ്ജീകരിച്ചിരിക്കുന്നു.
5. [ -g ഫയൽ ] →ഫയൽ നിലവിലുണ്ട്, അതിന്റെ SGID ബിറ്റ് സജ്ജീകരിച്ചിരിക്കുന്നു.
6. [ -k ഫയൽ ] →ഫയൽ നിലവിലുണ്ട്, അതിന്റെ സ്റ്റിക്കി ബിറ്റ് സജ്ജീകരിച്ചിരിക്കുന്നു.
7. [ -r ഫയൽ ] →ഫയൽ നിലവിലുണ്ട്, വായിക്കാനാവുന്നതുമാണ്.
8. [ -s ഫയൽ ]→ ഫയൽ നിലവിലുണ്ട്, അത് ശൂന്യമല്ല.
9. [ -w ഫയൽ ]→ഫയൽ നിലവിലുണ്ട്, അത് എഴുതാവുന്നതുമാണ്.
10. [ -x ഫയൽ ] ഫയൽ നിലവിലുണ്ടെങ്കിൽ അത് ശരിയാണ്.
11. [ string1 = string2 ] → സ്ട്രിംഗുകൾ തുല്യമാണ്.
12. [ string1 != string2 ] → സ്ട്രിംഗുകൾ തുല്യമല്ല.

[int1 op int2 ] മുമ്പത്തെ ലിസ്റ്റിന്റെ ഭാഗമായിരിക്കണം, അതേസമയം പിന്തുടരുന്ന ഇനങ്ങൾ (ഉദാഹരണത്തിന്, -eq –> int1 എന്നത് int2 ന് തുല്യമാണ്.) op എന്നിടത്ത് [ int1 op int2 ] ന്റെ കുട്ടികൾ ലിസ്റ്റ് ആയിരിക്കണം. ഇനിപ്പറയുന്ന താരതമ്യ ഓപ്പറേറ്ററുകളിൽ ഒന്നാണ്.

int1 int2 ന് തുല്യമാണെങ്കിൽ
1. -eq –> ശരിയാണ്.
int1 int2 ന് തുല്യമല്ലെങ്കിൽ
2. -ne –> true.
int1 int2 നേക്കാൾ കുറവാണെങ്കിൽ
3. -lt –> true.
int1 int2-നേക്കാൾ കുറവോ തുല്യമോ ആണെങ്കിൽ
4. -le –> true.
int1 int2 നേക്കാൾ വലുതാണെങ്കിൽ
5. -gt –> true.
int1 int2-നേക്കാൾ വലുതോ തുല്യമോ ആണെങ്കിൽ
6. -ge –> true.

മൂല്യങ്ങളുടെ പട്ടികയിൽ ഓരോ മൂല്യത്തിനും ഒന്നോ അതിലധികമോ കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യാൻ ഈ ലൂപ്പ് അനുവദിക്കുന്നു. അതിന്റെ അടിസ്ഥാന വാക്യഘടന ഇതാണ്:

for item in SEQUENCE; do 
		COMMANDS; 
done

ഓരോ ആവർത്തന സമയത്തും SEQUENCE എന്നതിലെ ഓരോ മൂല്യത്തെയും പ്രതിനിധീകരിക്കുന്ന ഒരു പൊതു വേരിയബിളാണ് ഇനം.

കൺട്രോൾ കമാൻഡ് പൂജ്യത്തിന് തുല്യമായ എക്uസിറ്റ് സ്റ്റാറ്റസ് ഉപയോഗിച്ച് എക്uസിറ്റ് ചെയ്യുന്നിടത്തോളം (വിജയകരമായി) ആവർത്തിച്ചുള്ള കമാൻഡുകളുടെ ഒരു ശ്രേണി എക്സിക്യൂട്ട് ചെയ്യാൻ ഈ ലൂപ്പ് അനുവദിക്കുന്നു. അതിന്റെ അടിസ്ഥാന വാക്യഘടന ഇതാണ്:

while EVALUATION_COMMAND; do 
		EXECUTE_COMMANDS; 
done

എവിടെ EVALUATION_COMMAND ഒരു വിജയത്തോടെയോ (0) പരാജയത്തോടെയോ (0) സ്റ്റാറ്റസ് കൂടാതെ EXECUTE_COMMANDS കൂടാതെ പുറത്തുകടക്കാൻ കഴിയുന്ന ഏത് കമാൻഡും (കൾ) ആകാം മറ്റ് നെസ്റ്റഡ് ലൂപ്പുകൾ ഉൾപ്പെടെ ഏതെങ്കിലും പ്രോഗ്രാമോ സ്ക്രിപ്റ്റോ ഷെൽ നിർമ്മാണമോ ആകാം.

ഇഫ് കൺസ്ട്രക്uറ്റിന്റെയും ഫോർ ലൂപ്പിന്റെയും ഉപയോഗം ഇനിപ്പറയുന്ന ഉദാഹരണത്തിലൂടെ ഞങ്ങൾ പ്രദർശിപ്പിക്കും.

ഒറ്റനോട്ടത്തിൽ നിരീക്ഷിക്കാൻ ആഗ്രഹിക്കുന്ന സേവനങ്ങളുടെ ഒരു ലിസ്റ്റ് ഉപയോഗിച്ച് നമുക്ക് ഒരു ഫയൽ സൃഷ്ടിക്കാം.

# 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). ഫോർ ലൂപ്പ് ഒരു സമയം ലിസ്റ്റിന്റെ ഒരു ഘടകം myservices.txt വായിക്കുന്നു. ആ ഒരൊറ്റ ഘടകത്തെ സൂചിപ്പിക്കുന്നു സേവനം എന്ന പേരുള്ള ജനറിക് വേരിയബിൾ. ഇനിപ്പറയുന്നതിന്റെ ഔട്ട്പുട്ട് ഉപയോഗിച്ച് ലിസ്റ്റ് ജനസംഖ്യയുള്ളതാണ്,

# cat myservices.txt

2). മുകളിലെ കമാൻഡ് പരാൻതീസിസിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, കൂടാതെ നമ്മൾ ആവർത്തിക്കുന്ന ലിസ്റ്റ് പോപ്പുലേറ്റ് ചെയ്യുന്നതിന് ഇത് മൂല്യനിർണ്ണയം നടത്തണമെന്ന് സൂചിപ്പിക്കാൻ ഒരു ഡോളർ ചിഹ്നത്തിന് മുമ്പായി നൽകിയിരിക്കുന്നു.

3). LIST ന്റെ ഓരോ ഘടകത്തിനും (സർവീസ് വേരിയബിളിന്റെ എല്ലാ ഉദാഹരണങ്ങളും അർത്ഥമാക്കുന്നത്), ഇനിപ്പറയുന്ന കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യും.

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

ഇത്തവണ ഒരു വേരിയബിളാണെന്ന് സൂചിപ്പിക്കാൻ ഒരു ഡോളർ ചിഹ്നം ഉപയോഗിച്ച് ഞങ്ങളുടെ ജനറിക് വേരിയബിളിന് (LIST ലെ ഓരോ ഘടകത്തെയും പ്രതിനിധീകരിക്കുന്ന) മുമ്പായി നൽകേണ്ടതുണ്ട്, അതിനാൽ ഓരോ ആവർത്തനത്തിലും അതിന്റെ മൂല്യം ഉപയോഗിക്കണം. ഔട്ട്പുട്ട് പിന്നീട് ഗ്രെപ്പിലേക്ക് പൈപ്പ് ചെയ്യുന്നു.

റണ്ണിംഗ് എന്ന വാക്ക് ദൃശ്യമാകുന്ന വരികൾ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുന്നതിൽ നിന്ന് -rep തടയാൻ –quiet ഫ്ലാഗ് ഉപയോഗിക്കുന്നു. അത് സംഭവിക്കുമ്പോൾ, മുകളിലെ കമാൻഡ് 0 എന്ന എക്uസിറ്റ് സ്റ്റാറ്റസ് നൽകുന്നു (ഇഫ് കൺസ്ട്രക്uറ്റിൽ $? പ്രതിനിധീകരിക്കുന്നു), അങ്ങനെ സേവനം പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു.

0 എന്നതിനേക്കാൾ വ്യത്യസ്uതമായ ഒരു എക്uസിറ്റ് സ്റ്റാറ്റസ് (systemctl status $service എന്നതിന്റെ ഔട്ട്uപുട്ടിൽ പദം റണ്ണിംഗ് കണ്ടെത്തിയില്ല എന്നർത്ഥം) സേവനം അല്ലെന്ന് സൂചിപ്പിക്കുന്നു പ്രവർത്തിക്കുന്ന.

ഫോർ ലൂപ്പിൽ പ്രവേശിക്കാൻ ശ്രമിക്കുന്നതിന് മുമ്പ് തന്നെ നമുക്ക് ഒരു പടി കൂടി മുന്നോട്ട് പോയി 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

നിങ്ങൾക്ക് ഒരു ടെക്uസ്uറ്റ് ഫയലിൽ ഹോസ്റ്റുകളുടെ ഒരു ലിസ്റ്റ് നിലനിർത്താനും അവ പിംഗ് ചെയ്യാവുന്നതാണോ അല്ലയോ എന്ന് ഇടയ്uക്കിടെ നിർണ്ണയിക്കാൻ ഒരു സ്uക്രിപ്റ്റ് ഉപയോഗിക്കാനും താൽപ്പര്യപ്പെട്ടേക്കാം (myhosts-ന്റെ ഉള്ളടക്കങ്ങൾ മാറ്റിസ്ഥാപിച്ച് സ്വയം ശ്രമിക്കുക. ).

റീഡ് ഷെൽ ബിൽറ്റ്-ഇൻ കമാൻഡ് മൈഹോസ്റ്റുകളെ വരിയായി വായിക്കാൻ while ലൂപ്പിനോട് പറയുകയും ഓരോ വരിയുടെയും ഉള്ളടക്കം വേരിയബിൾ ഹോസ്റ്റിലേക്ക് അസൈൻ ചെയ്യുകയും ചെയ്യുന്നു, അത് പിന്നീട് 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

ഇതും വായിക്കുക:

1. ഷെൽ സ്ക്രിപ്റ്റിംഗ് പഠിക്കുക: പുതുമുഖങ്ങളിൽ നിന്ന് സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്ററിലേക്കുള്ള ഒരു ഗൈഡ്
2. ഷെൽ പ്രോഗ്രാമിംഗ് പഠിക്കാനുള്ള 5 ഷെൽ സ്ക്രിപ്റ്റുകൾ

ഫയൽസിസ്റ്റം ട്രബിൾഷൂട്ടിംഗ്

ലിനക്സ് വളരെ സ്ഥിരതയുള്ള ഒരു ഓപ്പറേറ്റിംഗ് സിസ്റ്റമാണെങ്കിലും, ചില കാരണങ്ങളാൽ അത് തകരാറിലായാൽ (ഉദാഹരണത്തിന്, വൈദ്യുതി തടസ്സം കാരണം), നിങ്ങളുടെ ഒരു (അല്ലെങ്കിൽ അതിലധികമോ) ഫയൽ സിസ്റ്റങ്ങൾ ശരിയായി അൺമൗണ്ട് ചെയ്യപ്പെടില്ല, അങ്ങനെ Linux ചെയ്യുമ്പോൾ പിശകുകൾക്കായി സ്വയമേവ പരിശോധിക്കപ്പെടും. പുനരാരംഭിച്ചു.

കൂടാതെ, ഓരോ തവണയും ഒരു സാധാരണ ബൂട്ട് സമയത്ത് സിസ്റ്റം ബൂട്ട് ചെയ്യുമ്പോഴും, അത് മൌണ്ട് ചെയ്യുന്നതിനു മുമ്പ് ഫയൽ സിസ്റ്റങ്ങളുടെ സമഗ്രത പരിശോധിക്കുന്നു. രണ്ട് സാഹചര്യങ്ങളിലും ഇത് ചെയ്യുന്നത് fsck (\ഫയൽ സിസ്റ്റം പരിശോധന) എന്ന പേരിലുള്ള ഒരു ടൂൾ ഉപയോഗിച്ചാണ്.

fsck ഫയൽ സിസ്റ്റങ്ങളുടെ സമഗ്രത പരിശോധിക്കുന്നത് മാത്രമല്ല, കേടായ ഫയൽ സിസ്റ്റങ്ങൾ നന്നാക്കാൻ നിർദ്ദേശം നൽകിയാൽ അത് നന്നാക്കാനും ശ്രമിക്കും. നാശത്തിന്റെ തീവ്രതയെ ആശ്രയിച്ച്, fsck വിജയിച്ചേക്കാം അല്ലെങ്കിൽ വിജയിച്ചേക്കാം; അങ്ങനെ ചെയ്യുമ്പോൾ, വീണ്ടെടുക്കപ്പെട്ട ഫയലുകളുടെ ഭാഗങ്ങൾ ഓരോ ഫയൽ സിസ്റ്റത്തിന്റെയും റൂട്ടിൽ സ്ഥിതി ചെയ്യുന്ന നഷ്ടപ്പെട്ട+കണ്ടെത്തിയ ഡയറക്uടറിയിൽ സ്ഥാപിക്കും.

അവസാനമായി പക്ഷേ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഇപ്പോഴും യുഎസ്ബി ഡ്രൈവിലേക്ക് എഴുതുമ്പോൾ ഞങ്ങൾ ഒരു യുഎസ്ബി ഡ്രൈവ് നീക്കംചെയ്യാൻ ശ്രമിച്ചാൽ പൊരുത്തക്കേടുകൾ സംഭവിക്കാം, ഹാർഡ്uവെയർ തകരാറിലായേക്കാം.

fsck യുടെ അടിസ്ഥാന വാക്യഘടന ഇപ്രകാരമാണ്:

# fsck [options] filesystem

fsck ഉപയോഗിച്ച് ഒരു ഫയൽസിസ്റ്റം പരിശോധിക്കുന്നതിന്, നമ്മൾ ആദ്യം അത് അൺമൗണ്ട് ചെയ്യണം.

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

-y ഫ്ലാഗിന് പുറമെ, ചോദ്യങ്ങളൊന്നും ചോദിക്കാതെ തന്നെ ഫയൽ സിസ്റ്റങ്ങൾ സ്വയമേവ റിപ്പയർ ചെയ്യാനും ഫയൽസിസ്റ്റം വൃത്തിയായി കാണപ്പെടുമ്പോൾ പോലും പരിശോധന നിർബന്ധമാക്കാനും -a ഓപ്ഷൻ ഉപയോഗിക്കാം.

# fsck -af /dev/sdg1

എന്താണ് തെറ്റ് എന്ന് കണ്ടെത്താൻ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ (തൽക്കാലം ഒന്നും പരിഹരിക്കാൻ ശ്രമിക്കാതെ) ഞങ്ങൾക്ക് -n ഓപ്ഷൻ ഉപയോഗിച്ച് fsck പ്രവർത്തിപ്പിക്കാം, ഇത് ഫയൽസിസ്റ്റം പ്രശ്നങ്ങളെ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് ഔട്ട്പുട്ട് ചെയ്യും.

# fsck -n /dev/sdg1

fsck-ന്റെ ഔട്ട്uപുട്ടിലെ പിശക് സന്ദേശങ്ങളെ ആശ്രയിച്ച്, പ്രശ്uനം സ്വയം പരിഹരിക്കാൻ ശ്രമിക്കാമോ അതോ ഹാർഡ്uവെയറിൽ കൂടുതൽ പരിശോധനകൾ നടത്താൻ എഞ്ചിനീയറിംഗ് ടീമുകളിലേക്ക് അത് വർദ്ധിപ്പിക്കാമോ എന്ന് ഞങ്ങൾക്കറിയാം.

സംഗ്രഹം

LFCS പരീക്ഷയിൽ വിജയിക്കുന്നതിന് ആവശ്യമായ അടിസ്ഥാന ഡൊമെയ്uൻ കഴിവുകൾ ഉൾക്കൊള്ളാൻ ശ്രമിച്ച ഈ 10-ലേഖന പരമ്പരയുടെ അവസാനത്തിലാണ് ഞങ്ങൾ എത്തിയിരിക്കുന്നത്.

വ്യക്തമായ കാരണങ്ങളാൽ, ഈ വിഷയങ്ങളുടെ എല്ലാ വശങ്ങളും ഒരൊറ്റ ട്യൂട്ടോറിയലിൽ ഉൾപ്പെടുത്തുന്നത് സാധ്യമല്ല, അതുകൊണ്ടാണ് പുതിയ കാര്യങ്ങൾ സ്വയം പരീക്ഷിക്കാനും പഠനം തുടരാനും ഈ ലേഖനങ്ങൾ നിങ്ങളെ ശരിയായ പാതയിൽ എത്തിച്ചതെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു.

നിങ്ങൾക്ക് എന്തെങ്കിലും ചോദ്യങ്ങളോ അഭിപ്രായങ്ങളോ ഉണ്ടെങ്കിൽ, അവ എല്ലായ്പ്പോഴും സ്വാഗതം ചെയ്യുന്നു - അതിനാൽ ചുവടെയുള്ള ഫോം വഴി ഞങ്ങൾക്ക് ഒരു ലൈൻ ഡ്രോപ്പ് ചെയ്യാൻ മടിക്കരുത്!