Cele mai bune practici pentru a crea un script Shell în GNU / Linux

De obicei, când începi să lucrezi la Zona de administrare a serverelor cu sisteme de operare GNU / Linux și / sau Unix, cineva se găsește (fețe) lucrând într-un mediu în care există de obicei un o grămadă de sarcini programate au scris alți administratori și că la un moment dat trebuie gestiona (administra) alin rezolva orice problemă, îmbunătățește și / sau elimină, pentru a respecta o nouă cerință a instituției unde lucrează. Deci, nu este ciudat, că orice nou SysAdmin În orice loc de muncă, vă confruntați cu sarcina greoaie de a înțelege unele dintre Script Shell creat de alții vechi SysAdmin, care nu sunt bine scrise, sau sunt într-o structură logică sau de scriere, nu sunt ușor de înțeles sau, în cel mai rău caz, cu comenzi de comandă, atipice, vechi, ineficiente sau scrise într-un mod incomod și confuz.

Si bien rezolvarea scripturilor slab scrise este întotdeauna o enervare de moment, acest lucru învață pe oricine bun SysAdmin ceva important. Dacă cineva va crea un Script Shell a fi folosit dincolo de astăzi este întotdeauna mai bun scrie-le într-un mod foarte profesional și standardizat, astfel încât, în timp, oricine altcineva sau cineva să poată folosi efortul și cunoștințele minime realizează înțelegerea și administrarea într-un timp minim.

Prin urmare, după seria practică de publicații pe „Aflați scripturi Shell” unde examinăm câteva scripturi foarte practice cu comenzi simple și de bază, vom începe cu această nouă serie numită „Cele mai bune practici pentru a crea un script Shell în GNU / Linux”, unde ne vom concentra temeinic pe fiecare aspect mic al acestuia și motivul multor lucruri, adică vom acoperi câteva sfaturi care ne vor face să realizăm scripturi mai bune, dar nu atât pentru noi, cât pentru următoarea persoană (SysAdmin) care trebuie să le gestioneze. Deci, nu trebuie să treci prin sarcina plictisitoare și dificilă de a afla ce codific, cum și de ce și de ce nu mai funcționează.

În acest primul (primul) post din această nouă serie „Cele mai bune practici pentru un script Shell bun pentru GNU / Linux” Vom vorbi despre ceea ce merge sau ar trebui să meargă în Antet Shell Script.

=======================================
HEADER - INVOCAȚIA COCII
=======================================

#! / cale / interpreta [parametru-argument]

Linia de sus este structura de bază cu care este invocat un script Shell pentru GNU / Linux. Elementele sale pot fi descrise după cum urmează:

#! => sha-bang

