Bash script i utilitats: guia completa per automatitzar Linux

Informatec Digital » Recursos » Bash script i utilitats: guia completa per automatitzar Linux

Si treballes amb Linux diàriament -ja sigui administrant servidors , grapejant amb contenidors o desenvolupant aplicacions- dominar bash scripting és probablement l'habilitat que més temps t'estalviarà. Amb uns quants arxius de text i una mica d'imaginació pots automatitzar des de còpies de seguretat fins a desplegaments complexos, passant per tasques rutinàries que avui fas a mà sense adonar-te'n.

En aquesta guia veurem, amb calma però en profunditat, com fer servir scripts bash i col·leccions d'utilitats per portar els teus scripts de «quatre ordres soltes» a eines realment professionals. Partirem dels conceptes bàsics de shell, veurem ordres essencials, estructures de control, funcions, arrays, depuració, cron… i també alguns repositoris de funcions i GUI a Bash que eleven els teus scripts a un altre nivell.

Què és Bash i per què és tan útil per automatitzar

Bash (Bourne Again Shell) és l'intèrpret d'ordres més estès en sistemes tipus Unix: la gran majoria de distribucions Linux el porten com a shell per defecte, i també el trobes a macOS oa Windows a través de WSL o terminals tipus Git Bash. És, alhora, una interfície interactiva i un llenguatge de scripting.

Quan obris una terminal, Bash et mostra un prompt on pots escriure ordres. Cada ordre segueix normalment l'estructura ordre arguments . Tot el que saps fer «a mà» a la terminal es pot ficar en un fitxer de text per executar-lo en bloc.

Un script bash no és més que un fitxer de text pla amb una llista d'ordres que l'intèrpret d'ordres executa un darrere l'altre. Vet aquí la màgia: en comptes de teclejar 10 ordres cada dia, els guardes, els dónes permisos d'execució i els llances amb un sol pas. A més, hi pots afegir variables, condicionals, bucles i funcions per prendre decisions, repetir tasques i encapsular lògica.

Bash, a més, segueix la filosofia clàssica d'Unix: moltes eines petites que fan una cosa molt bé i es combinen amb pipes . Amb un sol script pots encadenar find, grep, set, awk, tar i gzip , ssh, scp i qualsevol altra utilitat del sistema per crear processos d'administració i manteniment molt potents.

Conceptes bàsics de shell i scripting a Bash

Per entendre bé l'scripting a Bash cal separar dues idees: l' intèrpret d'ordres i el propi scripting . L'intèrpret d'ordres és aquest programa que interpreta les ordres, i l'scripting és el procés d'agrupar aquestes ordres en un fitxer executable.

Un script típic comença sempre amb una línia especial anomenada shebang . Aquesta primera línia diu al sistema quin intèrpret ha de fer servir per executar el fitxer. El més habitual és veure alguna cosa com:

#!/bin/bash

També podeu utilitzar #!/usr/bin/env bash perquè el sistema busqui Bash al PATH. Això dóna més flexibilitat si la ruta a l'executable no és exactament /bin/bash, cosa que de vegades passa en entorns més exòtics.

Els scripts es guarden generalment amb extensió .sh (per claredat, no perquè sigui obligatori) i els has de donar permís d'execució amb chmod +x nom_script.sh . A partir d'aquí, pots llançar-los amb ./nom_script.sh o trucant directament a bash:

bash nombre_script.sh
./nombre_script.sh

És important entendre també els conceptes de stdin, stdout i stderr : l'entrada estàndard (teclat, o el que us redirigeixis), la sortida estàndard (pantalla) i la sortida d'errors. Saber redirigir aquests fluxos i combinar-los és clau per escriure scripts nets i fàcils de depurar.

Avantatges reals de fer servir scripts Bash en el teu dia a dia

Utilitzar Bash per automatitzar no és una mania d'administradors viejuns, té avantatges molt clars. Amb un únic fitxer pots empaquetar seqüències llargues d'ordres i executar-les tantes vegades com vulguis, de forma consistent i sense badades.

El primer gran guany és l' automatització . En comptes de repetir passos a mà cada vegada que desplegues una app o fas una còpia de seguretat, deixes tot escrit en un script i el llances quan toqui (o ho programes amb cron). Menys treball manual, menys errors ximples.

Un altre avantatge important és la portabilitat . Mentre les ordres que utilitzeu estiguin disponibles, el vostre script funcionarà en qualsevol distro Linux, en macOS o fins i tot en Windows amb un entorn Bash. Això fa que moltes tasques siguin fàcils de migrar entre entorns.

