Deze tutorial bespreekt hoe je gemakkelijk je eigen Bash scripts kunt schrijven onder Linux.

Als systeembeheerder is de kans groot dat je repetitieve taken uitvoert die geautomatiseerd zouden kunnen worden.

Gelukkig voor jou is er een programmeertaal die je onder Linux kunt gebruiken om scripts te schrijven: de programmeertaal Bash.

Met Bash kun je back-ups van het hele systeem plannen door zoveel commando’s op te geven als je wilt in Bash-scripts.

Je kunt ook aangepaste scripts hebben die gebruikers aanmaken en verwijderen en hun bijbehorende bestanden verwijderen.

Met Bash kun je ook scripts laten draaien die nuttige prestatiegegevens naar een bestand of database dumpen.

Bash is een zeer krachtige programmeertaal voor systeembeheerders.

In de tutorial van vandaag gaan we alle basiskennis over Bash leren: hoe je scripts maakt en uitvoert, hoe je variabelen en shell built-ins effectief gebruikt.

Wat u zult leren

Als u deze tutorial tot het einde doorleest, leert u de volgende concepten over Bash

• Hoe u Bash-scripts maakt en uitvoert met behulp van de opdrachtregel;
• Wat shebang is en hoe het door Linux wordt gebruikt voor scripting;
• Wat shell built-ins zijn en hoe ze verschillen van gewone systeemprogramma’s;
• Hoe u Bash variabelen gebruikt en wat speciale variabelen zijn;
• Hoe u Bash opdrachtsubstitutie gebruikt;
• Hoe eenvoudige IF statements te gebruiken in Bash;

Zoals u ziet is dit een behoorlijk lang programma, dus laten we zonder verder oponthoud beginnen met te kijken hoe u Bash scripts kunt maken en uitvoeren.

Aan de slag met Bash

Voordat er commando’s worden gegeven, eerst een korte uitleg over Bash en de gemeenschappelijke geschiedenis van de shell.

Geschiedenis van Bash

De eerste versie van de Bash-shell werd in 1989 uitgebracht door Brian Fox en het is een open-source implementatie van de Unix-shell.

Toen Unix-systemen begonnen te ontstaan, maakten dergelijke systemen gebruik van standaard Unix-shells, Bourne-shells genaamd.

In de begindagen van Unix waren systemen die waren ontwikkeld door bedrijven als het MIT of Bell Labs niet vrij en ze waren niet open-source.

Zelfs als er documentatie werd geleverd voor die gereedschappen, werd het een prioriteit voor het GNU initiatief (geleid door Richard Stallman) om een eigen versie van de Unix Shell te hebben.

Zes jaar na de aankondiging van het GNU project, werd de Bash (Bourne-Again Shell) shell geboren met nog meer mogelijkheden dan de oorspronkelijke Bourne shell.

Bash programmeertaal

Wanneer men werkt met een Unix-achtig systeem zoals Linux, heeft Bash meestal twee betekenissen :

• Bash is een opdrachtregelinterpreter of, met andere woorden, een Unix-shell. Dit betekent dat wanneer u een terminal opent, u te maken krijgt met een Unix-shell die meestal een Bash-shell is.

Wanneer u opdrachten rechtstreeks in de terminal typt, worden de opdrachten door de shell geïnterpreteerd, uitgevoerd met behulp van systeemaanroepen en worden er retourwaarden teruggegeven aan de eindgebruiker.

Als u niet zeker weet welke interpreter u op dit moment gebruikt, geeft de omgevingsvariabele SHELL aan welke shell u op dit moment gebruikt.

$ printenv SHELL

Zoals u kunt zien, gebruiken we in dit geval de Bash commando-interpreter correct om te werken.

Het is belangrijk om te weten dat termen als “Bash scripting” en “Shell scripting” weliswaar door elkaar worden gebruikt, maar dat ze, afhankelijk van uw distributie, misschien niet hetzelfde beschrijven.

Sommige recente distributies (zoals Debian 10) hebben symbolische links van de oorspronkelijke Bourne-shell (genaamd sh) naar hun eigen shell-implementaties (in dit geval Dash of Debian Almquist-shell)

• Bash is ook een beschrijving van een commandoregeltaal en wordt ook wel de Bash-taal genoemd. Bash beschikt over een reeks operatoren en operanden die kunnen worden gebruikt om over enkele basisfuncties te beschikken, zoals piping of het uitvoeren van meerdere opdrachten tegelijk.

Bij het uitvoeren van eenvoudige piping-opdrachten wordt gebruik gemaakt van het “|”-symbool. Dit symbool maakt deel uit van de Bash-opdrachtregeltaal.

Dezelfde logica geldt voor het “&&”-symbool dat de tweede opdracht uitvoert als, en alleen als, de eerste opdracht is geslaagd.

