5 redenen om Bash te leren (en waarom het je dagelijks werk makkelijker maakt)

door: AT Computing

Werk je met Linux-servers? Beheer je applicaties? Of ontwikkel je software op een Unix-achtig systeem? Dan gebruik je Bash — bewust of onbewust. In de praktijk zien we dat veel IT-professionals het werken met de shell "erbij doen". Ze kennen een paar commando's, kunnen zich voor de herhalende dagelijkse zaken redden, maar benutten lang niet alles wat met de (Bash) shell mogelijk is. Zonde! Bij AT Computing zien we vaak dat zodra iemand Bash écht begrijpt, het werk sneller, consistenter en betrouwbaarder wordt. Hieronder lees je vijf redenen waarom het de moeite waard is om Bash serieus te leren.

De Bash-shell (Bash staat voor Bourne Again SHell) is geen extra tool die je moet installeren. Het is dé standaard manier waarop je met de meestgebruikte GNU/Linux systemen zoals Red Hat, Ubuntu, Alma, SUSE, Rocky of Debian communiceert en standaard aanwezig. Bash is veel meer dan alleen een shell waarin je als gebruiker commando's kunt typen. Het is tevens een complete programmeertaal waarmee je scripts of zelfs complete programma's kunt schrijven. Bash fungeert als een soort butler die netjes wacht tot je als gebruiker van het systeem een opdracht geeft. Die wordt vervolgens uitgevoerd, waarna Bash weer netjes wacht tot het volgende commando wordt gegeven.

Wanneer je dit uitvoert:

ls

Vraag je via Bash aan het systeem om de inhoud van een directory te tonen.

Wanneer je dit doet:

systemctl restart nginx

Zorgt Bash ervoor dat je de betreffende service opnieuw start.

De shell is dus geen randverschijnsel. Het is de laag tussen jou en de kernel. Alles wat je op een Linux-systeem doet — processen starten, bestanden beheren, rechten aanpassen — loopt via die interface. Wie dagelijks met Linux werkt, maar de shell oppervlakkig gebruikt, mist controle en inzicht.

Een groot voordeel van Bash is dat deze shell standaard is uitgerust met een complete GNU-gereedschapkist aan boord.

Denk aan tools zoals:

• grep
• sed
• awk
• cut
• sort
• find

Met deze (soms) eenvoudige commando's kun je verrassend complexe taken uitvoeren en enorm veel werk automatiseren.

We geven een paar voorbeelden.

Stel dat je alle .log bestanden ouder dan 7 dagen wilt verwijderen:

find /var/log -name "*.log" -mtime +7 -delete

Of je wilt automatisch bestanden sorteren op extensie:

mkdir -p png jpg

for file in *; do
  case "$file" in
    *.png) mv "$file" png/ ;;
    *.jpg) mv "$file" jpg/ ;;
  esac
done

Dit zijn kleine voorbeelden, maar in de praktijk worden dit soort scripts gebruikt voor:

• log-rotatie
• back-ups
• deployment-taken
• data-transformatie
• monitoring

Zonder externe frameworks. Zonder afhankelijkheden. Gewoon met wat het systeem al biedt.

Veel IT-werk bestaat uit herhaling:

• logs controleren
• builds uitvoeren
• configuraties aanpassen
• bestanden converteren
• rapportages genereren
• processen monitoren en/of herstarten

Bash maakt dit eenvoudig te automatiseren.

Voorbeeld: alle .mov bestanden converteren naar .mp4 met ffmpeg:

#!/bin/bash

for file in *.mov; do
  output="${file%.mov}.mp4"
  ffmpeg -i "$file" "$output"
done

Maak het script uitvoerbaar:

chmod +x convert.sh

En voer het uit:

./convert.sh

Je kunt dit vervolgens iedere 5 minuten automatisch laten draaien via de tool cron:

*/5 * * * * /home/user/convert.sh

Wat eerst handwerk was, wordt een reproduceerbaar proces. En juist reproduceerbaarheid is essentieel in professionele IT-omgevingen.

In CI/CD pipelines, Docker-images en installatiescripts zie je Bash overal terug.

Bijvoorbeeld om op eenvoudige wijze te testen of installatie van dependencies van je JavaScript applicatie succesvol verloopt:

#!/bin/bash

npm install
npm test

if [ $? -eq 0 ]; then
  echo "Tests geslaagd. Deployen..."
  ./deploy.sh
else
  echo "Tests gefaald."
fi

Wanneer een script zoals hierboven faalt en niemand begrijpt waarom, kost dat tijd. Veel tijd.

Wie Bash begrijpt, ziet direct:

• wat er gebeurt
• waar de fout zit
• welke exit-code wordt teruggegeven

Dat maakt je niet alleen zelfstandiger, maar ook effectiever in teamverband.

Bash laat je fundamentele Unix-concepten in de praktijk zien.

Elke applicatie eindigt met een statuscode:

ls /niet/bestaande/map
echo $?

De statuscodes werken in basis heel eenvoudig: 0 betekent succes, 1 betekent fout en al het andere betekent dat er iets bijzonders aan de hand is.

Dit principe vormt de basis van vrijwel alle scripting en automatisering in Linux. Je kunt ook binnen je eigen script een statuscode meegeven als een deel van je script niet succesvol uitgevoerd kan worden. Je doet dit door in je script met exit te werken binnen conditionele constructies.

Bijvoorbeeld:

# controleer of de file file.txt bestaat en geeft statuscode 2 terug als het bestand niet bestaat.

if [[ ! -f "file.txt" ]]; then
    echo "Error: file not found" >&2
    exit 2   # File not found
fi