Els scripts també són molt transparents : al final són text pla. Qualsevol els pot obrir, revisar què fan i ajustar-los. No cal compilar res ni desxifrar binaris. I si els combines amb Git, tens versionat i auditoria de canvis gratuïts.

Per acabar, aprendre Bash és raonablement senzill. Si saps moure't alguna cosa per la terminal i tens nocions mínimes de programació (variables, if, bucles), et posaràs al dia ràpid. I la tornada d'aquesta inversió de temps és enorme en termes de productivitat.

Creació i estructura bàsica d'un script Bash

Muntar el teu primer script és gairebé trivial, però cal fer-ho bé des del principi. Un esquelet mínim de script Bash inclouria shebang, comentaris informatius, cos de l'script i sortida controlada.

El més habitual és començar amb:

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

Encara que sembli una ximpleria, és bona idea documentar sempre al principi què fa l'script, quins paràmetres espera i algun exemple ràpid d'ús. Aquesta informació es pot afegir amb comentaris , que a Bash comencen per # i l'intèrpret ignora del tot.

Després de la capçalera, escrius la lògica: definició de variables, lectura d'entrada, trucades a ordres, funcions, bucles, condicionals … tot allò que necessitis per automatitzar la tasca que tinguis entre mans.

Un altre detall important és acabar l'script retornant un codi de sortida coherent amb èxit N . El codi 0 significa èxit i qualsevol altre valor indica error. Aquest valor es pot consultar des de fora amb $? , el que et permet encadenar scripts i reaccionar a errors.

Comentaris, variables i tipus de dades a Bash

Els comentaris són els teus amics: serveixen per explicar què fa una part de l'script, per què s'ha pres una decisió, o quins dimonis pensa fer aquest bucle estrany d'aquí sis mesos quan ja no te'n recordis. Com en molts llenguatges, a Bash comencen amb # i arriben fins al final de la línia.

Pel que fa a les variables , Bash és d'allò més permissiu: no hi ha tipus formals, tot són cadenes i l'intèrpret d'ordres decideix si interpretar alguna cosa com a nombre quan li demanes. Per assignar uses nom=valor sense espais al voltant de la mateixa:

pais="España"
numero=42

Per llegir el contingut d'una variable, l'antepons amb $ : per exemple $pais . Si vols més claredat o concatenar textos complexos, és preferible fer servir ${pais} per delimitar-la bé.

Cal anar amb compte amb les cometes . Amb cometes dobles, Bash interpreta les variables i algunes seqüències especials ( $var, \n ). Amb cometes simples, tot el contingut es tracta com a text literal: '$var' s'imprimeix talment, sense expandir.

També hi ha variables especials per manejar arguments i context: $# (nombre d'arguments), $0 (nom de l'script), $1, $2… (arguments posicionals), $? (codi de sortida del darrer comandament), $$ (PID del procés), entre moltes altres que convé tenir localitzades.

Entrada i sortida a scripts Bash

Un script útil poques vegades viu aïllat: sol demanar dades a l'usuari, llegir d'arxius, processar logs o escriure resultats al disc. Per això necessites dominar bé read, fet i les redireccions.

La forma més senzilla de llegir una cosa que escrigui l'usuari és amb read :

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

Per bolcar text a la sortida estàndard fem servir echo o printf . Echo és més simple i ràpid d'escriure, printf us dóna un control total del format (alineacions, decimals, etc.). També podeu redirigir qualsevol sortida amb > (sobreescriure) o >> (afegir al final) cap a un fitxer.

Per exemple, per desar un «Hola món» en un fitxer:

echo "Hola mundo" > hola.txt

O per afegir línies sense esborrar això:

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

Si voleu separar sortides normals d'errors, recordeu que stdout és el descriptor 1 i stderr és el 2 . Pots enviar-los a fitxers diferents o fins i tot llençar-los a /dev/null si no t'interessen:

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

Ordres Bash imprescindibles per a scripting

Tot script Bash es recolza en un conjunt de comandes bàsiques de sistema. Molts els uses ja diàriament, però convé tenir clara la seva sintaxi quan els fiques en scripts: un espai mal col·locat o una ruta rara i et cau mig procés.

Per navegar pel sistema tens pwd (mostra el directori actual) i cd (canvia de carpeta). Per llistar continguts, ls amb les mil opcions. Crear directoris es fa amb mkdir , esborrar fitxers amb rm (amb molt de compte) i moure/copiar amb mv i cp.

