Bash-skript och verktyg: en komplett guide till att automatisera Linux

Informatec Digital » Resurser » Bash-skript och verktyg: en komplett guide till att automatisera Linux

Om du arbetar med Linux dagligen – oavsett om det gäller att hantera servrar , mixtra med containrar eller utveckla applikationer – är det förmodligen den färdighet som sparar dig mest tid att behärska bash-skript . Med några få textfiler och lite fantasi kan du automatisera allt från säkerhetskopior till komplexa distributioner, såväl som rutinuppgifter som du för närvarande utför manuellt utan att ens inse det.

I den här guiden tar vi en grundlig och detaljerad titt på hur du använder bash-skript och verktygssamlingar för att omvandla dina skript från enkla, grundläggande kommandon till verkligt professionella verktyg. Vi börjar med grunderna i skalet, går igenom viktiga kommandon, kontrollstrukturer, funktioner, arrayer, felsökning, cron och mer. Vi utforskar också några funktionsdatabaser och Bash GUI:er som tar dina skript till nästa nivå.

Vad är Bash och varför är det så användbart för automatisering?

Bash (Bourne Again Shell) är den mest utbredda kommandotolken på Unix-liknande system: de allra flesta Linuxdistributioner inkluderar det som standardskal, och det kan också hittas på macOS och Windows via WSL- eller Git Bash-liknande terminaler. Det är både ett interaktivt gränssnitt och ett skriptspråk.

När du öppnar en terminal visar Bash en prompt där du kan skriva kommandon. Varje kommando följer vanligtvis strukturkommandoargumenten . Allt du vet hur man gör "för hand" i terminalen kan läggas i en textfil för att köras i bulk.

Ett bash-skript är helt enkelt en vanlig textfil som innehåller en lista med kommandon som shell-skriptet kör ett efter ett. Det är magin: istället för att skriva 10 kommandon varje dag sparar du dem, ger dem körningsbehörigheter och kör dem i ett enda steg. Dessutom kan du lägga till variabler, villkor, loopar och funktioner för att fatta beslut, upprepa uppgifter och inkapsla logik.

Bash följer också den klassiska Unix-filosofin: många små verktyg som gör en sak väldigt bra och kombineras med pipes . Med ett enda skript kan du länka ihop find, grep, sed, awk, tar, gzip , ssh, scp och alla andra systemverktyg för att skapa mycket kraftfulla administrations- och underhållsprocesser.

Grundläggande begrepp för shell och skript i Bash

För att fullt ut förstå Bash-skript är det nödvändigt att skilja mellan två koncept: skalet och själva skriptet . Skalet är programmet som tolkar kommandon, och skript är processen att gruppera dessa kommandon i en körbar fil.

Ett typiskt skript börjar alltid med en speciell rad som kallas shebang . Den här första raden anger vilken tolk som ska användas för att köra filen. Vanligtvis ser du något liknande:

#!/bin/bash

Du kan också använda `#!/usr/bin/env bash` för att få systemet att leta efter Bash i PATH-filen. Detta ger mer flexibilitet om sökvägen till den körbara filen inte exakt är `/bin/bash`, vilket ibland händer i mer exotiska miljöer.

Skript sparas vanligtvis med tillägget .sh (för tydlighetens skull, inte för att det är obligatoriskt) och du måste ge dem körbehörighet med `chmod +x script_name.sh` . Därifrån kan du köra dem med `./ script_name.sh` eller genom att anropa bash direkt.

bash nombre_script.sh
./nombre_script.sh

Det är också viktigt att förstå begreppen stdin, stdout och stderr : standardinmatning (tangentbord, eller vad du nu omdirigerar det till), standardutmatning (skärm) och felutmatning. Att veta hur man omdirigerar och kombinerar dessa strömmar är nyckeln till att skriva rena, lättfelsökta skript.

Verkliga fördelar med att använda Bash-skript i ditt dagliga liv

