Scripturi și utilitare Bash: un ghid complet pentru automatizarea Linuxului

Informatec Digital » Recursos » Scripturi și utilitare Bash: un ghid complet pentru automatizarea Linuxului

Dacă lucrezi zilnic cu Linux - fie că gestionezi servere , te improvizezi cu containere sau dezvolți aplicații - stăpânirea scripturilor bash este probabil abilitatea care îți va economisi cel mai mult timp. Cu câteva fișiere text și puțină imaginație, poți automatiza totul, de la copii de rezervă la implementări complexe, precum și sarcini de rutină pe care le efectuezi în prezent manual, fără să-ți dai seama.

În acest ghid, vom analiza în detaliu cum să utilizați scripturile bash și colecțiile de utilitare pentru a transforma scripturile din comenzi simple, de bază, în instrumente cu adevărat profesionale. Vom începe cu elementele de bază ale shell-ului, vom acoperi comenzile esențiale, structurile de control, funcțiile, matricele, depanarea, cron-ul și multe altele. De asemenea, vom explora câteva repozitorii de funcții și interfețe grafice Bash care vă vor duce scripturile la nivelul următor.

Ce este Bash și de ce este atât de util pentru automatizare?

Bash (Bourne Again Shell) este cel mai răspândit interpretor de comenzi pe sistemele de tip Unix: marea majoritate a distribuțiilor Linux îl includ ca shell implicit și poate fi găsit și pe macOS și Windows prin intermediul terminalelor de tip WSL sau Git Bash. Este atât o interfață interactivă , cât și un limbaj de scripting.

Când deschideți un terminal, Bash afișează un prompt unde puteți tasta comenzi. Fiecare comandă urmează de obicei structura argumentelor comenzii . Tot ce știți să faceți „manual” în terminal poate fi pus într-un fișier text pentru a fi executat în bloc.

Un script bash este pur și simplu un fișier text simplu care conține o listă de comenzi pe care shell-ul le execută una după alta. Asta e magia: în loc să tastezi 10 comenzi în fiecare zi, le salvezi, le acorzi permisiuni de execuție și le rulezi într-un singur pas. În plus, poți adăuga variabile, condiționalități, bucle și funcții pentru a lua decizii, a repeta sarcini și a încapsula logica.

Bash urmează, de asemenea, filosofia clasică Unix: multe instrumente mici care fac un singur lucru foarte bine și sunt combinate cu pipe-uri . Cu un singur script, puteți înlănțui împreună find, grep, sed, awk, tar, gzip , ssh, scp și orice alt utilitar de sistem pentru a crea procese de administrare și întreținere foarte puternice.

Concepte de bază despre shell și scripting în Bash

Pentru a înțelege pe deplin scriptarea Bash, este necesar să distingem între două concepte: shell-ul și scriptarea în sine . Shell-ul este programul care interpretează comenzile, iar scriptarea este procesul de grupare a acestor comenzi într-un fișier executabil.

Un script tipic începe întotdeauna cu o linie specială numită shebang . Această primă linie îi spune sistemului ce interpretor să utilizeze pentru a executa fișierul. De obicei, veți vedea ceva de genul:

#!/bin/bash

De asemenea, puteți folosi `#!/usr/bin/env bash` pentru ca sistemul să caute Bash în PATH. Aceasta oferă mai multă flexibilitate dacă calea către executabil nu este exact `/bin/bash`, ceea ce se întâmplă uneori în medii mai exotice.

Scripturile sunt în general salvate cu extensia .sh (pentru claritate, nu pentru că este obligatorie) și trebuie să le acordați permisiunea de execuție cu comanda `chmod +x nume_script.sh` . De acolo, le puteți rula cu comanda `./ nume_script.sh` sau apelând direct bash.

bash nombre_script.sh
./nombre_script.sh

De asemenea, este important să înțelegeți conceptele de stdin, stdout și stderr : intrare standard (tastatură sau orice altceva către care o redirecționați), ieșire standard (ecran) și ieșire de eroare. Cunoașterea modului de redirecționare și combinare a acestor fluxuri este esențială pentru scrierea de scripturi curate și ușor de depanat.