Les ordres d'inspecció de text típics són cat (mostra fitxers), tac (al revés), head , tail , i les eines de filtratge com grep , set i awk . Són la base per crear scripts que analitzin logs, apliquin substitucions massives o extraguin dades concretes.

A nivell de sistema, val la pena conèixer ps i top per a processos, kill per finalitzar, df i du per a espai en disc, i systemctl per gestionar serveis en sistemes amb systemd. Totes aquestes ordres s'integren de forma natural dins de scripts.

Finalment, no oblidis man : el manual. Quasi qualsevol dubte sobre opcions i comportament d'una ordre es respon amb man ordre . Saber llegir una pàgina de manual amb facilitat és mitja carrera d'administrador feta.

Estructures de control: condicionals i bucles

Quan els teus scripts creixen una mica necessitaràs que prenguin decisions i repeteixin accions. Aquí entren en joc les estructures de control : if/else, case, while, until i for.

El condicional clàssic a Bash utilitza if juntament amb o ] per avaluar condicions. Per exemple, per comprovar si un nombre és més gran que 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

La sintaxi ] és més moderna i segura que , i permet operadors lògics més còmodes i maneig millorat de cadenes. Per a diversos casos predefinits, case resulta molt llegible, especialment quan tens múltiples valors esperats:

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

A l'apartat de bucles, while repeteix mentre es compleixi una condició, until fa just el contrari (repeteix fins que la condició sigui certa) i for serveix per a iterar sobre llistes, arrays o rangs numèrics. Per exemple, un for per recórrer dies de la setmana:

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

I un while típic amb comptador intern:

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

Funcions a Bash: reutilitzar lògica sense tornar-te boig

Les funcions a Bash et permeten agrupar ordres i reutilitzar-les tantes vegades com vulguis, fent que l'script sigui molt més net i manejable. A partir de certa mida, si no uses funcions, acabes amb un monstre difícil de mantenir.

Es poden declarar de dues maneres equivalents:

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

function hola2 {
  echo "Hola también"
}

Per invocar-les, només cal escriure el seu nom en una línia com si fossin una ordre més. No s'executen pel sol fet d'estar definides, així que no oblidis anomenar-les des del cos de l'script.

Les funcions reben paràmetres posicionals exactament igual que l'script: dins de la funció uses $1, $2, $# , etc. Pots tornar un codi numèric amb return N (pensat per indicar èxit o error) i variables globals per tornar resultats més rics com cadenes o arrays.

A més, pots marcar variables com a local dins d'una funció perquè no “contaminin” la resta de l'script. Això és molt recomanable per evitar trepitjar valors globals per accident.

Arraigs i maneig de text a Bash

Encara que Bash no és un llenguatge pensat per a càlculs complexos, sí que maneja arrays i operacions sobre cadenes suficients per a moltes tasques d'automatització. Saber utilitzar-los amplia força el que pots fer en unes quantes ordres.

Un array simple es defineix així:

frutas=(Pera Manzana Plátano)

Accedeixes a elements individuals amb ${fruites} , obtens tots amb ${fruites} , el nombre d'elements amb ${#fruites} i els índexs usats amb ${!fruites} . Això últim és útil quan hi ha «buits» a l'array i vols iterar només sobre posicions vàlides.

Per recórrer-lo sencer pots fer servir un for sobre els índexs:

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

