105.2 Lecke 1
Tanúsítvány: |
LPIC-1 |
---|---|
Verzió: |
5.0 |
Témakör: |
105 Shellek és shell scriptelés |
Fejezet: |
105.2 Egyszerű scriptek testre szabása vagy írása |
Lecke: |
1/2 |
Bevezetés
A Linux shell környezet lehetővé teszi olyan fájlok — úgynevezett scriptek — használatát, amelyek a rendszerben elérhető bármely program parancsait tartalmazzák, a shell beépített parancsaival kombinálva, ezzel automatizálhatóvá téve a felhasználó és/vagy a rendszer egyéni feladatait. Valójában az operációs rendszer karbantartási feladatainak nagy részét parancsokból, döntési struktúrákból és feltételes ciklusokból álló scriptek végzik. Bár a scripteket legtöbbször magával az operációs rendszerrel kapcsolatos feladatokhoz tervezik, hasznosak lehetnek felhasználóorientált feladatokhoz is, mint például fájlok tömeges átnevezése, adatgyűjtés és -elemzés, vagy bármilyen más módon ismétlődő parancssori tevékenység.
A scriptek nem mások, mint szövegfájlok, amelyek úgy viselkednek, mint a programok. Egy tényleges program — az interpreter (értelmező) — olvassa és végrehajtja a script-fájlban felsorolt utasításokat. Az interpreter interaktív munkamenetet is indíthat, ahol a parancsok — beleértve a scripteket is — beolvasásra és végrehajtásra kerülnek, ahogyan azokat beírják, mint a Linux shell munkamenetek esetében. A script-fájlok csoportosíthatják azokat az utasításokat és parancsokat, amelyek túl bonyolulttá válnak ahhoz, hogy aliasokként vagy egyéni shell-funkcióként lehessen őket megvalósítani. Továbbá a script-fájlok a hagyományos programokhoz hasonlóan karbantarthatók, és mivel csak szövegfájlok, bármely egyszerű szövegszerkesztővel létrehozhatók és módosíthatók.
Script-struktúra és -végrehajtás
Alapvetően egy script-fájl parancsok rendezett sorozata, amelyeket egy megfelelő parancsértelmezőnek kell végrehajtania. Az, hogy egy parancsértelmező hogyan olvassa be a parancsfájlt, változó, és a Bash shell munkamenetben is különböző módjai vannak, de a parancsfájl alapértelmezett interpretere az lesz, amelyet a parancsfájl első sorában, közvetlenül a #!
(az úgynevezett shebang) karakterek után jelzünk. Egy Bash shell utasításokat tartalmazó scriptben az első sorban a #!/bin/bash
sornak kell állnia. Ennek a sornak a feltüntetésével a fájlban lévő összes utasítás értelmezője a /bin/bash
lesz. Az első sor kivételével az összes többi, #
hash karakterrel kezdődő sort a program figyelmen kívül hagyja, így azok emlékeztetők és megjegyzések elhelyezésére használhatók. Az üres sorok szintén figyelmen kívül maradnak. Egy nagyon tömör shell script-fájlt tehát a következőképpen lehet megírni:
#!/bin/bash # A very simple script echo "Cheers from the script file! Current time is: " date +%H:%M
Ez a script csak két utasítást tartalmaz a /bin/bash
interpreter számára: a beépített echo
parancsot és a date
parancsot. Egy script-fájl futtatásának legalapvetőbb módja az interpreter futtatása a script elérési útvonalával, mint argumentummal. Tehát, feltételezve, hogy az előző példát egy script.sh
nevű script-fájlba mentettük az aktuális mappába, a Bash a következő paranccsal fogja beolvasni és értelmezni:
$ bash script.sh Cheers from the script file! Current time is: 10:57
A echo
parancs automatikusan új sort ad a tartalom megjelenése után, de az -n
kapcsolóval ez elnyomható. Így az echo -n
használata a scriptben azt eredményezi, hogy mindkét parancs kimenete ugyanabban a sorban jelenik meg:
$ bash script.sh Cheers from the script file! Current time is: 10:57
Bár nem kötelező használnunk, a .sh
utótag segít a shell-scriptek azonosításában a fájlok listázása és keresése során.
Tip
|
A Bash a |
Ha a script-fájlt a rendszer más felhasználói is futtatni akarják, fontos ellenőrizni, hogy a megfelelő olvasási jogosultságok be vannak-e állítva. A chmod o+r script.sh
parancs olvasási jogosultságot ad a rendszer összes felhasználójának, így a bash
parancs argumentumaként a script-fájl elérési útvonalát megadva a script.sh
parancsot futtathatják. Alternatív megoldásként a script-fájlnak megadható a végrehajtási bit jogosultsága, így a fájl hagyományos parancsként is végrehajtható. A végrehajtási bitet a chmod
paranccsal aktiválhatjuk a script-fájlon:
$ chmod +x script.sh
A végrehajtási bit engedélyezése esetén az aktuális mappában lévő script.sh
nevű script-fájl közvetlenül a ./script.sh
paranccsal hajtható végre. A PATH
környezeti változóban felsorolt mappában elhelyezett scriptek a teljes elérési útvonaluk nélkül is elérhetők lesznek.
Warning
|
A korlátozott műveleteket végrehajtó scriptek SUID jogosultsága aktiválva lehet, így a közönséges felhasználók is futtathatják a scriptet root jogosultságokkal. Ebben az esetben nagyon fontos biztosítani, hogy a root-on kívül más felhasználó ne rendelkezzen írási jogosultsággal a fájlban. Ellenkező esetben egy közönséges felhasználó módosíthatja a fájlt, hogy tetszőleges és potenciálisan káros műveleteket hajtson végre. |
A parancsok elhelyezése és behúzása a script-fájlokban nem túl szigorú. A shell script minden sora közönséges shell-parancsként kerül végrehajtásra, ugyanabban a sorrendben, ahogy a sor a script-fájlban megjelenik, és ugyanazok a szabályok, amelyek a shell promptra vonatkoznak, minden egyes script sorra külön-külön is érvényesek. Lehetőség van két vagy több parancsot is elhelyezni egy sorban, pontosvesszővel elválasztva:
echo "Cheers from the script file! Current time is:" ; date +%H:%M
Bár ez a formátum időnként kényelmes, használata opcionális, mivel soronként egy-egy parancsot is elhelyezhetünk, és ezek ugyanúgy végrehajtódnak, mintha pontosvesszővel lennének elválasztva. Más szóval a pontosvesszőt a Bash script-fájlokban helyettesítheti egy új sor karakter.
Egy script végrehajtásakor a benne szereplő parancsok nem közvetlenül az aktuális munkamenetben kerülnek végrehajtásra, hanem egy új Bash-folyamat, az úgynevezett sub-shell hajtja végre őket. Ez megakadályozza, hogy a script felülírja az aktuális munkamenet környezeti változóit, és azt is, hogy felügyelet nélkül maradjanak módosítások az aktuális munkamenetben. Ha a cél az, hogy a script tartalma az aktuális shell munkamenetben fusson, akkor a source script.sh
vagy . script.sh
(figyeljünk arra, hogy a pont és a script neve között szóköz van) parancsszóval kell végrehajtani.
Mint bármely más parancs végrehajtásakor, a shell prompt csak akkor lesz újra elérhető, amikor a script befejezi a végrehajtását, és a kilépési állapotkódja a $?
változóban lesz elérhető. Ennek a viselkedésnek a megváltoztatásához, hogy az aktuális shell is véget érjen, amikor a script futása befejeződik, a script — vagy bármely más parancs — előtt az exec
parancsnak kell állnia. Ez a parancs az aktuális shell munkamenet kilépési állapotkódját is lecseréli a sajátjára.
Változók
A shell scriptekben a változók ugyanúgy viselkednek, mint az interaktív munkamenetekben, mivel az interpreter ugyanaz. Például a SOLUTION=42
formátum (szóközök nélkül az egyenlőségjel körül) a SOLUTION
nevű változóhoz a 42
értéket rendeli. A konvenció szerint a változók neveinél nagybetűket használunk, de ez nem kötelező. A változók nevei azonban nem kezdődhetnek nem alfabetikus karakterekkel.
A felhasználó által létrehozott közönséges változókon kívül a Bash scriptek egy sor speciális változóval is rendelkeznek, amelyeket paramétereknek (parameters) neveznek. A közönséges változókkal ellentétben a paraméterek nevei egy nem betűjeles karakterrel kezdődnek, amely a funkciót jelöli. A scriptnek átadott argumentumok és egyéb hasznos információk a $0
, $*
, $?
stb. típusú paraméterekben tárolódnak, ahol a dollárjelet követő karakter jelzi a lekérdezendő információt:
$*
-
A scriptnek átadott összes argumentum.
$@
-
A scriptnek átadott összes argumentum. Ha idézőjelekkel együtt használjuk, mint
"$@"
, akkor minden argumentumot idézőjelek közé zárunk. $#
-
Az argumentumok száma.
$0
-
A script-fájl neve.
$!
-
Az utoljára végrehajtott program PID-je.
$$
-
Az aktuális shell PID-je.
$?
-
Az utolsó befejezett parancs numerikus kilépési állapotkódja. A POSIX szabványos folyamatok esetében a
0
numerikus érték azt jelenti, hogy az utolsó parancs sikeresen végrehajtásra került, ami a shell scriptekre is vonatkozik.
A pozicionális paraméter olyan paraméter, amelyet egy vagy több számjegy jelöl, kivéve az egyjegyű 0
-t. Például az $1
változó a scriptnek adott első argumentumnak felel meg (első pozicionális paraméter), $2
a második argumentumnak, és így tovább. Ha egy paraméter pozíciója nagyobb, mint kilenc, akkor a paraméterre kapcsos zárójelben kell hivatkozni, mint például ${10}
, ${11}
, stb.
A közönséges változók viszont arra szolgálnak, hogy manuálisan beillesztett értékeket vagy más parancsok által generált kimenetet tároljanak. A read
parancsot például arra használhatjuk a scriptben, hogy a végrehajtása során a felhasználótól inputot kérjünk:
echo "Do you want to continue (y/n)?" read ANSWER
A visszakapott érték az ANSWER
változóban kerül tárolásra. Ha a változó neve nincs megadva, akkor alapértelmezés szerint a REPLY
változó neve lesz használva. A read
paranccsal egynél több változó egyidejű olvasására is lehetőség van:
echo "Type your first name and last name:" read NAME SURNAME
Ebben az esetben minden szóközzel elválasztott kifejezés a NAME
és a SURNAME
változókhoz lesz hozzárendelve. Ha a megadott kifejezések száma nagyobb, mint a változók száma, akkor a többlet kifejezések az utolsó változóba kerülnek. A read
maga is megjelenítheti az üzenetet a felhasználónak a -p
kapcsolóval, így az echo
parancs ebben az esetben feleslegessé válik:
read -p "Type your first name and last name:" NAME SURNAME
A rendszerfeladatokat végrehajtó scripteknek gyakran szükségük van más programok által szolgáltatott információkra. A backtick notáció arra használható, hogy egy parancs kimenetét egy változóban tároljuk:
$ OS=`uname -o`
A példában az uname -o
parancs kimenete az OS
változóban lesz tárolva. A $()
paranccsal azonos eredményt kapunk:
$ OS=$(uname -o)
Egy változó hossza, azaz a benne lévő karakterek száma úgy adódik vissza, hogy a változó neve elé egy hasht (#
) írunk. Ez a funkció azonban megköveteli, hogy a változót a kapcsos zárójeles szintaxissal jelezzük:
$ OS=$(uname -o) $ echo $OS GNU/Linux $ echo ${#OS} 9
A Bash egydimenziós tömbváltozókat is tartalmaz, így az egymáshoz kapcsolódó elemek halmaza egyetlen változónévvel tárolható. Egy tömb minden eleméhez tartozik egy numerikus index, amelyet a megfelelő elemben lévő értékek írásához és olvasásához kell használni. A közönséges változóktól eltérően a tömböket a Bash beépített declare
parancsával kell deklarálni. Például egy SIZES
nevű változó tömbként való deklarálásához:
$ declare -a SIZES
A tömbök implicit módon is deklarálhatók, amikor egy előre definiált elemlistából töltjük fel őket, a zárójeles jelölés használatával:
$ SIZES=( 1048576 1073741824 )
A példában a két nagy egész számot (integer) a SIZES
tömbben tároltuk el. A tömb elemeire a hivatkozást kapcsos és szögletes zárójelekkel kell megadni, különben a Bash nem fogja helyesen megváltoztatni vagy megjeleníteni az elemet. Mivel a tömbindexek 0-val kezdődnek, az első elem tartalma a ${SIZES[0]}
-ban, a második elem a ${SIZES[1]}
-ban van, és így tovább:
$ echo ${SIZES[0]} 1048576 $ echo ${SIZES[1]} 1073741824
Az olvasással szemben a tömbelem tartalmának módosítása a kapcsos zárójelek nélkül történik (pl. SIZES[0]=1048576
). A közönséges változókhoz hasonlóan a tömb elemének hosszát hash karakterrel adjuk vissza (pl. ${#SIZES[0]}
az SIZES
tömb első elemének hossza). A tömb összes elemének számát kapjuk meg, ha indexként @
vagy *
szerepel:
$ echo ${#SIZES[@]} 2 $ echo ${#SIZES[*]} 2
A tömbök deklarálhatók úgy is, hogy egy parancs kimenetét használják kezdeti elemként a parancs behelyettesítésével. A következő példa egy olyan Bash tömb létrehozását mutatja be, amelynek elemei az aktuális rendszer támogatott fájlrendszerei:
$ FS=( $(cut -f 2 < /proc/filesystems) )
A cut -f 2 < /proc/filesystems
parancs megjeleníti a futó kernel által jelenleg támogatott összes fájlrendszert (ahogyan az a /proc/filesystems
fájl második oszlopában szerepel), így az FS
tömb most már minden támogatott fájlrendszerhez tartalmaz egy elemet. Bármilyen szöveges tartalom használható a tömb inicializálására, mivel alapértelmezés szerint minden szóköz (space), tab vagy újsor (newline) karakterekkel határolt kifejezés tömbelemmé válik.
Tip
|
A Bash a környezeti változó |
Aritmetikai kifejezések
A Bash a beépített expr
paranccsal praktikus módszert biztosít az egész számokkal végzett aritmetikai műveletek elvégzésére. Két numerikus változó, például $VAL1
és $VAL2
összeadható a következő paranccsal:
$ SUM=`expr $VAL1 + $VAL2`
A példa eredményeinek értéke a $SUM
változóban lesz elérhető. Az expr
parancsot helyettesíthetjük`$(())-vel, így az előző példa az alábbi módon átírható: `SUM=$(( $VAL1 + $VAL2 ))
. A hatványkifejezésekhez a dupla csillag operátort használhatjuk, így a korábbi tömbdeklaráció SIZES=( 1048576 1073741824)
az alábbi is lehet SIZES=( $((1024**2)) $((1024**3)) )
.
A parancshelyettesítés aritmetikai kifejezésekben is használható. Például a /proc/meminfo
fájl részletes információkat tartalmaz a rendszermemóriáról, beleértve a RAM-ban lévő szabad bájtok számát is:
$ FREE=$(( 1000 * `sed -nre '2s/[^[:digit:]]//gp' < /proc/meminfo` ))
A példa azt mutatja, hogy a sed
parancs hogyan használható a /proc/meminfo
tartalmának feldolgozására az aritmetikai kifejezésen belül. A /proc/meminfo
fájl második sora a szabad memória mennyiségét tartalmazza ezer bájtban, így az aritmetikai kifejezés megszorozza 1000-rel, hogy megkapja a RAM-ban lévő szabad bájtok számát.
Feltételes végrehajtás
Egyes parancsfájlok általában nem a parancsfájlban lévő összes parancsot hajtják végre, hanem csak azokat, amelyek megfelelnek egy előre meghatározott feltételnek. Például egy karbantartási script csak akkor küldhet figyelmeztető üzenetet a rendszergazda e-mail címére, ha egy parancs végrehajtása sikertelen. A Bash speciális módszereket biztosít a parancsok végrehajtásának sikerességének értékelésére, valamint általános feltételes struktúrákat, amelyek inkább a népszerű programozási nyelvekben találhatóakhoz hasonlítanak.
A parancsok &&
-vel való elválasztásával a jobb oldali parancs csak akkor kerül végrehajtásra, ha a bal oldali parancs nem ütközött hibába, azaz ha a kilépési állapota egyenlő volt a 0-val
:
COMMAND A && COMMAND B && COMMAND C
Az ellenkező viselkedés akkor következik be, ha a parancsokat ||
-vel választjuk el. Ebben az esetben a következő parancs csak akkor kerül végrehajtásra, ha az előző parancs hibát szenvedett, vagyis ha a visszatérő állapotkódja eltér a 0-tól.
Minden programozási nyelv egyik legfontosabb jellemzője, hogy a parancsokat előre meghatározott feltételek függvényében lehet végrehajtani. A parancsok feltételes végrehajtásának legegyszerűbb módja a Bash beépített if
parancsának használata, amely egy vagy több parancsot csak akkor hajt végre, ha az argumentumként megadott parancs 0 (siker) állapotkódot ad vissza. Egy másik parancs, a test
, sokféle speciális feltétel értékelésére használható, ezért többnyire a if
-vel együtt használják. A következő példában a Confirmed: /bin/bash is executable.
üzenet jelenik meg, ha a /bin/bash
fájl létezik és futtatható:
if test -x /bin/bash ; then echo "Confirmed: /bin/bash is executable." fi
A -x
kapcsoló hatására a test
parancs csak akkor ad 0 státuszkódot, ha a megadott elérési út egy futtatható fájl. A következő példa egy másik módot mutat, amellyel pontosan ugyanazt az eredményt érhetjük el, mivel a szögletes zárójelek a test
helyettesítésére is használhatók:
if [ -x /bin/bash ] ; then echo "Confirmed: /bin/bash is executable." fi
Az else
utasítás opcionális az if
esetén, de ha szerepel, akkor egy olyan parancsot vagy parancssorozatot határozhat meg, amelyet akkor kell végrehajtani, ha a feltételes kifejezés nem igaz:
if [ -x /bin/bash ] ; then echo "Confirmed: /bin/bash is executable." else echo "No, /bin/bash is not executable." fi
Az if
struktúráknak mindig fi
-vel kell végződniük, hogy a Bash interpreter tudja, hol végződnek a feltételes parancsok.
Scriptek kimenete
Még akkor is, ha a script célja csak fájlorientált műveletek elvégzése, fontos, hogy a standard kimeneten megjelenjenek az előrehaladással kapcsolatos üzenetek, hogy a felhasználó folyamatosan értesüljön az esetleges problémákról, és végül ezeket az üzeneteket felhasználhassa a műveleti logok létrehozásához.
A Bash beépített echo
parancsát általában egyszerű szöveges stringek megjelenítésére használjuk, de néhány bővített funkcióval is rendelkezik. Az -e
kapcsolóval az echo
parancs képes speciális karakterek megjelenítésére kivédett (escape) szekvenciák (egy speciális karaktert jelölő backslash szekvencia) használatával. Például:
#!/bin/bash # Get the operating system's generic name OS=$(uname -o) # Get the amount of free memory in bytes FREE=$(( 1000 * `sed -nre '2s/[^[:digit:]]//gp' < /proc/meminfo` )) echo -e "Operating system:\t$OS" echo -e "Unallocated RAM:\t$(( $FREE / 1024**2 )) MB"
Míg az idézőjelek használata kapcsolók nélküli echo
használatakor opcionális, addig az -e
kapcsoló használata esetén kötelező, különben a speciális karakterek nem jelenhetnek meg helyesen. Az előző scriptben mindkét echo
parancs a \t
tabulátor karaktert használja a szöveg igazítására, ami a következő kimenetet eredményezi:
Operating system: GNU/Linux Unallocated RAM: 1491 MB
A kimeneti sorok elválasztására a \n
újsor karakter használható, így pontosan ugyanazt a kimenetet kapjuk, ha a két echo
parancsból egyet csinálunk:
echo -e "Operating system:\t$OS\nUnallocated RAM:\t$(( $FREE / 1024**2 )) MB"
Bár a legtöbb szöveges üzenet megjelenítésére alkalmas, a echo
parancs nem biztos, hogy megfelelő a specifikusabb szövegminták megjelenítésére. A Bash beépített printf
parancsa nagyobb kontrollt ad a változók megjelenítésének módjára. A printf
parancs az első argumentumot használja a kimenet formátumaként, ahol a placeholdereket a következő argumentumok helyettesítik a parancssorban való megjelenésük sorrendjében. Például az előző példa üzenete a következő printf
paranccsal generálható:
printf "Operating system:\t%s\nUnallocated RAM:\t%d MB\n" $OS $(( $FREE / 1024**2 ))
A %s
placeholder szöveges tartalomra vonatkozik (a $OS
változó kerül a helyére), a %d
pedig egész számokra (helyébe a RAM-ban lévő szabad megabájtok száma kerül). A printf
nem illeszt újsor karaktert a szöveg végére, ezért a \n
karaktert kell a minta végére tenni, ha szükséges. A teljes mintát egyetlen argumentumként kell értelmezni, ezért azt idézőjelek közé kell zárni.
Tip
|
A |
A printf
esetében a változók a szövegmintán kívül helyezkednek el, ami lehetővé teszi, hogy a szövegmintát egy külön változóban tároljuk:
MSG='Operating system:\t%s\nUnallocated RAM:\t%d MB\n' printf "$MSG" $OS $(( $FREE / 1024**2 ))
Ez a módszer különösen hasznos a különböző kimeneti formátumok megjelenítéséhez, a felhasználó igényeitől függően. Megkönnyíti például egy olyan script megírását, amely egy külön szövegmintát alkalmaz, ha a felhasználó egy CSV (Comma Separated Values) listát használna az alapértelmezett kimeneti üzenet helyett.
Gyakorló feladatok
-
A
-s
opció aread
parancshoz hasznos a jelszavak beviteléhez, mivel nem jeleníti meg a képernyőn a beírt tartalmat. Hogyan lehetne aread
parancsot arra használni, hogy a felhasználó által bevitt értéket aPASSWORD
változóban tárolja, miközben a beírt tartalmat elrejti? -
A
whoami
parancs egyetlen célja, hogy megjelenítse a parancsot hívó felhasználó felhasználónevét, így leginkább a parancsot futtató felhasználó azonosítására használják a scripteken belül. Egy Bash scriptben hogyan lehetne awhoami
parancs kimenetét aWHO
nevű változóban tárolni? -
Milyen Bash operátornak kell lennie az
apt-get dist-upgrade
és asystemctl reboot
parancsok között, ha a root felhasználó csak akkor akarja végrehajtani asystemctl reboot
parancsot, ha azapt-get dist-upgrade
sikeresen befejeződött?
Gondolkodtató feladatok
-
Egy újonnan létrehozott Bash script futtatása után a felhasználó a következő hibaüzenetet kapja:
bash: ./script.sh: Permission denied
Figyelembe véve, hogy a
./script.sh
fájlt ugyanez a felhasználó hozta létre, mi lehet a hiba valószínű oka? -
Tegyük fel, hogy a
do.sh
nevű script-fájl futtatható, és azundo.sh
nevű szimbolikus link mutat rá. A scriptből hogyan tudnánk azonosítani, hogy a hívó fájl nevedo.sh
vagyundo.sh
? -
Egy megfelelően konfigurált e-mail szolgáltatással rendelkező rendszerben a
mail -s "Maintenance Error" root <<<<"Scheduled task error"
parancs a root felhasználónak küldi el az értesítő e-mailt. Egy ilyen parancsot az olyan felügyelet nélküli feladatokban lehet használni, mint például a cronjobs, hogy tájékoztassa a rendszergazdát egy váratlan problémáról. Írjunk egy if szerkezetet, amely végrehajtja a fent említettmail
parancsot, ha az előző parancs — bármi is volt az — kilépési állapota sikertelen.
Összefoglalás
Ez a lecke a Bash shell scriptek megértésének és írásának alapfogalmait tárgyalja. A Shell scriptek minden Linux disztribúció alapvető részét képezik, mivel nagyon rugalmas módot kínálnak a shell környezetben végzett felhasználói és rendszerfeladatok automatizálására. A lecke az alábbiakat veszi végig:
-
Shell script struktúra és helyes script-fájl jogosultságok
-
Script paraméterek
-
Változók használata a felhasználói bemenet beolvasására és a parancsok kimenetének tárolására
-
Bash tömbök
-
Egyszerű tesztek és feltételes végrehajtás
-
Kimenet formázása
A tárgyalt parancsok és eljárások a következők voltak:
-
Bash beépített jelölés a parancsok helyettesítéséhez, tömbök bővítéséhez és aritmetikai kifejezésekhez
-
Feltételes parancsvégrehajtás a
||
és&&
operátorokkal -
echo
-
chmod
-
exec
-
read
-
declare
-
test
-
if
-
printf
Válaszok a gyakorló feladatokra
-
A
-s
opció aread
parancshoz hasznos a jelszavak beviteléhez, mivel nem jeleníti meg a képernyőn a beírt tartalmat. Hogyan lehetne aread
parancsot arra használni, hogy a felhasználó által bevitt értéket aPASSWORD
változóban tárolja, miközben a beírt tartalmat elrejti?read -s PASSWORD
-
A
whoami
parancs egyetlen célja, hogy megjelenítse a parancsot hívó felhasználó felhasználónevét, így leginkább a parancsot futtató felhasználó azonosítására használják a scripteken belül. Egy Bash scriptben hogyan lehetne awhoami
parancs kimenetét aWHO
nevű változóban tárolni?WHO=`whoami`
vagyWHO=$(whoami)
-
Milyen Bash operátornak kell lennie az
apt-get dist-upgrade
és asystemctl reboot
parancsok között, ha a root felhasználó csak akkor akarja végrehajtani asystemctl reboot
parancsot, ha azapt-get dist-upgrade
sikeresen befejeződött?Az
&&
operátor, mintapt-get dist-upgrade && systemctl reboot
.
Válaszok a gondolkodtató feladatokra
-
Egy újonnan létrehozott Bash-script futtatása után a felhasználó a következő hibaüzenetet kapja:
bash: ./script.sh: Permission denied
Figyelembe véve, hogy a
./script.sh
fájlt ugyanez a felhasználó hozta létre, mi lehet a hiba valószínű oka?A
./script.sh
fájlon nincs engedélyezve a futattási jogosultság. -
Tegyük fel, hogy a
do.sh
nevű script-fájl futtatható, és azundo.sh
nevű szimbolikus link mutat rá. A scriptből hogyan tudnánk azonosítani, hogy a hívó fájl nevedo.sh
vagyundo.sh
?A
$0
speciális változó tartalmazza a script hívásához használt fájlnevet. -
Egy megfelelően konfigurált e-mail szolgáltatással rendelkező rendszerben a
mail -s "Maintenance Error" root <<<<"Scheduled task error"
parancs a root felhasználónak küldi el az értesítő e-mailt. Egy ilyen parancsot az olyan felügyelet nélküli feladatokban lehet használni, mint például a cronjobs, hogy tájékoztassa a rendszergazdát egy váratlan problémáról. Írjunk egy if szerkezetet, amely végrehajtja a fent említettmail
parancsot, ha az előző parancs — bármi is volt az — kilépési állapota sikertelen.if [ "$?" -ne 0 ]; then mail -s "Maintenance Error" root <<<"Scheduled task error"; fi