Avantajele reale ale utilizării scripturilor Bash în viața de zi cu zi

Utilizarea Bash pentru automatizare nu este doar o ciudățenie a administratorilor de modă veche; are avantaje foarte clare. Cu un singur fișier, puteți împacheta secvențe lungi de comenzi și le puteți rula de câte ori doriți, în mod consecvent și fără erori.

Primul beneficiu major este automatizarea . În loc să repetați manual pașii de fiecare dată când implementați o aplicație sau creați o copie de rezervă, scrieți totul într-un script și îl rulați atunci când este nevoie (sau îl programați cu cron). Mai puțină muncă manuală, mai puține greșeli stupide.

Un alt avantaj important este portabilitatea . Atâta timp cât comenzile pe care le utilizați sunt disponibile, scriptul dvs. va funcționa pe orice distribuție Linux, macOS sau chiar Windows cu un mediu Bash. Acest lucru face ca multe sarcini să fie ușor de migrat între medii.

Scripturile sunt, de asemenea, foarte transparente : sunt doar text simplu. Oricine le poate deschide, poate vedea ce fac și le poate ajusta. Nu trebuie să compilați nimic sau să decriptați fișiere binare. Și dacă le combinați cu Git, beneficiați gratuit de control al versiunilor și auditare a modificărilor.

În cele din urmă, învățarea limbajului Bash este destul de ușoară. Dacă știi cum să navighezi în terminal și ai cunoștințe de bază despre programare (variabile, instrucțiuni if, bucle), te vei obișnui rapid cu limbajul. Iar rentabilitatea acestei investiții de timp este enormă în ceea ce privește productivitatea.

Crearea și structura de bază a unui script Bash

Crearea primului script este aproape banală, dar cel mai bine este să o faci chiar de la început. Un schelet minimal de script Bash ar include un shebang, comentarii informative, corpul scriptului și o ieșire controlată.

Modul obișnuit de a începe este cu:

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

Deși poate părea banal, este întotdeauna o idee bună să documentați de la început ce face scriptul, ce parametri așteaptă și un exemplu rapid de utilizare. Aceste informații pot fi adăugate prin comentarii , care în Bash încep cu # și sunt complet ignorate de interpretor.

După antet, scrii logica: definiții de variabile, citire de intrări, apeluri de comenzi, funcții, bucle, condiționalități ... tot ce ai nevoie pentru a automatiza sarcina respectivă.

Un alt detaliu important este terminarea scriptului prin returnarea unui cod de ieșire consistent, cum ar fi `exit N` . Codul 0 înseamnă succes, iar orice altă valoare indică o eroare. Această valoare poate fi verificată din exterior folosind `$?` , permițându-vă să legați scripturi în lanț și să reacționați la eșecuri.

Comentarii, variabile și tipuri de date în Bash

Comentariile sunt prietenii tăi : sunt utile pentru a explica ce face o parte a scriptului, de ce a fost luată o decizie sau ce naiba va face acea buclă ciudată peste șase luni când ai uitat complet de ea. Ca în multe limbaje, în Bash încep cu # și merg la sfârșitul liniei.

În ceea ce privește variabilele , Bash este foarte permisiv: nu există tipuri formale, totul este un șir de caractere, iar shell-ul decide dacă interpretează ceva ca un număr atunci când îi ceri acest lucru. Pentru a atribui o valoare, folosești `name=value` fără spații în jurul semnului egal.

pais="España"
numero=42

Pentru a citi conținutul unei variabile, introduceți înaintea acesteia $ : de exemplu, $țară . Dacă doriți o mai mare claritate sau pentru a concatena texte complexe, este de preferat să utilizați ${țară} pentru a o delimita corect.

Atenție la ghilimele . Cu ghilimele duble, Bash interpretează variabilele și unele secvențe speciale ( „$var”, „\n” ). Cu ghilimele simple, tot conținutul este tratat ca text literal: „$var” este afișat ca atare, fără expansiune.

Există, de asemenea, variabile speciale pentru gestionarea argumentelor și a contextului: $# (numărul de argumente), $0 (numele scriptului), $1, $2… (argumente poziționale), $? (codul de ieșire al ultimei comenzi), $$ (PID-ul procesului), printre multe altele care sunt utile de localizat.

