Comprensió i aprenentatge dels scripts bàsics de Shell i la resolució de problemes del sistema de fitxers Linux - Part 10

La Linux Foundation va llançar la certificació LFCS (Linux Foundation Certified Sysadmin), una nova iniciativa que té com a objectiu permetre que les persones a tot arreu (i a qualsevol lloc) obtinguin la certificació de bàsic a intermedi. suport operatiu per a sistemes Linux, que inclou el suport de sistemes i serveis en execució, juntament amb un seguiment i anàlisi generals, a més de la presa de decisions intel·ligents quan es tracta de plantejar problemes als equips de suport superiors.

Mireu el següent vídeo que us guiarà una introducció al programa de certificació de la Linux Foundation.

Aquest és l'últim article (part 10) de la sèrie llarga de 10 tutorials actuals. En aquest article ens centrarem en els scripts bàsics de l'intèrpret d'ordres i la resolució de problemes dels sistemes de fitxers Linux. Tots dos temes són obligatoris per a l'examen de certificació LFCS.

Comprensió de terminals i shells

Aclarim primer alguns conceptes.

Un shell és un programa que pren ordres i les dóna al sistema operatiu perquè les executi.
Un terminal és un programa que ens permet, com a usuaris finals, interactuar amb l'intèrpret d'ordres. Un exemple de terminal és el terminal GNOME, tal com es mostra a la imatge següent.

Quan iniciem per primera vegada un shell, presenta un indicador d'ordres (també conegut com a línia d'ordres), que ens indica que l'intèrpret d'ordres està preparat per començar a acceptar ordres del seu dispositiu d'entrada estàndard, que sol ser el teclat.

És possible que vulgueu consultar un altre article d'aquesta sèrie (Utilitzar l'ordre per crear, editar i manipular fitxers - Part 1) per revisar algunes ordres útils.

Linux ofereix una sèrie d'opcions per a shells, les següents són les més habituals:

Bash significa Bourne Again SHell i és l'intèrpret d'ordres per defecte del projecte GNU. Incorpora funcions útils de l'intèrpret d'ordres Korn (ksh) i l'intèrpret d'ordres C (csh), oferint diverses millores al mateix temps. Aquest és l'intèrpret d'ordres predeterminat utilitzat per les distribucions cobertes a la certificació LFCS, i és l'intèrpret d'ordres que utilitzarem en aquest tutorial.

El Bourne SHell és l'intèrpret d'ordres més antic i, per tant, ha estat el shell predeterminat de molts sistemes operatius semblants a UNIX durant molts anys.

El Korn SHell és un shell Unix que va ser desenvolupat per David Korn als Bell Labs a principis dels anys vuitanta. És compatible enrere amb l'intèrpret d'ordres Bourne i inclou moltes característiques de l'intèrpret d'ordres C.

Un script d'intèrpret d'ordres és ni més ni menys que un fitxer de text convertit en un programa executable que combina ordres que l'intèrpret de comandaments executa una darrere l'altra.

Escriptura bàsica de Shell