Att använda Bash för automatisering är inte bara en egenhet för gammaldags administratörer; det har mycket tydliga fördelar. Med en enda fil kan du paketera långa sekvenser av kommandon och köra dem så många gånger du vill, konsekvent och utan fel.

Den första stora fördelen är automatisering . Istället för att manuellt upprepa steg varje gång du distribuerar en app eller skapar en säkerhetskopia, skriver du allt i ett skript och kör det vid behov (eller schemalägger det med cron). Mindre manuellt arbete, färre dumma misstag.

En annan viktig fördel är portabilitet . Så länge de kommandon du använder är tillgängliga kommer ditt skript att fungera på alla Linux-distributioner, macOS eller till och med Windows med en Bash-miljö. Detta gör det enkelt att migrera många uppgifter mellan miljöer.

Skripten är också väldigt transparenta : de är bara vanlig text. Vem som helst kan öppna dem, se vad de gör och justera dem. Du behöver inte kompilera någonting eller dekryptera binärfiler. Och om du kombinerar dem med Git får du gratis versionshantering och ändringsgranskning.

Slutligen är det relativt enkelt att lära sig Bash. Om du vet hur man navigerar i terminalen och har en grundläggande förståelse för programmering (variabler, if-satser, loopar) kommer du snabbt att komma igång. Och avkastningen på den tidsinvesteringen är enorm i termer av produktivitet.

Skapande och grundläggande struktur för ett Bash-skript

Att skapa sitt första skript är nästan trivialt, men det är bäst att göra det rätt från början. Ett minimalistiskt Bash-skriptskelett skulle inkludera en liten översikt, informativa kommentarer, skriptets innehåll och kontrollerad avslutning.

Det vanliga sättet att börja är med:

#!/bin/bash
# Descripción: pequeño script de ejemplo
echo "Hola, mundo"

Även om det kan verka trivialt är det alltid en bra idé att dokumentera i början vad skriptet gör, vilka parametrar det förväntar sig och ett snabbt användningsexempel. Denna information kan läggas till med kommentarer , som i Bash börjar med # och ignoreras helt av tolken.

Efter rubriken skriver du logiken: variabeldefinitioner, inläsning av indata, kommandoanrop, funktioner, loopar, villkor ... allt du behöver för att automatisera uppgiften.

En annan viktig detalj är att avsluta skriptet genom att returnera en konsekvent avslutningskod, till exempel `exit N` . Koden 0 betyder lyckad, och alla andra värden indikerar ett fel. Detta värde kan kontrolleras utifrån med hjälp av `$?` , vilket gör att du kan kedja skript och reagera på fel.

Kommentarer, variabler och datatyper i Bash

Kommentarer är dina vänner: de är användbara för att förklara vad en del av skriptet gör, varför ett beslut fattades, eller vad i all världen den där konstiga loopen kommer att göra om sex månader när du har glömt bort allt om den. Precis som i många språk börjar de i Bash med # och fortsätter till slutet av raden.

När det gäller variabler är Bash väldigt tillåtande: det finns inga formella typer, allt är en sträng, och skalet bestämmer om det ska tolka något som ett tal när du ber det om det. För att tilldela ett värde använder du `name=value` utan mellanslag runt likhetstecknet.

pais="España"
numero=42

För att läsa innehållet i en variabel, skriv $ före den : till exempel $country . Om du vill ha större tydlighet eller sammanfoga komplexa texter är det att föredra att använda ${country} för att avgränsa den korrekt.

Var försiktig med citattecken . Med dubbla citattecken tolkar Bash variabler och vissa specialsekvenser ( "$var", "\n" ). Med enkla citattecken behandlas allt innehåll som bokstavlig text: '$var' skrivs ut som det är, utan expansion.

Det finns också speciella variabler för att hantera argument och kontext: $# (antal argument), $0 (skriptnamn), $1, $2… (positionsargument), $? (utgångskod för det senaste kommandot), $$ (process-PID), bland många andra som är användbara att ha lokaliserade.

Inmatning och utmatning i Bash-skript