Sha-bang-ul (#!) în partea de sus a Scriptului creat sau care urmează să fie creat este un script care spune sistemului nostru de operare că fișierul nostru este un set de comenzi care vor fi alimentate (vor fi interpretate) de către interpretul de comandă indicat după acesta. Perechea de personaje #! de fapt, este un număr magic doi octeți, un marker special care desemnați un tip de fișierși, în cazul nostru, un script shell executabil. Imediat după sha-bang vine numele de calea în care se află interpretul care urmează să fie executat plus numele interpretului menționat. Cu alte cuvinte, aceasta este calea către programul care interpretează comenzile din script, indiferent dacă este un interpret, un limbaj de programare sau un utilitar. Acest shell execută apoi comenzile din script, începând din partea de sus (linia după sha-bang) și ignorând orice comentarii. niste sha bang Ei pot fi:

# / Bin / sh
#! / Bin / bash
#! / usr / bin / perl
#! / usr / bin / tcl
#! / bin / sed -f
#! / usr / awk -f

Fiecare dintre liniile descrise mai sus (ca exemplu) invocă un shell diferit. Linia / Bin / sh, invocați coajă în mod implicit (Bash pe un sistem de operare GNU / Linux) sau altele similare. Folosind # / Bin / sh, valoarea implicită a coajă Bourne În majoritatea variantelor comerciale ale sistemelor de operare bazate pe UNIX, acesta creează scriptul portabil către alte sisteme de operare care nu sunt Linux în mod corespunzător, dar similar sau bazat pe acesta sau UNIX, deși acest lucru sacrifică caracteristicile specifice ale BASH. Cu toate acestea, secvența „#! / Bin / sh” se conformează normei POSIX sh standard.

Rețineți că calea dată în sha-bang trebuie să fie corectă, altfel un mesaj de eroare, de obicei "Comanda nu a fost găsită", va fi singurul rezultat al executării scriptului. Amintiți-vă perechea de personaje »#! « poate fi omis dacă Scriptul constă doar dintr-un set de comenzi generice ale sistemului de operare, adică fără a utiliza directive Shell interne. Și rețineți încă o dată că »#! / Bin / sh« invocă interpretul shell implicit, care implicit este »#! / Bin / bash« într-o echipă cu el Sistem de operare GNU / Linux.

În ceea ce privește argumentele, există mai multe care ar putea fi utilizate, dar cel mai frecvent este: »-E«. ceea ce face scenariul validați erorile de execuție ale oricărei comenzio (linia de execuție) și dacă este pozitiv, forțează oprirea și ieșirea, unul tipic este »-F« alin indicați ce script să încărcați iar una dintre cele mai rare este »-Rm« care efectuează ștergerea acestuia odată ce executarea sa este terminată. Este posibilă specificarea numai în sha bang până la a argument unic (parametru) după numele programului de executat.

Și, în cele din urmă, spuneți scenariul variabilele globale pe care le veți utiliza în părțile esențiale ale codului dvs., pentru validarea evenimentelor, cum ar fi calea de execuție, utilizatorul autorizat, numele scriptului, printre altele. Și încheiați cu date despre program, creator, organizație, printre altele, plus licențierea care se aplică programului.

Sfatul meu (cele mai bune practici) pentru a alege cel mai bun sha-bang și rubrica a Script Shell sunet:

#! / usr / bin / env bash

De ce folosind comanda »Env« Indicăm sistemului de operare interpretul care va fi utilizat cu calea exactă specificată în el în mod implicit, ceea ce ne permite să avem un sha bang care îi sporește portabilitatea, pentru că nu în toate OS GNU / Linux interpreții sau programele au aceeași cale. Și fără argumente, pentru că pentru asta este mai bine să folosiți comanda set, pentru că odată cu el putem validați erorile, generale (-e) sau specifice (+ x / -x), sau pentru presetări globale clare pentru variabilele de mediu (-i) sau specifice (-u / –unset). Și în cele din urmă, să executați acțiuni specifice (- o) complementare în interiorul scenariului.

Așadar, HEADER-ul meu recomandat ar fi:

#! / usr / bin / env bash
# Indicați interpretul bash cu calea absolută de către sistemul de operare.

set -o ridicat
# Pentru a spune scriptului să se oprească și să se închidă când o comandă sau o linie de execuție eșuează.

set -o substantiv
# Pentru a spune scriptului să se oprească și să se închidă atunci când scriptul încearcă să utilizeze variabile nedeclarate.

set -o pipefail
# Pentru a obține starea de ieșire a ultimei comenzi care a returnat un cod de ieșire diferit de zero.

# set -o xtrace
# Pentru a urmări ce rulează. Util pentru depanare. Activați-l pentru a verifica numai erorile.

Nu uitați să urmați suplimentar aceste recomandări:

01.- Indentează codul tău: Este foarte important să vă faceți codul lizibil și este ceva pe care mulți oameni par să-l uite. Încercați să faceți indentările necesare pentru a percepe o structură logică bună la vedere.

02.- Adăugați spații între secțiunile de cod: Acest lucru vă poate ajuta să faceți codul mult mai ușor de înțeles, deoarece spațierea între module sau secțiuni face codul mai ușor de înțeles și ușor de înțeles.

03.- Comentează cât mai mult posibil despre cod: În partea de sus (sau de jos) a fiecărei ordine de comandă (linie de execuție) sau secțiune de cod, este ideal să adăugați o descriere a funcției scriptului (scripturilor) pentru a explica ce se întâmplă în interiorul codului.

04.- Creați variabile cu nume descriptive ale funcțiilor lor: Alocați nume de variabile descriptive care identifică în mod evident funcția pentru care va fi creată. Deși creați variabile temporare care nu vor fi utilizate niciodată în afara unui singur bloc de cod, este totuși bine să puneți un nume care să explice implicit (obiectiv) ce valori sau funcții gestionează.

05.- Folosiți sintaxa VARIABLE = $ (comandă) pentru substituirea comenzii: Dacă doriți să creați o variabilă a cărei valoare este derivată dintr-o altă comandă, există două moduri de a o face în bash. Cu bifa din spate, adică cu personajele „ , De exemplu: VARIABLE = `command -options parameters`, dar este deja depreciat, deci sintaxa VARIABLE = $ (comandă) este cel mai modern, acceptat și recomandat mod. NU -> DATE = `data +% F` / YES -> DATE = $ (data +% F)

06.- Utilizați module de superutilizare și validare utilizator autorizate și / sau variabile cu sau fără parolă: Pentru a crește nivelurile de securitate, dacă este necesar.

07.- Folosiți module și / sau variabile de validare a sistemului de operare (Distro, versiune, arhitectură): pentru a preveni utilizarea pe platforme inadecvate.

08.- Utilizați module (proceduri / secțiuni) pentru a confirma execuția acțiunilor critice sau în lot (module / funcții): Pentru a minimiza greșelile datorate improvizației sau neglijenței.

09.- Furnizați interfețe ușor de utilizat (ușor de utilizat): Prin Terminal cu meniuri și culori cu Dialog şi Interfețe grafice pentru utilizatorii de bază cu Zenity, Gxmessage. Și, dacă este posibil, utilizați suportul alertelor sonore care identifică evenimentele recunoscute în funcție de sunet. Am încercat pe cât posibil ca Scriptul dvs. să poată funcționează în ambele sensuri doar activând și dezactivând opțiunile / modulele / funcțiile.

10.- Includeți module de bun venit și adio (mesaje): în cazul în care este necesară creșterea interactivității cu utilizatorul.

11.- Includeți un modul de verificare a dublei execuții: Creați un fișier de blocare pentru a preveni executarea acestuia de mai multe ori în același timp.

12.- Raționalizați dimensiunea scriptului cu funcții și / sau module externe: Dacă scriptul este foarte mare împărțiți codul folosind funcții sau împărțiți-le în scripturi mici care sunt invocate prin intermediul unuia principal.

13.- Invocarea într-un mod clar și evident a apelurilor către alți interpreți (limbaje de programare) din Script: Invitați-le clar prin linii sau module.

Exemplu:

# ================================================== #
#!/bin/bash
#Llamando a un interprete externo a BASH
echo 'El siguiente texto será mostrado por el interprete de PERL'
perl -e 'print "Este texto es mostrado por un script PERL embebido.\n";'
exit 0
# ==================================================#

# ==================================================# 
#!/bin/bash #Llamando al interprete de Python. 
echo 'El siguiente es un script de python:'
echo print "Hola, mundo!" | tee $HOME/.testpythonbash.py
python $HOME/.testpythonbash.py exit 0
# ==================================================#

# ======================================================= #
#!/bin/bash
# bash-y-perl.sh

echo "Saludos desde la parte BASH del script."
# Es posible añadir mas comandos BASH aqui.

exit 0
# Fin de la parte BASH del script.

###########################################################

#!/usr/bin/perl
# Esta parte del script se invoca con la opcion -x.

print "Saludos desde la parte PERL del script.\n";
# Podemos añadir mas comandos PERL aqui.

# Fin de la parte PERL del script.
# ======================================================= #
 

În publicațiile viitoare vom extinde mai detaliat fiecare dintre practicile descrise mai sus.

Și dacă cunoașteți alte bune practici, ale voastre sau ale altora, nu ezitați să le comentați pentru a face un compendiu mai complet!

Până la următoarea publicare a acestei noi serii.