Intrare și ieșire în scripturi Bash

Un script util există rareori izolat: de obicei, solicită date de la utilizator, citește din fișiere, procesează jurnale sau scrie rezultate pe disc. Pentru aceasta, aveți nevoie de o bună înțelegere a comenzilor `read`, `echo` și redirecționare.

Cea mai simplă metodă de a citi ceva ce tastează utilizatorul este cu read :

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

Pentru a afișa text pe ieșirea standard, folosim `echo` sau `printf` . `echo` este mai simplu și mai rapid de scris, în timp ce `printf` vă oferă control complet asupra formatării (aliniere, zecimale etc.). De asemenea, puteți redirecționa orice ieșire către un fișier folosind `>` (suprascriere) sau `>>` (adăugare).

De exemplu, pentru a salva un mesaj „Salut, lume” într-un fișier:

echo "Hola mundo" > hola.txt

Sau pentru a adăuga linii fără a le șterge pe cele anterioare:

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

Dacă vrei să separi ieșirea normală de erori, reține că stdout este descriptorul 1 și stderr este descriptorul 2. Le poți trimite către fișiere diferite sau chiar le poți elimina în /dev/null dacă nu ai nevoie de ele.

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

Comenzi Bash esențiale pentru scripting

Fiecare script Bash se bazează pe un set de comenzi de sistem de bază . Probabil că folosești multe dintre ele zilnic, dar este important să le înțelegi sintaxa atunci când le folosești în scripturi: un spațiu plasat greșit sau o cale neobișnuită pot bloca întregul proces.

Pentru a naviga în sistem, aveți `pwd` (arată directorul curent) și `cd` (schimbă folderele). Pentru a lista conținutul, utilizați `ls` cu numeroasele sale opțiuni. Creați directoare cu `mkdir` , ștergeți fișiere cu `rm` (cu mare atenție) și mutați/copiați fișiere cu `mv` și `cp`.

Comenzile tipice de inspecție a textului includ `cat` (afișează fișierele), `tac` (inversează), `head` , `tail` și instrumente de filtrare precum `grep` , `sed` și `awk` . Acestea stau la baza creării de scripturi care analizează jurnalele, efectuează substituții în bloc sau extrag date specifice.

La nivel de sistem, merită să cunoașteți comenzile `ps` și `top` pentru procese, `kill` pentru terminarea proceselor, `df` și `du` pentru spațiul pe disc și `systemctl` pentru gestionarea serviciilor pe sistemele cu systemd. Toate aceste comenzi sunt integrate în mod natural în scripturi.

În cele din urmă, nu uitați de `man` : manualul. Aproape orice întrebare despre opțiunile și comportamentul comenzii poate primi răspuns cu `man command` . A putea citi fluent o pagină de manual este jumătate din bătălia pentru a deveni administrator.

Structuri de control: condiționale și bucle

Pe măsură ce scripturile tale cresc puțin, vei avea nevoie de ele pentru a lua decizii și a repeta acțiuni. Aici intervin structurile de control : if/else, case, while, until și for.

Condiționalitatea clasică din Bash folosește `if` împreună cu `[ ] ` pentru a evalua condițiile. De exemplu, pentru a verifica dacă un număr este mai mare decât 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

Sintaxa ] este mai modernă și mai sigură decât și permite operatori logici mai convenabili și o gestionare îmbunătățită a șirurilor de caractere. Pentru mai multe cazuri predefinite, case este foarte ușor de citit, mai ales când aveți mai multe valori așteptate:

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

În secțiunea despre bucle, `while` se repetă atâta timp cât o condiție este îndeplinită, `until` face opusul (se repetă până când condiția este adevărată), iar `for` este folosit pentru a itera peste liste, tablouri sau intervale numerice. De exemplu, o buclă `for` pentru a itera prin zilele săptămânii:

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

Și o buclă while tipică cu un contor intern:

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

Funcții în Bash: reutilizarea logicii fără a exagera