Ett användbart skript existerar sällan isolerat: det begär vanligtvis data från användaren, läser från filer, bearbetar loggar eller skriver resultat till disk. För detta behöver du en god förståelse för `read`, `echo` och redirection.

Det enklaste sättet att läsa något som användaren skriver är med read :

echo "Introduce tu nombre:"
read nombre
echo "Hola, $nombre"

För att skriva text till standardutdata använder vi `echo` eller `printf` . `echo` är enklare och snabbare att skriva, medan `printf` ger dig fullständig kontroll över formatering (justering, decimaler etc.). Du kan också omdirigera vilken utdata som helst till en fil med `>` (skriv över) eller `>>` (lägg till).

Till exempel, för att spara ett "Hej världen" till en fil:

echo "Hola mundo" > hola.txt

Eller för att lägga till rader utan att ta bort de föregående:

echo "Otra línea" >> hola.txt

Om du vill separera normal utdata från fel, kom ihåg att stdout är deskriptor 1 och stderr är deskriptor 2. Du kan skicka dem till andra filer eller till och med kassera dem till /dev/null om du inte behöver dem.

comando 1>salida.txt 2>errores.txt
comando >/dev/null 2>&1

Viktiga Bash-kommandon för skriptning

Varje Bash-skript är beroende av en uppsättning grundläggande systemkommandon . Du använder förmodligen många av dem dagligen, men det är viktigt att förstå deras syntax när du använder dem i skript: ett felplacerat mellanslag eller en ovanlig sökväg kan krascha hela processen.

För att navigera i systemet har du `pwd` (visar den aktuella katalogen) och `cd` (ändrar mappar). För att lista innehåll, använd `ls` med dess många alternativ. Skapa kataloger med `mkdir` , radera filer med `rm` (mycket försiktigt) och flytta/kopiera filer med `mv` och `cp`.

Typiska textinspektionskommandon inkluderar `cat` (visar filer), `tac` (vänder), `head` , `tail` och filtreringsverktyg som `grep` , `sed` och `awk` . Dessa utgör grunden för att skapa skript som analyserar loggar, utför masssubstitutioner eller extraherar specifika data.

På systemnivå är det värt att känna till `ps` och `top` för processer, `kill` för att avsluta processer, `df` och `du` för diskutrymme och `systemctl` för att hantera tjänster på system med systemd. Alla dessa kommandon är naturligt integrerade i skript.

Slutligen, glöm inte `man` : manualen. Nästan alla frågor om kommandoalternativ och beteende kan besvaras med `man command` . Att kunna läsa en manualsida flytande är halva jobbet för att bli administratör.

Kontrollstrukturer: villkor och loopar

Allt eftersom dina skript växer lite kommer du att behöva dem för att fatta beslut och upprepa åtgärder. Det är där kontrollstrukturer kommer in i bilden : if/else, case, while, until och for.

Det klassiska villkorsvärdet i Bash använder `if` tillsammans med `[ ] ` för att utvärdera villkor. Till exempel, för att kontrollera om ett tal är större än 10:

read num
if ]; then
  echo "El número es mayor a 10"
else
  echo "El número es menor o igual a 10"
fi

Syntaxen ] är modernare och säkrare än , och möjliggör mer praktiska logiska operatorer och förbättrad stränghantering. För flera fördefinierade fall är case mycket lättläst, särskilt när du har flera förväntade värden:

read n
case $n in
  101)  echo "Primer número" ;;
  510)  echo "Segundo número" ;;
  999)  echo "Tercer número" ;;
  *)    echo "Sin coincidencias" ;;
esac

I avsnittet om loopar upprepas `while` så länge ett villkor är uppfyllt, `until` gör motsatsen (upprepas tills villkoret är sant), och `for` används för att iterera över listor, arrayer eller numeriska områden. Till exempel, en `for`-loop för att iterera genom veckodagarna:

for dia in Lunes Martes Miércoles Jueves Viernes Sábado Domingo; do
  echo "Día: $dia"
