Best Practices zum Erstellen eines Shell-Skripts in GNU / Linux

Normalerweise, wenn Sie anfangen, an der zu arbeiten Serververwaltungsbereich mit GNU / Linux- und / oder Unix-BetriebssystemenMan findet sich (Gesichter) in einer Umgebung, in der es normalerweise eine gibt Eine Reihe geplanter Aufgaben, die andere Administratoren geschrieben haben und das müssen wir irgendwann verwalten (verwalten) für jedes Problem lösen, verbessern und / oder beseitigen, um einer neuen Anforderung der Institution zu entsprechen wo er arbeitet. Kein Wunder also, dass es neue gibt Sysadmin An jedem Arbeitsplatz stehen Sie vor der mühsamen Aufgabe, einige der Probleme zu verstehen Shell-Skript von anderen erstellt alter SysAdmin, die nicht gut geschrieben sind oder sich in einer logischen oder schriftlichen Struktur befinden, nicht leicht zu verstehen sind oder im schlimmsten Fall mit Befehlsbefehlen, atypisch, alt, ineffizient oder auf unangenehme und verwirrende Weise geschrieben.

Während schlecht geschriebene Skripte lösen ist immer ein momentaner Ärger, das lehrt jeder guter SysAdmin etwas Wichtiges. Wenn man eine erstellen will Shell-Skript über den heutigen Tag hinaus verwendet zu werden, ist immer besser Schreiben Sie sie sehr professionell und standardisiert, so dass im Laufe der Zeit jeder andere oder sich selbst mit dem kann Minimaler Aufwand und Wissen erreichen Verständnis und Verwaltung in kürzester Zeit.

Daher nach der praktischen Reihe von Veröffentlichungen am "Shell Scripting lernen" Wo wir einige sehr praktische Skripte mit einfachen und grundlegenden Befehlen untersuchen, beginnen wir mit dieser neuen Serie namens "Best Practices zum Erstellen eines Shell-Skripts in GNU / Linux", Hier werden wir uns gründlich auf jeden kleinen Aspekt und den Grund für viele Dinge konzentrieren, das heißt, wir werden einige Tipps behandeln, die uns dazu bringen, bessere Skripte zu erstellen, aber nicht so sehr für uns selbst, sondern für die nächste Person (SysAdmin), die dies tun muss verwalten sie. Sie müssen also nicht die mühsame und schwierige Aufgabe durchlaufen, herauszufinden, was ich codiere, wie und warum und warum es nicht mehr funktioniert.

Hierin erster (1.) Beitrag dieser neuen Serie "Best Practices für ein gutes Shell-Skript für GNU / Linux" Wir werden darüber sprechen, was in die geht oder gehen sollte Shell Script Header.

=======================================
HEADER - Anrufung der Muschel
=======================================

#! / path / interpret [Parameterargument]

Die oberste Zeile ist die Grundstruktur, mit der ein Shell-Skript für GNU / Linux aufgerufen wird. Seine Elemente können wie folgt beschrieben werden:

#! => sha-bang

