Millors pràctiques per crear un Script de Shell a GNU / Linux

En general, quan un comença ha treballar en el àrea d'Administració de Servidors amb Sistemes Operatius GNU / Linux i / o Unix, Un es troba (s'enfronta) ha treballar en un ambient on en general hi ha un munt de tasques programades que altres administradors van escriure i que en algun moment haurem gestionar (administrar) per la resoldre algun problema, millorar i / o eliminar, per complir amb algun nou requeriment de la Institució on treballa. Així que no és estrany, que qualsevol nou SysAdmin en qualsevol lloc de treball, s'enfronti a l'enutjosa tasca d'entendre alguns dels Guió de Shell creats per altres antics SysAdmin, Que no estan ben escrit, o estan en una estructura lògica o de redacció, gens fàcil d'entendre, o en el pitjor dels casos, amb ordres d'ordres, atípiques, antigues, ineficients, o escrites de forma maldestra i confusa.

Si bé la solució dels scripts mal escrits és sempre una molèstia momentània, això li ensenya a qualsevol bon SysAdmin alguna cosa important. Si un va ha crear un Guió de Shell que es va a utilitzar més enllà d'avui, sempre és millor escriure'ls de manera molt professional i estandarditzada, Perquè passat el temps, qualsevol altre, o un mateix, pugui amb el mínim esforç i coneixement assolir una comprensió i administració en un mínim de temps.

Per això, després de la sèrie practica de publicacions sobre «Aprendre Shell Scripting» on examinem alguns scripts molt pràctics amb comandaments senzill i bàsics, començarem amb aquesta nova sèrie anomenada «Millors practiques per crear un Script de Shell a GNU / Linux", on ens enfocarem a fons en cada petit aspecte dels mateix i el perquè de moltes coses, és a dir, cobrirem alguns consells que ens faran fer millors scripts, però no tant per a nosaltres mateix, sinó per la següent persona (SysAdmin) que hagi de gestionar-los. Perquè no hagi de passar per una tediosa i difícil tasca d'esbrinar que va codificar, com i per què, i per què ja no funciona.

En aquesta primera (1r) publicació d'aquesta nova sèrie «Millors practiques per a un bon Script d'Shell per a GNU / Linux" parlarem sobre el que va o hauria d'anar en el capçalera de l'Script de Shell.

=======================================
ENCAPÇALAT - INVOCACIÓ DEL SHELL
=======================================

#! / Ruta / interpreti [argument-paràmetre]

La Línia superior és l'estructura bàsica amb la qual invoca un Shell Script per a GNU / Linux. Els seus elements es poden descriure de la següent manera:

#! => Xa-bang