done

Och en typisk while-loop med en intern räknare:

i=0
while ]; do
  echo $i
  ((i++))
done

Funktioner i Bash: återanvända logik utan att bli galen

Funktioner i Bash låter dig gruppera kommandon och återanvända dem så många gånger du vill, vilket gör ditt skript mycket renare och mer hanterbart. Över en viss storlek, om du inte använder funktioner, slutar det med ett monster som är svårt att underhålla.

De kan deklareras på två likvärdiga sätt:

hola() {
  echo "Hola desde una función"
}

function hola2 {
  echo "Hola también"
}

För att anropa dem, skriv helt enkelt deras namn på en rad som om de vore vilket annat kommando som helst. De körs inte bara för att de är definierade, så glöm inte att anropa dem inifrån skriptets innehåll.

Funktioner får positionsparametrar precis som skriptet: inuti funktionen använder du $1, $2, $# , etc. Du kan returnera en numerisk kod med returkod N (avsedd att indikera om den lyckades eller felet) och globala variabler för att returnera mer omfattande resultat, såsom strängar eller arrayer.

Dessutom kan du markera variabler som lokala inom en funktion så att de inte "kontaminerar" resten av skriptet. Detta rekommenderas starkt för att undvika att globala värden skrivs över av misstag.

Arrayer och texthantering i Bash

Även om Bash inte är utformat för komplexa beräkningar, hanterar det arrayer och strängoperationer tillräckligt bra för många automatiseringsuppgifter. Att veta hur man använder dem utökar avsevärt vad du kan göra med bara några få kommandon.

En enkel array definieras enligt följande:

frutas=(Pera Manzana Plátano)