$ command1 && command2

Bash-scripts maken en uitvoeren

Nu u enige achtergrond heeft over de Bash-shell en de Bash-opdrachtregeltaal, laten we beginnen met het maken en uitvoeren van eenvoudige Bash-scripts.

Om je eerste Bash script te maken, maak je gewoon een bestand met de naam “script.sh”.

Zoals je waarschijnlijk al hebt gemerkt, gebruiken we nog steeds de “sh” extensie, verwijzend naar de originele Bourne shell (ook wel aangeduid als sh).

$ touch script.sh

Nu is het maken van een bestand dat eindigt op de extensie “sh” niet voldoende om je script als een shellscript te beschouwen.

Dat je bestand nog niet als een shellscript wordt beschouwd, kun je feitelijk zien door het commando bestand uit te voeren.

$ file script.sh

Zoals je hier kunt zien, wordt je bestand alleen beschreven als een eenvoudig leeg bestand.

Om uw bestand als een shellscriptbestand te kunnen beschrijven, moet u de regel shebang bovenaan uw bestand opgeven.

Shell specificeren met shebang

Als u Linux al geruime tijd gebruikt, is het zeer waarschijnlijk dat u de regel shebang aan het begin van uw bestand al eens bent tegengekomen.

Shebang, kort voor “Hash + “Bang”, is een one-liner die aan het begin van shell scripts wordt gezet om aan te geven welke shell moet worden gebruikt om dit script te interpreteren.

#!/bin/<shell>

In ons geval willen we werken met Bash scripts. Met andere woorden, we willen dat onze scripts worden geïnterpreteerd door een Bash interpreter.

Om het pad naar de interpreter te bepalen, kun je het “which” commando gebruiken.

$ which bash/bin/bash

Nu je het pad naar je interpreter weet, bewerk je je script bestand en voeg je de shebang regel toe bovenaan je bestand.

#!/bin/bash

Nu u deze regel aan het begin van uw bestand hebt toegevoegd, voert u het commando “file” opnieuw uit om het verschil te zien.

Zoals u kunt zien, is de uitvoer iets anders: deze keer wordt uw script gezien als een “Bourne-Again shell script” en nog belangrijker, als een uitvoerbaar bestand.

Wat zou er gebeuren als je de shebang regel niet zou specificeren bovenaan het script?

Wanneer je de shebang regel niet specificeert, wordt het script uitgevoerd met de huidige shell die gebruikt is om het execute commando te starten.

Nu je weet hoe je Bash scripts moet maken, laten we eens kijken hoe je ze kunt uitvoeren.

Uitvoeren van Bash scripts

Om Bash scripts onder Linux uit te voeren, hebt u in wezen twee mogelijkheden :

• Door de shell interpreter die u wilt gebruiken en het scriptbestand op te geven;
• Door het pad naar het scriptbestand te gebruiken

Specificatie van de shell interpreter

De eerste methode is vrij rechttoe rechtaan.

Om je bash script uit te voeren, ga je zelf de interpreter opgeven die je wilt gebruiken.

$ bash <script>$ /bin/bash <script>

Gebruik makend van het voorbeeld dat we eerder hebben gebruikt, zou dit ons de volgende uitvoer geven.

Zoals je kunt zien, heb je voor deze methode niet eens de execute rechten op het bestand nodig, je hoeft alleen maar in staat te zijn om de bash executable te gebruiken.

Zoals je ziet, kan ik dit script nog steeds uitvoeren als ik ben ingelogd als een andere gebruiker, zonder uitvoer-rechten.

Dit is een belangrijke opmerking, omdat je je scriptbestanden misschien in beveiligde mappen wilt opslaan (waar alleen jij toegang toe hebt) om te voorkomen dat andere gebruikers je bestanden kunnen uitvoeren.

Het pad naar het script opgeven

De andere manier om bash-scripts uit te voeren is door het pad naar het bestand op te geven.

Om deze methode te kunnen gebruiken, moet het bestand execute-permissies hebben.

Gebruik eerst het commando “chmod” om de execute-permissies voor de huidige gebruiker in te stellen.

$ chmod u+x <script>

Zoals u kunt zien, is de kleur van het bestand heel anders: uw huidige terminal markeert uitvoerbare bestanden met specifieke kleuren, in dit geval de groene kleur.

Nu uw script uitvoerbaar is, kunt u het uitvoeren door het relatieve of absolute pad naar het script op te geven.

Gebruik een bestand met de naam “script.sh” dat zich in mijn huidige werkdirectory bevindt, kan het script worden uitgevoerd door

$ ./script.sh

Als u zich in een andere directory bevindt, moet u het absolute pad naar het scriptbestand opgeven.

$ /home/user/script.sh