Der Sha-Bang (#!) Oben im Skript, das erstellt wurde oder erstellt werden soll, befindet sich a Skript, das unserem Betriebssystem mitteilt, dass es sich bei unserer Datei um eine Reihe von Befehlen handelt, die von dem danach angegebenen Befehlsinterpreter eingegeben (interpretiert) werden. Das Zeichenpaar #! eigentlich ist es ein magische Zahl Zwei-Byte, ein spezieller Marker, der Geben Sie einen Dateityp anund in unserem Fall ein ausführbares Shell-Skript. Unmittelbar nach dem Sha-Bang kommt der Name Der Pfad, in dem sich der auszuführende Interpreter befindet, sowie der Name des Interpreters. Mit anderen Worten, dies ist der Pfad zu dem Programm, das die Befehle im Skript interpretiert, unabhängig davon, ob es sich um einen Interpreter, eine Programmiersprache oder ein Dienstprogramm handelt. Diese Shell führt dann die Befehle im Skript aus, beginnend oben (die Zeile nach dem Sha-Bang) und ignoriert alle Kommentare. Etwas scha bums Sie können sein:

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

Jede der oben beschriebenen Zeilen (als Beispiel) ruft eine andere Shell auf. Die Linie / Bin / sh, rufe die auf Schale Standardmäßig (Bash auf einem GNU / Linux-Betriebssystem) oder ähnliches. Verwenden von # / Bin / sh, der Standardwert von Bourne-Muschel In den meisten kommerziellen Varianten von UNIX-basierten Betriebssystemen wird das Skript erstellt portabel auf andere Betriebssysteme, die nicht ordnungsgemäß Linux sind, aber ähnlich oder basierend darauf oder UNIX, obwohl dies spezifische Eigenschaften von BASH opfert. Allerdings ist die Reihenfolge "#! / Bin / sh" entspricht der Norm POSIX sh Standard.

Beachten Sie, dass Der im Sha-Bang angegebene Weg muss korrekt sein, sonst normalerweise eine Fehlermeldung "Befehl nicht gefunden"Dies ist das einzige Ergebnis der Skriptausführung. Erinnere dich an das Zeichenpaar »#! « Es kann weggelassen werden, wenn das Skript nur aus einer Reihe allgemeiner Betriebssystembefehle besteht, dh ohne interne Shell-Anweisungen. Und denken Sie noch einmal daran »#! / Bin / sh« Ruft den Standard-Shell-Interpreter auf, der standardmäßig verwendet wird »#! / Bin / bash« in einem Team mit ihm GNU / Linux-Betriebssystem.

In Bezug auf die Argumente gibt es mehrere, die verwendet werden könnten, aber die häufigste ist: »-E«. das macht das Skript Überprüfen Sie die Ausführungsfehler eines Befehlso (Ausführungszeile) und wenn positiv, erzwingt das Anhalten und Verlassenist ein typischer »-F« für Geben Sie an, welches Skript geladen werden soll und einer der seltensten ist »-Rm« das führt das Löschen durch, sobald seine Ausführung beendet ist. Es ist nur möglich, in der anzugeben scha bums bis einzelnes Argument (Parameter) nach dem Namen des auszuführenden Programms.

Und zum Schluss das Drehbuch erzählen Die globalen Variablen, die Sie in wesentlichen Teilen Ihres Codes verwenden, zur Validierung von Ereignissen, wie z. B. Ausführungspfad, autorisierter Benutzer, Skriptname usw. Und ende mit dem unter anderem Daten des Programms, des Erstellers, der Organisation sowie die für das Programm geltende Lizenzierung.

Mein Rat (Best Practices) zu wählen am besten sha-bang und Überschrift a Shell-Skript sind:

#! / usr / bin / env bash

Warum den Befehl verwenden? »Env« Wir geben dem Betriebssystem den zu verwendenden Interpreter mit dem genauen Pfad an, der standardmäßig darin angegeben ist, wodurch wir einen haben können scha bums das erhöht die Portabilität davon, weil nicht in allen OS GNU / Linux Dolmetscher oder Programme haben den gleichen Pfad. Und ohne Argumente, denn dafür ist es besser, den Befehl zu verwenden kompensieren, denn mit ihm können wir Fehler validieren, allgemein (-e) oder spezifisch (+ x / -x), O para Löschen Sie globale Voreinstellungen für Umgebungsvariablen (-i) oder bestimmte Variablen (-u / –unset). Und schließlich zu spezifische (- o) ergänzende Aktionen ausführen innerhalb des Skripts.

Mein empfohlener HEADER wäre also:

#! / usr / bin / env bash
# Geben Sie den Bash-Interpreter mit dem absoluten Pfad nach Betriebssystem an.

setze -o errexit
# Um das Skript anzuweisen, anzuhalten und zu schließen, wenn ein Befehl oder eine Ausführungszeile fehlschlägt.

setze -o Nomenmenge
# Weist das Skript an, anzuhalten und zu schließen, wenn das Skript versucht, nicht deklarierte Variablen zu verwenden.

setze -o Pipefail
# Um den Exit-Status der letzten Bestellung zu erhalten, die einen Exit-Code ungleich Null zurückgegeben hat.

# setze -o xtrace
# Um zu verfolgen, was läuft. Nützlich zum Debuggen. Aktivieren Sie diese Option, um nur nach Fehlern zu suchen.

Denken Sie daran, diese Empfehlungen zusätzlich zu befolgen:

01.- Geben Sie Ihren Code ein: Es ist sehr wichtig, Ihren Code lesbar zu machen, und viele Leute scheinen ihn auch zu vergessen. Versuchen Sie, die notwendigen Einrückungen vorzunehmen, um eine gute logische Struktur in Sichtweite zu erkennen.

02.- Leerzeichen zwischen Codeabschnitten hinzufügen: Dies kann dazu beitragen, den Code viel verständlicher zu machen, da der Abstand nach Modulen oder Abschnitten dazu beiträgt, dass der Code lesbar und leicht verständlich ist.

03.- Kommentiere so viel wie möglich zum Code: Am oberen (oder unteren) Rand jeder Befehlsreihenfolge (Ausführungszeile) oder jedes Codeabschnitts ist es ideal, eine Beschreibung der Funktion der Skripte hinzuzufügen, um zu erklären, was im Code selbst geschieht.

04.- Erstellen Sie Variablen mit beschreibenden Namen ihrer Funktionen: Weisen Sie beschreibende Variablennamen zu, die offensichtlich die Funktion identifizieren, für die sie erstellt werden. Obwohl Sie temporäre Variablen erstellen, die niemals außerhalb eines einzelnen Codeblocks verwendet werden, ist es dennoch sinnvoll, einen Namen einzugeben, der implizit (objektiv) erklärt, welche Werte oder Funktionen behandelt werden.

05.- Verwenden Sie die Syntax VARIABLE = $ (Befehl) für die Befehlssubstitution: Wenn Sie eine Variable erstellen möchten, deren Wert von einem anderen Befehl abgeleitet ist, gibt es zwei Möglichkeiten, dies in bash zu tun. Mit Backtickdas heißt, mit den Zeichen `` , Ejm: VARIABLE = `Befehlsoptionsparameter`, aber es ist schon veraltet, also die Syntax VARIABLE = $ (Befehl) Es ist der modernste, akzeptierteste und empfohlene Weg. NEIN -> DATUM = `Datum +% F` / JA -> DATUM = $ (Datum +% F)

06.- Verwenden Sie Superuser- und Authorized User Validation-Module und / oder Variablen mit oder ohne Passwort: Bei Bedarf die Sicherheitsstufe erhöhen.

07.- Verwenden Sie Module und / oder Variablen zur Validierung des Betriebssystems (Distribution, Version, Architektur): um die Verwendung auf ungeeigneten Plattformen zu verhindern.

08.- Verwenden Sie Module (Prozeduren / Abschnitte), um die Ausführung kritischer oder Batch-Aktionen (Module / Funktionen) zu bestätigen: Minimierung von Fehlern aufgrund von Improvisation oder Nachlässigkeit.

09.- Benutzerfreundliche Schnittstellen bereitstellen (benutzerfreundlich): By Terminal mit Menüs und Farben mit Dialog und Grafische Schnittstellen für Basisbenutzer mit Zenity, Gxmessage. Verwenden Sie nach Möglichkeit die Unterstützung von Schallwarnungen, um erkennbare Ereignisse anhand des Tons zu identifizieren. Ich habe so viel wie möglich versucht, dass Ihr Skript kann Arbeiten Sie in beide Richtungen, indem Sie Optionen / Module / Funktionen aktivieren und deaktivieren.

10.- Begrüßungs- und Abschiedsmodule (Nachrichten) einschließen: im Falle der Notwendigkeit, die Interaktivität mit dem Benutzer zu erhöhen.

11.- Fügen Sie ein Überprüfungsmodul für die doppelte Ausführung hinzu: Erstellen Sie eine Sperrdatei, um zu verhindern, dass sie mehr als einmal gleichzeitig ausgeführt wird.

12.- Rationalisieren Sie die Größe des Skripts mit externen Funktionen und / oder Modulen: Wenn das Skript sehr groß ist, teilen Sie den Code mithilfe von Funktionen oder in kleine Skripte, die über ein Hauptskript aufgerufen werden.

13.- Rufen Sie die Aufrufe anderer Dolmetscher (Programmiersprachen) im Skript klar und deutlich auf: Ruft sie klar durch Linien oder Module auf.

Beispiel:

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

In zukünftigen Veröffentlichungen werden wir jede der oben beschriebenen Praktiken detaillierter erweitern.

Und wenn Sie einige andere bewährte Praktiken kennen, Ihre eigenen oder andere, zögern Sie nicht, diese zu kommentieren, um ein vollständigeres Kompendium zu erstellen!

Bis zur nächsten Veröffentlichung dieser neuen Reihe.