Funcțiile din Bash vă permit să grupați comenzile și să le reutilizați de câte ori doriți, ceea ce face ca scriptul dvs. să fie mult mai curat și mai ușor de gestionat. Dincolo de o anumită dimensiune, dacă nu utilizați funcții, ajungeți să aveți un monstru dificil de întreținut.

Acestea pot fi declarate în două moduri echivalente:

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

function hola2 {
  echo "Hola también"
}

Pentru a le invoca, pur și simplu scrieți numele lor pe o linie ca și cum ar fi orice altă comandă. Nu se execută doar pentru că sunt definite, așa că nu uitați să le apelați din corpul scriptului.

Funcțiile primesc parametri poziționali exact ca scriptul: în interiorul funcției se utilizează $1, $2, $# etc. Se poate returna un cod numeric cu return N (destinat să indice succesul sau eroarea) și variabile globale pentru a returna rezultate mai bogate, cum ar fi șiruri de caractere sau tablouri.

În plus, puteți marca variabilele ca locale în cadrul unei funcții, astfel încât acestea să nu „contamineze” restul scriptului. Acest lucru este foarte recomandat pentru a evita suprascrierea accidentală a valorilor globale.

Tablouri și gestionarea textului în Bash

Deși Bash nu este conceput pentru calcule complexe, gestionează suficient de bine tablourile și operațiile cu șiruri de caractere pentru multe sarcini de automatizare. Cunoașterea modului de utilizare a acestora extinde considerabil ceea ce puteți face cu doar câteva comenzi.

O matrice simplă este definită după cum urmează:

frutas=(Pera Manzana Plátano)