Zoals u nu waarschijnlijk wel doorheeft, is deze methode niet erg handig als u elke keer het pad naar het script moet opgeven.

Gelukkig voor u is er een manier om uw script uit te voeren door simpelweg de bestandsnaam in te typen op de commandoregel.

Het script aan het PATH toevoegen

De extensie “.sh” is niet nodig om een script als een scriptbestand te beschouwen.

Om het eenvoudig te houden, gaan we het bestaande bestand “script.sh” bestand hernoemen naar “script”.

Om bestanden te hernoemen op Linux, gebruik je gewoon de “mv” opdracht en geef je de bron en bestemming doel op.

$ mv script.sh script

Nu, wat als je je script zou willen uitvoeren door “script” te typen?

Om dat te doen, moet je het pad naar je script toevoegen aan je PATH omgevingsvariabele.

Om de huidige waarde van je PATH omgevingsvariabele af te drukken, gebruik je “printenv” met het “PATH” argument.

$ printenv PATH

Om het PATH in uw huidige werkomgeving bij te werken, bewerkt u de PATH omgevingsvariabele met de volgende syntaxis.

$ export PATH="<path_to_script>:$PATH"

Nu is het zojuist gedefinieerde “script”-commando direct beschikbaar zonder paden op te geven: u kunt het net als alle andere commando’s starten.

Note: als u uw wijzigingen permanent wilt maken, volgt u deze stappen om uw PATH-variabele correct bij te werken.

Shell built-ins uitgelegd

Voordat u variabelen in uw shellscript declareert, is het belangrijk dat u weet wat shell built-ins zijn.

Wanneer je met de Bash shell werkt, ben je meestal “programma’s” aan het uitvoeren.

Voorbeelden van programma’s zijn “ls”, “fdisk” of “mkdir”. Hulp voor die commando’s kun je vinden met het commando “man”, een afkorting van “manual”.

Heb je echter ooit geprobeerd de documentatie voor het commando “source” te lezen?

Je zou de documentatie niet kunnen lezen met “man”, omdat het source-commando een ingebouwde shell-functie is.

Om de documentatie voor ingebouwde shell-ins te lezen, moet je het commando “help” gebruiken.

$ help <command>

De lijst van shell built-ins is vrij uitgebreid, maar hier is een screenshot van elk bash ingebouwd commando dat je op Ubuntu-systemen kunt vinden.

Bash-variabelen gebruiken

Nu u de Bash built-ins kent, is het tijd om uw eigen Bash-scripts te gaan schrijven.

Ter herinnering, de commando’s die u in uw terminal typt, kunnen op precies dezelfde manier in een Bash-script worden gebruikt.

Wilt u bijvoorbeeld een script dat alleen het commando “ls -l” uitvoert, dan bewerkt u gewoon uw script, voegt u de shebang-regel toe en het commando.

#!/bin/bash# This simple script executes the ls commandls -l

Nu, wat als u Bash-variabelen zou willen hebben?

Bash-variabelen zijn eenvoudige programmavariabelen die een groot aantal verschillende invoergegevens kunnen opslaan.

Om een Bash-variabele aan te geven, specificeert u eenvoudig de naam van de variabele en de waarde ervan, gescheiden door een gelijkheidsteken.

VAR=value

Om de inhoud van uw Bash-variabele in uw script te kunnen gebruiken, gebruikt u “$” en voegt u de naam van uw variabele toe.

echo $VAR

Zelfs als je deze syntaxis kunt gebruiken om de variabele waarde te hebben, kun je ook de “haakjes” notatie gebruiken.

echo ${VAR}

Met behulp van deze syntaxis kunnen variabelen met elkaar worden gecombineerd.

Als u bijvoorbeeld twee Bash-variabelen hebt met de namen VAR1 en VAR2, kunt u ze allebei laten afdrukken met de volgende syntaxis

echo "${VAR1}${VAR2}"

Commando’s uitvoeren binnen scripts

Om commando’s binnen Bash-scripts uit te voeren, moet u opdrachtsubstitutie gebruiken.

Commando substitutie is een techniek die in Bash shells wordt gebruikt om het resultaat van een commando in een variabele op te slaan.

Om een commando in Bash te substitueren, gebruik je het dollarteken en zet je het commando tussen haakjes.

VAR=$(command)

Om bijvoorbeeld het resultaat van het aantal bestanden in je huidige directory te krijgen, zou je schrijven

#!/bin/bashNUMBER=$(ls -l | wc -l)echo "${NUMBER} files in this directory!"

Zoals je ziet, is opdrachtsubstitutie best handig omdat het kan worden gebruikt om dynamisch commando’s in een shellscript uit te voeren en de waarde terug te geven aan de gebruiker.