Standaard heeft ieder commando dat je met Bash kunt aanroepen 1 ingang en 2 uitgangen: de ingang heet stdin, de uitgang wanneer uitvoer van het commando goed/normaal verloopt heet stdout en de uitgang voor als er iets fout gaat heet stderr. Het leuke is dat je met gebruik van een zogenoemde pipe de stdout van het ene commando kunt koppelen aan stdin van een volgend commando. Een pipe maak je door in de Bash-shell een vertikale streep (|) in te voeren.

Pipes zijn daarmee misschien wel het meest krachtige wapen van Bash. Met één regel die bestaat uit een aantal commando's en een serie pipes die de commando's verbindt kun je heel waardevolle "applicaties" bouwen die behoorlijk complexe taken zeer eenvoudig voor je uitvoeren. Laten we eens kijken hoe dat werkt.

We maken een pipe tussen het commando ls en het commando grep:

ls | grep ".txt"

Zoals gezegd wordt de standaard-output van het commando ls met de pipe doorgestuurd naar de standaard-input van het commando grep. Foutmeldingen in de output van ls blijven gewoon zichtbaar, want stdout wordt als je niets doet wel gepiped, stderr niet.

Wil je ook stderr via de pipe versturen? Dat kan. Hiervoor moet je dan een zogenoemde output redirection aan het commando toevoegen. Door "uitgang 2" (stderr) naar "uitgang 1" (stdout) "om te leiden", worden beiden via stdout naar buiten gestuurd. Dat ziet er in de shell als volgt uit:

ls /foute/map 2>&1 | grep "No such"

Laten we nu eens een iets realistischer voorbeeld hanteren. Stel dat we een tekstbestand genaamd fruit.txt hebben en de inhoud van het bestand met het commando cat bekijken in de terminal. We zien dan het volgende:

$ cat fruit.txt
Peer
Appel
Citroen
Banaan
Appel
Peer
Appel
Mango
Peer
Sinaasappel
Kiwi
Appel
Peer
Appel
Appel
Peer
Peer
Peer
$

Door het combineren van een aantal standaard commando's en het gebruik van pipes kunnen we de tekst uit dit bestand heel eenvoudig ontdubbelen en in alfabetische volgorde zetten. Eerst gebruiken we het commando cat om de inhoud van het bestand te kijken. cat stuurt de tekst naar stdout. In plaats van deze inhoud in de terminal te tonen, vangen we de output van stdout op met een pipe | en sturen we de tekst naar stdin van het volgende commando: sort.

Het commando sort zet standaard iedere regel tekst die via stdin binnenkomt in alfabetische volgorde. Hiermee sorteren we het fruit dus op naam. De uitkomst hiervan sturen we via de stdout van sort via een tweede pipe | naar een volgend commando: uniq. Dit commando analyseert de input en stuurt alleen unieke woorden naar stdout. Er zullen nu dus de nodige appels en peren uit worden gefilterd!

Omdat we nu niet nog een pipe | toepassen, is wat we nu in de terminal als output terug zien, feitelijk de stdout van het commando uniq en daarmee dus een ontdubbelde, alfabetische lijst met fruitnamen! Hieronder zie je het complete commando met de pipes en de output:

$ cat fruit.txt | sort | uniq
Appel
Banaan
Citroen
Kiwi
Mango
Peer
Sinaasappel
$

Door met pipes te werken leer je te begrijpen hoe processen communiceren en hoe data door een Linux-systeem stroomt. Dit inzicht helpt bij troubleshooting, performance-analyse en debugging.

Toegegeven: beginnen met Linux is best uitdagend. Ben je helemaal nieuw met Linux en de command line interface? Dan is ons advies om te beginnen met onze Linux/UNIX Fundamentals cursus. Tijdens deze cursus begin je vanaf de basis en leer je hoe Bash en de commando-structuur precies werkt.

Linux/Unix Fundamentals
https://www.vijfhart.nl/opleidingen/linux-unix-fundamentals/

Heb je al ervaring met Linux en wil je leren hoe je de shell professioneel inzet voor automatisering en scripting? Dan is deze cursus een logische volgende stap:

Linux Shell Scripting Fundamentals
https://www.vijfhart.nl/opleidingen/linux-shell-scripting-fundamentals/

Heb je Bash echt goed onder de knie? Dan loop je vanzelf tegen de volgende vraag aan:

• Hoe beheer ik meerdere systemen tegelijk?
• Hoe maak ik configuratie reproduceerbaar?
• Hoe voorkom ik handmatig werk op tien of misschien wel honderd servers?

Kijk dan zeker eens naar de open source configuratie-management tool Ansible.

Met Ansible automatiseer je configuratiebeheer, deployments en infrastructuur. Waar Bash vooral sterk is op één systeem, helpt Ansible je om complete omgevingen centraal aan te sturen.

Ben je hieraan toe dan adviseren we onze tweedaagse Ansible cursus:

Ansible Fundamentals
https://www.vijfhart.nl/opleidingen/ansible-fundamentals/

Bash geeft je controle op detailniveau.
Ansible geeft je schaal.

Samen vormen ze een zeer sterke basis voor het beheer van moderne Linux-omgevingen.

Met Bash werken is veel meer dan een simpel trucje kunnen op de command line interface. Het is een belangrijk onderdeel van je Linux-vakmanschap.

Het helpt je:

• sneller te werken
• problemen beter te analyseren
• processen te snappen en betrouwbaar te maken
• Linux-systemen echt te begrijpen

Wie professioneel met Linux werkt, kan eigenlijk niet zonder een solide basis in de shell. En als die basis eenmaal staat dan ligt de volgende uitdaging én een hele wereld aan nieuwe mogelijkheden al klaar.