Accesezi elemente individuale cu ${fruits} , le obții pe toate cu ${fruits} , numărul de elemente cu ${#fruits} și indicii utilizați cu ${!fruits} . Aceasta din urmă este utilă atunci când există „goluri” în matrice și vrei să iterezi doar peste pozițiile valide.

Pentru a itera prin întregul sistem, puteți utiliza o buclă for pe indici:

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

Bash acceptă mai multe operații încorporate asupra șirurilor de text : length ( ${#str} ), substrings ( ${str:N:M} ), substitutions ( ${str/ant/new} , ${str//ant/new} ), trimming of prefix and suffix ( ${str#text} , ${str%text} ) etc. Aceste instrumente elimină necesitatea utilizării sed sau awk pentru sarcini simple.

Pentru manipulări de text mai serioase - de exemplu, jurnale mari sau date tabelare - veți avea nevoie de grep, sed, awk, cut și altele asemenea, pe care le puteți lega împreună în pipe-uri sau le puteți integra direct în funcțiile Bash.

Permisiuni, execuție și cron: de la script independent la sarcină programată

După ce ai scris scriptul, trebuie să îl faci executabil și să decizi cum îl vei lansa. Pasul tipic este să aplici:

chmod +x mi_script.sh

De acolo, îl puteți rula cu `./my_script.sh` dacă vă aflați în același director sau referindu-vă la calea sa absolută: `/full/path /my_script.sh`. O altă opțiune este să îl invocați prin `bash my_script.sh` fără a-i acorda permisiuni de execuție, deși aceasta nu este o practică obișnuită în mediile de producție.

Când doriți ca scriptul să ruleze periodic (zilnic, săptămânal, la fiecare 5 minute etc.), intră în joc cron . Cu `crontab -e` puteți edita tabelul de activități al utilizatorului și puteți defini lucruri precum:

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

Prima linie rulează un script la miezul nopții în fiecare zi; a doua, la fiecare 5 minute. Câmpurile indică minutul, ora, ziua lunii, luna și ziua săptămânii, în această ordine. Puteți vedea ce este deja programat folosind `crontab -l` .

Dacă ceva nu merge bine, cel mai bine este să verificați jurnalele de sistem . Pe Debian/Ubuntu, mesajele cron sunt de obicei înregistrate în /var/log/syslog . Revizuirea lor vă va spune dacă jobul a rulat, dacă s-a blocat din cauza unor probleme de permisiuni sau dacă nici măcar nu a pornit.

Depanare, cele mai bune practici și variabile speciale în Bash

Depanarea scripturilor Bash are trucurile ei deoarece, în mod implicit, shell-ul continuă să se execute chiar dacă o comandă eșuează. Pentru a pune ordine în problemă, cel mai bine este să activați modul strict și să utilizați opțiunile de depanare oferite de Bash.

Pune ceva de genul acesta la începutul scriptului:

set -euo pipefail
set -x

Acest lucru face ca scriptul să se oprească la prima eroare ( -e ), să trateze variabilele nedefinite ca erori ( -u ), să detecteze erorile în conducte ( pipefail ) și să afișeze fiecare comandă extinsă înainte de a o executa ( -x ). În timpul dezvoltării, acest lucru este neprețuit; în producție, s-ar putea să preferați să activați -x doar în anumite secțiuni.

Pe lângă BASH_REMATCH (foarte utilă cu expresii regulate), Bash are variabile interne precum BASH_SUBSHELL (nivelul curent al subshell-ului), BASH_ENV (fișierul încărcat la pornirea unui subshell), BASH_EXECUTION_STRING (comanda executată) și BASH_VERSION (versiunea interpretorului). Toate acestea vă ajută să adaptați comportamentul scriptului la mediu, să depanați probleme neobișnuite și să asigurați compatibilitatea.

Ca bune practici suplimentare, se recomandă utilizarea unor nume de variabile descriptive , evitarea cuvintelor rezervate, documentarea funcțiilor, validarea întotdeauna a datelor introduse de utilizator și verificarea codurilor de ieșire ale comenzilor critice (copii de rezervă, ștergeri, mutări în bloc).

Și nu uitați de instrumente externe precum ShellCheck , care vă analizează scripturile și vă avertizează asupra erorilor subtile, practicilor greșite și construcțiilor periculoase. Integrarea lor în editorul sau în canalul CI/CD este o modalitate ușoară de a îmbunătăți calitatea.

Colecții de utilitare și interfețe grafice Bash pentru scripturile tale

Pe lângă funcțiile încorporate ale Bash, există framework-uri puternice și colecții de funcții găzduite pe GitHub pe care le puteți „conecta” la propriile scripturi folosind `source` . Acest lucru vă permite să încorporați în câteva secunde utilitare care altfel v-ar lua mult timp să le dezvoltați.

Un exemplu este Bashmatic , un framework cu sute de funcții care facilitează totul, de la formatarea ieșirilor și a jurnalelor până la executarea simultană a sarcinilor, gestionarea configurației și interacțiunea cu servicii externe. Se concentrează în mare măsură pe furnizarea de feedback clar dezvoltatorului în timp ce scriptul rulează, ceea ce este apreciat în special atunci când procesele durează minute sau ore pentru a fi finalizate.

Pentru a rula sarcini în paralel, proiecte precum bash-concurrent oferă o funcție gata de utilizare care lansează mai multe sarcini simultan și afișează ieșirea ordonată pe măsură ce acestea se termină. Acest lucru este ideal pentru scripturile care trebuie să proceseze multe elemente independente (mai multe servere, fișiere etc.).

Dacă aveți nevoie de interfețe grafice ușoare pe lângă Bash, există proiecte precum EasyBashGUI sau Script-Dialog care generează dialoguri GUI sau TUI în funcție de ce aveți instalat: kdialog, zenity, whiptail, dialog … În acest fel, același script poate funcționa bine indiferent dacă îl rulați dintr-un mediu grafic sau dintr-un terminal pur.

Ideea generală cu aceste biblioteci este întotdeauna aceeași: descarci sau clonezi repozitoriul, iar în scriptul tău adaugi o linie de genul ` source /path/to/utilities.sh` . Din acel moment, toate funcțiile definite în acel fișier devin disponibile în scriptul tău, ca și cum ar fi ale tale.

În cele din urmă, stăpânirea scriptării Bash și cunoașterea câtorva utilitare terțe vă oferă o trusă masivă de instrumente pentru automatizarea Linux (și a mediilor similare) fără a pierde timpul reinventând roata. De la scripturi personale mici la procese critice de administrare a sistemului, combinația de comenzi bine-cunoscute, structuri de control clare, practici bune de depanare și biblioteci externe face din Bash o componentă cheie a oricărui flux de lucru tehnic serios.