Over terugsturen naar de eindgebruiker gesproken, hoe ga je om met scripts die niet goed worden afgesloten?

Wat als een commando in het script niet goed is uitgevoerd?

Uitgangsstatussen begrijpen

Wanneer u een script uitvoert, zelfs als u geen waarde teruggeeft, geeft het script altijd wat we “een uitgangsstatus” noemen.

Een uitgangsstatus in Bash-scripting geeft aan of de uitvoering van het script succesvol was of niet.

Als de statuscode nul is, was de uitvoering van uw script succesvol. Als de waarde echter afwijkt van nul (bijvoorbeeld een, twee of meer), geeft dit aan dat de uitvoering van het script niet succesvol was.

Om de exit-status te demonstreren, voert u een geldig commando uit in uw bash-shell.

echo "This is a simple working command"

Nu, gebruik dit commando om de exit status van het laatst uitgevoerde commando te inspecteren.

echo ${?}

Zoals u kunt zien, is de uitvoer van dit commando “0” of de exit status van het laatste commando dat ik heb uitgevoerd.

Deze syntaxis (“${?}”) kan in scripts worden gebruikt om er zeker van te zijn dat commando’s goed zijn uitgevoerd.

De exit-status kan in scripts worden gebruikt om het script met een bepaalde statuscode af te sluiten.

Wilt u bijvoorbeeld het script met een fout afsluiten, dan kunt u het volgende commando in uw script gebruiken.

exit 1

Ook kunt u de “zero” exit code gebruiken om aan te geven dat het script met succes is uitgevoerd.

exit 0

Om te controleren of de statuscode correct was, heb je voorwaardelijke verklaringen nodig, zoals het IF statement.

Voorwaardes manipuleren in Bash

Soms gaat het bij het uitvoeren van bash scripts niet alleen om meerdere commando’s naast elkaar: je wilt ook voorwaardelijke acties hebben.

In sommige gevallen kan het handig zijn om een voorwaarde te hebben die controleert of de huidige gebruiker de root-gebruiker is (of slechts een specifieke gebruiker op uw systeem).

Een eenvoudige manier om voorwaarden in Bash te hebben is het gebruik van het if statement.

“If” is in de shell ingebouwd, met als gevolg dat de handleiding beschikbaar is via het commando “help”

$ help if

De hulppagina beschrijft de syntaxis voor het if-commando met behulp van puntkomma’s, maar we gaan deze syntaxis gebruiken (die gelijkwaardig is)

if ]then <commands>else <command>fi

Praktijkgeval : controleren of de gebruiker root is

Om te laten zien waar het if commando voor gebruikt kan worden, gaan we een eenvoudig script schrijven dat controleert of een gebruiker root is of niet.

Ter herinnering, de root gebruiker heeft altijd de UID op nul staan op elk Unix systeem.

Bewust van deze informatie, gaan we controleren of de UID op nul staat, als dit het geval is, gaan we de rest van het script uitvoeren, zo niet, dan sluiten we het script af.

Zoals in andere tutorials (over gebruikersbeheer) is uitgelegd, kun je de huidige gebruikers-ID opvragen met het commando “id”.

$ id -u1000

We gaan dit commando gebruiken om te controleren of de gebruiker die het script uitvoert root is of niet.

Maak een nieuw script en voeg de shebang regel toe.

#!/bin/bash

Direct eronder, voeg het “id” commando toe en sla het resultaat op in een variabele met de naam “USERID” met behulp van commando substitutie.

USERID=$(id -u)

Nu de “USERID” de huidige gebruikers-ID bevat, gebruik je een IF statement om te controleren of de gebruikers-ID nul is of niet.

Indien dit het geval is, schrijf je een eenvoudige informatieve boodschap, zo niet verlaat je het script met een exit-status van 1.

if ]then echo "This is root"else exit 1fi

Als je nu het script uitvoert als je huidige gebruiker, zal het script gewoon afsluiten met een exit status van 1.

Probeer nu het script als root-gebruiker uit te voeren (met het commando sudo)

Zoals u ziet, is uw informatieve boodschap weergegeven en is het script met een foutcode nul afgesloten.

Conclusie

In deze tutorial hebt u meer geleerd over de programmeertaal Bash en hoe u deze kunt gebruiken om Bash-scripts op uw systeem te maken.

U hebt ook meer geleerd over exit-statussen en voorwaardelijke verklaringen die belangrijk zijn om aangepaste logica in uw scripts in te stellen.

Nu je meer weet over Bash, kun je beginnen met het schrijven van je eigen scripts: je kunt bijvoorbeeld beginnen met een tutorial over het maken van archiefback-ups.

Als je geïnteresseerd bent in Linux-systeembeheer, hebben we daar een complete sectie aan gewijd op de website, dus zorg ervoor dat je die bekijkt!