Du kommer åt enskilda element med ${fruits} , får alla med ${fruits} , antalet element med ${#fruits} och de index som används med ${!fruits} . Det senare är användbart när det finns "luckor" i arrayen och du bara vill iterera över giltiga positioner.

För att iterera genom hela systemet kan du använda en for-loop på indexen:

for i in ${!frutas}; do
  echo "frutas = ${frutas}"
done

Bash stöder flera inbyggda operationer på textsträngar : längd ( ${#str} ), delsträngar ( ${str:N:M} ), substitutioner ( ${str/ant/new} , ${str//ant/new} ), trimning av prefix och suffix ( ${str#text} , ${str%text} ), etc. Dessa verktyg eliminerar behovet av att använda sed eller awk för enkla uppgifter.

För mer seriös textmanipulation – till exempel stora loggar eller tabelldata – behöver du grep, sed, awk, cut och liknande, som du kan kedja ihop i pipes eller integrera direkt i Bash-funktioner.

Behörigheter, körning och cron: från fristående skript till schemalagd uppgift

När du har skrivit ditt skript behöver du göra det körbart och bestämma hur du ska starta det. Det typiska steget är att tillämpa:

chmod +x mi_script.sh

Därifrån kan du köra den med `./my_script.sh` om du är i samma katalog, eller genom att referera till dess absoluta sökväg: `/full/path /my_script.sh`. Ett annat alternativ är att anropa den via `bash my_script.sh` utan att ge den körbehörigheter, även om detta inte är vanligt i produktionsmiljöer.

När du vill att skriptet ska köras regelbundet (dagligen, varje vecka, var 5:e minut, etc.) kommer cron in i bilden . Med `crontab -e` kan du redigera användarens aktivitetstabell och definiera saker som:

0 0 * * *   /ruta/backup.sh
*/5 * * * * /ruta/monitor.sh

Den första raden kör ett skript vid midnatt varje dag; den andra var 5:e minut. Fälten anger minut, timme, dag i månaden, månad och veckodag, i den ordningen. Du kan se vad som redan är schemalagt med hjälp av `crontab -l` .

Om något går fel är det bästa att kontrollera systemloggarna . På Debian/Ubuntu loggas cron-meddelanden vanligtvis i /var/log/syslog . Genom att granska dem kan du se om jobbet kördes, om det kraschade på grund av behörighetsproblem eller om det inte ens startade.

Felsökning, bästa praxis och specialvariabler i Bash

Felsökning av Bash-skript har sina knep eftersom skalet som standard fortsätter att köras även om ett kommando misslyckas. För att få ordning på problemet är det bäst att aktivera strict-läge och använda de felsökningsalternativ som Bash erbjuder.

Placera något liknande detta i början av skriptet:

set -euo pipefail
set -x

Detta gör att skriptet stannar vid det första felet ( -e ), behandlar odefinierade variabler som fel ( -u ), upptäcker fel i pipelines ( pipefail ) och visar varje expanderat kommando innan det körs ( -x ). Under utveckling är detta ovärderligt; i produktion kanske du föredrar att aktivera -x bara i specifika avsnitt.

Förutom BASH_REMATCH (mycket användbart med reguljära uttryck) har Bash interna variabler som BASH_SUBSHELL (aktuell subshell-nivå), BASH_ENV (fil som laddas när ett subshell startas), BASH_EXECUTION_STRING (kommando som körs) och BASH_VERSION (interpreterversion). Dessa hjälper dig alla att anpassa skriptets beteende till miljön, felsöka ovanliga problem och säkerställa kompatibilitet.

Som ytterligare god praxis rekommenderas att använda beskrivande variabelnamn , undvika reserverade ord, dokumentera funktioner, alltid validera användarinmatning och kontrollera avslutningskoderna för kritiska kommandon (säkerhetskopior, borttagningar, massflyttar).

Och glöm inte externa verktyg som ShellCheck , som analyserar dina skript och varnar dig för subtila fel, dåliga metoder och farliga konstruktioner. Att integrera det i din editor eller CI/CD-pipeline är ett enkelt sätt att förbättra din kvalitet.

Samlingar av Bash-verktyg och grafiska gränssnitt för dina skript

Förutom de inbyggda funktionerna i Bash finns det kraftfulla ramverk och funktionssamlingar på GitHub som du kan "koppla in" i dina egna skript med hjälp av `source` . Detta gör att du kan integrera verktyg på några sekunder som annars skulle ta lång tid att utveckla.

Ett exempel är Bashmatic , ett ramverk med hundratals funktioner som underlättar allt från formatering av utdata och loggar till samtidig körning av uppgifter, konfigurationshantering och interaktion med externa tjänster. Det är starkt fokuserat på att ge tydlig feedback till utvecklaren medan skriptet körs, vilket är särskilt uppskattat när dina processer tar minuter eller timmar att slutföra.

För att köra uppgifter parallellt tillhandahåller projekt som bash-concurrent en färdig funktion som startar flera jobb samtidigt och visar ordnad utdata när de är klara. Detta är idealiskt för skript som behöver bearbeta många oberoende element (flera servrar, filer etc.).

Om du behöver lättviktiga grafiska gränssnitt utöver Bash finns det projekt som EasyBashGUI eller Script-Dialog som genererar GUI- eller TUI-dialoger beroende på vad du har installerat: kdialog, zenity, whiptail, dialog ... På så sätt kan samma skript fungera bra oavsett om du kör det från en grafisk miljö eller från en ren terminal.

Den allmänna idén med dessa bibliotek är alltid densamma: du laddar ner eller klonar repositoriet, och i ditt skript lägger du till en rad som ` source /path/to/utilities.sh` . Från och med då blir alla funktioner som definieras i den filen tillgängliga i ditt skript, som om de vore dina egna.

I slutändan ger behärskning av Bash-skript och kunskap om några tredjepartsverktyg dig en enorm verktygslåda för att automatisera Linux (och liknande miljöer) utan att slösa tid på att uppfinna hjulet på nytt. Från små personliga skript till kritiska systemadministrationsprocesser gör kombinationen av välkända kommandon, tydliga kontrollstrukturer, goda felsökningsmetoder och externa bibliotek Bash till en nyckelkomponent i alla seriösa tekniska arbetsflöden.