El xa-bang (#!) a la part superior de l'Script creat o ha crear-se és una script que li diu al nostre Sistema Operatiu que el nostre arxiu és un conjunt d'ordres que s'alimentarà (serà interpretat) per l'intèrpret d'ordres indicat després de la mateixa. El parell de caràcters #! en realitat, és un nombre màgic de doble byte, un marcador especial que designa un tipus de fitxer, I en el nostre cas, un script de shell executable. Immediatament després de l'sha-bang ve el nom de la ruta on s'ubica el interpreti a executar-se més el nom d'aquest interpreti. En altres paraules, aquesta és la ruta d'accés a el programa que interpreta els comandaments en el guió, ja es tracti d'una intèrpret, un llenguatge de programació, o una utilitat. Aquest intèrpret d'ordres a continuació, executa les ordres en l'script, començant en la part superior (la línia que segueix a la de l'sha-bang), i fent cas omís dels comentaris. alguns xa-bang poden ser:

#! / Bin / sh
#! / Bin / bash
#! / Usr / bin / perl
#! / Usr / bin / tcl
#! / Bin / set -f
#! / Usr / awk -f

Cadascuna de les línies a dalt descrites (com a exemple) invoca un intèrpret d'ordres diferents. la línia / bin / sh, Invoca el petxina per defecte (Bash en un Sistema Operatiu GNU / Linux) o un altre similar. usant #! / Bin / sh, El valor predeterminat de l' Bourne Shell en la majoria de les variants comercials dels sistemes operatius basats en UNIX, fa que el Script creat sigui portable cap a altres Sistemes Operatius que no són Linux pròpiament, Sinó similars o basats en ell o UNIX, encara que això sacrifica característiques específiques de BASH. No obstant això, la seqüència «#! / Bin / sh» s'ajusta a la norma POSIX sh estàndard.

Recordeu que la ruta donada en el xa-bang ha de ser correcta, En cas contrari un missatge d'error, en general, «Comando no trobat», Serà l'únic resultat de l'execució de l'script. Recordeu que el parell de caràcters »#! « es pot ometre si l'Script es compon només d'un conjunt d'ordres genèrics de el Sistema Operatiu, és a dir, sense utilitzar directives internes de l'Shell. I tingui en compte una vegada més que »#! / Bin / sh« invoca l'intèrpret shell per defecte, que per defecte és »#! / Bin / bash« en un equip amb el Sistema Operatiu GNU / Linux.

Pel que fa als arguments, són diversos els que es poguessin emprar però el més comú és: »-I«. el qual fa que l'script validi els errors d'execució d'algun comando (Línia de execució) i en cas positiu, forza la parada i sortida de la mateixa, Un típic és »-F« per la indicar quin és l'script que ha de carregar i un dels més rars és »-RM« que realitza l'esborrat d'ell mateix un cop finalitza la seva execució. Només és possible especificar en el xa-bang fins a un únic argument (paràmetre) després de el nom de el programa a executar.

I per últim, indicar-li a l'script les variables globals que utilitzarà en parts essencials de el codi, Per validació d'esdeveniments, com ara la ruta d'execució, usuari autoritzat, nom de l'script, entre d'altres. I finalitzar amb els dades de el programa, creador, organització, entre d'altres, més el llicenciament que aplica a el programa.

El meu consell (Millors pràctiques) per escollir el millor xa-bang i encapçalat d'un Guió de Shell són:

#! / Usr / bin / env bash

Perquè mitjançant la comanda »Env« li indiquem a el Sistema Operatiu el vaig interpretar a usar-se amb la ruta exacta especificada dins el mateix per defecte, la qual cosa ens permet tenir un xa-bang que ens augmenti la portabilitat de la mateixa, pel fet que no en tots els SO GNU / Linux els intèrprets o programes tenen la mateixa ruta. I sense arguments, a causa que per això és millor l'ús de la comanda establir, A causa de que amb el podem validar errors, generals (-i) o específics (+ x / -x), O per netejar els valors predefinits globals per a les variables d'entorns (-i) o especifiques (-u / -unset). I per últim, per executar accions determinades (- o) complementàries dins l'script.

Pel que la meva ENCAPÇALAT recomanat seria:

#! / Usr / bin / env bash
# Indiqueu el interpreti bash amb ruta absoluta per Sistema Operatiu.

setembre -o errexit
# Per indicar-li a l'script detenir i tancar-se quan un comando o línia d'execució falli.

setembre -o nounset
# Per indicar-li a l'script detenir i tancar-se quan la seqüència de comandaments intenta utilitzar variables no declarades.

setembre -o pipefail
# Per obtenir l'estat de sortida de l'última ordre que va donar un codi de sortida diferent de zero.

# Setembre -o xtrace
# Per rastrejar el que s'executa. Útil per a la depuració. D'habilitar per verificar errors només.

Recordeu addicionalment seguir aquestes recomanacions:

01.- Indente el seu codi: La fabricació del seu codi en forma llegible és molt important, i és una cosa que molta gent sembla oblidar també. Procureu realitzar les indentaciones necessàries per percebre una bona estructura lògica a la vista.

02.- Afegiu espais de separació entre seccions de codi: Això pot ajudar a que el codi sigui molt més comprensible, ja que l'espaiament per mòduls o seccions ajuda a fer el codi llegible i fàcil d'entendre.

03.- Comenteu el més que pugui el codi: A dalt (o baix) de cada Ordre de Comando (Línia d'Execució) o Secció de Codi és ideal afegir una descripció de la funció de la (es) seqüència (s) de comandaments per explicar el que passa dins de l'propi codi.

04.- Crear variables amb noms descriptius de les seves funcions: Assigneu noms de variables descriptives que identifiquin de forma òbvia la funció per a la qual serà creada. Tot i que creu variables temporals que mai s'utilitzaran fora d'un bloc de codi únic, fins i tot així és bo posar un nom que implícitament (objectivament) d'explicació de quins valors o funcions maneja.

05.- Utilitzeu la sintaxi VARIABLE = $ (comandament) per a la substitució d'ordres: Per crear una variable el valor es derivi d'un altre ordre, hi ha dues maneres de fer-ho en bash. amb backtick, És a dir, amb els caràcters `` , Ejm: VARIABLE = `comandament -opcions parámetros`, Però ja està en desús, així que la sintaxi VARIABLE = $ (comandament) és la manera més moderna, acceptada i recomanada. NO -> DATE = `date +% F` / SI -> DATE = $ (date +% F)

06.- Utilitzeu mòduls i / o variables de Validació de superusuari i Usuari Autoritzat amb o sense contrasenya: Per augmentar els nivells de seguretat en cas de ser necessari.

07.- Utilitzeu mòduls i / o variables de Validació de el Sistema Operatiu (Distro, Versió, Arquitectura): per prevenir ús en plataformes no adequades.

08.- Utilitzeu mòduls (procediments / seccions) de confirmació d'execució d'accions (mòduls / funcions) critiques o per lots: Per minimitzar errors per improvisació o descuit.

09.- Proveeixi Interfícies Amigables a l'usuari (User-friendly): Per Terminal amb menús i colors amb Diàleg i amb Interfícies gràfiques per a Usuaris bàsics amb Zenity, Gxmessage. I si és possible utilitzeu el suport d'alertes sòniques identificadores d'esdeveniments recognoscibles segons el so. Vaig tractar en la mesura del possible que el seu Script pugui funcionar de les 2 maneres amb només habilitar i deshabilitar opcions / mòduls / funcions.

10.- Inclúyale mòduls (missatges) de Benvinguda i Comiat: en cas de ser necessaris per a augmentar la interactivitat amb l'usuari.

11.- Inclogui un mòdul de verificació de doble execució: Créele un arxiu de bloqueig per evitar que pugui ser executat mes d'1 vegada a el mateix temps.

12.- Racionalitzi la mida de l'script amb Funcions i / o Mòduls externs: Si el Script és molt gran divideixi el codi utilitzant funcions o divídalos en petits script que siguin invocats per mitjà d'un principal.

13.- Invocació de forma clara i evident els cridats a altres Intèrprets (llenguatges de programació) dins de l'Script: Invóquelos de forma clara per línies o mòduls.

Exemple:

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

En properes publicacions ampliarem més a detalls cada un de les practiques dalt descrites.

I si coneixes algunes altres bones pràctiques pròpies o alienes, no dubtis en comentar-per fer un compendi més complet!

Fins a la següent publicació d'aquesta nova sèrie.