Com s'ha esmentat anteriorment, un script de shell neix com un fitxer de text senzill. Així, es pot crear i editar amb el nostre editor de text preferit. És possible que vulgueu considerar l'ús de vi/m (consulteu Ús de vi Editor - Part 2 d'aquesta sèrie), que inclou el ressaltat de sintaxi per a la vostra comoditat.

Escriviu l'ordre següent per crear un fitxer anomenat myscript.sh i premeu Intro.

# vim myscript.sh

La primera línia d'un script d'intèrpret d'ordres ha de ser la següent (també coneguda com a shebang).

#!/bin/bash

\indica al sistema operatiu el nom de l'intèrpret que s'ha d'utilitzar per executar el text que segueix.

Ara és el moment d'afegir les nostres ordres. Podem aclarir el propòsit de cada comanda, o tot l'script, afegint comentaris també. Tingueu en compte que l'intèrpret d'ordres ignora aquelles línies que comencen amb un signe de lletra # (comentaris explicatius).

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

Un cop escrit i desat l'script, hem de fer-lo executable.

# chmod 755 myscript.sh

Abans d'executar el nostre script, hem de dir algunes paraules sobre la variable d'entorn PATH. Si correm,

echo $PATH

des de la línia d'ordres, veurem el contingut de PATH: una llista de directoris separats per dos punts que es cerquen quan introduïm el nom d'un programa executable. S'anomena variable d'entorn perquè forma part de l'entorn de l'intèrpret d'ordres: un conjunt d'informació que està disponible per a l'intèrpret d'ordres i els seus processos secundaris quan s'inicia l'intèrpret d'ordres.

Quan escrivim una ordre i premem Enter, l'intèrpret d'ordres cerca a tots els directoris llistats a la variable PATH i executa la primera instància que es troba. Vegem un exemple,

Si hi ha dos fitxers executables amb el mateix nom, un a /usr/local/bin i un altre a /usr/bin, s'executarà el del primer directori. primer, mentre que l'altre serà ignorat.

Si no hem desat el nostre script dins d'un dels directoris enumerats a la variable PATH, hem d'afegir ./ al nom del fitxer per executar-lo. En cas contrari, el podem executar tal com ho faríem amb una ordre normal.

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

Sempre que necessiteu especificar diferents cursos d'acció que cal dur a terme en un script d'intèrpret d'ordres, com a resultat de l'èxit o el fracàs d'una ordre, utilitzareu la construcció if per definir aquestes condicions. La seva sintaxi bàsica és:

if CONDITION; then 
	COMMANDS;
else
	OTHER-COMMANDS 
fi

On CONDICIÓ pot ser una de les següents (aquí només es citen les condicions més freqüents) i s'avalua com a certa quan:

[ -a fitxer ] → el fitxer existeix.
[ -d fitxer ] → el fitxer existeix i és un directori.
[ -f fitxer ] →el fitxer existeix i és un fitxer normal.
[fitxer -u ] →el fitxer existeix i el seu bit SUID (establir l'ID d'usuari) està establert.
[ -g fitxer ] →el fitxer existeix i el seu bit SGID està establert.
[ -k fitxer ] →el fitxer existeix i el seu bit enganxós està establert.
[fitxer -r ] →el fitxer existeix i es pot llegir.
[ -s fitxer ]→ el fitxer existeix i no està buit.
[ -w fitxer ]→el fitxer existeix i es pot escriure.
[ -x file ] és cert si el fitxer existeix i és executable.
[ cadena1 = cadena2 ] → les cadenes són iguals.
[ string1 != string2 ] →les cadenes no són iguals.

[ int1 op int2 ] hauria de formar part de la llista anterior, mentre que els elements següents (per exemple, -eq –> és cert si int1 és igual a int2.) hauria de ser una llista fills de [ int1 op int2 ] on op és un dels operadors de comparació següents.

-eq –> és cert si int1 és igual a int2.
-ne –> cert si int1 no és igual a int2.
-lt –> cert si int1 és menor que int2.
-le –> true si int1 és menor o igual que int2.
-gt –> true si int1 és més gran que int2.
-ge –> true si int1 és major o igual que int2.

Aquest bucle permet executar una o més ordres per a cada valor d'una llista de valors. La seva sintaxi bàsica és:

for item in SEQUENCE; do 
		COMMANDS; 
done

On element és una variable genèrica que representa cada valor de SEQUÈNCIA durant cada iteració.

Aquest bucle permet executar una sèrie d'ordres repetitives sempre que l'ordre de control s'executi amb un estat de sortida igual a zero (amb èxit). La seva sintaxi bàsica és:

while EVALUATION_COMMAND; do 
		EXECUTE_COMMANDS; 
done

On EVALUATION_COMMAND pot ser qualsevol ordre(s) que pugui sortir amb un estat d'èxit (0) o fracàs (que no sigui 0) i EXECUTE_COMMANDS pot ser qualsevol programa, script o construcció d'intèrpret d'ordres, inclosos altres bucles imbricats.

Demostrarem l'ús de la construcció if i el bucle for amb l'exemple següent.

Creem un fitxer amb una llista de serveis que volem supervisar d'un cop d'ull.

# cat myservices.txt

sshd
mariadb
httpd
crond
firewalld

El nostre script de shell hauria de semblar.

#!/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). El bucle for llegeix el fitxer myservices.txt un element de LIST alhora. Aquest element únic es denota amb la variable genèrica anomenada servei. La LLISTA s'omple amb la sortida de,

# cat myservices.txt

2). L'ordre anterior està inclosa entre parèntesis i precedida d'un signe de dòlar per indicar que s'ha d'avaluar per omplir la LLISTA sobre la qual repetirem.