Sobre cadenes de text, Bash suporta prou operacions integrades : longitud ( ${#cad} ), subcadenes ( ${cad:N:M} ), substitucions ( ${cad/ant/nou} , ${cad//ant/nou} ), retallades de prefix i sufix ( ${cad#text} , ${cad%text ). Aquestes eines eviten llençar de set o awk per a tasques senzilles.

Per manipulació de text més seriosa -per exemple logs grans o dades tabulars- ja entren en joc grep, set, awk, cut i companyia, que pots encadenar a pipes o integrar directament en funcions Bash.

Permisos, execució i cron: de script solt a tasca programada

Un cop tens el teu script fet, cal fer-ho executable i decidir com el llançaràs. El pas típic és aplicar:

chmod +x mi_script.sh

A partir d'aquí, pots executar-lo amb ./el meu_script.sh si ets al mateix directori, o bé referenciant la seva ruta absoluta: /ruta/completa/el meu_script.sh . Una altra opció és invocar-ho a través de bash mi_script.sh sense donar-li permisos d'execució, encara que no és el més habitual en entorns productius.

Quan voleu que l'script s'executi de forma periòdica (diària, setmanal, cada 5 minuts, etc.) entra en escena cron . Amb crontab -e editeu la taula de tasques de l'usuari i podeu definir coses com:

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

La primera línia executa un script a mitjanit cada dia; la segona, cada 5 minuts. Els camps indiquen minut, hora, dia del mes, mes i dia de la setmana, en aquest ordre. Amb crontab -l veus el que ja tens programat.

Si alguna cosa falla, el més assenyat és mirar els logs del sistema . A Debian/Ubuntu, els missatges de cron se solen registrar a /var/log/syslog . Revisar-los et dirà si el job ha corregut, si ha petat per permisos o si no arriba a llançar-se.

Depuració, bones pràctiques i variables especials de Bash

Depurar scripts Bash té el seu truc perquè, per defecte, l'intèrpret d'ordres segueix executant encara que alguna ordre falli. Per posar ordre, convé activar un mode estricte i fer servir les opcions de depuració que ofereix Bash.

Col·locar al principi de l'script alguna cosa com:

set -euo pipefail
set -x

fa que l'script pari en el primer error ( -e ), tracti variables no definides com a error ( -u ), detecti errors en pipelines ( pipefail ) i mostri cada ordre expandida abans d'executar-lo ( -x ). Durant el desenvolupament això és or pur; en producció potser prefereixes activar -x només en seccions concretes.

A més de BASH_REMATCH (molt útil amb expressions regulars), Bash té variables internes com BASH_SUBSHELL (nivell de subshell actual), BASH_ENV (fitxer que es carrega en iniciar un subshell), BASH_EXECUTION_STRING (ordre que s'està executant) o BASH_VERSION (versió de l'in). Totes us ajuden a adaptar el comportament de l'script segons l'entorn, depurar problemes rars o assegurar compatibilitat.

Com a bones pràctiques addicionals, és recomanable fer servir noms de variable descriptius , evitar paraules reservades, documentar funcions, validar sempre l'entrada de l'usuari i comprovar els codis de sortida d'ordres crítiques (còpies de seguretat, esborrats, moviments massius).

I no oblidis eines externes com ShellCheck , que analitza els teus scripts i avisa d'errors subtils, males pràctiques i construccions perilloses. Integrar-lo al teu editor o al teu pipeline CI/CD és una manera senzilla de pujar el nivell de qualitat.

Col·leccions d'utilitats Bash i GUIs pels teus scripts

A més del que porta Bash de sèrie, hi ha frameworks i col·leccions de funcions molt potents allotjats a GitHub que pots «endollar» als teus propis scripts usant source . Això et permet incorporar en segons utilitats que, altrament, et costaria molt de temps desenvolupar.

Un exemple és Bashmatic , un framework amb centenars de funcions que faciliten des del format de sortida i logs fins a l'execució concurrent de tasques, la gestió de configuracions o la interacció amb serveis externs. Està molt orientat a donar feedback clar al desenvolupador mentre s'executa l'script, cosa que s'agraeix quan els teus processos duren minuts o hores.

Per executar tasques en paral·lel, projectes com a bash-concurrent proporcionen una funció llista per utilitzar que llança diversos treballs alhora i mostra una sortida ordenada a mesura que van acabant. Això és ideal per a scripts que han de processar molts elements independents (diversos servidors, fitxers, etc.).

Si necessites interfícies gràfiques lleugeres sobre Bash, hi ha projectes com EasyBashGUI o Script-Dialog que generen diàlegs GUI o TUI en funció del que tinguis instal·lat: kdialog, zenity, whiptail, dialog … D'aquesta manera, un mateix script pot funcionar bé tant si el llences des d'un entorn gràfic com des d'una terminal pura.

La idea general amb aquestes llibreries és sempre la mateixa: descàrregues o clones el repositori, i al teu script hi afegeixes una línia tipus source /ruta/a/utilidades.sh . A partir d'aquí, totes les funcions definides en aquest fitxer passen a estar disponibles al vostre script, com si fossin pròpies.

Al final, dominar Bash scripting i conèixer algunes utilitats de tercers us dóna una caixa d'eines enorme per automatitzar Linux (i entorns similars) sense perdre temps reinventant la roda. Des de petits scripts personals fins a processos crítics d'administració de sistemes, la combinació de comandes ben conegudes, estructures de control clares, bones pràctiques de depuració i llibreries externes converteix Bash en una peça clau de qualsevol flux de treball tècnic seriós.