3). Per a cada element de LIST (és a dir, cada instància de la variable de servei), s'executarà la següent comanda.

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

Aquesta vegada hem de precedir la nostra variable genèrica (que representa cada element de LIST) amb un signe de dòlar per indicar que és una variable i, per tant, s'ha d'utilitzar el seu valor en cada iteració. Aleshores, la sortida es canalitza a grep.

La marca –quiet s'utilitza per evitar que grep mostri a la pantalla les línies on apareix la paraula corrent. Quan això succeeix, l'ordre anterior retorna un estat de sortida de 0 (representat per $? a la construcció if), verificant així que el servei s'està executant.

Un estat de sortida diferent de 0 (és a dir, la paraula en execució no s'ha trobat a la sortida de systemctl status $service) indica que el servei no és corrent.

Podríem anar un pas més enllà i comprovar l'existència de myservices.txt abans fins i tot d'intentar entrar al bucle for.

#!/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

És possible que vulgueu mantenir una llista d'amfitrions en un fitxer de text i utilitzar un script per determinar de tant en tant si es poden fer ping o no (no dubteu a substituir el contingut de myhosts i provar-ho vosaltres mateixos). ).

L'ordre incorporada de read shell diu al bucle while que llegeixi myhosts línia per línia i assigna el contingut de cada línia a la variable host, que després es passa a l'ordre 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

Llegiu també:

Aprèn a crear scripts de Shell: una guia dels novells a l'administrador del sistema
5 scripts de Shell per aprendre la programació de Shell

Resolució de problemes del sistema de fitxers

Tot i que Linux és un sistema operatiu molt estable, si es bloqueja per algun motiu (per exemple, a causa d'un tall d'alimentació), un (o més) dels vostres sistemes de fitxers no es desmuntaran correctament i, per tant, es comprovaran automàticament si hi ha errors quan Linux es reinicia.

A més, cada vegada que el sistema arrenca durant un arrencada normal, sempre comprova la integritat dels sistemes de fitxers abans de muntar-los. En ambdós casos, això es realitza mitjançant una eina anomenada fsck (comprovació del sistema de fitxers).

fsck no només comprovarà la integritat dels sistemes de fitxers, sinó que també intentarà reparar els sistemes de fitxers corruptes si se'ls indica. Depenent de la gravetat del dany, fsck pot tenir èxit o no; quan ho fa, les parts recuperades dels fitxers es col·loquen al directori perdut+trobat, situat a l'arrel de cada sistema de fitxers.

Finalment, però no menys important, hem de tenir en compte que també es poden produir inconsistències si intentem treure una unitat USB quan el sistema operatiu encara hi està escrivint, i fins i tot poden provocar danys al maquinari.

La sintaxi bàsica de fsck és la següent:

# fsck [options] filesystem

Per comprovar un sistema de fitxers amb fsck, primer hem de desmuntar-lo.

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

A més de la marca -y, podem utilitzar l'opció -a per reparar automàticament els sistemes de fitxers sense fer cap pregunta, i forçar la comprovació fins i tot quan el sistema de fitxers sembla net.

# fsck -af /dev/sdg1

Si només ens interessa esbrinar què passa (sense intentar arreglar res de moment) podem executar fsck amb l'opció -n, que donarà sortida als problemes del sistema de fitxers a la sortida estàndard.

# fsck -n /dev/sdg1

Depenent dels missatges d'error a la sortida de fsck, sabrem si podem intentar resoldre el problema nosaltres mateixos o enviar-lo als equips d'enginyeria per fer més comprovacions del maquinari.

Resum

Hem arribat al final d'aquesta sèrie de 10 articles on hem intentat cobrir les competències bàsiques de domini necessàries per aprovar l'examen LFCS.

Per raons òbvies, no és possible cobrir tots els aspectes d'aquests temes en cap tutorial únic, i per això esperem que aquests articles us hagin posat en el camí correcte per provar coses noves i continuar aprenent.

Si teniu cap pregunta o comentari, sempre són benvinguts, així que no dubteu a escriure'ns a través del formulari següent!