...
Pregătire interviuri

100 de întrebări de interviu Linux, cu răspunsuri

Întrebările despre Linux care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Linux: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 136 minde citit
Întrebări de interviu Linux cu răspunsuri

La un interviu în care se verifică Linux, fie pentru un rol de backend, QA, DevOps sau suport, întrebările vin de obicei în trei forme: teorie scurtă (ce face o comandă, ce înseamnă o permisiune), exerciții în terminal (scrie un one-liner, citește un script și spune ce afișează) și scenarii de depanare („serviciul nu pornește”, „discul e plin”, „primești Permission denied”). Uneori primești și o temă: un script Bash care procesează un log sau automatizează un backup.

La nivel junior se așteaptă să te miști sigur prin terminal: navigare, fișiere, permisiuni, procese, pipe-uri, grep și primele scripturi. La nivel mid se verifică dacă știi de ce se întâmplă lucrurile: cum interpretează shell-ul o linie, cum funcționează systemd și cron, cum depanezi metodic fără să strici nimic pe un server care rulează. Întrebările de nivel senior sunt despre detalii de sistem și despre siguranța modificărilor în producție.

Întrebările sunt grupate pe teme, de la junior la senior. Citește întâi răspunsul scurt și încearcă să-l spui cu voce tare, apoi verifică răspunsul detaliat. Cel mai bun exercițiu: rulează fiecare exemplu într-un terminal, schimbă-l și vezi ce se întâmplă.

Fișiere, foldere și navigare

1 Junior

Ce găsești, în mare, în folderele /etc, /var, /home, /usr, /tmp și /opt?

Răspuns scurt: /etc are configurările sistemului, /var datele care se schimbă (loguri, cozi, cache), /home folderele utilizatorilor, /usr programele și bibliotecile instalate, /tmp fișiere temporare, /opt aplicații instalate separat.

Structura vine din Filesystem Hierarchy Standard (FHS), respectată în linii mari de majoritatea distribuțiilor. Totul pornește dintr-o singură rădăcină, /, chiar dacă datele stau pe mai multe discuri.

  • /etc: fișiere de configurare text, de exemplu /etc/passwd, /etc/fstab, /etc/nginx/. Aici editezi când schimbi comportamentul unui serviciu.
  • /var: date variabile: /var/log (loguri), /var/lib (starea aplicațiilor, de exemplu baze de date), /var/cache, /var/spool (cozi de mail sau cron).
  • /home/<user>: fișierele personale; root are propriul folder, /root.
  • /usr: programe (/usr/bin), biblioteci (/usr/lib), documentație. Software-ul compilat local merge, prin convenție, în /usr/local.
  • /tmp: fișiere temporare, șterse de obicei la repornire sau periodic.
  • /opt: pachete de aplicații de la terți, instalate într-un singur folder.
  • /bin, /sbin, /lib: pe distribuțiile moderne sunt adesea link-uri spre echivalentele din /usr.
  • /proc și /sys: sisteme de fișiere virtuale generate de kernel.
  • /dev: fișierele de dispozitiv.

La interviu contează să știi unde cauți: configurarea în /etc, logurile în /var/log, binarul cu which sau în /usr/bin. De asta depinde cât de repede depanezi pe un server pe care nu l-ai mai văzut.

Ce urmărește intervievatorul: Verifică dacă te orientezi pe un server necunoscut. Greșeala tipică: confuzia între /usr (programe) și „user”, sau ideea că logurile stau în folderul aplicației.

2 Junior

Care e diferența dintre o cale absolută și una relativă? Ce înseamnă ., .., ~ și cd -?

Răspuns scurt: O cale absolută începe cu / și pornește din rădăcină; una relativă pornește din folderul curent. . e folderul curent, .. părintele, ~ folderul tău personal, iar cd - te întoarce în folderul anterior.

Shell-ul ține minte folderul curent (îl vezi cu pwd). O cale relativă se rezolvă față de el, una absolută nu depinde de el.

BASH
pwd                 # /home/ana/proiect
cd src              # relativă -> /home/ana/proiect/src
cd ../docs          # urcă un nivel, apoi intră în docs
cd /var/log         # absolută, funcționează de oriunde
cd ~                # /home/ana (la fel ca simplul cd)
cd -                # înapoi în /home/ana/proiect/docs
ls ~/proiect/*.md   # ~ se expandează de shell

~ este expandat de shell în valoarea lui $HOME, iar ~maria înseamnă folderul personal al utilizatorului maria. Atenție: ~ nu se expandează între ghilimele, așa că "~/fisier" este un nume literal.

. apare des când rulezi un script din folderul curent: ./deploy.sh. Folderul curent nu e în PATH din motive de securitate, așa că simplul deploy.sh dă „command not found”.

În scripturi, căile absolute sunt mai sigure, pentru că scriptul poate fi rulat din alt folder (de exemplu din cron, unde folderul curent este de obicei home-ul utilizatorului). Un tipar util este cd "$(dirname "$0")" la începutul scriptului, ca să lucrezi relativ la locul în care se află scriptul.

Ce urmărește intervievatorul: E o întrebare de bază care arată cât de des ai lucrat efectiv în terminal. Candidații uită adesea că ~ nu se expandează între ghilimele și că scripturile rulate din cron au alt folder curent.

Eroarea, în practică:No such file or directorycd: No such file or directory

3 Junior

Explică fiecare coloană din această linie afișată de ls -la:

-rw-r--r-- 1 ana dev 4096 Oct 12 09:30 .bashrc

Răspuns scurt: Tipul și permisiunile, numărul de link-uri hard, proprietarul, grupul, mărimea în bytes, data ultimei modificări și numele. Punctul din față face fișierul ascuns, de aceea apare doar cu -a.

Coloanele, pe rând:

  • -rw-r--r--: primul caracter e tipul (- fișier obișnuit, d director, l link simbolic, c/b dispozitive, s socket, p pipe). Urmează trei grupuri de câte trei: permisiunile proprietarului, ale grupului și ale celorlalți.
  • 1: numărul de link-uri hard spre același inode. La directoare include intrarea . și subdirectoarele.
  • ana: utilizatorul proprietar.
  • dev: grupul proprietar.
  • 4096: mărimea în bytes; ls -lh o afișează în K, M, G.
  • Oct 12 09:30: data ultimei modificări a conținutului (mtime). Pentru fișiere mai vechi de jumătate de an, ls afișează anul în loc de oră.
  • .bashrc: numele.

Flag-urile contează: -l înseamnă format lung, -a include fișierele care încep cu punct (inclusiv . și ..), -A le include fără . și .., -t sortează după dată, -r inversează, -S sortează după mărime. Combinația ls -lhtr e utilă în foldere de loguri: cel mai recent fișier apare ultimul.

Fișierele „ascunse” nu au nimic special în afară de convenția punctului: majoritatea configurărilor personale (.bashrc, .ssh/, .gitconfig) sunt așa ca să nu aglomereze listarea obișnuită.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că citești rapid informația, nu doar că știi comanda. Mulți nu știu ce înseamnă numărul de link-uri sau ce indică primul caracter.

4 Junior

Cine expandează wildcard-urile *, ?, [...] și {a,b}: comanda sau shell-ul? Ce afișează echo *.xyz dacă nu există niciun astfel de fișier?

Răspuns scurt: Shell-ul le expandează înainte să pornească comanda, care primește deja lista de nume. Dacă nimic nu se potrivește, Bash transmite implicit textul neschimbat, deci echo afișează *.xyz.

Acest mecanism se numește globbing. Când scrii rm *.log, rm nu vede niciodată steluța: shell-ul caută fișierele potrivite din folderul curent și rulează de fapt rm a.log b.log c.log.

  • * potrivește orice șir, inclusiv gol, dar nu fișierele care încep cu punct.
  • ? potrivește exact un caracter: file?.txt prinde file1.txt, nu file10.txt.
  • [abc] sau [0-9] potrivește un caracter din set.
  • {a,b} și {1..5} nu sunt globbing, ci brace expansion: generează șiruri chiar dacă fișierele nu există. mkdir -p proiect/{src,test,docs} creează trei foldere.
BASH
ls
# a.txt  b.txt
echo *.txt     # a.txt b.txt
echo *.xyz     # *.xyz  (nicio potrivire, textul rămâne)
echo {x,y}.md  # x.md y.md (nu verifică existența)

Comportamentul fără potrivire poate fi periculos în scripturi: for f in *.csv va rula o dată cu f='*.csv' dacă folderul e gol. Soluții: shopt -s nullglob (expansiune goală) sau un test [ -e "$f" ] || continue.

Pentru că shell-ul face expansiunea, la find . -name "*.log" pui ghilimele: vrei ca find să primească modelul, nu lista fișierelor din folderul curent.

Ce urmărește intervievatorul: Verifică dacă înțelegi cine face ce între shell și comandă. Greșeala clasică: find -name *.log fără ghilimele, care merge uneori și eșuează inexplicabil alteori.

Eroarea, în practică:find: paths must precede expressioncannot move to a subdirectory of itself

5 Junior

Cum ștergi un fișier numit -f și cum te ferești de ștergeri accidentale cu rm?

Răspuns scurt: Cu rm -- -f sau rm ./-f, ca numele să nu fie citit ca opțiune. rm nu are coș de gunoi, așa că verifici întâi cu ls același model, folosești -i la nevoie și eviți variabilele necitate în căi.

Majoritatea comenzilor tratează argumentele care încep cu - ca opțiuni. -- marchează sfârșitul opțiunilor; tot ce urmează e argument. Varianta ./-f funcționează pentru că numele nu mai începe cu cratimă.

BASH
rm -- -f
rm ./-f
rmdir gol/          # șterge doar foldere goale
rm -r folder/       # recursiv
rm -ri folder/      # cere confirmare pentru fiecare fișier

Reguli practice care evită dezastre:

  • Rulează întâi ls cu exact același model (ls *.tmp), apoi înlocuiește ls cu rm.
  • rm nu mută fișierele într-un coș; spațiul e marcat liber, iar recuperarea e incertă. Pentru date importante contează backup-ul.
  • Într-un script, rm -rf "$DIR/"* cu DIR gol devine rm -rf /*. Folosește ${DIR:?}, care oprește scriptul dacă variabila e goală, și set -u.
  • GNU rm refuză implicit rm -rf / (opțiunea --preserve-root), dar nu și /*.
  • rmdir e mai sigur decât rm -r când te aștepți ca folderul să fie gol: dacă nu e, primești eroare.

La interviu poți spune și că, pe servere, preferi să muți întâi fișierele într-un folder de carantină sau să comprimi logurile vechi, în loc să ștergi direct.

Ce urmărește intervievatorul: Testează reflexele de siguranță. Candidații știu rm -rf, dar puțini știu de -- sau de capcana variabilei goale într-un script.

6 Junior

Ai dat peste o comandă pe care nu o cunoști. Cum afli ce face și de unde vine? Ce diferență este între which și type?

Răspuns scurt: Folosești man comanda, comanda --help și type comanda. which caută doar fișiere executabile în PATH, pe când type spune ce va rula Bash de fapt: alias, funcție, comandă internă (builtin) sau fișier.

Sursele de ajutor, în ordinea în care le folosești de obicei:

  • comanda --help: rezumat rapid al opțiunilor, convenție GNU.
  • man comanda: manualul complet; în man cauți cu /text, n sare la următorul rezultat, q iese. Secțiunile contează: man 5 crontab arată formatul fișierului, man 1 crontab comanda.
  • man -k cuvânt (sau apropos): caută comenzi după descriere.
  • help cd: pentru builtin-urile Bash, care nu au pagini man separate.
BASH
type ls      # ls is aliased to `ls --color=auto'
type cd      # cd is a shell builtin
type ll      # poate fi alias sau funcție
which python3   # /usr/bin/python3
type -a echo    # arată toate variantele: builtin și /usr/bin/echo

Diferența contează la depanare. Dacă which arată un binar, dar shell-ul rulează un alias cu alt comportament, which te minte. De asemenea, cd nu poate fi un program extern: un proces copil nu poate schimba folderul curent al părintelui, deci trebuie să fie builtin.

Pentru a afla din ce pachet vine un fișier: dpkg -S /usr/bin/curl pe Debian/Ubuntu sau rpm -qf /usr/bin/curl pe familia Red Hat.

Ce urmărește intervievatorul: Arată dacă știi să te descurci singur. Mulți folosesc doar căutarea pe internet și nu știu că which ignoră alias-urile și builtin-urile.

Eroarea, în practică:command not foundinvalid option / unrecognized option

7 Junior

Ce diferență este între cp -r și cp -a? Și de ce mv pe un fișier de 10 GB este instantaneu uneori și lent alteori?

Răspuns scurt: cp -r copiază recursiv, dar fișierele noi primesc proprietarul tău și data curentă; cp -a păstrează permisiunile, proprietarii, datele și link-urile simbolice. mv în același sistem de fișiere doar redenumește intrarea; între sisteme diferite copiază și apoi șterge.

cp -a (archive) este echivalent cu -dR --preserve=all: recursiv, păstrează link-urile simbolice ca link-uri (nu copiază ținta), modul, proprietarul (dacă ai dreptul), timpii și atributele extinse. E alegerea potrivită când faci o copie de rezervă a unui folder de configurare sau muți date între directoare.

BASH
cp -r site/ site-copie/     # copie simplă
cp -a /etc/nginx /root/nginx.bak
cp -i a.txt b.txt           # întreabă înainte să suprascrie
cp -n a.txt b.txt           # nu suprascrie niciodată

La mv, totul depinde de unde e destinația. Un fișier este, de fapt, un inode cu date, iar directorul conține doar o intrare nume -> inode. Dacă sursa și destinația sunt pe același sistem de fișiere, mv face un apel rename(): schimbă intrarea din director, iar datele nu se mișcă. Durează la fel pentru 1 KB sau 10 GB și e o operație atomică.

Dacă destinația e pe altă partiție sau alt disc (de exemplu din /home pe un disc montat în /mnt/backup), nu se poate redenumi peste granița sistemului de fișiere, așa că mv copiază datele și apoi șterge sursa. Atomicitatea lui rename() este motivul pentru care scrii întâi un fișier temporar în același folder și apoi faci mv peste fișierul final.

Ce urmărește intervievatorul: Verifică dacă înțelegi că un fișier e separat de numele lui. Răspunsul slab se oprește la „-a copiază tot”, fără să explice de ce mv e uneori instant.

Eroarea, în practică:cp: -r not specified; omitting directory

8 Mid

Ce este un inode? Ce informații conține și ce nu conține?

Răspuns scurt: Inode-ul este structura care descrie un fișier: tip, permisiuni, proprietar, grup, mărime, timpi, număr de link-uri și unde sunt blocurile de date. Nu conține numele fișierului: numele stă în director, care leagă un nume de un număr de inode.

Pe sistemele de fișiere clasice Linux (ext4, XFS), fiecare fișier și director are un inode identificat printr-un număr unic în acel sistem de fișiere. Directorul este o listă de perechi nume -> număr de inode.

BASH
ls -i raport.txt      # 1835012 raport.txt
stat raport.txt
#  Size: 2048   Blocks: 8   IO Block: 4096  regular file
#  Inode: 1835012   Links: 1
#  Access: (0644/-rw-r--r--)  Uid: (1000/ana)  Gid: (1000/ana)
#  Modify: ...  Change: ...

Consecințe practice:

  • Două nume pot indica același inode: asta sunt link-urile hard. Datele se eliberează abia când numărul de link-uri ajunge la zero și niciun proces nu mai ține fișierul deschis.
  • Redenumirea nu atinge inode-ul, doar directorul. De aceea redenumirea cere drept de scriere pe director, nu pe fișier.
  • Timpii: mtime (conținut modificat), ctime (metadate modificate, de exemplu permisiuni; nu e „creation time”) și atime (ultimul acces, adesea actualizat relaxat, cu relatime).
  • Numărul de inode-uri e fixat la crearea unui sistem ext4. Poți rămâne fără inode-uri cu spațiu liber pe disc, dacă ai milioane de fișiere mici; verifici cu df -i.

Pentru a găsi toate numele unui inode: find / -xdev -inum 1835012.

Ce urmărește intervievatorul: Este o întrebare care separă utilizatorii de cei care înțeleg sistemul. Greșeala frecventă: să spui că inode-ul conține numele sau că ctime înseamnă data creării.

9 Senior

Ce înseamnă „în Linux totul este un fișier”? Dă exemple din /dev, /proc și /sys.

Răspuns scurt: Kernelul expune dispozitive, procese și setări prin aceeași interfață ca fișierele: le deschizi, citești și scrii cu aceleași apeluri. /dev are dispozitivele, /proc informații despre procese și kernel, /sys dispozitive și drivere.

Ideea vine din Unix: un set mic de apeluri (open, read, write, close) funcționează pe lucruri foarte diferite, așa că uneltele obișnuite (cat, echo, redirecționările) devin unelte de administrare.

  • /dev: fișiere de dispozitiv. /dev/sda e un disc întreg (dispozitiv de tip bloc), /dev/tty terminalul tău. Câteva speciale: /dev/null aruncă tot ce primește, /dev/zero produce zerouri la infinit, /dev/urandom produce bytes aleatori.
  • /proc: sistem de fișiere virtual, generat la citire. /proc/cpuinfo, /proc/meminfo, /proc/loadavg, iar pentru fiecare proces /proc/<pid>/ cu cmdline, environ, status, fd/.
  • /sys: structura dispozitivelor și a driverelor, plus parametri ajustabili.
BASH
head -c 16 /dev/urandom | base64          # 16 bytes aleatori
dd if=/dev/zero of=test.img bs=1M count=100  # fișier de 100 MB
cat /proc/sys/net/ipv4/ip_forward          # 0 sau 1
ls -l /proc/$$/fd                          # descriptorii shell-ului tău

Scrierea în /proc/sys schimbă parametrii kernelului pe loc (temporar); pentru a-i păstra după repornire folosești sysctl cu fișiere în /etc/sysctl.d/.

Nu chiar totul este un fișier: interfețele de rețea, de exemplu, nu au un fișier în /dev, iar socket-urile de rețea se creează prin apeluri dedicate. Dar principiul explică de ce depanarea în Linux se face atât de mult cu cat și ls.

Ce urmărește intervievatorul: Verifică profunzimea: dacă știi că /proc nu e pe disc și că poți citi starea unui proces direct de acolo. Un răspuns bun dă exemple concrete, nu doar sloganul.

Text: grep, find, sed, awk

10 Junior

Ce fac opțiunile -i, -v, -n, -c, -r, -l și -w ale lui grep? Dă câte un exemplu util.

Răspuns scurt: -i ignoră majusculele, -v afișează liniile care nu se potrivesc, -n adaugă numărul liniei, -c numără liniile potrivite, -r caută recursiv, -l listează doar fișierele, iar -w potrivește doar cuvinte întregi.

grep caută linii care conțin un model (o expresie regulată) și e probabil comanda cea mai folosită la depanare.

BASH
grep -i "error" app.log            # Error, ERROR, error
grep -v "^#" nginx.conf            # fără liniile de comentariu
grep -n "listen" nginx.conf        # 12:    listen 80;
grep -c "500" access.log           # câte linii conțin 500
grep -r "DB_HOST" /etc/myapp/      # recursiv în folder
grep -rl "TODO" src/               # doar numele fișierelor
grep -w "id" schema.sql            # nu prinde "valid" sau "idx"
grep -A 3 -B 2 "Traceback" app.log # context: 2 linii înainte, 3 după

Câteva detalii care contează:

  • -c numără linii, nu apariții. Pentru apariții: grep -o "500" access.log | wc -l.
  • -v "^#" lasă și liniile goale; pentru a le elimina și pe ele: grep -v -e "^#" -e "^$".
  • -F tratează modelul ca text fix, fără regex. E mai rapid și te scapă de escaping când cauți ceva ca a.b[0].
  • grep întoarce cod de ieșire 0 dacă a găsit ceva, 1 dacă nu și 2 la eroare. În scripturi folosești grep -q, care nu afișează nimic: if grep -q "^ana:" /etc/passwd; then ....

Pe un access.log, grep " 500 " e mai sigur decât grep 500, care ar prinde și mărimi de răspuns sau ore.

Ce urmărește intervievatorul: Intervievatorul verifică dacă folosești grep cu precizie. Greșeli tipice: confuzia între -c și numărul de apariții și necunoașterea codului de ieșire folosit în scripturi.

Eroarea, în practică:grep: Is a directory

11 Junior

De ce uniq are aproape mereu nevoie de sort înainte? Scrie un pipeline care afișează cele mai folosite 5 shell-uri din /etc/passwd.

Răspuns scurt: uniq elimină doar duplicatele aflate pe linii consecutive, deci liniile identice trebuie aduse una lângă alta cu sort. Pipeline: cut -d: -f7 /etc/passwd | sort | uniq -c | sort -rn | head -5.

uniq citește linie cu linie și compară fiecare linie doar cu precedenta. Pe intrarea a b a, scoate tot a b a. După sort devine a a b, iar uniq produce a b.

BASH
cut -d: -f7 /etc/passwd | sort | uniq -c | sort -rn | head -5
#      18 /usr/sbin/nologin
#       3 /bin/bash
#       1 /bin/sync

Pas cu pas:

  • cut -d: -f7: împarte fiecare linie după : și păstrează câmpul 7, shell-ul de login.
  • sort: grupează valorile identice.
  • uniq -c: comprimă grupurile și pune numărul aparițiilor în față.
  • sort -rn: sortare numerică (-n), descrescătoare (-r). Fără -n, sortarea e lexicografică și „10” ajunge înaintea lui „9”.
  • head -5: primele cinci.

Variante utile: sort -u face sortare și eliminarea duplicatelor într-un singur pas; uniq -d arată doar liniile duplicate; sort -t, -k3,3n sortează un CSV numeric după coloana 3; sort -h înțelege mărimi ca 2K, 1G (util după du -h).

Atenție la cut: separatorul este un singur caracter și nu tratează mai multe spații consecutive ca unul. Pentru ieșiri aliniate cu spații (de exemplu ps), awk '{print $2}' e mai potrivit.

Ce urmărește intervievatorul: Testează înțelegerea modelului „unelte mici legate prin pipe”. Mulți scriu uniq fără sort sau uită -n la sortarea numerelor.

12 Junior

Cum urmărești un log în timp real? Care e diferența dintre tail -f și tail -F, și de ce folosești less în loc de cat pentru fișiere mari?

Răspuns scurt: tail -f afișează liniile noi pe măsură ce sunt scrise. tail -F redeschide fișierul dacă e înlocuit, de exemplu la rotația logurilor. less paginează fără să încarce totul pe ecran și permite căutare și navigare.

tail -f ține fișierul deschis după descriptor. Când logrotate redenumește app.log în app.log.1 și creează un app.log nou, tail -f continuă să urmărească fișierul vechi și nu mai vezi nimic nou. tail -F (echivalent cu --follow=name --retry) urmărește numele și redeschide fișierul când apare unul nou.

BASH
tail -n 100 app.log            # ultimele 100 de linii
tail -F /var/log/nginx/error.log
tail -F app.log | grep --line-buffered ERROR
head -n 20 date.csv            # primele 20 de linii
less +F app.log                # ca tail -f; Ctrl+C oprește urmărirea

cat pe un fișier de câțiva GB inundă terminalul și nu te ajută să găsești nimic. În less:

  • /text caută înainte, ?text înapoi, n/N următorul sau precedentul rezultat;
  • G sare la final, g la început;
  • F intră în modul urmărire, iar Ctrl+C revine la navigare;
  • -S nu împachetează liniile lungi, -N arată numerele de linie.

--line-buffered la grep contează în pipeline-uri continue: fără el, grep scrie ieșirea în blocuri când nu scrie direct în terminal, și pare că nu se întâmplă nimic. Pentru loguri de servicii systemd folosești journalctl -f -u serviciu în loc de fișiere.

Ce urmărește intervievatorul: Verifică experiența reală cu loguri. Diferența dintre -f și -F e un detaliu pe care îl știe cine a pierdut deja minute bune urmărind un fișier rotit.

13 Junior

Scrie comenzi find care găsesc: fișierele .log din /var/log mai mari de 100 MB, fișierele modificate în ultimele 24 de ore din /etc și directoarele goale din folderul curent.

Răspuns scurt: find /var/log -type f -name "*.log" -size +100M, find /etc -type f -mtime -1 și find . -type d -empty. Modelul pentru -name se pune între ghilimele, ca să nu-l expandeze shell-ul.

find parcurge recursiv un arbore și aplică testele de la stânga la dreapta, cu AND implicit între ele.

BASH
find /var/log -type f -name "*.log" -size +100M
find /etc -type f -mtime -1
find . -type d -empty
find /home -type f -iname "*.jpg"          # nume fără diferență de majuscule
find /tmp -type f -mmin +60                # mai vechi de 60 de minute
find . -name "*.bak" -o -name "*.tmp"      # OR
find / -xdev -type f -size +1G 2>/dev/null # nu trece pe alte sisteme de fișiere
find . -maxdepth 1 -type f                 # doar nivelul curent

Detalii care apar la interviu:

  • -type f fișiere, -type d directoare, -type l link-uri simbolice.
  • -mtime -1 înseamnă „mai puțin de o zi” (24 de ore, rotunjit în zile întregi), +7 „mai mult de 7 zile”. -mmin lucrează în minute.
  • -size +100M folosește unități k, M, G; fără unitate, unitatea e blocul de 512 bytes.
  • 2>/dev/null ascunde erorile „Permission denied” din folderele pe care nu le poți citi.
  • -xdev te oprește să cobori în /proc sau în discuri montate, important când cauți ce umple partiția rădăcină.

Spre deosebire de locate, care folosește o bază de date actualizată periodic, find caută live, deci e mai lent, dar mereu corect.

Ce urmărește intervievatorul: Verifică dacă scrii comenzi corecte fără să cauți pe internet. Greșeli tipice: lipsa ghilimelelor la -name și confuzia între -mtime -1 și +1.

Eroarea, în practică:find: paths must precede expressionfind: warning: global option -maxdepth after -name

14 Mid

Care e diferența dintre find ... -exec cmd {} \;, find ... -exec cmd {} + și find ... | xargs cmd? Cum tratezi corect numele de fișiere cu spații?

Răspuns scurt: \; rulează comanda o dată pentru fiecare fișier, + pune multe fișiere într-o singură rulare, iar xargs construiește comenzi din intrarea standard. Pentru nume cu spații folosești find -print0 | xargs -0 sau varianta -exec ... +.

Diferența este numărul de procese pornite și modul în care sunt transmise numele.

BASH
find . -name "*.tmp" -exec rm {} \;       # un rm pentru fiecare fișier
find . -name "*.tmp" -exec rm {} +        # rm a b c ... în loturi mari
find . -name "*.tmp" -print0 | xargs -0 rm
find . -name "*.log" -print0 | xargs -0 -P 4 -n 10 gzip   # 4 în paralel

La 100.000 de fișiere, \; pornește 100.000 de procese, deci e mult mai lent. + se comportă ca xargs: adună cât mai multe argumente în limita lungimii maxime a liniei de comandă.

xargs simplu împarte intrarea după spații și newline-uri, așa că un fișier raport final.txt devine două argumente, raport și final.txt. Soluția este separatorul nul: -print0 scrie numele separate prin caracterul \0, care nu poate apărea într-un nume de fișier, iar xargs -0 le citește așa.

Când ai nevoie de numele în mijlocul comenzii, xargs -I{} rulează câte o comandă pe element: xargs -0 -I{} mv {} arhiva/. -P paralelizează, util pentru comprimare sau descărcări.

Pentru ștergere simplă, find . -name "*.tmp" -delete e cel mai direct. Atenție la ordinea testelor: -delete pus înaintea lui -name șterge tot ce găsește. Rulează întâi cu -print ca să vezi lista.

Ce urmărește intervievatorul: Verifică dacă scrii comenzi care nu se strică pe date reale. Mulți nu știu că xargs simplu sparge numele cu spații sau că \; e foarte lent pe multe fișiere.

Eroarea, în practică:find: missing argument to `-exec'

15 Mid

Cum înlocuiești un text în toate fișierele .conf dintr-un folder cu sed? La ce trebuie să fii atent când folosești -i?

Răspuns scurt: sed -i 's/vechi/nou/g' *.conf modifică fișierele pe loc. Atenție: nu există anulare, deci folosești -i.bak pentru copie, testezi întâi fără -i, alegi alt delimitator când textul are / și știi că -i diferă pe macOS.

Comanda s din sed are forma s/model/înlocuire/flaguri. Flagul g înlocuiește toate aparițiile de pe linie; fără el, doar prima.

BASH
sed 's/localhost/db.intern/g' app.conf           # afișează, nu modifică
sed -i.bak 's/localhost/db.intern/g' *.conf      # modifică, păstrează .bak
sed -i 's|/var/www/vechi|/srv/site|g' site.conf  # delimitator | pentru căi
sed -i 's/^#\?\(PermitRootLogin\).*/\1 no/' sshd_config   # grup capturat
sed -E 's/([0-9]+)\.([0-9]+)/\2.\1/' date.txt    # regex extins cu -E
grep -rl "localhost" conf/ | xargs sed -i 's/localhost/db.intern/g'

Lucruri de știut:

  • Testează întâi fără -i sau cu sed -n 's/.../.../gp', care afișează doar liniile schimbate.
  • Delimitatorul poate fi aproape orice caracter; | sau # evită „gardul” de \/ la căi.
  • În model, ., *, [, ^, $ sunt speciale. Ca să cauți un punct literal scrii \..
  • Variabile: folosește ghilimele duble ca să fie expandate: sed -i "s/VERSIUNE/$v/" f. Dacă $v conține /, comanda se strică, de aici încă un motiv pentru alt delimitator.
  • Pe macOS (BSD sed), -i cere un argument: sed -i '' 's/a/b/' f. Un script scris pe Linux cu sed -i 's/..' poate eșua acolo.
  • sed -i creează un fișier nou și îl redenumește peste cel vechi, deci schimbă inode-ul; un link hard spre fișierul vechi rămâne neschimbat.

Ce urmărește intervievatorul: Arată dacă știi să faci modificări în masă fără riscuri. Răspunsul slab nu menționează testarea fără -i, backup-ul sau problema delimitatorului.

Eroarea, în practică:sed: unterminated `s' commandsed: unknown command

16 Mid

Ai un fișier cu coloane separate prin spații. Folosește awk ca să afișezi coloana a doua, numărul liniei și numărul de câmpuri, apoi suma coloanei a treia.

Răspuns scurt: awk '{print NR, NF, $2}' f afișează numărul liniei, numărul de câmpuri și coloana 2. Suma: awk '{s += $3} END {print s}' f. -F schimbă separatorul, de exemplu -F, pentru CSV simplu.

awk citește intrarea linie cu linie, o împarte în câmpuri ($1, $2, ..., $0 e linia întreagă) și rulează programul pentru fiecare linie. Structura e model { acțiune }; blocurile BEGIN și END rulează înainte și după toată intrarea.

BASH
awk '{print NR, NF, $2}' vanzari.txt
awk '{s += $3} END {print "Total:", s}' vanzari.txt
awk -F, 'NR > 1 {s += $4} END {printf "%.2f\n", s}' vanzari.csv  # sare antetul
awk '$3 > 1000 {print $1, $3}' vanzari.txt        # filtrare pe valoare
awk '{print $NF}' f                               # ultimul câmp
awk -F: '$3 >= 1000 {print $1}' /etc/passwd       # utilizatori obișnuiți

Variabile utile: NR numărul liniei curente din toată intrarea, NF numărul de câmpuri din linie, FS separatorul de intrare, OFS separatorul de ieșire. Implicit, awk separă după orice secvență de spații și tab-uri, deci merge bine cu ieșiri aliniate de tipul ps sau df.

Variabilele neinițializate pornesc de la 0 sau șir gol, de aceea s += $3 funcționează fără declarare. $NF este ultimul câmp, iar $(NF-1) penultimul.

Limita: -F, nu înțelege CSV-uri cu ghilimele care conțin virgule ("Popescu, Ion"). Pentru astfel de fișiere, folosești o unealtă care înțelege formatul (de exemplu Python cu modulul csv) sau GNU awk cu FPAT.

Ce urmărește intervievatorul: Verifică dacă știi să faci calcule rapide pe date direct în terminal. Greșeala frecventă: uitarea antetului din CSV, care intră în sumă ca 0 sau strică filtrele.

Eroarea, în practică:awk: syntax error

17 Mid

Ai un CSV data,categorie,suma cu antet. Scrie un one-liner awk care afișează totalul pe fiecare categorie, sortat descrescător după total.

Răspuns scurt: awk -F, 'NR>1 {t[$2] += $3} END {for (c in t) print t[c], c}' vanzari.csv | sort -rn. Folosești un tablou asociativ indexat după categorie, iar ordinea din for (c in t) nu e garantată, de aceea sortezi după.

Tablourile din awk sunt asociative: cheia poate fi orice șir. E echivalentul unui GROUP BY din SQL.

BASH
cat vanzari.csv
# data,categorie,suma
# 2026-10-01,carti,120
# 2026-10-01,jocuri,80
# 2026-10-02,carti,45.5

awk -F, 'NR > 1 { total[$2] += $3; nr[$2]++ }
END { for (c in total) printf "%.2f %s %d\n", total[c], c, nr[c] }' vanzari.csv | sort -rn
# 165.50 carti 2
# 80.00 jocuri 1

Ce face fiecare parte:

  • NR > 1 sare antetul.
  • total[$2] += $3 adună suma în cheia categoriei; nr[$2]++ numără tranzacțiile, ca să poți calcula și media cu total[c]/nr[c].
  • În END parcurgi cheile. Ordinea lui for (c in t) este nedefinită, așa că sortezi rezultatul cu sort -rn. GNU awk are și PROCINFO["sorted_in"], dar nu e portabil.
  • printf controlează formatul; print ar afișa numerele cu precizia implicită.

Dacă fișierul vine din Windows, are terminații \r\n, iar ultima coloană va conține \r. Suma tot funcționează, dar cheile care stau pe ultima coloană ar diferi. O curățare rapidă: tr -d '\r' < vanzari.csv | awk ... sau sub(/\r$/, "") în awk.

Ce urmărește intervievatorul: Este o întrebare clasică de cod live pentru roluri care lucrează cu loguri sau date. Candidații slabi încearcă bucle Bash lente sau uită că ordinea cheilor nu e garantată.

18 Mid

Ce diferență este între expresiile regulate de bază (BRE), extinse (ERE) și PCRE în grep? Ce potrivește modelul ^[0-9]{1,3}(\.[0-9]{1,3}){3}$?

Răspuns scurt: În BRE, +, ?, {}, | și () trebuie precedate de \ ca să fie speciale; ERE (grep -E) le folosește direct; PCRE (grep -P) adaugă \d, lookahead și altele. Modelul potrivește linii formate doar dintr-un șir de tip IPv4.

Implicit, grep și sed folosesc BRE: ., *, ^, $, [] sunt speciale, dar +, ?, |, {n,m} și grupurile trebuie scrise \+, \?, \|, \{1,3\}, \(...\) (ultimele sunt extensii GNU). Cu -E (sau egrep, învechit) obții ERE, unde aceste caractere sunt speciale direct. grep -P folosește sintaxa Perl, disponibilă în GNU grep, dar nu peste tot.

BASH
grep -E '^[0-9]{1,3}(\.[0-9]{1,3}){3}$' ip.txt
grep '^[0-9]\{1,3\}\(\.[0-9]\{1,3\}\)\{3\}$' ip.txt   # același lucru în BRE
grep -P '\d+ms$' app.log
grep -oE '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[a-z]{2,}' contacte.txt

Modelul din întrebare: ^ și $ ancorează începutul și sfârșitul liniei; [0-9]{1,3} înseamnă 1-3 cifre; (\.[0-9]{1,3}){3} înseamnă de trei ori un punct literal urmat de 1-3 cifre. Potrivește 192.168.1.10, dar și 999.999.999.999, deci verifică forma, nu validitatea. Pentru validare reală compari numeric fiecare octet sau folosești o bibliotecă.

Fără ancore, modelul ar prinde și adresa 10.0.0.1 a picat, ceea ce e bine pentru căutare, dar rău pentru validare. -o afișează doar potrivirea, nu toată linia, foarte util pentru extragere din loguri.

Ce urmărește intervievatorul: Verifică dacă știi de ce un regex „nu merge” în grep, dar merge în alt limbaj. Mulți uită că punctul nescăpat potrivește orice caracter.

Eroarea, în practică:grep: Unmatched [grep: warning: stray \ before d

19 Senior

Ai două liste de utilizatori, una exportată ieri și una azi. Cum afli cine a apărut, cine a dispărut și cum verifici că un fișier de backup copiat pe alt server este identic cu originalul?

Răspuns scurt: Sortezi ambele liste și folosești comm -13 pentru cei noi și comm -23 pentru cei dispăruți; diff arată și el diferențele. Pentru integritate compari sume de control, de exemplu sha256sum, calculate pe fiecare server.

comm compară două fișiere sortate și scoate trei coloane: doar în primul, doar în al doilea, în ambele. Cu -1, -2, -3 ascunzi coloanele pe care nu le vrei.

BASH
sort -u ieri.txt > a; sort -u azi.txt > b
comm -13 a b    # doar în azi: utilizatori noi
comm -23 a b    # doar în ieri: utilizatori dispăruți
comm -12 a b    # în ambele

# fără fișiere temporare, cu process substitution
comm -13 <(sort -u ieri.txt) <(sort -u azi.txt)

diff -u ieri.txt azi.txt     # format unificat, ca la patch-uri
diff -rq dir1/ dir2/         # ce fișiere diferă între două foldere

comm cere intrare sortată cu aceeași ordine de sortare (locale). Dacă una a fost sortată cu LC_ALL=C și alta nu, rezultatul e greșit; în scripturi e sigur să setezi LC_ALL=C pentru ambele.

Pentru fișiere mari copiate între servere, compararea conținutului direct ar cere transferul lor din nou. Calculezi o sumă de control pe fiecare parte și compari doar șirul:

BASH
sha256sum backup.tar.gz > backup.tar.gz.sha256
# pe celălalt server, în același folder:
sha256sum -c backup.tar.gz.sha256    # backup.tar.gz: OK

md5sum detectează la fel de bine coruperea accidentală, dar nu mai e considerat sigur împotriva modificării intenționate; pentru verificarea descărcărilor folosești SHA-256 și, ideal, o semnătură. cmp spune la ce byte diferă două fișiere binare.

Ce urmărește intervievatorul: Verifică dacă alegi unealta potrivită pentru comparații de mulțimi și integritate. Greșeala tipică: comm pe fișiere nesortate sau încrederea doar în mărimea fișierului.

Eroarea, în practică:sha256sum: checksum did NOT match

Pipe-uri, redirecționări și shell

Exersează capitolul cu exerciții reale: Curs Linux pentru începători →
20 Junior

Ce diferență este între cele două comenzi de mai jos, în ce se afișează pe ecran și ce ajunge în fișier?

BASH
ls /nu-exista /tmp > out.txt 2>&1
ls /nu-exista /tmp 2>&1 > out.txt

Răspuns scurt: În prima, atât ieșirea, cât și eroarea ajung în out.txt. În a doua, eroarea apare pe ecran și doar listarea lui /tmp intră în fișier, pentru că redirecționările se aplică de la stânga la dreapta.

Fiecare proces are trei descriptori deschiși: 0 (stdin), 1 (stdout) și 2 (stderr). 2>&1 nu înseamnă „trimite erorile unde va merge stdout”, ci „fă descriptorul 2 o copie a ceea ce este acum descriptorul 1”.

Prima comandă, pas cu pas:

  • > out.txt: descriptorul 1 indică acum fișierul.
  • 2>&1: descriptorul 2 devine copia lui 1, adică tot fișierul.
  • Rezultat: totul ajunge în out.txt, ecranul rămâne gol.

A doua comandă:

  • 2>&1: descriptorul 2 devine copia lui 1, care în acel moment e încă terminalul.
  • > out.txt: doar descriptorul 1 se mută în fișier.
  • Rezultat: mesajul ls: cannot access '/nu-exista' apare pe ecran, iar în fișier ajunge doar conținutul lui /tmp.
BASH
cmd > out.txt 2>&1     # varianta portabilă pentru „tot în fișier”
cmd &> out.txt         # prescurtare Bash, același efect
cmd 2> erori.txt       # doar erorile
cmd >> out.txt 2>&1    # adăugare, nu suprascriere
cmd 2>&1 | grep ERR    # și erorile trec prin pipe

Ultimul exemplu funcționează pentru că pipe-ul se configurează înaintea redirecționărilor: stdout e deja pipe-ul, iar 2>&1 copiază acel pipe. Același principiu explică de ce cmd | grep x nu filtrează erorile: ele merg direct pe ecran.

Ce urmărește intervievatorul: Verifică dacă înțelegi modelul descriptorilor, nu doar sintaxa memorată. Majoritatea candidaților știu 2>&1, dar puțini explică de ce ordinea schimbă rezultatul.

Eroarea, în practică:find: Permission denied

21 Junior

Ce diferență este între ;, && și || între comenzi? Ce problemă are cmd1 && cmd2 || cmd3 folosit ca if/else?

Răspuns scurt: ; rulează comenzile una după alta indiferent de rezultat, && rulează următoarea doar dacă precedenta a reușit (cod 0), || doar dacă a eșuat. a && b || c rulează c și când a reușește, dar b eșuează.

Shell-ul decide pe baza codului de ieșire: 0 înseamnă succes, orice altceva eșec.

BASH
mkdir build ; cd build           # cd rulează chiar dacă mkdir a eșuat
mkdir -p build && cd build       # cd doar dacă mkdir a reușit
cd /app || exit 1                # oprește scriptul dacă folderul lipsește
make && make test && ./deploy.sh # lanț: fiecare pas cere succesul celui anterior

cd /app || exit 1 este un tipar foarte important în scripturi: fără el, dacă cd eșuează, comenzile următoare (de exemplu un rm -rf *) rulează în folderul greșit.

Capcana cu „if/else” scurt:

BASH
ping -c1 server && echo "merge" > /readonly/f || echo "server căzut"

Dacă ping reușește, dar scrierea eșuează, se afișează „server căzut”, deși serverul răspunde. || se aplică rezultatului întregului a && b, nu doar lui a. Când partea din mijloc poate eșua, scrii un if real:

BASH
if ping -c1 -W2 server >/dev/null; then
  echo "merge"
else
  echo "server căzut"
fi

&& și || au aceeași prioritate și se evaluează de la stânga la dreapta, iar ; și newline-ul separă comenzi complete. Pentru grupare folosești { ...; }.

Ce urmărește intervievatorul: Arată dacă scrii scripturi care se opresc corect la erori. Greșeala frecventă e folosirea lui a && b || c ca if/else în situații în care b poate eșua.

22 Junior

Ce este un here-document? Ce diferență este între <<EOF și <<'EOF' și la ce folosește <<<?

Răspuns scurt: Un here-document trimite mai multe linii de text ca intrare standard unei comenzi, până la linia cu marcajul final. Cu <<EOF variabilele și $(...) se expandează; cu <<'EOF' textul rămâne literal. <<< (here-string) trimite un singur șir.

Here-document-ul e util când vrei să generezi un fișier de configurare dintr-un script sau să dai mai multe linii unei comenzi.

BASH
NUME=ana
cat <<EOF
Salut, $NUME
Azi este $(date +%F)
EOF
# Salut, ana
# Azi este 2026-10-31

cat <<'EOF' > /usr/local/bin/info.sh
#!/bin/bash
echo "Utilizator: $USER"
EOF
# fișierul conține literal $USER, va fi expandat abia la rulare

Diferența dintre forme:

  • <<EOF: expandează $var, $(cmd) și \. Potrivit când completezi un șablon cu valori din script.
  • <<'EOF' (sau <<"EOF"): nu expandează nimic. Potrivit când scrii un alt script sau un text cu $ care trebuie păstrat.
  • <<-EOF: elimină tab-urile de la începutul liniilor (doar tab-uri, nu spații), ca să poți indenta în interiorul unei funcții.

Marcajul de final trebuie să fie singur pe linie, fără spații înainte (în afară de tab-uri cu <<-) sau după.

Here-string-ul trimite un șir ca intrare:

BASH
read -r an luna zi <<< "2026 10 31"
grep -c "a" <<< "$text"
bc <<< "scale=2; 10/3"     # 3.33

Pentru a scrie un fișier ca root, combini cu tee: sudo tee /etc/app.conf > /dev/null <<'EOF' ... EOF.

Ce urmărește intervievatorul: Verifică dacă știi să generezi fișiere din scripturi fără zeci de echo. Greșeala tipică: $ expandat accidental pentru că marcajul nu a fost pus între ghilimele.

23 Junior

De ce sudo echo "nameserver 1.1.1.1" > /etc/resolv.conf dă „Permission denied” și cum o scrii corect?

Răspuns scurt: Redirecționarea > o face shell-ul tău, care rulează ca utilizator obișnuit, nu sudo. Doar echo primește drepturi de root. Variantele corecte sunt echo ... | sudo tee /etc/resolv.conf sau sudo sh -c 'echo ... > /etc/resolv.conf'.

Shell-ul analizează linia înainte să pornească vreo comandă. Vede > /etc/resolv.conf, încearcă să deschidă fișierul pentru scriere cu drepturile tale și eșuează. sudo nici nu ajunge să ruleze.

BASH
echo "nameserver 1.1.1.1" | sudo tee /etc/resolv.conf
echo "vm.swappiness=10" | sudo tee -a /etc/sysctl.d/99-local.conf  # adaugă
echo "linie" | sudo tee /etc/x > /dev/null    # fără afișare pe ecran
sudo sh -c 'echo "nameserver 1.1.1.1" > /etc/resolv.conf'

tee citește intrarea standard și o scrie atât în fișier, cât și pe ecran. Aici e util pentru că tee este procesul care deschide fișierul, iar el rulează cu sudo. -a adaugă la final în loc să suprascrie, echivalentul lui >>.

sudo sh -c '...' rulează tot șirul într-un shell de root, deci și redirecționarea. Atenție la ghilimele: cu ghilimele simple, variabilele tale nu sunt expandate în interior.

tee e util și în afara lui sudo: make 2>&1 | tee build.log îți arată ieșirea live și o salvează.

Un detaliu de context: pe multe sisteme cu systemd, /etc/resolv.conf e un link gestionat de systemd-resolved, iar modificarea manuală se pierde. Configurarea DNS se face atunci în fișierele serviciului, nu direct.

Ce urmărește intervievatorul: Este o capcană clasică ce arată dacă înțelegi că redirecționările țin de shell. Cine răspunde bine explică de ce, nu doar dă soluția tee.

Eroarea, în practică:sudo echo > fișier: Permission denied

24 Mid

Ce afișează scriptul de mai jos și de ce? Cum îl repari?

BASH
count=0
cat users.txt | while read -r u; do
  count=$((count + 1))
done
echo "Total: $count"

Răspuns scurt: Afișează Total: 0, pentru că fiecare parte a unui pipe rulează într-un subshell, iar count se modifică doar în copia din subshell. Repari cu redirecționare: while ...; done < users.txt.

Într-un pipeline, Bash rulează fiecare comandă într-un proces separat. Bucla while e într-un subshell, care primește o copie a variabilelor. Incrementările se fac acolo, iar când pipe-ul se termină, subshell-ul dispare cu tot cu valoarea. În shell-ul părinte, count a rămas 0.

Variante corecte:

BASH
count=0
while read -r u; do
  count=$((count + 1))
done < users.txt
echo "Total: $count"

# când intrarea vine dintr-o comandă, process substitution
while read -r u; do
  count=$((count + 1))
done < <(grep -v '^#' users.txt)

# în Bash 4.2+, în scripturi (fără job control)
shopt -s lastpipe

shopt -s lastpipe face ca ultima comandă din pipe să ruleze în shell-ul curent, dar funcționează doar când job control-ul e dezactivat, adică în scripturi, nu în terminalul interactiv.

Același mecanism explică și alte surprize: echo "x" | read v nu setează v, iar ( cd /tmp ) nu schimbă folderul curent. Parantezele rotunde creează explicit un subshell, acoladele { ...; } grupează comenzile în shell-ul curent.

Dacă vrei doar numărul de linii, wc -l < users.txt e mult mai simplu. Bucla are rost când faci ceva pentru fiecare linie.

Ce urmărește intervievatorul: Este o întrebare de tip „ce afișează” care verifică modelul de procese al shell-ului. Aproape toți candidații prind o dată bug-ul acesta în practică; intervievatorul vrea să vadă dacă îl și explici.

25 Mid

Ce face <(...), adică process substitution? Dă un exemplu în care te scapă de fișiere temporare.

Răspuns scurt: <(cmd) rulează comanda și îi oferă ieșirea ca pe un fișier, printr-o cale de tip /dev/fd/63. Așa poți da ieșirea unei comenzi unui program care cere nume de fișier, de exemplu diff <(sort a) <(sort b).

Unele programe acceptă doar nume de fișiere, nu intrare standard, sau au nevoie de două intrări simultan. Pipe-ul obișnuit nu ajută, pentru că oferă o singură intrare. Process substitution creează un pipe cu nume (sau un /dev/fd/N) și pune calea lui în linia de comandă.

BASH
echo <(true)
# /dev/fd/63

diff <(sort lista1.txt) <(sort lista2.txt)
diff <(ssh web1 cat /etc/nginx/nginx.conf) <(ssh web2 cat /etc/nginx/nginx.conf)
comm -12 <(sort a.txt) <(sort b.txt)

while read -r user; do
  echo "procesez $user"
done < <(cut -d: -f1 /etc/passwd)

tar czf - date/ | tee >(sha256sum > date.sha256) > date.tar.gz

Exemplul cu două servere arată avantajul: compari configurările direct, fără să copiezi fișiere și fără să cureți fișiere temporare după.

Forma >(cmd) este inversa: îți dă un „fișier” în care scrii și care ajunge la intrarea comenzii. În ultimul exemplu, tee scrie arhiva simultan în fișier și în sha256sum, deci calculezi suma fără să citești arhiva de două ori.

Limite: e o funcție Bash (și zsh, ksh), nu există în sh POSIX, deci un script cu #!/bin/sh pe Ubuntu, unde sh este dash, dă eroare de sintaxă. „Fișierul” poate fi citit o singură dată, secvențial, deci nu merge cu programe care sar înainte și înapoi în fișier.

Ce urmărește intervievatorul: Verifică familiaritatea cu Bash dincolo de bază. Un candidat bun știe și de ce nu merge în sh și când e preferabil unui fișier temporar.

26 Mid

Ce afișează codul de mai jos? Cum afli care comandă din pipeline a eșuat?

BASH
grep "x" fisier-care-nu-exista.txt | sort | head -3
echo "cod: $?"

Răspuns scurt: Afișează cod: 0: fără pipefail, codul unui pipeline este cel al ultimei comenzi, head, care a reușit. Codurile fiecărei comenzi se află în tabloul PIPESTATUS, aici 2 0 0.

grep scrie eroarea pe stderr și iese cu 2, dar sort primește o intrare goală și reușește, iar head la fel. Shell-ul raportează în $? doar codul ultimei comenzi.

BASH
grep "x" lipsa.txt | sort | head -3
echo "${PIPESTATUS[@]}"     # 2 0 0

PIPESTATUS trebuie citit imediat după pipeline: orice altă comandă, chiar și echo "$?", îl suprascrie. Dacă ai nevoie și de $?, și de tablou, le salvezi împreună: rc=("${PIPESTATUS[@]}").

Opțiuni pentru a trata eșecul în scripturi:

BASH
set -o pipefail
grep "x" lipsa.txt | sort | head -3
echo $?    # 2: cel mai din dreapta cod nenul

Cu pipefail, codul pipeline-ului este al ultimei comenzi care a eșuat, sau 0 dacă toate au reușit.

Un efect secundar de cunoscut: pipefail poate raporta eșecuri care nu sunt reale. Când head închide pipe-ul după primele linii, comanda din stânga primește SIGPIPE și iese cu 141. Într-un script cu set -eo pipefail, cat fisier-mare | head -1 poate opri scriptul. Rezolvi citind direct (head -1 fisier-mare) sau acceptând explicit codul: cmd | head -1 || true, cu grijă să nu ascunzi erori reale.

Mai e un caz: grep iese cu 1 când nu găsește nimic, ceea ce nu e o eroare logică, dar pipefail îl tratează ca eșec.

Ce urmărește intervievatorul: Arată dacă știi de ce scripturile „au mers” deși un pas a eșuat. Candidatul bun știe și de PIPESTATUS, nu doar de pipefail, și de efectul SIGPIPE.

27 Mid

De ce se termină imediat comanda yes | head -n 3, deși yes scrie la infinit? Ce se întâmplă în spate?

Răspuns scurt: head citește trei linii și iese, închizând capătul de citire al pipe-ului. Când yes scrie în continuare, kernelul îi trimite semnalul SIGPIPE, care îl oprește. Pipe-ul are un buffer mic, deci yes nu umple memoria.

Un pipe este un buffer din kernel cu două capete: unul de scriere și unul de citire. Shell-ul pornește ambele procese în paralel, nu unul după altul, și le conectează stdout-ul și stdin-ul la pipe.

Ce se întâmplă:

  • yes scrie y\n în pipe. Când buffer-ul se umple (pe Linux, implicit 64 KiB), apelul write blochează procesul până se face loc. Așa se reglează automat viteza celor două procese.
  • head citește trei linii, le afișează și iese.
  • Capătul de citire nu mai are niciun proces. Următorul write al lui yes primește SIGPIPE, iar acțiunea implicită a semnalului este terminarea procesului.
BASH
yes | head -n 3
echo "${PIPESTATUS[@]}"   # 141 0   (128 + 13, SIGPIPE are numărul 13)

Consecințe practice:

  • Poți procesa fișiere enorme cu zcat log.gz | grep x | head fără să citești totul: când head termină, lanțul se oprește.
  • Un pipeline nu folosește fișiere temporare, iar memoria e limitată la buffere.
  • Codul 141 apare în scripturi cu pipefail și poate fi confundat cu o eroare reală.
  • Un program care ignoră SIGPIPE primește în schimb eroarea EPIPE la scriere; Python, de exemplu, afișează BrokenPipeError în astfel de situații.

Codurile peste 128 înseamnă, prin convenție, „terminat de semnalul cod minus 128”: 130 este Ctrl+C (SIGINT), 137 este SIGKILL, 143 este SIGTERM.

Ce urmărește intervievatorul: Verifică înțelegerea pipe-urilor ca mecanism al kernelului, nu doar ca sintaxă. Cine știe convenția 128+N citește mult mai repede codurile de ieșire din loguri.

28 Senior

În ce ordine face Bash expansiunile pe o linie de comandă? De ce contează ordinea în practică?

Răspuns scurt: Ordinea este: brace expansion, tilde, apoi parametri, aritmetică și substituție de comenzi (de la stânga la dreapta), apoi word splitting, apoi globbing și, la final, eliminarea ghilimelelor. Contează pentru că rezultatul unei variabile poate fi spart în cuvinte și expandat ca wildcard.

Shell-ul transformă linia în mai mulți pași, iar fiecare pas lucrează pe rezultatul celui anterior:

  • brace expansion: {a,b}, {1..3};
  • tilde: ~, ~user;
  • parametri și variabile, aritmetică $(( )), substituție de comenzi $( ), de la stânga la dreapta;
  • word splitting: rezultatele expansiunilor necitate sunt sparte după caracterele din IFS (spațiu, tab, newline);
  • globbing: fiecare cuvânt care conține *, ? sau [ e înlocuit cu fișierele potrivite;
  • eliminarea ghilimelelor.

Consecințe concrete:

BASH
n=3
echo {1..$n}        # {1..3}: brace expansion are loc înaintea variabilelor
seq 1 "$n"          # soluția

f="raport *.txt"
ls $f               # word splitting -> "raport", "*.txt", apoi globbing pe *.txt
ls "$f"             # un singur argument, fără globbing

dir="~/date"
cd "$dir"           # eșuează: tilda nu se expandează din variabilă
dir="$HOME/date"    # corect

Ghilimelele duble opresc word splitting și globbing, dar permit expansiunea variabilelor și a lui $( ). Ghilimelele simple opresc tot. De aceea regula „pune variabilele între ghilimele” este cea mai importantă regulă de robustețe în Bash.

Știind ordinea, poți explica și de ce eval e periculos: rulează încă o dată toate etapele peste un text care poate veni de la utilizator.

Ce urmărește intervievatorul: Este o întrebare de profunzime care arată dacă depanezi Bash din înțelegere, nu prin încercări. Puțini candidați știu de ce {1..$n} nu funcționează.

Permisiuni, utilizatori și grupuri

29 Junior

Ce înseamnă fiecare dintre permisiunile r, w și x pe un director, spre deosebire de un fișier?

Răspuns scurt: Pe director, r permite listarea numelor, w permite crearea, ștergerea și redenumirea intrărilor, iar x permite intrarea în director și accesul la fișierele din el. Fără x, nu poți folosi nimic din director, chiar dacă știi numele.

Pentru un fișier, sensul e intuitiv: r citești conținutul, w îl modifici, x îl rulezi ca program. Pentru un director, conținutul este lista de nume, iar permisiunile se aplică acestei liste.

  • r pe director: poți rula ls și vezi numele. Fără x vezi numele, dar nu și detaliile (ls -l dă erori).
  • w pe director: poți crea, șterge sau redenumi fișiere în el. Ai nevoie și de x ca să funcționeze.
  • x pe director: îl poți traversa: cd în el, deschide fișiere din el sau din subdirectoare.
BASH
mkdir d; touch d/f
chmod 300 d      # -wx: fără r
ls d             # Permission denied
cat d/f          # merge, dacă știi numele
chmod 600 d      # rw-: fără x
cd d             # Permission denied

Concluzii practice:

  • Ca să citești /srv/site/index.html, ai nevoie de x pe /, /srv și /srv/site, plus r pe fișier. Lipsa lui x pe un singur director din cale dă „Permission denied”.
  • Ștergerea unui fișier ține de directorul în care se află, nu de fișierul însuși. Poți șterge un fișier read-only dacă ai w și x pe director.
  • Permisiunile tipice: directoare 755 sau 750, fișiere 644 sau 640. Un director cu 644 este practic inutilizabil pentru ceilalți.

Root ocolește aceste verificări (cu excepția lui x pe fișiere, unde cere ca măcar cineva să aibă execuție).

Ce urmărește intervievatorul: Diferența dintre fișier și director e ceea ce se verifică aici, dincolo de citirea lui rwx. Greșeala frecventă: candidatul crede că x pe director nu are sens sau că ștergerea depinde de permisiunile fișierului.

Eroarea, în practică:rm: cannot remove: Permission deniedcd: Permission denied

30 Junior

Folosește chmod în mod simbolic: adaugă execuția pentru proprietar, scoate scrierea pentru grup și elimină orice drept pentru ceilalți. Cum setezi recursiv 755 pe directoare și 644 pe fișiere?

Răspuns scurt: chmod u+x,g-w,o= fisier. Pentru arbori folosești find: find dir -type d -exec chmod 755 {} + și find dir -type f -exec chmod 644 {} +, pentru că chmod -R 755 ar face executabile toate fișierele.

Modul simbolic are forma cine operator drepturi:

  • cine: u (user, proprietarul), g (group), o (others), a (all);
  • operator: + adaugă, - scoate, = setează exact;
  • drepturi: r, w, x, plus X, s, t.
BASH
chmod u+x deploy.sh
chmod g-w,o= secret.txt      # o= lasă ceilalți fără niciun drept
chmod a+r public.html
chmod u=rwx,g=rx,o= script.sh  # echivalent cu 750
chmod --reference=a.txt b.txt  # copiază permisiunile

Avantajul față de modul numeric: schimbi doar ce te interesează și lași restul neatins. chmod +x (fără u, g, o) adaugă execuția ținând cont de umask.

Pentru un arbore întreg, chmod -R 755 site/ e o greșeală frecventă: toate fișierele devin executabile. Variante corecte:

BASH
find site/ -type d -exec chmod 755 {} +
find site/ -type f -exec chmod 644 {} +

chmod -R u=rwX,g=rX,o=rX site/

X (majusculă) adaugă execuția doar directoarelor și fișierelor care au deja execuție pentru cineva. Așa, o singură comandă recursivă face directoarele traversabile fără să transforme imaginile și HTML-urile în programe.

chmod -R 777 pentru „a repara” o problemă de acces este semnul unui diagnostic greșit: oricine de pe sistem poate modifica fișierele, inclusiv un proces compromis.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să modifici permisiunile țintit. chmod -R 755 pe tot site-ul sau 777 ca soluție universală sunt semnale negative clare.

Eroarea, în practică:./script.sh: Permission deniedchmod: invalid mode

31 Junior

Ce fac chown și chgrp? Poate un utilizator obișnuit să dea un fișier al lui altui utilizator?

Răspuns scurt: chown schimbă proprietarul și, opțional, grupul (chown ana:dev f), iar chgrp doar grupul. Un utilizator obișnuit nu poate schimba proprietarul pe Linux; poate schimba grupul doar către un grup din care face parte. Doar root poate da fișiere altcuiva.

Sintaxa:

BASH
sudo chown www-data site/index.html          # doar proprietarul
sudo chown www-data:www-data site/index.html # proprietar și grup
sudo chown :dev raport.txt                   # doar grupul
sudo chown -R deploy:deploy /srv/app         # recursiv
chgrp dev raport.txt                         # dacă ești în grupul dev
ls -ln raport.txt                            # arată UID și GID numeric

De ce nu poți da un fișier altcuiva: s-ar putea ocoli cotele de disc (umpli spațiul în numele altcuiva) și s-ar putea crea confuzii de securitate, de exemplu un fișier care pare să fie al altui utilizator. Linux restricționează schimbarea proprietarului la procesele cu capabilitatea CAP_CHOWN, adică practic root.

Detalii de reținut:

  • La schimbarea proprietarului unui fișier executabil, biții setuid și setgid sunt șterși automat, ca măsură de siguranță.
  • chown -R urmează sau nu link-urile simbolice în funcție de opțiuni (-H, -L, -P); implicit, GNU chown -R nu le urmează. chown -h schimbă link-ul în sine.
  • Fișierele dintr-o arhivă sau de pe alt sistem păstrează UID-ul numeric. Dacă UID 1001 este „ana” pe un server și „ion” pe altul, fișierul îi aparține lui ion. De aceea ls -ln e util la depanare.

În deploy-uri se întâmplă des ca fișierele să ajungă ale lui root după un sudo git pull, iar aplicația, care rulează ca alt utilizator, nu mai poate scrie.

Ce urmărește intervievatorul: Verifică dacă știi modelul de proprietate. O confuzie frecventă: ideea că un utilizator poate „dărui” fișiere sau că chown simplu schimbă și grupul.

Eroarea, în practică:chown: Operation not permitted

32 Junior

Ce conțin fișierele /etc/passwd, /etc/shadow și /etc/group? De ce parolele nu mai sunt în /etc/passwd?

Răspuns scurt: /etc/passwd are conturile: nume, UID, GID principal, descriere, home și shell. /etc/shadow are hash-urile parolelor și regulile de expirare. /etc/group are grupurile și membrii lor. Parolele au fost mutate pentru că passwd trebuie să poată fi citit de toți.

O linie din /etc/passwd are șapte câmpuri separate prin ::

ana:x:1000:1000:Ana Pop,,,:/home/ana:/bin/bash
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin

Nume, x (parola e în shadow), UID, GID-ul grupului principal, descriere (câmpul GECOS), folderul personal și shell-ul de login. Conturile de serviciu au de obicei shell-ul /usr/sbin/nologin, ca să nu se poată autentifica interactiv. UID 0 este root; conturile obișnuite încep, pe majoritatea distribuțiilor, de la 1000.

/etc/passwd trebuie să fie citibil de toți, pentru că multe programe traduc UID-uri în nume (de exemplu ls -l). Când hash-urile stăteau acolo, oricine putea copia fișierul și încerca să spargă parolele offline. /etc/shadow are permisiuni restrictive (doar root și, pe unele distribuții, grupul shadow):

ana:$y$j9T$...:20000:0:99999:7:::

Hash-ul începe cu un identificator de algoritm: $6$ este SHA-512, $y$ este yescrypt, implicit pe Debian 11+ și Ubuntu 22.04+. Un ! sau * în față înseamnă cont blocat sau fără parolă de login.

/etc/group: dev:x:1005:ana,ion. Ultimul câmp listează membrii pentru care grupul este secundar.

Nu editezi aceste fișiere direct: folosești useradd, usermod, passwd, sau vipw și vigr, care blochează fișierul și verifică sintaxa. Pentru căutări: getent passwd ana, care funcționează și când conturile vin din LDAP.

Ce urmărește intervievatorul: Arată dacă înțelegi de unde vin utilizatorii și de ce. Răspunsul slab spune că parolele sunt în passwd sau nu știe ce înseamnă shell-ul nologin.

Eroarea, în practică:usermod: user does not existsudo: unknown user

33 Junior

Ai adăugat utilizatorul ion în grupul dev cu usermod -G dev ion. Ce ai stricat și de ce ion tot nu are acces la folderul grupului imediat după?

Răspuns scurt: Fără -a, -G înlocuiește lista de grupuri secundare, deci ion a ieșit din toate celelalte grupuri, inclusiv din sudo. Corect este usermod -aG dev ion. Grupurile se citesc la autentificare, deci ion trebuie să se reconecteze.

usermod -G setează lista completă de grupuri secundare. Dacă ion era în sudo și docker, după comandă e doar în dev. Opțiunea -a (append) adaugă la listă.

BASH
id ion
# uid=1001(ion) gid=1001(ion) groups=1001(ion),27(sudo)
sudo usermod -G dev ion       # greșit
id ion
# groups=1001(ion),1005(dev)  -> a pierdut sudo
sudo usermod -aG dev ion      # corect
sudo gpasswd -a ion dev       # alternativă, adaugă un singur grup

De ce accesul nu apare imediat: lista de grupuri face parte din credențialele procesului și se stabilește la login. Shell-ul în care lucrează ion a fost pornit cu vechea listă, iar copiii lui o moștenesc. Comanda groups fără argument arată grupurile procesului curent, în timp ce id ion citește configurarea nouă.

Soluții: ion se deconectează și se reconectează (inclusiv sesiunile SSH), sau rulează newgrp dev pentru un shell nou cu grupul activ. Serviciile care rulează ca ion trebuie repornite.

Comenzi conexe: useradd -m -s /bin/bash -G dev ion creează contul cu home și shell; pe Debian/Ubuntu, adduser ion este un script interactiv mai prietenos, care face aceleași lucruri. passwd ion setează parola, groupadd dev creează grupul, userdel -r ion șterge contul și folderul personal.

Dacă ți-ai scos singur grupul sudo, ai nevoie de alt cont de administrator sau de consolă pentru recuperare.

Ce urmărește intervievatorul: Verifică un detaliu care a blocat mulți administratori. Intervievatorul caută cuvântul „append” și înțelegerea faptului că grupurile se încarcă la autentificare.

Eroarea, în practică:user is not in the sudoers fileusermod: group does not exist

34 Mid

Ce este umask? Ce permisiuni primesc un fișier nou și un director nou cu umask 022, respectiv umask 077?

Răspuns scurt: umask este masca de biți scoși din permisiunile implicite la crearea fișierelor. Pornind de la 666 pentru fișiere și 777 pentru directoare, 022 dă 644 și 755, iar 077 dă 600 și 700.

Programele cer la creare permisiuni maxime: de obicei 666 (rw-rw-rw-) pentru fișiere și 777 pentru directoare. Kernelul elimină biții prezenți în umask. Nu e o scădere aritmetică, ci o operație pe biți: permisiuni AND NOT umask.

BASH
umask           # 0022
touch f; mkdir d
ls -ld f d
# -rw-r--r-- f    (666 fără 022 = 644)
# drwxr-xr-x d    (777 fără 022 = 755)

umask 077
touch secret; mkdir priv
# -rw------- secret   (600)
# drwx------ priv     (700)

umask 027       # 640 pentru fișiere, 750 pentru directoare

De ce operația pe biți contează: cu umask 033, un fișier nu devine 633 (rezultatul scăderii 666-033), ci 644, pentru că biții de execuție nu erau prezenți de la început.

Fișierele noi nu primesc execuție, indiferent de umask: de aceea faci chmod +x pe scripturi.

Unde se setează:

  • pentru sesiuni, în /etc/profile, ~/.bashrc sau prin pam_umask și UMASK din /etc/login.defs;
  • pentru servicii systemd, cu directiva UMask=0027 în unit; altfel serviciul are umask-ul implicit al lui systemd, de obicei 0022.

Un caz practic: o aplicație scrie fișiere de export pe care un alt serviciu din același grup trebuie să le citească. Cu umask 077, fișierele vor fi 600 și celălalt serviciu primește „Permission denied”. Ajustezi umask-ul serviciului, nu faci chmod după fiecare fișier.

Ce urmărește intervievatorul: Verifică dacă știi calculul și unde se configurează. Greșeala tipică e „scăderea” 666-033 sau ideea că umask se aplică fișierelor existente.

35 Mid

Ce afișează secvența de mai jos, rulată de utilizatorul ana? Explică de ce.

BASH
mkdir ~/lucru && cd ~/lucru
sudo touch fisier-root
sudo chmod 600 fisier-root
cat fisier-root
rm -f fisier-root
ls

Răspuns scurt: cat dă „Permission denied”, pentru că fișierul e al lui root cu 600. rm -f reușește, iar ls nu mai afișează nimic: ștergerea modifică directorul, iar ana are w și x pe propriul director.

Fișierul creat cu sudo touch aparține lui root:root, iar după chmod 600 doar root îl poate citi sau modifica. Când ana rulează cat, kernelul verifică permisiunile fișierului, iar ana intră la „others”, care nu au nimic.

Ștergerea nu este o operație asupra fișierului, ci asupra directorului: elimini o intrare nume -> inode din ~/lucru. Kernelul verifică w și x pe director, iar directorul este al lui ana. Fără -f, rm ar fi întrebat „remove write-protected regular empty file?”, dar ar fi putut șterge oricum.

BASH
cat fisier-root
# cat: fisier-root: Permission denied
rm -f fisier-root     # fără eroare
ls                    # nimic

Asta are consecințe:

  • În directoare la care mai mulți utilizatori au w, oricine poate șterge fișierele altora. Soluția este sticky bit-ul, folosit pe /tmp.
  • Dacă vrei ca un fișier să nu poată fi șters, nu e suficient chmod 444. Trebuie protejat directorul sau folosit atributul imutabil: sudo chattr +i fisier (pe ext4 și alte sisteme de fișiere care îl suportă). Nici root nu îl poate șterge până nu rulează chattr -i.
  • Mutarea unui fișier în alt director cere drepturi pe ambele directoare, nu pe fișier.

Întrebarea apare des în variante, ca test de înțelegere a faptului că numele fișierului aparține directorului.

Ce urmărește intervievatorul: Este o întrebare-capcană de tip „ce afișează”. Majoritatea candidaților răspund că rm va eșua; cei care înțeleg inode-ul și directorul o rezolvă imediat.

Eroarea, în practică:rm: cannot remove: Permission denied

36 Mid

Echipa dev are nevoie de folderul comun /srv/proiect, în care fiecare poate crea fișiere, toate fișierele noi aparțin grupului dev și nimeni nu poate șterge fișierele altora. Cum îl configurezi?

Răspuns scurt: Setezi grupul dev, permisiunile 2770 sau 3770 și un umask de grup permisiv. Bitul setgid (2) pe director face ca fișierele noi să moștenească grupul, iar sticky bit-ul (1) permite ștergerea doar proprietarului fișierului.

Pașii:

BASH
sudo groupadd dev
sudo usermod -aG dev ana; sudo usermod -aG dev ion
sudo mkdir -p /srv/proiect
sudo chown root:dev /srv/proiect
sudo chmod 3770 /srv/proiect
ls -ld /srv/proiect
# drwxrws--T 2 root dev 4096 ... /srv/proiect

Ce face fiecare bit:

  • 770: proprietarul și grupul au acces complet, ceilalți nimic.
  • setgid pe director (2, afișat s în locul x al grupului): fișierele și subdirectoarele noi primesc grupul directorului (dev), nu grupul principal al celui care le creează. Subdirectoarele moștenesc și bitul setgid.
  • sticky bit (1, afișat t în locul x al celorlalți; T mare dacă ceilalți nu au x): într-un director cu sticky bit, un fișier poate fi șters sau redenumit doar de proprietarul lui, de proprietarul directorului sau de root. E același mecanism ca pe /tmp (drwxrwxrwt).

Rămâne o problemă: cu umask 022, fișierele noi vor fi 644, deci colegii le pot citi, dar nu modifica. Ai trei variante:

  • umask 002 pentru utilizatorii echipei;
  • ACL implicite pe director: setfacl -d -m g:dev:rwX /srv/proiect, care dau grupului drept de scriere pe fișierele noi indiferent de umask;
  • un mod explicit în aplicațiile care scriu acolo.

Membrii trebuie să se reconecteze după usermod, ca să primească noul grup.

Ce urmărește intervievatorul: Este un scenariu real de administrare care verifică setgid și sticky bit fără să ceară definiții. Candidații uită adesea problema umask-ului, care face ca fișierele să nu fie editabile de colegi.

37 Senior

O aplicație Node.js trebuie să asculte pe portul 443, dar nu vrei să ruleze ca root. Ce variante ai și ce sunt Linux capabilities?

Răspuns scurt: Porturile sub 1024 cer în mod normal privilegii. Variantele: un reverse proxy pe 443 care trimite spre un port mare, capabilitatea CAP_NET_BIND_SERVICE dată prin systemd sau setcap, ori redirecționare de port în firewall. Capabilities împart puterile lui root în drepturi separate.

Tradițional, un proces era fie root (UID 0, ocolește toate verificările), fie neprivilegiat. Capabilities împart puterile lui root în unități separate: CAP_NET_BIND_SERVICE (porturi sub 1024), CAP_CHOWN, CAP_NET_ADMIN (configurare rețea), CAP_SYS_ADMIN (foarte largă) și altele. Un proces poate primi doar ce îi trebuie.

Variante, de la cea mai folosită:

  • Reverse proxy: nginx ascultă pe 443, termină TLS și trimite spre 127.0.0.1:3000. Aplicația nu are nevoie de niciun privilegiu.
  • systemd, fără root:
[Service]
User=app
AmbientCapabilities=CAP_NET_BIND_SERVICE
CapabilityBoundingSet=CAP_NET_BIND_SERVICE
NoNewPrivileges=true
  • setcap pe binar:
BASH
sudo setcap 'cap_net_bind_service=+ep' /usr/bin/node
getcap /usr/bin/node

Aici e un dezavantaj: capabilitatea se aplică oricărui script rulat cu acel node, de către orice utilizator, și se pierde la actualizarea pachetului, care înlocuiește binarul.

  • Redirecționare de port în firewall (443 -> 8443).
  • Parametrul net.ipv4.ip_unprivileged_port_start poate coborî pragul porturilor privilegiate pentru tot sistemul, dar afectează toate procesele.

Varianta systemd e cea mai precisă, pentru că dreptul e legat de serviciu, nu de binar. Pentru a vedea capabilitățile unui proces: grep Cap /proc/<pid>/status și capsh --decode=<valoare>.

Ce urmărește intervievatorul: Verifică dacă gândești în termeni de privilegii minime la nivel de sistem. Un răspuns slab propune rularea ca root „că e mai simplu” sau un setcap pe interpretorul global fără să vadă riscul.

Procese și semnale

38 Junior

Ce informații îți dă ps aux? Ce înseamnă stările R, S, D, T și Z din coloana STAT?

Răspuns scurt: ps aux listează toate procesele, cu utilizatorul, PID-ul, procentul de CPU și memorie, memoria virtuală și rezidentă, terminalul, starea, ora pornirii, timpul de CPU și comanda. R rulează, S doarme, D așteaptă I/O neîntreruptibil, T e oprit, Z e zombie.

Coloanele din ps aux:

USER   PID %CPU %MEM    VSZ   RSS TTY  STAT START  TIME COMMAND
www    812  2.1  3.4 845320 69812 ?    Sl   09:12  0:41 node server.js
  • VSZ: memoria virtuală rezervată (în KiB), adesea mult mai mare decât cea folosită efectiv.
  • RSS: memoria rezidentă, aflată efectiv în RAM; contează mai mult în practică.
  • TTY: ? înseamnă fără terminal, specific serviciilor.
  • TIME: timpul total de CPU consumat, nu de cât timp rulează.

Stările principale:

  • R: rulează sau așteaptă la rând pentru CPU.
  • S: somn întreruptibil, așteaptă un eveniment (rețea, timer). Majoritatea proceselor sunt aici.
  • D: somn neîntreruptibil, de obicei în așteptarea discului sau a unui sistem de fișiere în rețea; nu răspunde nici la semnale.
  • T: oprit, de exemplu cu Ctrl+Z.
  • Z: zombie, procesul s-a terminat, dar părintele nu i-a preluat codul de ieșire.

Sufixe: s lider de sesiune, l are mai multe thread-uri, + în grupul din prim-plan, < prioritate ridicată, N prioritate scăzută.

Variante utile:

BASH
ps -ef --forest                     # arborele părinte-copil
ps -eo pid,ppid,user,%cpu,%mem,cmd --sort=-%mem | head
ps -o pid,stat,cmd -p 812

ps aux (stil BSD, fără cratimă) și ps -ef (stil System V) arată aproape aceleași procese, cu formate de coloane diferite.

Ce urmărește intervievatorul: Verifică dacă citești corect ieșirea, nu doar dacă știi comanda. Confuzia frecventă: VSZ mare interpretat ca memorie consumată sau TIME interpretat ca durată de rulare.

39 Junior

Ai pornit o comandă lungă în terminal și ai nevoie de prompt. Cum o trimiți în fundal, cum o readuci și ce fac &, Ctrl+Z, jobs, fg și bg?

Răspuns scurt: Ctrl+Z oprește procesul din prim-plan, bg îl continuă în fundal, fg îl readuce în prim-plan, iar jobs listează joburile shell-ului. O comandă urmată de & pornește direct în fundal.

Shell-ul ține evidența proceselor pornite din el sub formă de joburi, numerotate %1, %2 și așa mai departe.

BASH
tar czf backup.tar.gz /date      # rulează în prim-plan, terminalul e ocupat
^Z                               # Ctrl+Z
# [1]+  Stopped   tar czf backup.tar.gz /date
bg %1                            # continuă în fundal
# [1]+ tar czf backup.tar.gz /date &
jobs -l                          # listă cu PID-uri
fg %1                            # înapoi în prim-plan
sleep 300 &                      # pornit direct în fundal
# [2] 48213
kill %2                          # semnal către job
wait                             # așteaptă terminarea joburilor din fundal

Ce se întâmplă tehnic: Ctrl+Z trimite semnalul SIGTSTP, care oprește procesul (stare T). bg îi trimite SIGCONT, iar procesul continuă fără să mai citească de la terminal. Ctrl+C trimite SIGINT procesului din prim-plan, de obicei pentru a-l opri.

Limite de știut:

  • Un job din fundal care încearcă să citească de la tastatură este oprit automat (SIGTTIN).
  • Ieșirea lui continuă să apară în terminal și se amestecă cu ce scrii; o redirecționezi: cmd > out.log 2>&1 &.
  • Joburile aparțin shell-ului. Dacă închizi sesiunea SSH, procesele primesc de obicei SIGHUP și se opresc. Pentru procese care trebuie să supraviețuiască folosești nohup, disown, tmux sau un serviciu systemd.

$! conține PID-ul ultimului proces pornit în fundal, util în scripturi.

Ce urmărește intervievatorul: E o întrebare de lucru zilnic în terminal. Răspunsul bun menționează și că joburile se pierd la închiderea sesiunii, nu doar comenzile.

40 Junior

Ai pornit o migrare de date care durează două ore printr-o sesiune SSH. Ce se întâmplă dacă îți pică conexiunea și cum o pornești corect?

Răspuns scurt: La închiderea sesiunii, procesele din ea primesc de obicei SIGHUP și se opresc, deci migrarea se întrerupe. O pornești în tmux sau screen, la care te poți reatașa, cu nohup, sau ca unitate systemd temporară cu systemd-run.

Când conexiunea SSH se închide, terminalul virtual dispare, iar shell-ul și joburile lui primesc SIGHUP („hang up”). Acțiunea implicită a semnalului este terminarea. O migrare oprită la jumătate poate lăsa date inconsistente.

Variante, de la cea mai practică:

BASH
tmux new -s migrare          # sesiune care rămâne pe server
./migrare.sh
# Ctrl+B apoi D: detașare; poți închide SSH
tmux attach -t migrare       # reatașare, vezi ieșirea live

nohup ./migrare.sh > migrare.log 2>&1 &   # ignoră SIGHUP

./migrare.sh &               # deja pornit?
disown -h %1                 # shell-ul nu îi mai trimite SIGHUP

sudo systemd-run --unit=migrare ./migrare.sh
journalctl -u migrare -f     # loguri

Diferențe:

  • tmux/screen păstrează un terminal întreg: poți vedea progresul, răspunde la întrebări interactive și reveni de pe alt calculator. E alegerea uzuală pentru operații manuale lungi.
  • nohup face procesul să ignore SIGHUP și redirecționează ieșirea în nohup.out dacă nu o redirecționezi tu. Nu te poți reatașa.
  • disown salvează un proces deja pornit, dar ieșirea lui spre terminalul închis se pierde.
  • systemd-run pune procesul sub supravegherea lui systemd, cu loguri în journal și posibilitatea de a-l opri curat.

Pe unele sisteme, systemd-logind are opțiunea KillUserProcesses=yes, care oprește la logout și procesele pornite cu nohup. Atunci doar systemd-run sau loginctl enable-linger rezolvă problema.

Ce urmărește intervievatorul: Verifică experiența cu operații reale pe servere. Un răspuns bun explică SIGHUP și alege unealta în funcție de nevoie, nu doar „pun & la final”.

Eroarea, în practică:nohup: appending output to 'nohup.out'

41 Junior

Ce urmărești în top când vrei să vezi ce încarcă serverul? Cum poate un proces să aibă %CPU 250?

Răspuns scurt: Te uiți la rândul %Cpu(s) (în special us, sy, wa), la memorie și la primele procese sortate după CPU (P) sau memorie (M). %CPU peste 100 înseamnă că procesul folosește mai multe nuclee: 250 înseamnă aproximativ două nuclee și jumătate.

Antetul din top are mai multe părți utile:

%Cpu(s): 62.0 us,  8.1 sy,  0.0 ni, 20.3 id,  9.4 wa,  0.0 hi,  0.2 si,  0.0 st
  • us: timp în cod de aplicație; sy: timp în kernel (apeluri de sistem, rețea).
  • id: inactiv; wa: CPU-ul așteaptă după I/O (disc). Un wa mare indică discul, nu procesorul.
  • st (steal): timp luat de hipervizor; relevant pe mașini virtuale cu resurse partajate.

În lista de procese, coloana %CPU se raportează implicit la un singur nucleu, deci un proces cu mai multe thread-uri poate depăși 100. Pe o mașină cu 4 nuclee, maximul teoretic e 400. Apăsând 1 vezi fiecare nucleu separat; Shift+I comută în modul în care procentul se împarte la numărul de nuclee.

Taste utile în top:

  • P sortare după CPU, M după memorie, T după timp total;
  • c comanda completă, H thread-uri în loc de procese;
  • k trimite un semnal, r schimbă prioritatea (renice);
  • u filtrează după utilizator.

htop oferă același lucru mai ușor de citit, cu bare per nucleu și arbore de procese. Pentru o captură în script: top -b -n 1 | head -20.

Mai util decât un singur instantaneu e trendul: un proces cu 100% CPU pentru câteva secunde e normal la o compilare, dar nu și constant pe un server web care nu primește trafic.

Ce urmărește intervievatorul: Verifică dacă interpretezi cifrele, nu doar deschizi top. Mulți nu știu ce e wa sau cred că 250% CPU e o eroare de afișare.

42 Junior

Cum oprești toate procesele cu un anumit nume? Ce diferență este între kill, pkill, pgrep și killall și ce semnal trimite kill fără opțiuni?

Răspuns scurt: kill primește PID-uri, pgrep găsește PID-uri după nume, pkill trimite semnalul direct după nume sau alt criteriu, iar killall oprește după numele exact al programului. Fără opțiuni, toate trimit SIGTERM (15).

kill este de fapt „trimite un semnal”; numele vine de la acțiunea implicită a majorității semnalelor.

BASH
pgrep -a gunicorn            # PID și comanda
pgrep -u www-data nginx      # doar procesele utilizatorului
pkill gunicorn               # SIGTERM tuturor proceselor potrivite
pkill -f "python worker.py"  # potrivire pe toată linia de comandă
pkill -HUP nginx             # SIGHUP: multe servicii își recitesc config-ul
killall -9 firefox           # nume exact
kill -l                      # lista semnalelor
kill -0 1234 && echo viu     # verifică existența fără să trimită semnal

Atenție la potriviri:

  • pgrep și pkill potrivesc implicit numele procesului ca regex, deci pkill php poate opri și php-fpm. Verifici întâi cu pgrep -a.
  • -f caută în toată linia de comandă și se poate potrivi și cu procesul tău pkill -f, sau cu un editor care are deschis fișierul cu acel nume.
  • Pe sistemele Solaris mai vechi, killall oprea toate procesele, așa că nu e o comandă de folosit fără să știi pe ce sistem ești.

Semnale utile în afară de TERM și KILL: HUP pentru reîncărcarea configurării (nginx, rsyslog, sshd), USR1/USR2 cu semnificație definită de aplicație (de exemplu redeschiderea fișierelor de log), STOP și CONT pentru suspendare și reluare.

Pentru servicii gestionate de systemd folosești systemctl reload sau systemctl kill, nu pkill, ca systemd să nu repornească procesul sau să nu-și piardă evidența lui.

Ce urmărește intervievatorul: Verifică dacă oprești procese cu precizie. Candidații folosesc des pkill cu un model prea larg și opresc mai mult decât voiau.

Eroarea, în practică:kill: Operation not permittedkill: arguments must be process or job IDs

43 Mid

Ce este un proces zombie și ce este un proces orfan? Cum scapi de zombie?

Răspuns scurt: Un zombie s-a terminat, dar părintele nu i-a citit codul de ieșire cu wait(). Un orfan e un proces viu rămas fără părinte, adoptat de PID 1. Zombie-ul dispare când părintele face wait sau se termină.

Când un proces se termină, kernelul îi eliberează memoria și fișierele, dar păstrează o intrare mică cu PID-ul și codul de ieșire, ca părintele să le poată citi prin wait() sau waitpid(). Până atunci, procesul apare cu starea Z și <defunct> în ps.

BASH
ps -eo pid,ppid,stat,cmd | awk '$3 ~ /Z/'
#  4521  4380 Z    [worker] <defunct>
ps -o pid,cmd -p 4380      # cine e părintele

kill -9 pe un zombie nu are niciun efect: procesul e deja mort. Ai trei opțiuni:

  • să determini părintele să facă wait, de exemplu cu kill -CHLD 4380, dacă programul are un handler pentru SIGCHLD;
  • să repornești sau să oprești părintele: zombie-ul devine orfan, e adoptat de PID 1 (sau de un „subreaper”), iar acesta îl curăță imediat;
  • să repari bug-ul din aplicație, care nu își așteaptă copiii.

Câțiva zombie nu consumă resurse importante. Problema apare când un părinte cu bug creează mii: PID-urile sunt finite (/proc/sys/kernel/pid_max), iar epuizarea lor împiedică pornirea proceselor noi.

Un orfan este un proces viu al cărui părinte s-a terminat. Kernelul îl atașează la PID 1 (systemd), care va face wait la final. Orfanii sunt normali: așa funcționează procesele daemon clasice, care fac fork și lasă părintele să iasă.

În scripturi Bash, procesele pornite cu & sunt așteptate de shell la final; wait explicit e util ca să afli și codul lor de ieșire.

Ce urmărește intervievatorul: Este o întrebare clasică de sistem. Greșeala tipică: „îl omor cu kill -9”. Intervievatorul vrea să audă de wait(), de părinte și de adopția de către PID 1.

44 Mid

Pe același server rulează o aplicație web și un job de raportare care consumă mult CPU și disc. Cum faci ca jobul să deranjeze cât mai puțin aplicația, fără să-l oprești?

Răspuns scurt: Îi scazi prioritatea de CPU cu nice sau renice (valori de la -20 la 19, mai mare înseamnă mai puțin prioritar) și pe cea de disc cu ionice -c3 sau -c2 -n7. Pentru limite ferme folosești cgroups, de exemplu systemd-run cu CPUQuota.

Schedulerul Linux împarte CPU-ul între procese în funcție de valoarea nice: de la -20 (cel mai prioritar) la 19 (cel mai puțin prioritar), implicit 0. Un utilizator obișnuit poate doar crește valoarea pentru procesele lui; scăderea cere root.

BASH
nice -n 15 ./raport.sh              # pornit cu prioritate scăzută
renice -n 19 -p 23817               # proces deja pornit
ionice -c3 -p 23817                 # disc doar când e liber (idle)
nice -n 19 ionice -c2 -n7 ./raport.sh

Ce trebuie spus la interviu:

  • nice este relativ: un proces cu 19 primește totuși CPU când sistemul e liber, ceea ce e bine, pentru că jobul se termină mai repede noaptea. Nu e o limită fermă.
  • Dacă jobul e limitat de disc, nice aproape nu ajută; contează ionice. Clasele -c3 (idle) și -c2 -n7 (best effort, prioritate minimă) au efect deplin cu schedulere de I/O care le respectă, ca BFQ, și efect redus cu altele.
  • Pentru limite garantate folosești cgroups, de obicei prin systemd:
BASH
sudo systemd-run --unit=raport -p CPUQuota=50% -p IOWeight=10 \
  -p MemoryMax=2G ./raport.sh

CPUQuota=50% înseamnă cel mult jumătate dintr-un nucleu. Același lucru îl pui în unit-ul unui serviciu, cu directivele CPUQuota=, MemoryMax=, Nice=, IOSchedulingClass=.

Soluția pe termen lung poate fi rularea jobului în afara orelor de vârf sau pe altă mașină, dar întrebarea testează uneltele pentru situația imediată.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre prioritate și limită și dacă te gândești la disc, nu doar la CPU. Răspunsul slab se oprește la nice fără să verifice ce resursă e problema.

Eroarea, în practică:renice: failed to set priority

45 Mid

Un proces este în starea D și nu se oprește nici cu kill -9. Ce înseamnă și ce poți face?

Răspuns scurt: Starea D înseamnă somn neîntreruptibil: procesul așteaptă în kernel finalizarea unei operații de I/O, de obicei pe disc sau pe un sistem de fișiere în rețea, și nu primește semnale până nu revine. Cauți resursa blocată, nu procesul.

Semnalele, inclusiv SIGKILL, sunt livrate când procesul revine din kernel sau este într-o așteptare întreruptibilă. Unele operații (citirea unui bloc de pe disc, anumite operații NFS) sunt marcate neîntreruptibile ca să nu lase structuri de date pe jumătate modificate. Dacă dispozitivul nu răspunde, procesul rămâne blocat, iar kill -9 este pus în așteptare.

Cum investighezi:

BASH
ps -eo pid,stat,wchan:32,cmd | awk '$2 ~ /D/'
#  3121 D    nfs_wait_bit_killable  rsync ...
cat /proc/3121/stack          # stiva din kernel (ca root)
dmesg -T | tail -50           # erori de disc, timeout-uri NFS
mount | grep nfs              # ce sisteme de fișiere în rețea ai
iostat -x 2                   # disc saturat? (pachetul sysstat)

Coloana wchan arată funcția din kernel în care așteaptă. Cauze frecvente:

  • un server NFS sau un share de rețea care nu mai răspunde, montat cu opțiunea hard (implicită la NFS), care repetă la nesfârșit;
  • un disc defect sau un controller care face timeout-uri, vizibile în dmesg;
  • un disc atât de încărcat încât cererile stau în coadă foarte mult.

Ce poți face: să restabilești resursa (serverul NFS, conexiunea), după care procesul se deblochează singur; pentru NFS, uneori umount -f sau umount -l (lazy). Dacă dispozitivul e definitiv pierdut, de multe ori singura soluție este repornirea mașinii.

Procesele în D contribuie la load average, de aceea poți vedea un load mare cu CPU aproape liber.

Ce urmărește intervievatorul: Verifică înțelegerea legăturii dintre semnale și kernel. Răspunsul slab propune kill -9 repetat; cel bun mută atenția pe disc sau rețea.

46 Senior

Ce se întâmplă, la nivel de apeluri de sistem, când scrii ls -l în Bash și apeși Enter? De ce cd nu poate fi un program separat?

Răspuns scurt: Bash face fork() și obține o copie a lui însuși; copilul aplică redirecționările și face execve("/usr/bin/ls", ...), care îi înlocuiește programul, iar părintele așteaptă cu wait(). cd trebuie să fie builtin, pentru că un copil nu poate schimba folderul curent al părintelui.

Pașii:

  • Bash citește linia, face expansiunile și separă comanda de argumente.
  • Caută numele: alias, funcție, builtin, apoi în folderele din PATH. Rezultatul e ținut minte într-o tabelă (hash), de aceea după mutarea unui binar ai nevoie uneori de hash -r.
  • fork() (în practică clone()): kernelul creează un proces copil identic, cu memoria partajată copy-on-write, deci aproape fără cost inițial.
  • În copil se aplică redirecționările (dup2 pe descriptori), apoi execve() înlocuiește imaginea procesului cu programul ls. PID-ul rămâne același, descriptorii deschiși se păstrează (cu excepția celor marcați close-on-exec), iar variabilele exportate trec în noul program.
  • Părintele face waitpid() și primește codul de ieșire, pus în $?.
BASH
strace -f -e trace=clone,execve,wait4 bash -c 'ls -l > /dev/null'

Starea procesului (folder curent, variabile, umask, limite) aparține fiecărui proces. Un copil care face chdir() își schimbă doar propriul folder și dispare imediat după. De aceea cd, export, source, exit, ulimit, umask sunt builtin: trebuie să modifice chiar shell-ul.

Din același motiv, un script rulat cu ./setenv.sh nu poate schimba variabilele terminalului tău, dar source setenv.sh poate.

PID 1 (pe majoritatea distribuțiilor, systemd) este primul proces pornit de kernel. Toate celelalte procese descind din el, iar el preia orfanii. Dacă PID 1 se termină, kernelul intră în panică.

Ce urmărește intervievatorul: Verifică dacă înțelegi modelul de procese Unix, nu doar uneltele. Un candidat senior explică fork/exec fluent și leagă de el comportamente observabile, cum ar fi diferența dintre source și rularea unui script.

47 Senior

Un proces Java sau Python pare blocat: nu scrie nimic în log, dar rulează. Ce poți afla despre el din /proc și cu lsof și strace, fără să-l repornești?

Răspuns scurt: Din /proc/<pid> vezi linia de comandă, variabilele de mediu, starea, limitele și descriptorii deschiși. lsof -p arată fișierele și conexiunile, iar strace -p arată în timp real apelurile de sistem, de exemplu un read blocat pe un socket sau un futex care indică un lock.

Pașii, de la cel mai puțin invaziv:

BASH
PID=4127
cat /proc/$PID/status | grep -E 'State|Threads|VmRSS'
tr '\0' ' ' < /proc/$PID/cmdline; echo
sudo tr '\0' '\n' < /proc/$PID/environ | grep -i db
ls -l /proc/$PID/cwd                # folderul curent
ls -l /proc/$PID/fd | wc -l         # câți descriptori are deschiși
cat /proc/$PID/limits | grep files  # limita de fișiere deschise
sudo lsof -p $PID -a -i             # doar conexiunile de rețea
sudo strace -f -tt -p $PID -e trace=network,read,write

Ce cauți:

  • State: dacă e S și strace arată un read() sau recvfrom() blocat pe un socket, procesul așteaptă răspuns de la alt serviciu (bază de date, API). lsof îți arată spre ce IP și port este conexiunea.
  • futex() repetat sau blocat: thread-uri care așteaptă un lock, posibil deadlock în aplicație.
  • Numărul de descriptori aproape de limită: „Too many open files”, de obicei o scurgere de conexiuni.
  • environ arată configurarea cu care a pornit procesul, nu ce e acum în fișierul .env.

strace încetinește procesul și cere privilegii (ptrace), deci în producție îl folosești scurt și țintit. Pe unele sisteme, kernel.yama.ptrace_scope restricționează atașarea.

Pentru limbajele cu mașină virtuală, uneltele lor dau informații la nivel de cod: jstack <pid> pentru Java sau py-spy dump --pid <pid> pentru Python arată stiva fiecărui thread, fără oprire.

Ce urmărește intervievatorul: Verifică dacă poți diagnostica fără să repornești, adică fără să pierzi dovezile. Candidatul senior combină /proc, lsof și strace și știe costul fiecăruia în producție.

Servicii, pachete, disc și cron

Exersează capitolul cu exerciții reale: Curs Linux pentru începători →
48 Junior

Ce diferență este între apt update, apt upgrade și apt full-upgrade? Când folosești apt-get în loc de apt?

Răspuns scurt: apt update descarcă listele de pachete din depozite, fără să instaleze nimic. apt upgrade actualizează pachetele fără să șteargă nimic, iar full-upgrade poate șterge sau instala pachete ca să rezolve dependențe noi. În scripturi folosești apt-get, care are o interfață stabilă.

Managerul de pachete lucrează cu un index local al pachetelor disponibile. Indexul se învechește, de aceea update vine întotdeauna înaintea instalărilor.

BASH
sudo apt update                  # reîmprospătează indexul
apt list --upgradable            # ce se poate actualiza
sudo apt upgrade                 # actualizează, nu elimină nimic
sudo apt full-upgrade            # poate elimina pachete în conflict
sudo apt install nginx           # instalează, cu dependențe
sudo apt remove nginx            # elimină, păstrează config-ul din /etc
sudo apt purge nginx             # elimină și config-ul
sudo apt autoremove              # dependențe care nu mai sunt necesare
apt show nginx                   # detalii, versiune, dependențe
apt-cache policy nginx           # ce versiune vine din ce depozit

Diferența dintre upgrade și full-upgrade apare când o versiune nouă cere o dependență nouă sau intră în conflict cu un pachet instalat. upgrade lasă astfel de pachete „reținute” (kept back), full-upgrade rezolvă situația, eventual eliminând ceva. Pe un server de producție citești lista înainte să confirmi.

apt este interfața pentru oameni: bară de progres, culori, mesaje care se pot schimba între versiuni. Afișează chiar avertismentul că nu are o interfață stabilă pentru scripturi. apt-get și apt-cache au comportament stabil, deci în scripturi și Dockerfile-uri folosești apt-get install -y.

Sub apt stă dpkg, care instalează efectiv fișierele .deb: dpkg -l listează pachetele instalate, dpkg -L nginx arată fișierele unui pachet. Depozitele sunt configurate în /etc/apt/sources.list și /etc/apt/sources.list.d/.

Ce urmărește intervievatorul: Verifică dacă știi ce face fiecare comandă înainte să o rulezi pe un server. Greșeala comună: credința că apt update actualizează pachetele.

Eroarea, în practică:E: Unable to locate packageE: Could not open lock file (13: Permission denied)

49 Junior

Lucrezi pe un server Rocky Linux după ce ai folosit doar Ubuntu. Care sunt echivalentele comenzilor de pachete și cum afli ce pachet conține un anumit fișier?

Răspuns scurt: Pe familia Red Hat (RHEL, Rocky, Alma, Fedora) folosești dnf în loc de apt, cu pachete .rpm în loc de .deb. Pachetul care deține un fișier instalat îl afli cu rpm -qf, iar pe cel care ar furniza un fișier cu dnf provides.

Cele două familii mari au unelte diferite, dar concepte la fel: depozite, index, dependențe.

BASH
# Debian / Ubuntu            # RHEL / Rocky / Fedora
apt update                   # dnf check-update (sau dnf makecache)
apt install nginx            # dnf install nginx
apt remove nginx             # dnf remove nginx
apt upgrade                  # dnf upgrade
apt search redis             # dnf search redis
dpkg -l                      # rpm -qa
dpkg -L nginx                # rpm -ql nginx
dpkg -S /usr/bin/curl        # rpm -qf /usr/bin/curl
apt-file search bin/dig      # dnf provides '*/bin/dig'

dnf provides e foarte util când îți lipsește o comandă: dnf provides '*/bin/dig' îți spune că vine din bind-utils. Pe Ubuntu, echivalentul e apt-file (trebuie instalat și inițializat cu apt-file update).

Alte diferențe pe care le simți imediat:

  • Numele pachetelor diferă: apache2 față de httpd, dnsutils față de bind-utils.
  • Configurarea serviciilor e în locuri diferite: /etc/apache2/ față de /etc/httpd/.
  • Familia Red Hat are SELinux activ implicit, care poate bloca un serviciu chiar dacă permisiunile clasice sunt corecte. Ubuntu are AppArmor.
  • Firewall-ul implicit pe Rocky e firewalld, pe Ubuntu ufw (adesea inactiv implicit).
  • yum este numele vechi; pe RHEL 8+ comanda yum e un alias spre dnf.

cat /etc/os-release îți spune exact pe ce distribuție și versiune ești înainte să rulezi orice.

Ce urmărește intervievatorul: Verifică dacă te adaptezi rapid la altă distribuție. Un candidat bun pomenește și diferențele care nu sunt de pachete, de exemplu SELinux și firewall-ul.

50 Junior

Care e diferența dintre systemctl start, enable și enable --now? Ce face systemctl mask?

Răspuns scurt: start pornește serviciul acum, dar nu și la repornirea serverului; enable îl pornește automat la boot, dar nu acum; enable --now le face pe amândouă. mask blochează complet serviciul, ca să nu poată fi pornit nici manual, nici ca dependență.

systemd separă două lucruri: starea curentă (rulează sau nu) și configurarea de pornire (pornește sau nu la boot).

BASH
sudo systemctl start nginx         # acum
sudo systemctl enable nginx        # la boot (creează un link în *.wants/)
sudo systemctl enable --now nginx  # amândouă
sudo systemctl disable --now nginx # oprește și scoate de la boot
systemctl is-active nginx          # active / inactive / failed
systemctl is-enabled nginx         # enabled / disabled / masked / static
systemctl --failed                 # toate unitățile căzute
sudo systemctl restart nginx       # oprește și pornește
sudo systemctl reload nginx        # recitește config-ul fără oprire

Greșeala clasică: pornești un serviciu cu start, totul merge, iar după o repornire a serverului site-ul e căzut, pentru că serviciul nu era enabled. Invers, enable fără --now nu pornește nimic imediat.

enable creează link-uri simbolice în /etc/systemd/system/<target>.wants/, conform secțiunii [Install] din unit (de obicei WantedBy=multi-user.target). Starea static înseamnă că unitatea nu are secțiune [Install] și e pornită doar ca dependență.

mask leagă unitatea de /dev/null. Spre deosebire de disable, un serviciu dezactivat poate fi pornit în continuare de alt serviciu care depinde de el sau manual; unul mascat nu. E util când ai două servicii în conflict (de exemplu două servere de timp) și vrei să fii sigur că unul nu va porni. unmask anulează.

reload funcționează doar dacă serviciul îl suportă; altfel, reload-or-restart.

Ce urmărește intervievatorul: Verifică diferența dintre stare și configurare. Serviciile care „nu au pornit după restart” sunt o problemă frecventă de producție, iar intervievatorul vrea să vadă că o știi.

Eroarea, în practică:The unit files have no installation configsystemctl: Unknown command verb

51 Junior

Scrie liniile de crontab care rulează /opt/backup.sh în fiecare noapte la 2:30, un script la fiecare 15 minute și un raport în fiecare luni la 8:00.

Răspuns scurt: 30 2 * * * /opt/backup.sh, */15 * * * * /opt/check.sh și 0 8 * * 1 /opt/raport.sh. Câmpurile sunt, în ordine: minut, oră, zi din lună, lună, zi din săptămână (0 sau 7 e duminică).

Fiecare linie din crontab are cinci câmpuri de timp urmate de comandă:

# min  ora  zi  luna  zi_sapt  comanda
  30   2    *   *     *        /opt/backup.sh >> /var/log/backup.log 2>&1
  */15 *    *   *     *        /opt/check.sh
  0    8    *   *     1        /opt/raport.sh
  0    9-17 *   *     1-5      /opt/ora-de-lucru.sh
  0    0    1   *     *        /opt/lunar.sh

Sintaxa câmpurilor: * orice valoare, */15 din 15 în 15, 1-5 interval, 1,15 listă. Prescurtări: @reboot, @daily, @hourly.

Comenzi:

BASH
crontab -e          # editezi crontab-ul utilizatorului curent
crontab -l          # îl afișezi
sudo crontab -u www-data -l

Pe lângă crontab-urile utilizatorilor există /etc/crontab și fișierele din /etc/cron.d/, care au un câmp suplimentar: utilizatorul care rulează comanda, pus înainte de comandă. Folderele /etc/cron.daily/ și altele similare rulează scripturile din ele (fără extensie, pe Debian).

O capcană: când specifici și ziua din lună, și ziua din săptămână, cron rulează dacă oricare se potrivește, nu ambele. 0 8 1 * 1 rulează pe 1 ale lunii și în fiecare luni.

Ora folosită este cea a sistemului (timedatectl). La trecerea la ora de vară, joburile programate între 2 și 3 noaptea pot fi sărite sau rulate de două ori, în funcție de implementare, de aceea joburile importante nu se pun în acel interval.

Redirecționează mereu ieșirea într-un log: altfel cron încearcă să o trimită pe mail, iar pe majoritatea serverelor se pierde.

Ce urmărește intervievatorul: Verifică dacă scrii corect sintaxa fără să cauți un generator online. Greșeli tipice: ordinea câmpurilor și uitarea redirecționării ieșirii.

Eroarea, în practică:errors in crontab file, can't installno crontab for elev

52 Junior

Cum creezi o arhivă comprimată dintr-un folder, cum îi listezi conținutul și cum o extragi în alt folder? Ce diferență este între .tar.gz și .zip?

Răspuns scurt: Creezi cu tar czf arhiva.tar.gz folder/, listezi cu tar tzf și extragi cu tar xzf arhiva.tar.gz -C /dest. tar adună fișierele într-un singur flux, iar gzip comprimă fluxul; .zip arhivează și comprimă fiecare fișier separat.

Literele din comanda tar: c create, x extract, t list, z gzip, j bzip2, J xz, f urmat de numele fișierului, v verbose.

BASH
tar czf site-2026-10-31.tar.gz site/
tar tzf site-2026-10-31.tar.gz | head
tar xzf site-2026-10-31.tar.gz -C /tmp/restaurare
tar czf backup.tar.gz --exclude='node_modules' --exclude='*.log' proiect/
tar xzf arhiva.tar.gz site/index.html      # doar un fișier
tar cJf mare.tar.xz date/                  # xz: mai mic, mai lent

gzip app.log          # înlocuiește cu app.log.gz
gunzip app.log.gz
zcat app.log.gz | grep ERROR    # citești fără să decomprimi pe disc
zip -r site.zip site/; unzip site.zip -d /tmp/x

Diferențe practice:

  • tar păstrează permisiunile, proprietarii (la extragere ca root), link-urile simbolice și timpii, deci e alegerea pentru backup-uri pe Linux.
  • .tar.gz comprimă tot fluxul, ceea ce dă de obicei un raport mai bun pe multe fișiere mici asemănătoare; .zip comprimă individual, deci poți extrage rapid un singur fișier și e mai ușor de deschis pe Windows.
  • gzip e rapid și peste tot; xz și zstd comprimă mai bine. zstd (opțiunea --zstd în GNU tar recent) e foarte rapid.

Atenție la căi: tar czf b.tar.gz /var/www salvează căile fără / inițial (GNU tar îl elimină și afișează un avertisment), deci la extragere se creează var/www în folderul curent. Verifici întotdeauna cu tar tzf înainte să extragi o arhivă primită.

Ce urmărește intervievatorul: Verifică uzul de zi cu zi și siguranța. Un candidat bun listează conținutul înainte de extragere și știe ce se păstrează în arhivă.

Eroarea, în practică:tar: Not found in archivetar: You must specify one of the '-Acdtrux'

53 Junior

Ce înseamnă să montezi un sistem de fișiere? De ce umount /mnt/date poate da „target is busy” și cum rezolvi?

Răspuns scurt: Montarea atașează un sistem de fișiere (o partiție, un stick, un share de rețea) într-un folder din arborele unic. „Target is busy” înseamnă că un proces folosește ceva de acolo; îl găsești cu lsof +D /mnt/date sau fuser -vm /mnt/date.

În Linux nu există litere de unități ca în Windows. Orice disc devine accesibil când e montat într-un folder gol, numit punct de montare.

BASH
lsblk -f                         # discuri, partiții, sisteme de fișiere, unde sunt montate
sudo mount /dev/sdb1 /mnt/date
findmnt /mnt/date                # detalii despre montare
mount | grep sdb1
df -h /mnt/date
sudo umount /mnt/date

Conținutul pe care îl avea folderul /mnt/date înainte de montare nu se pierde, ci e ascuns până la demontare. Asta explică uneori fișiere „dispărute” sau spațiu „ocupat de nimic”.

„Target is busy” apare când un proces are deschis un fișier de pe acel sistem de fișiere sau are folderul curent acolo. Cel mai des este chiar shell-ul tău, aflat în /mnt/date.

BASH
cd /                             # ieși din folder
sudo fuser -vm /mnt/date         # cine îl folosește
sudo lsof +f -- /mnt/date
sudo umount /mnt/date

Oprești sau muți procesele găsite, apoi demontezi. Există și umount -l (lazy), care detașează imediat folderul din arbore și eliberează sistemul de fișiere când nu mai e folosit. E util la share-uri de rețea blocate, dar nu e potrivit pentru un stick pe care vrei să-l scoți, pentru că nu știi când s-au scris efectiv datele.

Montările făcute cu mount se pierd la repornire. Pentru montări permanente se folosește /etc/fstab.

Ce urmărește intervievatorul: Verifică modelul arborelui unic de fișiere. Mulți nu știu cum găsesc procesul care ține ocupat discul și sar direct la repornirea serverului.

54 Mid

Scrie un unit systemd pentru o aplicație Python care trebuie să ruleze ca utilizatorul app, să citească variabile dintr-un fișier .env și să repornească automat dacă se oprește.

Răspuns scurt: Creezi /etc/systemd/system/app.service cu [Unit], [Service] (cu User, WorkingDirectory, EnvironmentFile, ExecStart, Restart=on-failure) și [Install], apoi rulezi systemctl daemon-reload și systemctl enable --now app.

[Unit]
Description=Aplicația web
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=app
Group=app
WorkingDirectory=/srv/app
EnvironmentFile=/srv/app/.env
ExecStart=/srv/app/venv/bin/gunicorn -w 3 -b 127.0.0.1:8000 app:app
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
BASH
sudo systemctl daemon-reload
sudo systemctl enable --now app
systemctl status app

Puncte importante:

  • ExecStart cere calea absolută a executabilului. Dacă folosești un mediu virtual, dai calea din venv/bin, nu python din PATH.
  • Type=simple presupune că procesul rămâne în prim-plan. Dacă programul se transformă singur în daemon, systemd crede că s-a terminat.
  • EnvironmentFile citește linii CHEIE=valoare. Nu e un script shell: nu se fac substituții $(...), iar ghilimelele au reguli proprii.
  • Restart=on-failure repornește la ieșire cu cod nenul sau la semnal. Restart=always repornește și la ieșire normală. Dacă serviciul cade de prea multe ori într-un interval scurt (StartLimitBurst, StartLimitIntervalSec), systemd renunță și îl pune în failed.
  • După orice modificare a fișierului rulezi daemon-reload, altfel systemd folosește versiunea veche.
  • Nu suprascrii unit-urile din pachete în /lib/systemd/system; folosești systemctl edit nume pentru un override.

Opțiuni de întărire utile: NoNewPrivileges=true, ProtectSystem=strict, ReadWritePaths=/srv/app/uploads, PrivateTmp=true.

Ce urmărește intervievatorul: Este o sarcină practică frecventă la interviuri pentru backend și DevOps. Greșelile tipice: lipsa daemon-reload, căi relative în ExecStart și rularea ca root.

Eroarea, în practică:Failed to start: Unit not foundStart request repeated too quickly

55 Mid

Cum afli cu journalctl doar erorile serviciului app din ultima oră? Dar logurile de la boot-ul anterior, de dinaintea unei căderi?

Răspuns scurt: journalctl -u app -p err --since "1 hour ago" arată erorile din ultima oră. journalctl -b -1 arată boot-ul anterior, dacă jurnalul e persistent pe disc; altfel e pierdut la repornire.

Journalul systemd păstrează logurile structurat, cu câmpuri (unitate, prioritate, PID), deci poți filtra precis fără grep.

BASH
journalctl -u app -p err --since "1 hour ago"
journalctl -u app -f                       # urmărire live
journalctl -u app -n 100 --no-pager        # ultimele 100 de linii
journalctl -u nginx -u app --since today
journalctl --since "2026-10-31 09:00" --until "2026-10-31 09:30"
journalctl -b                              # boot-ul curent
journalctl -b -1 -p warning                # boot-ul anterior
journalctl --list-boots
journalctl -k                              # mesaje de kernel (ca dmesg)
journalctl _PID=4127
journalctl -u app -o json-pretty -n 1      # toate câmpurile
journalctl --disk-usage
sudo journalctl --vacuum-time=14d          # păstrează două săptămâni

Prioritățile urmează nivelurile syslog: emerg, alert, crit, err, warning, notice, info, debug. -p err arată err și tot ce e mai grav.

Persistența: dacă folderul /var/log/journal nu există și Storage=auto în /etc/systemd/journald.conf, jurnalul stă în /run/log/journal, adică în memorie, și dispare la repornire. Atunci journalctl -b -1 dă eroare. Pe multe distribuții jurnalul e persistent implicit, dar e bine să verifici înainte să ai nevoie de el:

BASH
sudo mkdir -p /var/log/journal && sudo systemctl restart systemd-journald

Un utilizator obișnuit vede doar propriile loguri, dacă nu e în grupul systemd-journal sau adm.

Când ieșirea aplicației nu apare deloc, verifici dacă aplicația scrie în stdout/stderr (capturate automat de systemd) sau într-un fișier propriu.

Ce urmărește intervievatorul: Verifică dacă găsești rapid informația relevantă într-un volum mare de loguri. Mulți nu știu că logurile pot fi pierdute la repornire dacă jurnalul nu e persistent.

Eroarea, în practică:Job for nginx.service failedMain process exited, status=1/FAILURE

56 Mid

Un script merge perfect când îl rulezi din terminal, dar din cron nu face nimic. Care sunt cauzele obișnuite și cum depanezi?

Răspuns scurt: Cron rulează cu un mediu minimal: PATH scurt, fără variabilele din .bashrc, alt folder curent și adesea /bin/sh în loc de Bash. Alte cauze: caracterul % necitat, lipsa dreptului de execuție și ieșirea care nu e salvată nicăieri.

Cele mai frecvente cauze:

  • PATH: în cron, PATH este de obicei doar /usr/bin:/bin. O comandă din /usr/local/bin sau dintr-un mediu virtual nu e găsită.
  • Variabile de mediu: .bashrc și .profile nu sunt citite, deci lipsesc variabilele exportate acolo (chei, JAVA_HOME, NVM).
  • Folderul curent: e home-ul utilizatorului, nu folderul scriptului, deci căile relative nu mai indică fișierele corecte.
  • Shell-ul: comanda din crontab rulează cu /bin/sh; pe Ubuntu e dash, care nu înțelege sintaxa Bash folosită direct în linia de crontab.
  • %: în crontab, % înseamnă newline, deci date +%F trebuie scris date +\%F.
  • Permisiuni: scriptul nu e executabil sau rulează ca alt utilizator.

Depanare:

SHELL=/bin/bash
PATH=/usr/local/bin:/usr/bin:/bin
*/5 * * * * cd /srv/app && ./sync.sh >> /var/log/sync.log 2>&1
* * * * * env > /tmp/cron-env.txt

Linia cu env îți arată exact mediul în care rulează cron. Poți simula mediul: env -i HOME=$HOME PATH=/usr/bin:/bin /bin/sh -c './sync.sh'.

Verifici și că jobul a pornit: grep CRON /var/log/syslog pe Ubuntu sau journalctl -u cron. Dacă nu apare deloc, problema e în sintaxa liniei sau în faptul că crontab -e nu a salvat-o.

În script, setezi tu ce îți trebuie: căi absolute, cd "$(dirname "$0")", variabile citite explicit dintr-un fișier de configurare.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente probleme practice cu cron. Intervievatorul vrea să audă de mediul minimal și de salvarea ieșirii, nu doar „verific sintaxa”.

Eroarea, în practică:(CRON) info (No MTA installed...)

57 Mid

Ai atașat un disc nou de 200 GB la un server. Descrie pașii până când discul e montat permanent în /data, inclusiv după repornire.

Răspuns scurt: Identifici discul cu lsblk, creezi o partiție (opțional), formatezi cu mkfs.ext4, afli UUID-ul cu blkid, adaugi o linie în /etc/fstab cu UUID, /data, tipul și opțiunile, apoi testezi cu mount -a înainte de orice repornire.

Pașii:

BASH
lsblk                                   # discul nou apare, de exemplu sdb, fără partiții
sudo parted -s /dev/sdb mklabel gpt mkpart primary ext4 0% 100%
sudo mkfs.ext4 -L date /dev/sdb1
sudo blkid /dev/sdb1
# /dev/sdb1: LABEL="date" UUID="3f2a...-..." TYPE="ext4"
sudo mkdir -p /data

Linia din /etc/fstab:

UUID=3f2a...  /data  ext4  defaults,nofail  0  2
BASH
sudo mount -a          # montează tot din fstab; o eroare apare acum, nu la boot
findmnt /data
sudo systemctl daemon-reload   # systemd generează unitățile de montare din fstab

De ce aceste alegeri:

  • UUID în loc de /dev/sdb1: numele de dispozitiv se pot schimba la repornire sau când adaugi alt disc, iar UUID-ul rămâne același.
  • nofail: dacă discul lipsește, serverul pornește totuși, în loc să intre în modul de urgență. Pentru un disc de date e de obicei alegerea corectă; pentru unul de care depinde sistemul, nu.
  • Ultimele două câmpuri: dump (aproape mereu 0) și ordinea verificării cu fsck (1 pentru rădăcină, 2 pentru celelalte, 0 fără verificare).
  • mount -a este testul obligatoriu. O greșeală de tipar în fstab poate face serverul să nu mai pornească.

Pe discuri de cloud, mulți sar peste partiționare și formatează direct /dev/sdb. Pentru flexibilitate (mărire ulterioară, mai multe discuri) se folosește LVM. Ca la orice operație pe discuri, verifici de două ori că /dev/sdb e discul nou: mkfs pe discul greșit șterge datele.

Ce urmărește intervievatorul: Verifică dacă ai făcut asta de fapt, nu doar ai citit despre mount. Semnalele bune: UUID, nofail și testarea cu mount -a înainte de repornire.

58 Senior

Descrie ce se întâmplă de la apăsarea butonului de pornire până la promptul de login pe un server Linux modern.

Răspuns scurt: Firmware-ul (UEFI sau BIOS) pornește bootloader-ul, de obicei GRUB, care încarcă kernelul și initramfs-ul. Kernelul inițializează hardware-ul, folosește initramfs ca să găsească și să monteze rădăcina, apoi pornește PID 1, systemd, care aduce sistemul la target-ul implicit.

Etapele:

  • Firmware: UEFI (sau BIOS pe sistemele vechi) face testele hardware și pornește bootloader-ul de pe partiția EFI sau din sectorul de boot.
  • Bootloader: GRUB afișează meniul, citește configurarea (generată în /boot/grub/grub.cfg), încarcă în memorie kernelul (vmlinuz) și initramfs, cu parametrii din linia de comandă a kernelului, de exemplu root=UUID=....
  • Kernel: inițializează procesorul, memoria și driverele incluse, apoi montează initramfs ca rădăcină temporară.
  • initramfs: un mini-sistem cu module și scripturi care fac rădăcina accesibilă: încarcă driverele de disc, deschide volume LVM sau criptate, asamblează RAID-ul. Apoi comută pe rădăcina reală.
  • systemd (PID 1): citește unitățile, montează sistemele din fstab, pornește serviciile în paralel, conform dependențelor, până la target-ul implicit (multi-user.target pe servere, graphical.target pe desktop).
  • getty sau sshd: oferă login-ul.
BASH
systemd-analyze                  # cât a durat fiecare etapă
systemd-analyze blame | head     # serviciile cele mai lente
systemctl get-default
cat /proc/cmdline                # parametrii primiți de kernel
journalctl -b -p err             # erorile din acest boot

De ce contează la depanare: fiecare etapă are alt tip de eșec. „No bootable device” ține de firmware. Un prompt grub> arată că lipsește configurația. Un kernel panic cu „unable to mount root fs” ține de initramfs sau de UUID-ul rădăcinii. Intrarea în emergency mode indică de obicei fstab sau un sistem de fișiere care cere fsck. Știind unde s-a oprit procesul, știi ce să repari.

Ce urmărește intervievatorul: Verifică o înțelegere de ansamblu, utilă când un server nu mai pornește. Candidatul senior leagă fiecare etapă de simptomele ei de eșec.

Eroarea, în practică:System has not been booted with systemd

59 Senior

Cum faci un deploy pe un singur server astfel încât trecerea la versiunea nouă să fie instantanee și să poți reveni la versiunea veche în câteva secunde?

Răspuns scurt: Ții fiecare versiune într-un folder separat (releases/2026-10-31-1200) și un link simbolic current spre versiunea activă. Schimbi link-ul atomic cu ln -sfn plus mv -T, apoi reîncarci serviciul; revenirea înseamnă mutarea link-ului înapoi.

Structura:

/srv/app/
  releases/2026-10-30-1700/
  releases/2026-10-31-1200/
  shared/.env  shared/uploads/
  current -> releases/2026-10-31-1200

Serviciul systemd și configurarea nginx folosesc doar /srv/app/current. Scriptul de deploy:

BASH
#!/usr/bin/env bash
set -euo pipefail
REL=/srv/app/releases/$(date +%Y-%m-%d-%H%M)
mkdir -p "$REL"
tar xzf /tmp/build.tar.gz -C "$REL"
ln -s /srv/app/shared/.env "$REL/.env"
ln -sfn "$REL" /srv/app/current.tmp
mv -T /srv/app/current.tmp /srv/app/current   # rename() atomic
sudo systemctl reload app || sudo systemctl restart app
ls -1dt /srv/app/releases/* | tail -n +6 | xargs -r rm -rf   # păstrează 5

De ce așa:

  • ln -sfn direct peste current șterge link-ul și creează altul, deci există un moment în care link-ul nu există. Crearea unui link temporar și apoi mv -T folosește rename(), care e atomic: orice proces vede fie versiunea veche, fie pe cea nouă.
  • -T (GNU) tratează destinația ca fișier, altfel mv ar pune link-ul în interiorul folderului spre care indică current.
  • Datele care trebuie să supraviețuiască între versiuni (configurare, fișiere încărcate) stau în shared/ și sunt legate în fiecare versiune.
  • Rollback: ln -sfn releases/2026-10-30-1700 current.tmp && mv -T current.tmp current și reload.

Limite: procesele deja pornite păstrează folderul vechi ca folder curent până la restart, deci trebuie să reîncarci serviciul. Schimbările de schemă ale bazei de date trebuie să fie compatibile cu ambele versiuni, altfel rollback-ul codului nu ajunge.

Ce urmărește intervievatorul: Verifică dacă înțelegi atomicitatea operațiilor pe fișiere și o aplici la deploy. Un răspuns slab copiază fișierele peste versiunea veche, lăsând serverul într-o stare amestecată în timpul copierii.

Eroarea, în practică:ln: failed to create symbolic link: File exists

Rețea și SSH

60 Junior

Cum afli adresa IP a serverului, gateway-ul implicit și ce interfețe de rețea are? Ce înlocuiește ip din uneltele vechi?

Răspuns scurt: ip -br a arată interfețele și adresele, ip r tabela de rutare, unde linia default via este gateway-ul. ip (pachetul iproute2) înlocuiește ifconfig, route și arp din pachetul vechi net-tools, care lipsește adesea pe sistemele noi.

BASH
ip -br a
# lo      UNKNOWN  127.0.0.1/8 ::1/128
# ens3    UP       10.0.1.15/24 fe80::...
ip a show ens3          # detalii: MAC, MTU, adrese
ip r
# default via 10.0.1.1 dev ens3
# 10.0.1.0/24 dev ens3 proto kernel scope link src 10.0.1.15
ip route get 8.8.8.8    # ce interfață și ce gateway ar folosi
ip neigh                # tabela ARP (vecinii din rețeaua locală)
ip -s link show ens3    # pachete și erori pe interfață
hostname -I             # doar adresele
curl -s ifconfig.me     # IP-ul public văzut din afară (serviciu extern)

Ce citești:

  • lo este interfața locală, 127.0.0.1. Un serviciu care ascultă doar acolo nu e accesibil din rețea.
  • Adresa privată (de exemplu 10.x, 172.16-31.x, 192.168.x) e cea din rețeaua internă; pe un server din cloud, IP-ul public e adesea tradus prin NAT și nu apare pe nicio interfață. De aceea curl ifconfig.me poate arăta altă adresă decât ip a.
  • Linia default via e ruta folosită pentru tot ce nu e în rețelele locale. Fără ea, serverul comunică doar în rețeaua lui.
  • ip route get e cel mai rapid mod de a vedea pe unde iese traficul spre o anumită adresă, util când serverul are mai multe interfețe.

Modificările făcute cu ip addr add sau ip route add sunt temporare. Configurarea permanentă se face prin netplan (Ubuntu), NetworkManager (nmcli) sau systemd-networkd, în funcție de distribuție.

Ce urmărește intervievatorul: Verifică orientarea de bază în rețea. Mulți folosesc încă doar ifconfig și nu știu de ce IP-ul public al unei mașini din cloud nu apare în ip a.

Eroarea, în practică:ping: Destination Host Unreachable

61 Junior

ping către un server nu primește răspuns, dar site-ul de pe el se încarcă în browser. Cum e posibil? Ce îți arată traceroute sau mtr?

Răspuns scurt: ping folosește ICMP, pe care multe firewall-uri sau furnizori de cloud îl blochează, în timp ce traficul HTTP pe TCP 443 e permis. traceroute și mtr arată ruterele prin care trec pachetele și unde apar întârzieri sau pierderi.

ping trimite pachete ICMP Echo Request și așteaptă Echo Reply. E un test util, dar nu dovedește nimic despre un serviciu anume: lipsa răspunsului poate însemna că ICMP e filtrat, iar un răspuns nu garantează că aplicația merge.

BASH
ping -c 4 exemplu.ro          # 4 pachete, apoi statistici
ping -c 4 -W 2 10.0.1.20      # timeout de 2 secunde
curl -sI https://exemplu.ro   # testează chiar serviciul
nc -zv exemplu.ro 443         # portul TCP acceptă conexiuni?
traceroute -n exemplu.ro
mtr -rwn -c 50 exemplu.ro     # raport după 50 de runde

Pentru un serviciu web, testul relevant este conexiunea TCP la portul lui sau o cerere HTTP, nu ping.

traceroute trimite pachete cu TTL (time to live) crescător: 1, 2, 3 și așa mai departe. Fiecare ruter care scade TTL-ul la 0 răspunde cu un mesaj ICMP, așa că afli lista nodurilor de pe drum. Asteriscurile (* * *) înseamnă că acel ruter nu răspunde la astfel de pachete, ceea ce e frecvent și nu indică neapărat o problemă.

mtr combină ping și traceroute și repetă măsurătorile, afișând pierderile și latența pentru fiecare nod. Cum îl citești: dacă pierderea apare la un nod din mijloc, dar nodurile de după au 0%, acel ruter doar limitează răspunsurile ICMP. O problemă reală se vede ca pierdere care începe la un nod și continuă până la destinație.

-n dezactivează traducerea inversă a adreselor în nume, ceea ce face rezultatele mai rapide.

Ce urmărește intervievatorul: Verifică dacă alegi testul potrivit pentru ce vrei să dovedești. Greșeala frecventă: concluzia „serverul e căzut” doar pentru că nu răspunde la ping.

Eroarea, în practică:ping: Destination Host Unreachable

62 Junior

Cum folosești curl ca să vezi doar header-ele unui răspuns, să urmezi redirecționările, să trimiți un POST cu JSON și să afișezi doar codul HTTP?

Răspuns scurt: curl -I sau curl -sD - -o /dev/null pentru header-e, -L pentru redirecționări, -X POST -H "Content-Type: application/json" -d '{...}' pentru JSON și -s -o /dev/null -w "%{http_code}" pentru codul de status.

curl este unealta standard pentru testarea API-urilor și a serverelor web din terminal.

BASH
curl -I https://exemplu.ro                 # cerere HEAD, doar header-e
curl -sL https://exemplu.ro -o pagina.html # urmează 301/302, salvează
curl -v https://api.exemplu.ro/health      # tot dialogul, inclusiv TLS
curl -s -o /dev/null -w "%{http_code} %{time_total}s\n" https://exemplu.ro
curl -X POST https://api.exemplu.ro/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{"nume": "Ana", "email": "ana@exemplu.ro"}'
curl -fsS https://exemplu.ro/health || echo "căzut"
curl --resolve exemplu.ro:443:10.0.1.20 https://exemplu.ro/

Ce trebuie știut:

  • -I face o cerere HEAD, iar unele aplicații răspund diferit la HEAD față de GET. Varianta sigură pentru header-ele unui GET: curl -sD - -o /dev/null URL.
  • -d setează automat metoda POST; -X POST e explicit, dar redundant. Fără header-ul Content-Type, datele sunt trimise ca formular (application/x-www-form-urlencoded). Versiunile noi (7.82+) au --json, care pune header-ele automat.
  • Implicit, curl iese cu cod 0 și pentru răspunsuri 404 sau 500. În scripturi folosești -f (--fail), ca să obții cod nenul la erori HTTP, iar -sS ascunde progresul, dar păstrează mesajele de eroare.
  • --resolve testează un server anume sub un nume de domeniu, fără să modifici DNS-ul. Util înainte de mutarea unui site.
  • -k dezactivează verificarea certificatului; e acceptabil doar pentru teste punctuale, niciodată într-un script de producție.

Ce urmărește intervievatorul: Verifică uzul practic pentru testarea API-urilor. Mulți nu știu că curl reușește și la 500 fără -f, ceea ce strică verificările din scripturi.

Eroarea, în practică:curl: (22) returned error: 404

63 Junior

Cum afli la ce IP se rezolvă un domeniu cu dig? În ce ordine caută sistemul un nume și ce rol au /etc/hosts și /etc/resolv.conf?

Răspuns scurt: dig +short exemplu.ro afișează adresele, iar dig @1.1.1.1 exemplu.ro întreabă un anumit server DNS. Sistemul consultă de obicei întâi /etc/hosts, apoi DNS-ul din /etc/resolv.conf, în ordinea definită în /etc/nsswitch.conf.

BASH
dig +short exemplu.ro              # doar adresa sau adresele
dig exemplu.ro A                   # răspuns complet, cu TTL
dig +short exemplu.ro MX           # serverele de mail
dig @1.1.1.1 exemplu.ro            # întrebi direct un resolver public
dig +trace exemplu.ro              # de la rădăcină până la serverul autoritar
dig -x 93.184.216.34 +short        # rezolvare inversă
getent hosts exemplu.ro            # ce vede o aplicație obișnuită

dig interoghează direct DNS-ul și ignoră /etc/hosts. Aplicațiile obișnuite (curl, browserul, aplicația ta) folosesc biblioteca de sistem, care respectă ordinea din /etc/nsswitch.conf:

hosts: files dns

files înseamnă /etc/hosts, apoi dns înseamnă serverele din /etc/resolv.conf. De aceea getent hosts arată ce va folosi aplicația, iar dig ce spune DNS-ul. Dacă cele două diferă, cel mai probabil există o intrare în /etc/hosts.

/etc/hosts e util pentru teste (de exemplu, să vezi site-ul pe serverul nou înainte de schimbarea DNS), dar intrările uitate acolo produc probleme greu de găsit.

/etc/resolv.conf conține nameserver (serverele DNS) și search (domenii adăugate numelor scurte). Pe Ubuntu cu systemd-resolved, fișierul indică un resolver local, 127.0.0.53, iar serverele reale le vezi cu resolvectl status.

Când un nume tocmai a fost schimbat, rezultatele vechi pot rămâne în cache-uri până expiră TTL-ul.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre ce răspunde DNS-ul și ce folosește efectiv o aplicație. Mulți nu știu că dig ignoră /etc/hosts.

Eroarea, în practică:curl: (6) Could not resolve host

64 Junior

Cum configurezi autentificarea SSH cu chei pentru un server nou? Ce permisiuni trebuie să aibă fișierele din ~/.ssh?

Răspuns scurt: Generezi o pereche cu ssh-keygen -t ed25519, copiezi cheia publică pe server cu ssh-copy-id user@server (ajunge în ~/.ssh/authorized_keys) și testezi. ~/.ssh trebuie să fie 700, cheia privată și authorized_keys 600; altfel SSH poate refuza cheile.

BASH
ssh-keygen -t ed25519 -C "ana@laptop"
# creează ~/.ssh/id_ed25519 (privată) și ~/.ssh/id_ed25519.pub (publică)
ssh-copy-id -i ~/.ssh/id_ed25519.pub ana@10.0.1.15
ssh ana@10.0.1.15                  # ar trebui să nu mai ceară parola contului

# manual, dacă nu ai ssh-copy-id
cat ~/.ssh/id_ed25519.pub | ssh ana@10.0.1.15 \
  'mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys'

Cum funcționează: serverul are cheia ta publică. La conectare, clientul demonstrează că deține cheia privată semnând o provocare, fără ca cheia privată să părăsească vreodată calculatorul tău.

Permisiuni:

  • ~/.ssh: 700; ~/.ssh/authorized_keys: 600; cheia privată: 600; cheia publică poate fi 644.
  • Și folderul home al utilizatorului de pe server nu trebuie să fie scriptibil de alții. Cu opțiunea implicită StrictModes yes, sshd ignoră authorized_keys dacă permisiunile sunt prea largi, iar tu primești din nou cererea de parolă. Motivul apare în logul serverului (journalctl -u ssh sau /var/log/auth.log).
  • Clientul refuză să folosească o cheie privată citibilă de alții, cu mesajul „UNPROTECTED PRIVATE KEY FILE”.

ed25519 este alegerea modernă: chei scurte, rapide și sigure; RSA rămâne pentru sisteme vechi, cu minimum 3072 de biți. Pune o parolă (passphrase) pe cheia privată și folosește ssh-agent, ca să nu o scrii la fiecare conectare.

Ce urmărește intervievatorul: Verifică un flux pe care orice dezvoltator îl face. Greșeala tipică: permisiunile greșite, iar candidatul nu știe că motivul refuzului apare în logul serverului.

Eroarea, în practică:Permission denied (publickey,password)WARNING: UNPROTECTED PRIVATE KEY FILE!

65 Junior

Ce diferență este între scp și rsync? Ce face slash-ul de la final în rsync -av src/ dest/ față de rsync -av src dest/?

Răspuns scurt: scp copiază fișierele integral de fiecare dată; rsync transferă doar diferențele, poate relua transferuri și poate sincroniza ștergerile. src/ copiază conținutul folderului în dest/, iar src fără slash creează dest/src/.

BASH
scp raport.pdf ana@server:/tmp/
scp -r site/ ana@server:/var/www/        # recursiv
scp ana@server:/var/log/app.log .        # de pe server local

rsync -avz site/ ana@server:/var/www/site/
rsync -avz --delete site/ ana@server:/var/www/site/
rsync -avzn --delete site/ ana@server:/var/www/site/   # -n: simulare
rsync -av --exclude 'node_modules' proiect/ backup/proiect/
rsync -avP mare.iso ana@server:/date/                  # progres și reluare

rsync compară fișierele (implicit după mărime și dată) și, pentru cele schimbate, trimite doar blocurile diferite. La al doilea backup al unui folder mare, transferul e de obicei mult mai mic. -a (archive) păstrează permisiunile, timpii, link-urile simbolice și, ca root, proprietarii; -z comprimă în timpul transferului; -P arată progresul și păstrează fișierele parțiale pentru reluare.

Slash-ul final al sursei schimbă rezultatul:

  • rsync -av src/ dest/: dest/ conține a.txt, b.txt din src.
  • rsync -av src dest/: dest/ conține src/a.txt, src/b.txt.

Slash-ul de la destinație nu contează în același fel. Combinat cu --delete, care șterge din destinație ce nu există în sursă, o greșeală de slash poate șterge date. De aceea rulezi întâi cu -n (dry run) și citești lista.

scp rămâne util pentru copieri simple, o singură dată. În OpenSSH 9.0+, scp folosește implicit protocolul SFTP în locul vechiului protocol SCP, cu mici diferențe de comportament la căi cu caractere speciale.

Ce urmărește intervievatorul: Verifică dacă știi să faci backup-uri și transferuri eficiente și sigure. Capcana slash-ului împreună cu --delete e un exemplu clasic de greșeală costisitoare.

Eroarea, în practică:rsync: change_dir failed: No such file

66 Mid

Te conectezi zilnic la zece servere, unele accesibile doar printr-un server bastion. Cum îți simplifici munca cu ~/.ssh/config?

Răspuns scurt: Definești câte un bloc Host cu alias, HostName, User, Port și IdentityFile, iar pentru serverele interne adaugi ProxyJump bastion. Apoi ssh db1 face automat saltul prin bastion, cu cheile tale, fără ca cheile să fie copiate pe bastion.

Host bastion
    HostName 203.0.113.10
    User ana
    IdentityFile ~/.ssh/id_ed25519

Host web1 web2 db1
    User deploy
    ProxyJump bastion
    IdentityFile ~/.ssh/id_ed25519_prod

Host web1
    HostName 10.0.1.11
Host web2
    HostName 10.0.1.12
Host db1
    HostName 10.0.2.21
    Port 2222

Host *
    ServerAliveInterval 30
    IdentitiesOnly yes
BASH
ssh db1                       # trece prin bastion automat
scp backup.sql db1:/tmp/      # alias-urile merg și cu scp, rsync, git
ssh -J bastion deploy@10.0.2.21   # echivalentul din linia de comandă

Detalii utile:

  • ProxyJump (OpenSSH 7.3+) deschide o conexiune spre bastion și, prin ea, una spre serverul final. Autentificarea la serverul final se face tot de pe laptopul tău, deci cheia privată nu trebuie să stea pe bastion.
  • SSH folosește prima valoare găsită pentru fiecare opțiune, de aceea blocurile specifice stau înaintea lui Host *.
  • IdentitiesOnly yes împiedică trimiterea tuturor cheilor din agent pe rând; cu multe chei, serverul poate refuza conexiunea după prea multe încercări eșuate.
  • ServerAliveInterval trimite mesaje periodice, ca un firewall să nu închidă conexiunile inactive.
  • Pentru multe comenzi la rând pe același server, ControlMaster auto cu ControlPath și ControlPersist 10m refolosește o conexiune deschisă, făcând conectările următoare aproape instantanee.

Fișierul trebuie să aibă permisiuni restrictive (600).

Ce urmărește intervievatorul: Arată cât de eficient lucrezi cu mai multe servere. Un răspuns bun alege ProxyJump în loc de agent forwarding sau de copierea cheilor pe bastion.

67 Mid

Baza de date PostgreSQL ascultă doar pe 127.0.0.1:5432 pe un server la distanță. Cum te conectezi la ea de pe laptop fără să o expui în internet? Ce fac ssh -L, -R și -D?

Răspuns scurt: Cu un tunel local: ssh -L 5433:127.0.0.1:5432 user@server, apoi te conectezi la localhost:5433 pe laptop. -L aduce un port de la distanță la tine, -R expune un port local pe server, -D creează un proxy SOCKS prin server.

Un tunel SSH transportă o conexiune TCP prin conexiunea SSH criptată.

BASH
ssh -N -L 5433:127.0.0.1:5432 ana@db-server
psql -h 127.0.0.1 -p 5433 -U app aplicatie     # pe laptop

ssh -N -L 8080:10.0.2.30:80 ana@bastion         # serviciu intern din rețeaua bastionului

ssh -N -R 9000:127.0.0.1:3000 ana@server        # serverul vede pe portul 9000 aplicația de pe laptop

ssh -N -D 1080 ana@server                       # proxy SOCKS5 pe localhost:1080
curl --socks5-hostname 127.0.0.1:1080 http://intern.exemplu.local

Cum se citește -L 5433:127.0.0.1:5432: ascultă pe laptop la portul 5433, iar fiecare conexiune primită e trimisă prin SSH, iar serverul se conectează la 127.0.0.1:5432. Adresa țintă e interpretată de pe server, deci 127.0.0.1 este serverul însuși, nu laptopul.

  • -L (local): accesezi servicii care nu sunt expuse public, cum ar fi baze de date, panouri de administrare sau API-uri interne.
  • -R (remote): faci accesibil temporar ceva de pe calculatorul tău, de exemplu pentru un webhook de test. Implicit, portul ascultă doar pe localhost-ul serverului (GatewayPorts no).
  • -D (dynamic): un proxy SOCKS; browserul sau curl trimit tot traficul prin server.
  • -N nu deschide shell, doar tunelul; -f îl trimite în fundal.

E mult mai sigur decât deschiderea portului 5432 în firewall. Administratorii pot dezactiva tunelurile în sshd_config (AllowTcpForwarding no), așa că, dacă un tunel nu merge, verifici și această opțiune.

Ce urmărește intervievatorul: Verifică o tehnică foarte folosită în practică pentru acces sigur. Confuzia frecventă: candidatul crede că 127.0.0.1 din tunel se referă la laptop.

68 Mid

Pe un server Ubuntu nou vrei să permiți doar SSH, HTTP și HTTPS. Cum configurezi firewall-ul cu ufw fără să te blochezi singur afară?

Răspuns scurt: Setezi politicile implicite (deny incoming, allow outgoing), permiți SSH înainte de activare (ufw allow OpenSSH sau portul tău), apoi 80 și 443, și abia la final ufw enable. Păstrezi o sesiune deschisă și testezi o conexiune nouă.

BASH
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow OpenSSH               # sau: sudo ufw allow 22/tcp
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow from 10.0.1.0/24 to any port 5432 proto tcp   # DB doar din rețeaua internă
sudo ufw limit 22/tcp                # limitează încercările repetate
sudo ufw enable
sudo ufw status numbered
sudo ufw delete 4                    # ștergi o regulă după număr

Ordinea contează: dacă rulezi ufw enable cu politica implicită deny înainte să permiți SSH, conexiunea ta curentă poate supraviețui (conexiunile stabilite sunt de obicei păstrate), dar nicio conexiune nouă nu va mai merge. Dacă SSH rulează pe alt port decât 22, permiți acel port, nu profilul OpenSSH.

Reguli de siguranță:

  • Păstrezi sesiunea SSH curentă deschisă și testezi într-un terminal nou înainte să închizi.
  • Pe un server din cloud, ai și firewall-ul furnizorului (security group); ambele trebuie să permită traficul. Consola web a furnizorului e varianta de recuperare.

ufw este o interfață peste nftables/iptables. Pe familia Red Hat folosești firewalld:

BASH
sudo firewall-cmd --permanent --add-service=http --add-service=https
sudo firewall-cmd --reload
sudo firewall-cmd --list-all

Fără --permanent, regula se pierde la reload. Atenție: Docker, dacă e instalat, își adaugă propriile reguli și poate expune porturi care ocolesc regulile ufw.

Ce urmărește intervievatorul: Verifică atât comenzile, cât și disciplina operațională. Intervievatorul vrea să audă de ordinea pașilor și de testarea dintr-o sesiune nouă.

Eroarea, în practică:ufw: Could not find a profile matching

69 Mid

Un API întoarce JSON. Cum extragi din terminal, cu curl și jq, numele tuturor utilizatorilor activi și cum numeri câți sunt?

Răspuns scurt: curl -s URL | jq -r '.users[] | select(.active) | .name' afișează numele, câte unul pe linie. Pentru număr: jq '[.users[] | select(.active)] | length'. -r scoate valorile fără ghilimele, potrivit pentru alte comenzi.

Să zicem că API-ul răspunde așa:

JSON
{"users": [
  {"id": 1, "name": "Ana", "active": true, "roles": ["admin"]},
  {"id": 2, "name": "Ion", "active": false, "roles": []},
  {"id": 3, "name": "Maria", "active": true, "roles": ["dev", "ops"]}
]}
BASH
URL=https://api.exemplu.ro/users
curl -fsS "$URL" | jq -r '.users[] | select(.active) | .name'
# Ana
# Maria
curl -fsS "$URL" | jq '[.users[] | select(.active)] | length'
# 2
curl -fsS "$URL" | jq -r '.users[] | "\(.id)\t\(.name)\t\(.roles | join(","))"'
curl -fsS "$URL" | jq '.users | map({id, name})'
curl -fsS "$URL" | jq -e '.users | length > 0' > /dev/null && echo "are date"

Elementele din jq:

  • .users[] desface tabloul în elemente separate;
  • | trimite fiecare element la filtrul următor, la fel ca pipe-ul din shell;
  • select(cond) păstrează doar elementele pentru care condiția e adevărată;
  • [ ... ] adună rezultatele înapoi într-un tablou, ca să poți aplica length;
  • -r (raw) scoate șirurile fără ghilimele; fără el, rezultatul e JSON valid.
  • -e setează codul de ieșire după rezultat (fals sau null dau cod nenul), util în scripturi.

Pentru a construi JSON cu valori din variabile, nu concatenezi șiruri, ci folosești jq -n --arg n "$NUME" '{name: $n}', care face escaping corect pentru ghilimele și caractere speciale.

grep și sed pe JSON par să meargă până când API-ul schimbă formatarea sau apare o virgulă într-un nume.

Ce urmărește intervievatorul: Verifică dacă procesezi date structurate corect, nu cu grep. E o abilitate frecventă în scripturi de automatizare și testare de API-uri.

Eroarea, în practică:jq: Cannot index array withjq: nume/0 is not defined

70 Senior

La conectarea SSH primești „WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!”. Ce înseamnă, cum procedezi și ce riscuri are ForwardAgent yes?

Răspuns scurt: Cheia de host a serverului diferă de cea salvată în known_hosts: fie serverul a fost reinstalat, fie cineva interceptează conexiunea. Verifici amprenta pe un canal separat înainte de ssh-keygen -R. Cu agent forwarding, cine are root pe server îți poate folosi cheile cât ești conectat.

La prima conectare, SSH îți arată amprenta cheii serverului și o salvează în ~/.ssh/known_hosts. La următoarele conectări compară cheia primită cu cea salvată. Asta te protejează de un atac de tip man-in-the-middle, în care cineva se interpune între tine și server.

Cauzele unei schimbări:

  • legitime: serverul a fost reinstalat, IP-ul a fost refolosit pentru altă mașină, cheile de host au fost regenerate;
  • periculoase: DNS sau rețea compromise, care te trimit spre alt server.

Procedura corectă: nu ignori avertismentul. Obții amprenta reală pe alt canal (consola furnizorului de cloud, colegul care a reinstalat serverul, sistemul de inventar):

BASH
# pe server, din consolă
ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
# pe laptop, după confirmare
ssh-keygen -R server.exemplu.ro
ssh server.exemplu.ro          # compari amprenta afișată

În automatizări, StrictHostKeyChecking no elimină această protecție; mai bine distribui cheile cunoscute sau folosești certificate SSH semnate de o autoritate internă.

Agent forwarding (ssh -A) face ca serverul să poată cere agentului de pe laptopul tău să semneze în numele cheilor tale. Cheia privată nu ajunge pe server, dar oricine are root acolo poate folosi socket-ul agentului, cât timp ești conectat, ca să se autentifice pe alte servere ca tine. Alternative: ProxyJump pentru bastioane, chei separate cu drepturi limitate pentru, de exemplu, git pull pe server (deploy keys), și ssh-add -c, care cere confirmare la fiecare folosire.

Ce urmărește intervievatorul: Verifică maturitatea în materie de securitate operațională. Răspunsul slab e „șterg linia din known_hosts” fără verificare și „pun -A ca să meargă git”.

Eroarea, în practică:Host key verification failed

Scripting Bash

71 Junior

Ce diferență este între a rula un script cu ./script.sh, bash script.sh și source script.sh? Ce rol are prima linie, #!/bin/bash?

Răspuns scurt: ./script.sh cere drept de execuție și folosește interpretorul din shebang, bash script.sh forțează Bash fără să ceară execuție, iar ambele rulează într-un proces nou. source rulează scriptul în shell-ul curent, deci variabilele și cd-urile rămân după.

Shebang-ul (#!) este citit de kernel la execve(): dacă fișierul începe cu #!, kernelul pornește interpretorul indicat și îi dă fișierul ca argument.

BASH
cat > salut.sh <<'EOF'
#!/usr/bin/env bash
NUME="Ana"
cd /tmp
echo "Salut, $NUME din $(pwd)"
EOF

./salut.sh          # Permission denied: lipsește x
chmod +x salut.sh
./salut.sh          # Salut, Ana din /tmp
echo "$NUME"; pwd   # gol; folderul tău nu s-a schimbat
bash salut.sh       # merge și fără chmod +x
source salut.sh     # sau: . salut.sh
echo "$NUME"; pwd   # Ana; /tmp

Diferențe:

  • ./script.sh respectă shebang-ul. Dacă scrii #!/bin/sh și folosești sintaxă Bash, pe Ubuntu scriptul rulează cu dash și poate eșua.
  • bash script.sh ignoră shebang-ul și folosește Bash. E util pentru depanare: bash -x script.sh afișează fiecare comandă înainte de execuție.
  • source (sau .) execută liniile în shell-ul curent. Se folosește pentru fișiere care setează variabile sau funcții: .bashrc, un fișier de configurare, un venv/bin/activate. Un exit într-un fișier încărcat cu source închide terminalul tău.

#!/usr/bin/env bash caută bash în PATH, util pe sisteme unde Bash nu e în /bin (de exemplu, o versiune nouă instalată pe macOS). #!/bin/bash e mai previzibil pe servere.

Fără shebang, ./script este rulat de obicei cu shell-ul curent sau cu sh, în funcție de shell, deci comportamentul devine neclar.

Ce urmărește intervievatorul: Este o întrebare de bază despre scripturi care arată dacă înțelegi procesele. Mulți nu știu de ce un script care face export nu schimbă nimic în terminal.

Eroarea, în practică:script.sh: command not found (lipsește ./)./script.sh: Permission denied

72 Junior

Ce e greșit în fiecare linie de mai jos?

BASH
NUME = "Ana"
echo "Fișier: $NUME_backup.txt"
cale='$HOME/date'

Răspuns scurt: Prima rulează comanda NUME cu argumentele = și Ana, pentru că la atribuire nu pot exista spații. A doua caută variabila NUME_backup, deci trebuie ${NUME}_backup.txt. A treia nu expandează $HOME din cauza ghilimelelor simple.

Bash are reguli stricte de sintaxă pentru variabile:

BASH
NUME = "Ana"          # NUME: command not found
NUME="Ana"            # corect: fără spații în jurul lui =

echo "Fișier: $NUME_backup.txt"
# Fișier: .txt   (variabila NUME_backup nu există și e goală)
echo "Fișier: ${NUME}_backup.txt"
# Fișier: Ana_backup.txt

cale='$HOME/date'
echo "$cale"          # $HOME/date
cale="$HOME/date"
echo "$cale"          # /home/ana/date

Explicații:

  • Linia NUME = "Ana" e interpretată ca o comandă cu argumente, pentru că spațiile separă cuvintele. Forma NUME= comanda (cu spațiu doar după =) are alt sens: rulează comanda cu variabila NUME setată temporar la gol.
  • Numele de variabile pot conține litere, cifre și _. Bash ia cel mai lung nume posibil, deci $NUME_backup este o singură variabilă. Acoladele delimitează numele.
  • Ghilimelele simple păstrează totul literal. Ghilimelele duble permit $var, $(...) și \.

Alte reguli:

  • Variabilele nu au tip; totul e șir, cu excepția contextelor aritmetice.
  • O variabilă neinițializată e goală, fără eroare, ceea ce ascunde greșeli de tipar. set -u transformă folosirea ei în eroare.
  • Prin convenție, majusculele sunt pentru variabile de mediu și constante, minusculele pentru variabilele locale din script, ca să nu suprascrii accidental PATH sau USER.
  • readonly și declare -r creează constante.

Ce urmărește intervievatorul: Verifică greșelile pe care le face aproape oricine la primele scripturi. Intervievatorul vrea explicația cauzei, nu doar varianta corectă.

Eroarea, în practică:pret = 100: command not found (atribuire)not a valid identifier

73 Junior

Ce este o variabilă de mediu și ce face export? Unde adaugi un folder în PATH permanent și care e diferența dintre .bashrc și .bash_profile?

Răspuns scurt: O variabilă de mediu e moștenită de procesele copil; export marchează o variabilă din shell ca variabilă de mediu. Pentru PATH permanent adaugi export PATH="$HOME/bin:$PATH" în ~/.bashrc. .bash_profile e citit de shell-urile de login, .bashrc de cele interactive non-login.

Fiecare proces are un set de variabile de mediu, primit de la părinte. O variabilă simplă din shell există doar în shell; după export, e copiată în mediul tuturor comenzilor pornite ulterior.

BASH
X=1; bash -c 'echo "X=$X"'        # X=
export X=1; bash -c 'echo "X=$X"' # X=1
DEBUG=1 ./app.sh                  # setată doar pentru această comandă
env | grep -i proxy               # variabilele de mediu curente
echo "$PATH" | tr ':' '\n'        # folderele din PATH, pe rând

PATH este lista de foldere în care shell-ul caută comenzile, de la stânga la dreapta; primul fișier găsit câștigă. De aceea:

BASH
export PATH="$HOME/.local/bin:$PATH"   # are prioritate față de sistem
export PATH="$PATH:/opt/tool/bin"      # e folosit doar dacă nu există altă comandă cu același nume

Greșeala care strică terminalul: export PATH="/opt/tool/bin", fără $PATH. Toate comenzile obișnuite devin „command not found” până la sesiunea următoare.

Fișierele de pornire în Bash:

  • shell de login (SSH, consolă, bash -l): citește /etc/profile, apoi primul găsit dintre ~/.bash_profile, ~/.bash_login, ~/.profile;
  • shell interactiv non-login (un terminal nou în interfața grafică, bash simplu): citește ~/.bashrc.

Pe Ubuntu, ~/.profile include ~/.bashrc, așa că pui setările în .bashrc. Dacă ai creat un .bash_profile, .profile nu mai e citit, iar efectul pare inexplicabil. După modificare: source ~/.bashrc.

Serviciile systemd și cron nu citesc aceste fișiere; mediul lor se configurează separat.

Ce urmărește intervievatorul: Verifică înțelegerea moștenirii mediului între procese. Problemele cu PATH și cu fișierele de pornire sunt printre cele mai frecvente cereri de ajutor de la colegi.

Eroarea, în practică:script.sh: command not found (lipsește ./)not a valid identifier

74 Junior

Ce conțin $0, $1, $#, $@ și $*? Ce afișează scriptul de mai jos rulat cu ./args.sh "a b" c?

BASH
#!/bin/bash
echo "$#"
for x in $@; do echo "[$x]"; done
for x in "$@"; do echo "<$x>"; done

Răspuns scurt: $0 e numele scriptului, $1 primul argument, $# numărul de argumente, iar $@ și $* toate argumentele. Scriptul afișează 2, apoi [a], [b], [c], apoi <a b>, <c>: doar "$@" păstrează argumentele exact cum au fost date.

Ieșirea completă:

2
[a]
[b]
[c]
<a b>
<c>

Scriptul primește două argumente: a b (un singur argument, datorită ghilimelelor la apel) și c, deci $# este 2. În prima buclă, $@ necitat trece prin word splitting, iar a b se rupe în două. În a doua, "$@" se expandează la fiecare argument ca cuvânt separat, exact cum a fost transmis.

Diferențele:

  • "$@" devine "$1" "$2" ...: forma corectă aproape întotdeauna, de exemplu când transmiți argumentele mai departe: exec java -jar app.jar "$@".
  • "$*" devine un singur șir, cu argumentele unite prin primul caracter din IFS (implicit spațiu): "a b c". Util pentru mesaje.
  • $@ și $* fără ghilimele se comportă la fel și sunt rareori ce vrei.

Alte variabile speciale:

BASH
$0     # calea scriptului, așa cum a fost apelat
${10}  # argumentul 10 cere acolade; $10 este ${1}0
shift  # elimină $1, restul se mută cu o poziție
$?     # codul de ieșire al ultimei comenzi
$$     # PID-ul shell-ului
$!     # PID-ul ultimului proces din fundal

Validare tipică la începutul scriptului:

BASH
if [ "$#" -lt 1 ]; then
  echo "Utilizare: $0 <fișier>..." >&2
  exit 2
fi

Ce urmărește intervievatorul: Este o întrebare clasică de tip „ce afișează” care verifică regulile de quoting. Aproape toți candidații știu ce face $1; puțini explică diferența dintre $@ și "$@".

Eroarea, în practică:parameter null or not set

75 Junior

Ce diferență este între [ ] și [[ ]] în Bash? De ce [ $a == $b ] poate da eroare și când folosești -eq în loc de ==?

Răspuns scurt: [ este o comandă (sinonim cu test) cu argumente obișnuite, deci variabilele goale sau cu spații o strică. [[ ]] e sintaxă Bash: nu face word splitting, acceptă &&, ||, potriviri cu modele și regex. -eq compară numere, == compară șiruri.

[ este, istoric, un program (/usr/bin/[) și un builtin. Argumentele lui trec prin toate expansiunile, așa că:

BASH
a=""
[ $a == "x" ]       # devine [ == x ]  -> "unary operator expected"
[ "$a" == "x" ]     # corect: variabilele între ghilimele
a="unu doi"
[ $a = "x" ]        # devine [ unu doi = x ] -> "too many arguments"

[[ ]] este parte din sintaxa Bash, analizată înainte de expansiuni, deci variabilele necitate nu sunt sparte în cuvinte:

BASH
[[ $a == "x" ]]                    # sigur chiar dacă $a e gol
[[ $f == *.log ]]                  # potrivire cu model (fără ghilimele în dreapta)
[[ $email =~ ^[^@]+@[^@]+\.[a-z]+$ ]] && echo valid
[[ -f $f && -r $f ]]               # && în interior
[ -f "$f" ] && [ -r "$f" ]         # echivalent cu [

Comparații:

  • șiruri: = sau ==, !=, -z (gol), -n (nevid);
  • numere: -eq, -ne, -lt, -le, -gt, -ge;
  • în (( )): comparații aritmetice cu operatori obișnuiți: (( n > 10 )).

[ 10 \< 9 ] sau [[ 10 < 9 ]] compară lexicografic, deci „10” e mai mic decât „9”. Pentru numere folosești -lt sau (( 10 < 9 )).

În [, == nu e POSIX; forma portabilă este =. [[ ]] nu există în sh/dash, deci un script cu #!/bin/sh care o folosește eșuează pe Ubuntu.

Teste de fișiere uzuale: -e există, -f fișier obișnuit, -d director, -x executabil, -s nevid, -L link simbolic.

Ce urmărește intervievatorul: Verifică dacă scrii condiții care nu se strică la date neașteptate. Greșeli tipice: variabile necitate în [ ] și compararea numerelor cu operatori de șiruri.

Eroarea, în practică:[: too many arguments[: unary operator expected

76 Junior

Ce afișează fiecare buclă de mai jos? Scrie apoi o buclă care redenumește toate fișierele .jpeg din folderul curent în .jpg.

BASH
for i in 1 2 3; do echo -n "$i "; done; echo
for i in {1..5..2}; do echo -n "$i "; done; echo
for ((i=3; i>0; i--)); do echo -n "$i "; done; echo

Răspuns scurt: Prima afișează 1 2 3, a doua 1 3 5 (pas de 2), a treia 3 2 1. Redenumirea: for f in *.jpeg; do mv -- "$f" "${f%.jpeg}.jpg"; done, cu variabila între ghilimele ca să meargă și numele cu spații.

Bash are două forme de for: una care parcurge o listă de cuvinte și una în stil C, cu inițializare, condiție și pas.

BASH
for i in 1 2 3; do echo -n "$i "; done; echo        # 1 2 3
for i in {1..5..2}; do echo -n "$i "; done; echo    # 1 3 5
for ((i=3; i>0; i--)); do echo -n "$i "; done; echo # 3 2 1

{1..5..2} este brace expansion cu pas (Bash 4+). Nu acceptă variabile: pentru limite din variabile folosești seq 1 2 "$n" sau forma (( )).

Redenumirea în masă:

BASH
shopt -s nullglob
for f in *.jpeg; do
  mv -n -- "$f" "${f%.jpeg}.jpg"
done
  • *.jpeg e expandat de shell, iar fiecare nume, cu tot cu spații, devine un element al listei. Nu folosi for f in $(ls *.jpeg): ieșirea lui ls trece prin word splitting și numele cu spații se rup.
  • ${f%.jpeg} taie sufixul .jpeg de la final.
  • nullglob face ca bucla să nu ruleze deloc dacă nu există fișiere; altfel ar încerca să mute un fișier numit literal *.jpeg.
  • -n nu suprascrie un .jpg existent; -- protejează numele care încep cu cratimă.

Pentru recursivitate, combini cu find:

BASH
find . -type f -name '*.jpeg' -exec sh -c 'for f; do mv -n -- "$f" "${f%.jpeg}.jpg"; done' sh {} +

Înainte de o redenumire reală, rulezi bucla cu echo mv ..., ca să vezi comenzile fără să le execuți.

Ce urmărește intervievatorul: Verifică sintaxa buclelor și dacă scrii cod care funcționează pe nume reale de fișiere. Greșeala clasică: for f in $(ls).

Eroarea, în practică:seq: invalid floating point argument

77 Junior

Care este forma corectă de a citi un fișier linie cu linie în Bash? De ce se recomandă IFS= și -r?

Răspuns scurt: while IFS= read -r linie; do ...; done < fisier. IFS= păstrează spațiile de la începutul și sfârșitul liniei, iar -r împiedică interpretarea backslash-urilor. Fără ele, liniile ajung modificate.

read citește o linie și o împarte în câmpuri după caracterele din IFS. Implicit, elimină spațiile de la capete și tratează \ ca escape.

BASH
printf '  indentat\\n\ncale\\cu\\backslash\n' > t.txt

while read linie; do echo "[$linie]"; done < t.txt
# [indentatn]
# [calecubackslash]   spațiile și backslash-urile s-au pierdut

while IFS= read -r linie; do echo "[$linie]"; done < t.txt
# [  indentat\n]
# [cale\cu\backslash]

Separarea în câmpuri e utilă când vrei coloane:

BASH
while IFS=: read -r user _ uid _ _ home shell; do
  (( uid >= 1000 )) && echo "$user $home"
done < /etc/passwd

while IFS=, read -r data categorie suma; do
  echo "$categorie: $suma"
done < <(tail -n +2 vanzari.csv)

_ e o convenție pentru câmpurile ignorate. Ultima variabilă primește tot restul liniei.

Capcane frecvente:

  • Ultima linie fără newline final nu e procesată, pentru că read întoarce cod nenul. Soluția: while IFS= read -r l || [ -n "$l" ]; do.
  • Comenzile din buclă care citesc de la stdin (de exemplu ssh, ffmpeg) consumă restul fișierului, iar bucla se oprește după prima linie. Folosești ssh -n sau < /dev/null pentru acea comandă, ori citești fișierul pe alt descriptor: while read -r l <&3; do ...; done 3< fisier.
  • cat fisier | while ... rulează bucla într-un subshell, deci variabilele modificate se pierd.

Pentru fișiere mari, awk e mult mai rapid decât o buclă Bash.

Ce urmărește intervievatorul: Verifică dacă știi tiparul idiomatic și de ce arată așa. Bug-ul cu ssh care „mănâncă” intrarea buclei apare des la scripturile care rulează comenzi pe o listă de servere.

78 Junior

Ce este codul de ieșire al unei comenzi? Cum îl folosești într-un if și ce cod ar trebui să întoarcă scriptul tău la eroare?

Răspuns scurt: Fiecare comandă se termină cu un număr între 0 și 255, citit în $?: 0 înseamnă succes, orice altceva eșec. if testează direct codul comenzii, deci scrii if grep -q x f; then. Scriptul tău iese cu exit 1 (sau alt cod nenul) la eroare.

În shell, if nu evaluează expresii booleene, ci rulează o comandă și verifică dacă a întors 0. [, [[, grep, test sunt toate comenzi cu coduri de ieșire.

BASH
if grep -q "^ana:" /etc/passwd; then
  echo "utilizatorul există"
fi

if ! ping -c1 -W2 db1 > /dev/null; then
  echo "db1 nu răspunde" >&2
  exit 1
fi

cp a b
rc=$?
if [ "$rc" -ne 0 ]; then echo "cp a eșuat cu $rc" >&2; fi

Un anti-tipar frecvent: cmd; if [ $? -eq 0 ]; then. E mai lung și fragil, pentru că orice comandă inserată între cele două suprascrie $?. Forma directă if cmd; then e mai clară.

Convenții de coduri:

  • 0: succes; 1: eroare generală; 2: folosire greșită (argumente invalide), după modelul multor utilitare;
  • 126: comanda există, dar nu poate fi executată (permisiuni); 127: comanda nu a fost găsită;
  • 128+N: procesul a fost oprit de semnalul N (130 pentru Ctrl+C, 137 pentru SIGKILL).

Codurile sunt doar 0-255: exit 256 devine 0, iar exit -1 devine 255.

Mesajele de eroare se scriu pe stderr (>&2), ca să nu se amestece cu datele de ieșire ale scriptului. Codul corect contează pentru cine folosește scriptul: cron, systemd, pipeline-uri CI sau alt script decid pe baza lui dacă pasul a reușit. Un script care afișează „EROARE” dar iese cu 0 trece drept reușit.

Ce urmărește intervievatorul: Verifică dacă scrii scripturi care comunică corect cu restul sistemului. Greșeala tipică e un script care eșuează, dar întoarce 0, așa că pipeline-ul continuă.

79 Junior

Ce afișează codul de mai jos? Cum faci în Bash un calcul cu zecimale?

BASH
a=7; b=2
echo $((a / b)) $((a % b)) $((a ** b))
echo "$a + $b"
x=$a+$b; echo $x

Răspuns scurt: Afișează 3 1 49, apoi 7 + 2, apoi 7+2. Aritmetica Bash lucrează doar cu numere întregi, iar în afara lui $(( )) totul e text. Pentru zecimale folosești bc sau awk.

Bash face calcule numai în contexte aritmetice: $(( )), (( )), let și variabilele declarate cu declare -i. Altfel, + e un caracter obișnuit.

BASH
a=7; b=2
echo $((a / b)) $((a % b)) $((a ** b))   # 3 1 49
echo "$a + $b"                           # 7 + 2
x=$a+$b; echo $x                         # 7+2
  • / face împărțire întreagă, cu trunchiere spre zero: $(( -7 / 2 )) dă -3.
  • % este restul, ** puterea.
  • În interiorul lui $(( )) variabilele se pot scrie fără $.
  • Numerele care încep cu 0 sunt citite în baza 8: $(( 08 + 1 )) dă eroare („value too great for base”). Apare des când lucrezi cu date sau ore (09). Soluția: $(( 10#08 + 1 )).
BASH
(( count++ ))                 # incrementare
(( n > 10 )) && echo mare     # comparație
i=$(( i + 1 ))

Pentru zecimale:

BASH
echo "scale=2; 7 / 2" | bc              # 3.50
bc -l <<< "s(1)"                        # funcții matematice cu -l
awk -v a=7 -v b=2 'BEGIN { printf "%.2f\n", a / b }'   # 3.50
printf "%.1f\n" "$(bc -l <<< '10/3')"   # 3.3

scale setează numărul de zecimale în bc; implicit e 0, deci echo "7/2" | bc afișează tot 3.

O capcană cu set -e: (( count++ )) când count este 0 are valoarea 0, deci întoarce cod 1 și oprește scriptul. Folosești count=$((count + 1)) sau (( ++count )).

Ce urmărește intervievatorul: Verifică dacă știi limitele aritmeticii din shell. Candidații sunt surprinși de împărțirea întreagă și de numerele care încep cu zero.

Eroarea, în practică:division by 0 (error token is ...)invalid arithmetic operator (zecimale)

80 Junior

Scriptul de mai jos șterge fișierele temporare ale unui utilizator. Ce se întâmplă dacă un fișier se numește raport final.tmp? Cum îl corectezi?

BASH
for f in $(find /tmp/app -name "*.tmp"); do
  rm $f
done

Răspuns scurt: Ieșirea lui find e spartă după spații, deci bucla încearcă să șteargă /tmp/app/raport și final.tmp, fișiere care nu există sau, mai rău, alte fișiere. Corect: find /tmp/app -name "*.tmp" -delete sau -exec rm -- {} +.

Două probleme se suprapun:

  • $(find ...) necitat trece prin word splitting: /tmp/app/raport final.tmp devine două cuvinte, /tmp/app/raport și final.tmp.
  • rm $f necitat repetă problema, iar cuvintele cu * sau ? ar mai trece și prin globbing.

Rezultatul: rm: cannot remove '/tmp/app/raport': No such file or directory și rm: cannot remove 'final.tmp'. Dacă există un fișier final.tmp în folderul curent al scriptului, acela va fi șters.

Variante corecte:

BASH
find /tmp/app -name "*.tmp" -type f -delete

find /tmp/app -name "*.tmp" -type f -exec rm -- {} +

while IFS= read -r -d '' f; do
  echo "șterg $f"
  rm -- "$f"
done < <(find /tmp/app -name "*.tmp" -type f -print0)

A treia variantă e utilă când vrei să faci mai mult pentru fiecare fișier. -print0 și read -d '' folosesc caracterul nul ca separator, singurul caracter care nu poate apărea într-un nume de fișier (newline-ul poate apărea).

Regula generală: pune între ghilimele duble orice expansiune ("$f", "$(cmd)", "${arr[@]}"), cu excepția cazurilor în care vrei explicit word splitting. Unealta shellcheck semnalează automat aceste probleme (de exemplu SC2086 pentru variabile necitate și SC2044 pentru bucla peste find).

Ce urmărește intervievatorul: Este exercițiul clasic „unde e bug-ul” pentru Bash. Intervievatorul vrea să vadă dacă recunoști word splitting-ul ca risc de securitate și de date, nu doar ca neplăcere.

Eroarea, în practică:ambiguous redirect

81 Mid

Cum întoarce o funcție Bash o valoare? Ce afișează codul de mai jos?

BASH
total=0
aduna() {
  total=$(( $1 + $2 ))
  local rez=$(( $1 * $2 ))
  echo "$rez"
  return 3
}
p=$(aduna 4 5)
echo "p=$p cod=$? total=$total"

Răspuns scurt: Afișează p=20 cod=3 total=0. return setează doar codul de ieșire (0-255); valoarea se întoarce prin echo și $(...). total rămâne 0, pentru că $(...) rulează funcția într-un subshell.

În Bash, funcțiile se comportă ca niște comenzi mici: au argumente ($1, $2), cod de ieșire și ieșire standard.

  • return N setează codul de ieșire, nu o valoare. E folosit pentru succes sau eșec: if functie; then.
  • „Valoarea” unei funcții este ce scrie pe stdout, captat cu $(...).
  • $(...) rulează funcția într-un subshell, deci modificările variabilelor globale făcute înăuntru nu ajung în shell-ul principal. De aceea total rămâne 0.
  • $? după atribuirea p=$(...) este codul comenzii din substituție, adică 3.

Variante, după nevoie:

BASH
# 1. returnezi prin stdout
extensie() { echo "${1##*.}"; }
ext=$(extensie "arhiva.tar.gz")      # gz

# 2. modifici o variabilă globală, apel direct, fără $()
aduna() { total=$(( $1 + $2 )); }
aduna 4 5; echo "$total"            # 9

# 3. nameref (Bash 4.3+): numele variabilei rezultat e argument
aduna_in() { local -n _out=$1; _out=$(( $2 + $3 )); }
aduna_in rez 4 5; echo "$rez"       # 9

local limitează o variabilă la funcție. Fără local, orice variabilă setată în funcție e globală și poate suprascrie variabile din restul scriptului. O capcană: local x=$(cmd) întoarce codul lui local (0), nu al lui cmd. Dacă îți trebuie codul, declari separat: local x; x=$(cmd).

Mesajele de diagnostic dintr-o funcție care întoarce valoare prin stdout trebuie scrise pe stderr (>&2), altfel ajung în rezultat.

Ce urmărește intervievatorul: Verifică modelul de funcții din Bash, diferit de alte limbaje. Mulți presupun că return întoarce o valoare și nu observă efectul subshell-ului.

Eroarea, în practică:local: can only be used in a function

82 Mid

Scrie partea de parsare a opțiunilor pentru un script backup.sh -v -d /dest -k 7 sursa, folosind getopts, și tratează opțiunile necunoscute.

Răspuns scurt: Folosești while getopts ":vd:k:" opt; do case $opt in ... esac; done, unde : după o literă înseamnă că opțiunea cere valoare, iar : inițial îți dă controlul asupra erorilor. După buclă, shift $((OPTIND - 1)) lasă în $@ argumentele rămase.

BASH
#!/usr/bin/env bash
set -euo pipefail

utilizare() {
  echo "Utilizare: $0 [-v] [-d dest] [-k zile] sursa" >&2
  exit 2
}

verbose=0
dest=/backup
keep=7

while getopts ":vd:k:h" opt; do
  case "$opt" in
    v) verbose=1 ;;
    d) dest=$OPTARG ;;
    k) [[ $OPTARG =~ ^[0-9]+$ ]] || { echo "-k cere un număr" >&2; exit 2; }
       keep=$OPTARG ;;
    h) utilizare ;;
    :) echo "Opțiunea -$OPTARG cere o valoare" >&2; utilizare ;;
    \?) echo "Opțiune necunoscută: -$OPTARG" >&2; utilizare ;;
  esac
done
shift $((OPTIND - 1))

[ "$#" -eq 1 ] || utilizare
sursa=$1
(( verbose )) && echo "Backup $sursa -> $dest, păstrez $keep zile"

Cum funcționează:

  • Șirul ":vd:k:h": fiecare literă e o opțiune, iar : după ea înseamnă că primește valoare, disponibilă în OPTARG.
  • : la începutul șirului activează modul „silențios”: getopts nu mai afișează mesaje proprii, ci pune ? în opt pentru opțiuni necunoscute și : pentru valori lipsă.
  • OPTIND reține indexul următorului argument de procesat; shift elimină opțiunile, rămân doar argumentele poziționale.
  • getopts acceptă și opțiuni grupate (-vk 7) și se oprește la primul argument care nu e opțiune sau la --.

case este potrivit pentru ramificări după valoare: acceptă modele (*.tar.gz), y|Y|da)) și se termină fiecare ramură cu ;;.

Limita: getopts (builtin, POSIX) nu suportă opțiuni lungi ca --dest. Pentru ele există getopt din util-linux (alt program, cu altă sintaxă) sau o buclă manuală cu case "$1" in --dest) ...; shift 2;;.

Ce urmărește intervievatorul: Verifică dacă scrii scripturi care se comportă ca unelte reale. Semnalele bune: validarea valorilor, mesajul de utilizare pe stderr și shift după parsare.

Eroarea, în practică:getopts: illegal option

83 Mid

Cum lucrezi cu tablouri în Bash? Scrie un exemplu cu un tablou indexat de servere și un tablou asociativ cu porturi, și explică de ce contează "${arr[@]}".

Răspuns scurt: Declari tablouri indexate cu arr=(a b c) și asociative cu declare -A m (Bash 4+). Le parcurgi cu "${arr[@]}" pentru valori și "${!m[@]}" pentru chei; ghilimelele păstrează fiecare element întreg, chiar dacă are spații.

BASH
servere=(web1 web2 "db principal")
servere+=(cache1)
echo "${#servere[@]}"          # 4 elemente
echo "${servere[0]}"           # web1
echo "${servere[-1]}"          # cache1 (Bash 4.3+)

for s in "${servere[@]}"; do echo "[$s]"; done
# [web1] [web2] [db principal] [cache1]
for s in ${servere[@]}; do echo "[$s]"; done
# ... [db] [principal] ...  greșit

declare -A port=([web]=80 [https]=443 [db]=5432)
port[redis]=6379
for nume in "${!port[@]}"; do
  echo "$nume -> ${port[$nume]}"
done
[[ -v port[db] ]] && echo "are cheia db"
unset 'port[redis]'

mapfile -t linii < hosts.txt   # fiecare linie devine un element
echo "${servere[@]:1:2}"       # felie: elementele 1 și 2

De reținut:

  • "${arr[@]}" se expandează la fiecare element ca argument separat, la fel ca "$@". Fără ghilimele, elementele cu spații se sparg.
  • "${arr[*]}" unește totul într-un singur șir.
  • $arr fără index înseamnă doar primul element, o greșeală frecventă.
  • Ordinea cheilor într-un tablou asociativ nu este garantată.
  • Tablourile asociative cer Bash 4+. macOS vine implicit cu Bash 3.2, unde declare -A nu există, ceea ce strică scripturi rulate pe laptopuri.
  • Tablourile nu pot fi exportate către procese copil și nu există în sh.

Tablourile sunt potrivite pentru a construi linii de comandă în siguranță:

BASH
opts=(-avz --delete)
[ "$dry" = 1 ] && opts+=(-n)
rsync "${opts[@]}" src/ dest/

Așa eviți să pui opțiunile într-un șir și să depinzi de word splitting.

Ce urmărește intervievatorul: Verifică dacă știi structurile de date din Bash și limitele lor. Un candidat bun folosește tablouri pentru argumente de comandă, nu șiruri concatenate.

84 Mid

Fără să apelezi sed, basename sau cut, cum obții dintr-o variabilă f=/var/log/app/eroare.2026.log numele fișierului, folderul, extensia și numele fără extensie? Cum setezi o valoare implicită?

Răspuns scurt: Folosești expansiunile de parametri: ${f##*/} pentru nume, ${f%/*} pentru folder, ${f##*.} pentru extensie și ${f%.*} pentru calea fără extensie. Valoarea implicită: ${VAR:-implicit}; ${VAR:?mesaj} oprește scriptul dacă variabila lipsește.

Expansiunile de parametri lucrează direct în shell, fără să pornească procese, deci sunt rapide în bucle mari.

BASH
f=/var/log/app/eroare.2026.log
echo "${f##*/}"     # eroare.2026.log   (șterge cel mai lung prefix până la /)
echo "${f%/*}"      # /var/log/app      (șterge cel mai scurt sufix de la /)
echo "${f##*.}"     # log
n=${f##*/}
echo "${n%.*}"      # eroare.2026      (cel mai scurt sufix de la .)
echo "${n%%.*}"     # eroare           (cel mai lung sufix de la .)
echo "${#n}"        # 15, lungimea

Regula de memorare: # taie de la început, % de la final; dublat (##, %%) înseamnă potrivirea cea mai lungă.

Alte forme utile:

BASH
echo "${f/eroare/info}"       # înlocuiește prima apariție
echo "${f//\//_}"             # înlocuiește toate / cu _
s="Linux"; echo "${s:0:3}"    # Lin, subșir
echo "${s^^} ${s,,}"          # LINUX linux (Bash 4+)

PORT=${PORT:-8080}            # implicit dacă e nesetată sau goală
: "${DEST:?DEST trebuie setată}"   # eroare și ieșire dacă lipsește
echo "${DEBUG:+--verbose}"    # --verbose doar dacă DEBUG e setată

:- tratează și valoarea goală ca lipsă; - fără două puncte tratează ca lipsă doar variabila nesetată. : din fața lui ${DEST:?} este comanda care nu face nimic, folosită ca să evalueze expansiunea.

${DIR:?} este o protecție bună în comenzi periculoase: rm -rf "${DIR:?}/"* nu poate deveni niciodată rm -rf /*.

Ce urmărește intervievatorul: Verifică dacă scrii Bash idiomatic și eficient. Mulți apelează basename sau sed în bucle de mii de iterații și nu cunosc ${VAR:?} ca protecție.

Eroarea, în practică:rm: dangerous to operate recursively on '/'parameter null or not set

85 Mid

Scriptul tău creează fișiere temporare și pornește un proces în fundal. Cum te asiguri că totul e curățat și dacă scriptul se termină cu eroare sau e oprit cu Ctrl+C?

Răspuns scurt: Creezi fișierele cu mktemp și înregistrezi o funcție de curățare cu trap cleanup EXIT, care rulează la orice ieșire a scriptului. Pentru INT și TERM adaugi trap-uri care ies explicit, ca EXIT să ruleze și atunci.

BASH
#!/usr/bin/env bash
set -euo pipefail

tmpdir=$(mktemp -d)
pid_server=""

cleanup() {
  local rc=$?
  [ -n "$pid_server" ] && kill "$pid_server" 2>/dev/null || true
  rm -rf -- "$tmpdir"
  exit "$rc"
}
trap cleanup EXIT
trap 'exit 130' INT
trap 'exit 143' TERM

python3 -m http.server 8099 --directory "$tmpdir" &
pid_server=$!

curl -fsS https://exemplu.ro/date.json -o "$tmpdir/date.json"
jq '.items | length' "$tmpdir/date.json"

Explicații:

  • mktemp -d creează un folder cu nume unic și imprevizibil (de exemplu /tmp/tmp.k3J9aQ), cu permisiuni 700. Un nume fix ca /tmp/date.json poate intra în conflict cu alte rulări și permite atacuri prin link-uri simbolice create dinainte de alți utilizatori.
  • trap ... EXIT rulează la ieșirea normală, la exit și la eșecurile prinse de set -e.
  • La un semnal, Bash rulează trap-ul pentru semnal; prin exit 130 declanșezi și EXIT, iar codul de ieșire respectă convenția 128+N.
  • local rc=$? păstrează codul original, ca scriptul să nu raporteze succes după o eroare.
  • || true în cleanup împiedică set -e să întrerupă curățarea dacă procesul s-a terminat deja.

SIGKILL (kill -9) nu poate fi prins, deci nicio curățare nu rulează. De aceea fișierele temporare stau în /tmp, curățat periodic de sistem (de exemplu prin systemd-tmpfiles), nu în folderul aplicației.

Ce urmărește intervievatorul: Verifică dacă scrii scripturi care nu lasă resturi în urmă. Candidații slabi pun curățarea la finalul scriptului, unde nu se ajunge niciodată când apare o eroare.

86 Mid

Găsește problemele din acest script de deploy:

BASH
#!/bin/sh
APP_DIR=$1
cd $APP_DIR
rm -rf build/*
if [ $ENV == "prod" ]
then
  npm run build:prod
fi
cp -r build/* /var/www/
echo "Deploy OK"

Răspuns scurt: Problemele: shebang sh cu sintaxa ==, variabile necitate, cd fără verificare (un cd eșuat face ca rm -rf build/* să ruleze în alt folder), lipsa validării argumentului, ENV posibil nesetat, nicio oprire la erori, iar „Deploy OK” se afișează oricum.

Pe rând:

  • #!/bin/sh: pe Ubuntu e dash, iar == în [ nu e POSIX; în dash dă eroare.
  • APP_DIR=$1 fără validare: dacă scriptul e rulat fără argument, cd $APP_DIR devine cd, adică home-ul utilizatorului.
  • cd $APP_DIR fără || exit și necitat: dacă folderul nu există sau are spații, scriptul continuă în folderul curent.
  • rm -rf build/* rulează apoi în locul greșit.
  • [ $ENV == "prod" ]: dacă ENV e gol, devine [ == prod ] și dă eroare de sintaxă, iar ramura se sare fără niciun avertisment.
  • Nu există oprire la erori: dacă npm run build:prod eșuează, se copiază build-ul vechi sau nimic, iar mesajul spune tot „Deploy OK”.
  • cp -r build/* nu copiază fișierele ascunse (de exemplu .htaccess) și nu șterge fișierele vechi din destinație.

Varianta corectată:

BASH
#!/usr/bin/env bash
set -euo pipefail

APP_DIR=${1:?Utilizare: $0 <folder-aplicație>}
ENV=${ENV:-staging}

cd -- "$APP_DIR"
rm -rf -- ./build
if [[ $ENV == prod ]]; then
  npm run build:prod
else
  npm run build
fi
[ -f build/index.html ] || { echo "Build incomplet" >&2; exit 1; }
rsync -a --delete build/ /var/www/site/
echo "Deploy OK ($ENV)"

Cu set -e, un cd eșuat oprește scriptul, la fel și build-ul eșuat. Verificarea artefactului înainte de copiere previne publicarea unui build gol. rsync --delete sincronizează exact, inclusiv fișierele ascunse, și elimină fișierele rămase din versiunea veche.

Ce urmărește intervievatorul: Este un exercițiu de code review care arată dacă vezi riscurile reale, nu doar stilul. Intervievatorul pune accent pe cd neverificat urmat de rm -rf.

Eroarea, în practică:rm: dangerous to operate recursively on '/'

87 Mid

Scrie un script care face backup zilnic al folderului /srv/app/uploads într-o arhivă cu data în nume și păstrează doar ultimele 7 arhive.

Răspuns scurt: Creezi arhiva cu tar czf într-un fișier temporar, o redenumești la final ca să fie completă, apoi ștergi arhivele mai vechi decât ultimele 7, sortate după nume. Scriptul pornește cu set -euo pipefail și scrie mesajele în log.

BASH
#!/usr/bin/env bash
set -euo pipefail

SRC=/srv/app/uploads
DEST=/backup/uploads
KEEP=7
stamp=$(date +%Y-%m-%d_%H%M)
final="$DEST/uploads_$stamp.tar.gz"
tmp="$final.partial"

log() { echo "$(date '+%F %T') $*"; }
trap 'rm -f -- "$tmp"' EXIT

mkdir -p -- "$DEST"
log "start backup $SRC"
tar -czf "$tmp" -C "$(dirname "$SRC")" "$(basename "$SRC")"
tar -tzf "$tmp" > /dev/null            # verifică arhiva
mv -- "$tmp" "$final"
log "creat $final ($(du -h "$final" | cut -f1))"

ls -1 "$DEST"/uploads_*.tar.gz | sort | head -n -"$KEEP" | while IFS= read -r vechi; do
  log "șterg $vechi"
  rm -f -- "$vechi"
done

Crontab:

15 3 * * * /usr/local/bin/backup-uploads.sh >> /var/log/backup-uploads.log 2>&1

Decizii de explicat:

  • Data în format AAAA-LL-ZZ se sortează corect alfabetic, deci sort pe nume e și sortare cronologică.
  • Arhiva se scrie ca .partial și se redenumește doar la final. Dacă discul se umple la jumătate, nu rămâne o arhivă coruptă cu nume valid, iar trap șterge fișierul parțial.
  • -C face ca arhiva să conțină uploads/..., nu căi absolute.
  • head -n -7 (GNU) afișează toate liniile, cu excepția ultimelor 7, adică arhivele de șters. Alternativa find "$DEST" -name 'uploads_*.tar.gz' -mtime +7 -delete păstrează după vârstă, nu după număr, și ar șterge tot dacă backup-ul n-a mai rulat de o săptămână.
  • ls e acceptabil aici pentru că numele sunt generate de script și nu au spații.

Un backup pe același disc nu protejează de pierderea discului: următorul pas e copierea în altă locație (rsync pe alt server sau un bucket de stocare) și testarea periodică a restaurării.

Ce urmărește intervievatorul: Este o temă tipică de interviu practic. Se urmăresc arhiva atomică, rotația corectă și gândul la restaurare, nu doar comanda tar.

88 Senior

Un script de sincronizare rulează din cron la fiecare 5 minute, dar uneori durează 12 minute, iar rulările se suprapun și strică datele. Cum previi asta?

Răspuns scurt: Folosești un lock exclusiv cu flock: fie în crontab (flock -n /run/lock/sync.lock /opt/sync.sh), fie în script, pe un descriptor deschis. -n face ca o rulare nouă să iasă imediat dacă cea veche încă rulează. Kernelul eliberează lock-ul automat la terminarea procesului.

Soluția naivă, un fișier PID creat la start și șters la final, are două probleme: verificarea și crearea nu sunt atomice (două procese pot vedea simultan că fișierul nu există), iar dacă scriptul e oprit cu kill -9, fișierul rămâne și blochează toate rulările viitoare.

flock folosește lock-uri gestionate de kernel pe un fișier deschis. Lock-ul este legat de descriptor și dispare automat când procesul se termină, indiferent cum.

În crontab:

*/5 * * * * flock -n /run/lock/sync.lock /opt/sync.sh >> /var/log/sync.log 2>&1

În script:

BASH
#!/usr/bin/env bash
set -euo pipefail
exec 9> /run/lock/sync.lock
if ! flock -n 9; then
  echo "$(date '+%F %T') rulare anterioară încă activă, ies" >&2
  exit 0
fi
# ... sincronizarea; lock-ul se eliberează la ieșire

exec 9> deschide fișierul pe descriptorul 9 pentru tot scriptul. Varianta din script e mai sigură, pentru că protecția nu depinde de cine scrie linia din crontab.

Opțiuni:

  • -n: ieși imediat dacă lock-ul e ocupat; potrivit pentru joburi periodice, unde următoarea rulare va prelua.
  • -w 60: aștepți cel mult 60 de secunde.
  • fără opțiuni: aștepți la nesfârșit; periculos, pentru că rulările se acumulează.

Merită și investigat de ce un job de 5 minute durează 12, și monitorizată durata. O alternativă este un timer systemd, care nu pornește serviciul a doua oară cât timp rulează deja.

flock funcționează pe un singur server. Pentru mai multe servere care rulează același job, ai nevoie de un lock distribuit (în baza de date, Redis) sau de un singur nod desemnat.

Ce urmărește intervievatorul: Verifică dacă știi să faci joburile robuste la concurență. Răspunsul slab e un fișier PID verificat cu if [ -f ], cu condiția de cursă și problema fișierelor rămase.

89 Senior

Echipa ta are scripturi scrise în Bash care trebuie să ruleze și pe Alpine (BusyBox sh) și pe macOS. Ce probleme de portabilitate apar și cum asiguri calitatea scripturilor?

Răspuns scurt: Diferă shell-ul (sh POSIX nu are [[ ]], tablouri, <( ); macOS are Bash 3.2) și utilitarele GNU față de BSD/BusyBox (sed -i, date -d). Alegi explicit ținta, testezi pe fiecare platformă și rulezi shellcheck în CI.

Două surse de diferențe:

  • Shell-ul. sh POSIX (dash, BusyBox ash) nu are [[ ]], tablouri, local standardizat (deși majoritatea îl acceptă), <( ), {1..5}, $'...', == în [, pipefail (inclus în POSIX abia din ediția 2024, deci lipsește din multe implementări). macOS are Bash 3.2, fără tablouri asociative, mapfile sau ${var,,}.
  • Utilitarele. GNU (Linux obișnuit) față de BSD (macOS) și BusyBox (Alpine):
  • sed -i 's/a/b/' f merge în GNU; BSD cere sed -i '' ...;
  • date -d '1 day ago' e GNU; BSD folosește date -v-1d;
  • readlink -f, grep -P, head -n -5, find -printf, stat -c sunt specifice GNU sau au alte opțiuni.

Strategii:

BASH
#!/bin/sh
# POSIX: [ ], case, $(( )), funcții simple
case "$(uname -s)" in
  Darwin) sed_i() { sed -i '' "$@"; } ;;
  *)      sed_i() { sed -i "$@"; } ;;
esac
  • Decizi conștient: fie scrii POSIX sh și eviți bashismele, fie ceri Bash 4+ și verifici la pornire: (( BASH_VERSINFO[0] >= 4 )) || { echo "Bash 4+ necesar" >&2; exit 1; }.
  • shellcheck detectează bashismele când shebang-ul este sh, variabilele necitate, cd neverificat și multe alte probleme. Îl rulezi în CI și ca hook pre-commit; shfmt uniformizează formatarea.
  • Teste automate cu bats pe fiecare platformă țintă.

Partea de judecată: când un script crește peste câteva sute de linii, are nevoie de structuri de date complexe sau trebuie să ruleze identic pe multe platforme, e momentul să-l rescrii într-un limbaj de programare.

Ce urmărește intervievatorul: Verifică experiența cu scripturi întreținute de o echipă, nu de o singură persoană. Candidatul senior știe exemple concrete de diferențe GNU/BSD și pune verificarea în CI.

Eroarea, în practică:bad substitution

Depanare și situații practice

Exersează capitolul cu exerciții reale: Curs Linux pentru începători →
90 Junior

Ai instalat o unealtă, dar terminalul spune „command not found”. Care sunt cauzele posibile și cum le verifici?

Răspuns scurt: Fie executabilul e într-un folder care nu e în PATH, fie shell-ul nu a reîncărcat PATH-ul sau tabela de comenzi, fie instalarea a eșuat sau binarul are alt nume. Verifici cu type, ls pe calea de instalare, echo $PATH și hash -r.

Pași de verificare:

BASH
type unealta                         # ce știe shell-ul despre ea
ls -l ~/.local/bin/unealta /usr/local/bin/unealta 2>&1
echo "$PATH" | tr ':' '\n'
dpkg -L unealta | grep bin/          # unde a pus pachetul fișierele
pip show -f unealta | grep bin       # pentru pachete Python
npm prefix -g                        # pachetele npm globale stau în <prefix>/bin
hash -r                              # golește tabela de comenzi a Bash

Cauze frecvente:

  • Folder lipsă din PATH. pip install --user, npm install -g cu prefix personal, cargo install sau go install pun binarele în ~/.local/bin, ~/.npm-global/bin, ~/.cargo/bin, ~/go/bin. Adaugi folderul în PATH în ~/.bashrc și rulezi source ~/.bashrc sau deschizi un terminal nou.
  • Shell-ul a reținut altă cale. Bash ține minte unde a găsit o comandă. Dacă ai mutat sau reinstalat binarul, poate căuta în locul vechi; hash -r rezolvă.
  • Nume diferit. Pachetul fd-find instalează pe Debian/Ubuntu comanda fdfind, pachetul python3 instalează python3, nu python.
  • Instalare eșuată sau făcută pentru alt utilizator (de exemplu cu sudo pip, care a instalat pentru root).
  • sudo are alt PATH. sudo unealta poate da „command not found” deși unealta merge, pentru că sudo folosește secure_path din sudoers. Folosești calea completă: sudo "$(command -v unealta)".

Un caz derutant: „No such file or directory” la un fișier care există clar înseamnă de obicei că lipsește interpretorul din shebang sau linkerul dinamic (de exemplu un binar compilat pentru altă arhitectură sau pentru glibc pe Alpine, care folosește musl).

Ce urmărește intervievatorul: Verifică dacă depanezi metodic o problemă foarte comună. Un candidat bun știe de hash -r și de diferența de PATH sub sudo.

Eroarea, în practică:command not foundCommand 'tree' not found, but can be installed

91 Junior

Un coleg a scris un script pe Windows și l-a urcat pe server. La rulare primește /bin/bash^M: bad interpreter: No such file or directory. Ce înseamnă și cum repari?

Răspuns scurt: Fișierul are terminații de linie Windows (\r\n), iar \r (afișat ^M) devine parte din numele interpretorului, /bin/bash\r, care nu există. Repari cu dos2unix script.sh sau sed -i 's/\r$//' script.sh și previi prin setarea editorului sau a Git-ului.

Linux folosește un singur caracter pentru sfârșitul liniei (LF, \n), Windows două (CR LF, \r\n). Kernelul citește shebang-ul până la \n, deci interpretorul cerut este /bin/bash\r.

Cum confirmi:

BASH
file script.sh
# script.sh: Bourne-Again shell script, ASCII text executable, with CRLF line terminators
head -1 script.sh | od -c | head -2
# ... /   b   a   s   h  \r  \n
cat -A script.sh | head -3        # liniile se termină în ^M$

Reparare:

BASH
dos2unix script.sh                 # dacă e instalat
sed -i 's/\r$//' script.sh
tr -d '\r' < script.sh > tmp && mv tmp script.sh

Chiar dacă rulezi cu bash script.sh, ocolind shebang-ul, apar alte erori ciudate: $'\r': command not found, variabile care conțin \r la final, căi care „nu există” deși arată corect, if care se plâng de sintaxă.

Prevenire:

  • În Git, un fișier .gitattributes în proiect: *.sh text eol=lf. Așa, scripturile au LF indiferent de setările colegilor.
  • Editorul (VS Code, Notepad++) poate fi setat pe LF pentru proiect, de exemplu prin .editorconfig.

Alte cauze pentru „Permission denied” la ./script.sh, cu care se confundă des: lipsa dreptului de execuție (chmod +x) sau un sistem de fișiere montat cu noexec (frecvent pentru /tmp pe serverele întărite). Verifici cu ls -l și findmnt -T script.sh; ca soluție temporară, bash script.sh funcționează și pe noexec.

Ce urmărește intervievatorul: Este o problemă practică foarte frecventă în echipe mixte. Intervievatorul vrea să vadă că recunoști ^M și că propui și prevenirea, nu doar reparația.

Eroarea, în practică:/bin/bash^M: bad interpreter

92 Junior

Un coleg nou rezolvă orice „Permission denied” cu sudo sau chmod -R 777. Cum i-ai explica de ce nu e o idee bună și ce să facă în schimb?

Răspuns scurt: I-aș explica, pe un exemplu concret de pe serverul nostru, că 777 și sudo ascund cauza și deschid fișierele oricui, inclusiv unui proces compromis. Apoi i-aș arăta pașii de diagnostic: cine rulează procesul, al cui e fișierul, ce drepturi are calea întreagă.

Un răspuns structurat:

  • Contextul: nu îl critic în fața echipei, ci aleg o situație reală, de preferat chiar ultima lui problemă, și o rezolvăm împreună.
  • De ce e o problemă, pe înțelesul lui:
  • chmod -R 777 permite oricărui utilizator și oricărui proces de pe server să modifice fișierele. Dacă aplicația web are o vulnerabilitate, atacatorul poate rescrie codul sau configurarea.
  • Fișierele executabile devin scriptibile de oricine, iar unele programe refuză să ruleze în aceste condiții: SSH ignoră cheile cu permisiuni largi, unele servicii refuză fișierele de configurare scriptibile de toți.
  • sudo folosit ca reflex creează fișiere deținute de root în folderele aplicației, iar problema reapare mai târziu, când aplicația nu le mai poate scrie.
  • Ascunde cauza: data viitoare nu va ști ce s-a întâmplat.
  • Ce să facă în schimb, ca procedură scurtă:
BASH
ps -o user= -p "$(pgrep -f gunicorn | head -1)"   # cu ce utilizator rulează procesul
namei -l /srv/app/uploads/poza.jpg                # permisiunile pe toată calea
id app                                            # din ce grupuri face parte

Apoi alegem dreptul minim: schimbăm proprietarul cu chown, adăugăm utilizatorul într-un grup sau setăm 750/640.

  • Fixarea cunoașterii: îi dau o comandă de verificare de folosit data viitoare, notăm procedura în documentația echipei și verific, la următoarea problemă similară, că o aplică singur.

Ideea e să plece cu o metodă, nu cu o regulă de tipul „nu ai voie”.

Ce urmărește intervievatorul: Verifică abilitatea de a explica și de a forma colegii, plus înțelegerea principiului drepturilor minime. Un răspuns bun are atât partea tehnică, cât și pe cea de comunicare.

Eroarea, în practică:Permission denied la citirea unui fișier

93 Mid

După o modificare, serviciul app nu mai pornește. systemctl status app arată status=203/EXEC. Cum depanezi și ce înseamnă alte coduri de acest tip?

Răspuns scurt: 203/EXEC înseamnă că systemd nu a putut executa comanda din ExecStart: cale greșită, fișier lipsă, fără drept de execuție sau shebang invalid. Citești mesajul complet cu journalctl -u app -b, verifici calea și testezi comanda manual ca utilizatorul serviciului.

Coduri de ieșire de tip 2xx sunt generate de systemd însuși, înainte ca programul să pornească efectiv. Cele frecvente:

  • 203/EXEC: executabilul nu poate fi rulat;
  • 200/CHDIR: WorkingDirectory nu există sau nu e accesibil;
  • 217/USER: utilizatorul din User= nu există;
  • 226/NAMESPACE: problemă cu opțiunile de izolare, de exemplu o cale din ReadWritePaths care nu există.

Dacă procesul pornește și apoi iese, vezi codul aplicației (status=1/FAILURE) sau un semnal (status=9/KILL, posibil OOM killer).

Pași:

BASH
systemctl status app --no-pager -l
journalctl -u app -b --no-pager | tail -50
systemctl cat app                       # unit-ul efectiv, cu override-uri
ls -l /srv/app/venv/bin/gunicorn
head -1 /srv/app/venv/bin/gunicorn      # shebang spre un python care încă există?
sudo -u app /srv/app/venv/bin/gunicorn -b 127.0.0.1:8000 app:app   # rulare manuală
systemd-analyze verify /etc/systemd/system/app.service

Cauze tipice pentru 203/EXEC:

  • cale relativă sau greșită în ExecStart (de exemplu venv recreat în alt loc);
  • un script fără chmod +x sau cu terminații CRLF;
  • un mediu virtual Python mutat, al cărui shebang indică interpretorul vechi;
  • noexec pe sistemul de fișiere sau SELinux, care blochează executarea din acel folder.

Rularea manuală cu sudo -u app și cu aceleași variabile reproduce condițiile serviciului: alt utilizator, fără .bashrc, alt PATH. După corectare: systemctl daemon-reload, systemctl restart app. Dacă serviciul a eșuat de prea multe ori, poate fi necesar întâi systemctl reset-failed app.

Ce urmărește intervievatorul: Verifică dacă citești mesajele lui systemd, nu doar repornești la nesfârșit. Semnalul bun e testarea comenzii exact ca utilizatorul serviciului.

Eroarea, în practică:Job for nginx.service failedstatus=203/EXEC

94 Mid

Aplicația dă eroarea „No space left on device”, dar df -h arată 40% spațiu liber pe partiție. Ce verifici?

Răspuns scurt: Cel mai probabil s-au terminat inode-urile, verificabil cu df -i, de obicei din cauza a milioane de fișiere mici (sesiuni, cache). Alte cauze: aplicația scrie pe altă partiție decât crezi, un tmpfs plin, cote de disc sau blocurile rezervate pentru root.

Eroarea ENOSPC nu înseamnă doar lipsă de bytes. Verificări, în ordine:

BASH
df -i /var                       # IUse% 100% -> inode-uri epuizate
df -h "$(dirname /cale/la/fisier/scris)"   # partiția corectă
findmnt -T /var/lib/app/sessions # pe ce sistem de fișiere e calea
df -h /tmp /run /dev/shm         # tmpfs-uri în memorie, cu limită proprie
quota -s -u app 2>/dev/null      # cote pe utilizator

Inode-uri epuizate: pe ext4 numărul de inode-uri e fixat la formatare. Un folder cu milioane de fișiere de sesiune, miniaturi sau mesaje în coadă consumă toate inode-urile, deși ocupă puțini GB. Găsești folderul vinovat:

BASH
sudo find /var -xdev -type f | cut -d/ -f2-4 | sort | uniq -c | sort -rn | head

Rezolvare: ștergi fișierele inutile (de exemplu sesiunile expirate, cu find ... -mmin +1440 -delete) și repari cauza: curățarea automată care nu mai rulează sau aplicația care nu își șterge fișierele. Pe termen lung, mutarea pe XFS (alocă inode-uri dinamic) sau reformatarea cu mai multe inode-uri (mkfs.ext4 -i).

Alte cauze:

  • Blocurile rezervate: ext4 rezervă implicit 5% pentru root. Un proces obișnuit poate primi ENOSPC când df mai arată câteva procente. tune2fs -l /dev/sda1 | grep -i reserved le arată.
  • tmpfs: /tmp montat în memorie pe unele distribuții, cu limită separată.
  • Partiția greșită: aplicația scrie, de fapt, în /var/lib/docker sau într-un disc montat separat.
  • Fișierele mari șterse, dar încă deschise, care apar în df, nu în du. Aici însă df arată spațiu liber, deci nu e cazul.

Ce urmărește intervievatorul: Verifică dacă știi că spațiul pe disc are două dimensiuni. Majoritatea candidaților se uită doar la df -h și rămân blocați.

Eroarea, în practică:No space left on device

95 Mid

Ai configurat nginx să servească un site din /home/ana/site, dar primești 403 Forbidden, iar logul nginx spune Permission denied. Fișierele au 644. Ce lipsește?

Răspuns scurt: Utilizatorul nginx (de obicei www-data) are nevoie de x pe fiecare director din cale, iar /home/ana are de obicei 750 sau 700. Verifici cu namei -l /home/ana/site/index.html. Soluția corectă e mutarea site-ului în /var/www sau /srv; pe RHEL verifici și SELinux.

nginx rulează procesele care servesc cererile ca utilizator neprivilegiat: www-data pe Debian/Ubuntu, nginx pe familia Red Hat. Pentru a citi /home/ana/site/index.html, procesul are nevoie de x pe /, /home, /home/ana, /home/ana/site și de r pe fișier.

BASH
sudo tail -5 /var/log/nginx/error.log
# open() "/home/ana/site/index.html" failed (13: Permission denied)
namei -l /home/ana/site/index.html
# drwxr-xr-x root root /
# drwxr-xr-x root root home
# drwxr-x--- ana  ana  ana        <- www-data nu are x
# drwxr-xr-x ana  ana  site
# -rw-r--r-- ana  ana  index.html
sudo -u www-data cat /home/ana/site/index.html   # reproduci problema

Pe Ubuntu 21.04+ folderele personale noi au implicit 750, deci problema e foarte frecventă.

Soluții, de la cea mai bună:

  • mutarea site-ului într-un loc destinat: /var/www/site sau /srv/site, cu ana ca proprietar și grupul www-data, directoare 750 și fișiere 640;
  • un ACL țintit: setfacl -m u:www-data:x /home/ana dă doar traversarea, fără listare;
  • chmod o+x /home/ana, acceptabil, dar deschide traversarea pentru toți utilizatorii.

chmod 777 pe tot folderul nu e o soluție și oricum nu era problema, pentru că fișierele aveau deja 644.

Pe RHEL, Rocky sau Fedora, chiar cu permisiuni corecte, SELinux blochează nginx să citească din /home. Verifici cu ls -Z și ausearch -m avc -ts recent; repari setând contextul corect (semanage fcontext ... httpd_sys_content_t și restorecon -Rv) sau, din nou, mutând site-ul în /var/www.

Ce urmărește intervievatorul: Verifică regula traversării directoarelor într-un caz real. Mulți se uită doar la permisiunile fișierului și nu la calea întreagă.

Eroarea, în practică:nginx 403 Forbidden: Permission denied

96 Mid

Povestește (sau descrie cum ai proceda) o situație în care ai rulat o comandă greșită pe un server de producție, de exemplu ai șters fișiere care nu trebuiau șterse.

Răspuns scurt: Structurez răspunsul în: ce s-a întâmplat, cum am limitat imediat efectul, cum am comunicat, cum am restaurat și ce am schimbat ca să nu se repete. Accentul e pe transparență rapidă și pe măsuri de prevenție concrete, nu pe vină.

Un model de răspuns, de tip STAR (situație, sarcină, acțiune, rezultat):

  • Situația: curățam loguri vechi pe un server de aplicație cu find ... -delete, dar calea era greșită și am șters și fișierele încărcate de utilizatori din ziua respectivă.
  • Prima reacție: m-am oprit imediat. Nu am mai rulat comenzi „de reparare” pe loc, ca să nu stric și mai mult. Am verificat exact ce lipsea (ls, logurile aplicației, comanda din istoric cu history).
  • Comunicarea: am anunțat în câteva minute echipa și persoana responsabilă de serviciu, cu ce s-a întâmplat, impactul estimat și ce urmează să fac. A ascunde o greșeală în producție o face mai gravă.
  • Limitarea și restaurarea: am restaurat din backup-ul de noapte, am recuperat fișierele din ziua respectivă din altă sursă (o copie din stocarea externă sau din logurile de încărcare, de exemplu) și am verificat cu utilizatorii afectați.
  • Prevenția: am propus și implementat măsuri concrete:
  • rularea întâi cu -print sau echo, apoi cu -delete;
  • un script revizuit în locul comenzii manuale, cu ${DIR:?} și căi absolute;
  • un prompt colorat diferit pe serverele de producție;
  • backup-uri mai dese pentru folderul cu fișierele utilizatorilor și un test de restaurare.
  • Ce am învățat: că o comandă cu efect ireversibil merită verificată de două ori sau citită de un coleg.

Dacă nu ai trăit o astfel de situație, spui sincer și descrii cum ai proceda, folosind aceeași structură.

Ce urmărește intervievatorul: Verifică onestitatea, calmul sub presiune și orientarea spre prevenție. Răspunsurile proaste dau vina pe alții sau descriu o „reparare” ascunsă, fără comunicare.

97 Senior

După o modificare în /etc/fstab, serverul nu mai pornește și intră în „emergency mode”. Cum îl repari?

Răspuns scurt: Te autentifici în emergency mode (ca root, de la consolă), remontezi rădăcina în mod citire-scriere, corectezi sau comentezi linia greșită din /etc/fstab, testezi cu mount -a și repornești. Dacă nu ai consolă, folosești consola furnizorului sau un sistem de recuperare.

systemd tratează intrările din fstab ca dependențe ale pornirii. Dacă o intrare fără nofail nu poate fi montată (UUID greșit, disc lipsă, tip de sistem de fișiere greșit, greșeală de tipar), pornirea se oprește în emergency.target.

Pași:

BASH
# în emergency mode, după parola de root
journalctl -xb | grep -iE 'mount|fstab|timed out' | tail -20
systemctl --failed
mount -o remount,rw /
vi /etc/fstab                  # corectezi sau comentezi linia
blkid                          # UUID-urile reale ale partițiilor
mount -a                       # testul înainte de repornire
systemctl daemon-reload
reboot                         # sau: systemctl default

Dacă rădăcina însăși nu se montează, sau nu există parolă de root (contul e blocat implicit pe Ubuntu), ai variante:

  • în GRUB, apeși e și adaugi la linia kernelului systemd.unit=emergency.target sau, ca ultimă soluție, init=/bin/bash, apoi remontezi rădăcina rw;
  • pe un server din cloud, folosești consola serială a furnizorului sau atașezi discul la o altă mașină, îl montezi și corectezi fișierul de acolo;
  • dacă e o problemă de sistem de fișiere, rulezi fsck pe partiția nemontată.

Pentru a preveni:

  • după orice modificare a fstab-ului, mount -a și findmnt --verify, înainte de repornire;
  • UUID-uri, nu /dev/sdX;
  • nofail pentru discuri de date, iar pentru share-uri de rețea _netdev și eventual x-systemd.automount;
  • o copie a fișierului înainte de modificare (cp /etc/fstab /etc/fstab.bak) și, pe servere din cloud, acces la consola de recuperare verificat dinainte.

Ce urmărește intervievatorul: Verifică abilitatea de recuperare când sistemul nu mai pornește. Candidatul senior știe mai multe căi de acces (emergency mode, GRUB, consola din cloud) și pune accent pe prevenție.

98 Senior

Trebuie să modifici configurarea SSH și regulile de firewall pe un server la distanță, fără acces la consolă. Cum te asiguri că nu te blochezi singur afară?

Răspuns scurt: Validezi configurarea înainte de aplicare (sshd -t), păstrezi sesiunea curentă deschisă și testezi dintr-o conexiune nouă, iar pentru firewall programezi un rollback automat (cu at sau un sleep în fundal) pe care îl anulezi doar după ce verifici că ai acces.

Principiul: orice modificare care îți poate tăia accesul trebuie să aibă o cale de revenire care nu depinde de acces.

Pentru SSH:

BASH
sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak
sudoedit /etc/ssh/sshd_config.d/50-local.conf
sudo sshd -t                     # validează sintaxa; fără ieșire = OK
sudo systemctl reload ssh        # numele unității e ssh pe Debian/Ubuntu, sshd pe RHEL
# din alt terminal, fără să închizi sesiunea curentă:
ssh -v server

reload nu închide sesiunile existente, deci ai în continuare o sesiune deschisă cu care poți reveni. Doar după ce o conexiune nouă reușește închizi vechea sesiune.

Pentru firewall, unde o regulă greșită poate tăia și conexiunea curentă:

BASH
sudo cp /etc/nftables.conf /root/nftables.bak
echo 'cp /root/nftables.bak /etc/nftables.conf && nft -f /etc/nftables.conf' | sudo at now + 5 minutes
sudo nft -f /etc/nftables.conf   # aplici noua configurare
# testezi dintr-o conexiune nouă; dacă merge:
sudo atrm "$(sudo atq | tail -1 | cut -f1)"

Alternative la at: sudo sh -c 'sleep 300 && nft -f /root/nftables.bak' & rulat în tmux, sau iptables-apply, care cere confirmare și revine automat dacă nu o primește.

Alte măsuri:

  • modificări mici, una câte una, nu toată configurarea deodată;
  • încercarea întâi pe un server de test identic;
  • dacă e posibil, o fereastră de mentenanță și acces la consola furnizorului verificat dinainte;
  • configurarea gestionată cu o unealtă de automatizare și revizuită de un coleg.

Ce urmărește intervievatorul: Verifică disciplina operațională pe sisteme la distanță. Răspunsul senior are întotdeauna un mecanism de revenire automată, nu doar „am grijă”.

99 Senior

Un proces al aplicației folosește 100% dintr-un nucleu de câteva ore, iar restul serverului începe să sufere. Cum investighezi cauza și ce faci pe termen scurt, fără să pierzi informațiile de diagnostic?

Răspuns scurt: Identifici procesul și thread-ul cu top -H, aduni dovezi înainte de orice restart (stive de thread-uri cu unealta limbajului, strace -c, perf top), limitezi impactul cu renice sau CPUQuota și abia apoi repornești, dacă e nevoie, cu datele salvate pentru analiză.

Ordinea contează: un restart imediat rezolvă simptomul, dar șterge orice urmă a cauzei, care va reveni.

Identificare:

BASH
top -o %CPU                    # procesul
top -H -p 4127                 # thread-ul care consumă
ps -L -o tid,pcpu,comm -p 4127 --sort=-pcpu | head

Colectarea dovezilor, în funcție de tehnologie:

BASH
printf '%x\n' 4188             # TID în hex, pentru Java
jstack 4127 > /tmp/stack1.txt; sleep 5; jstack 4127 > /tmp/stack2.txt
py-spy dump --pid 4127         # Python
sudo strace -c -f -p 4127      # Ctrl+C după câteva secunde: sumarul apelurilor
sudo perf top -p 4127          # funcțiile cele mai costisitoare (cu simboluri)

Ce indică rezultatele:

  • stiva aceluiași thread arată mereu aceeași funcție: buclă infinită sau o expresie regulată cu backtracking catastrofal pe o intrare anume;
  • strace -c cu multe apeluri epoll_wait sau read care întorc imediat: un socket închis citit în buclă;
  • foarte puține apeluri de sistem: calcul pur în spațiul utilizatorului; pentru Java, verifici și thread-urile de garbage collection (memorie aproape plină).

Limitarea impactului, fără oprire:

BASH
sudo renice -n 15 -p 4127
sudo systemctl set-property --runtime app.service CPUQuota=50%

--runtime aplică limita doar până la repornire. Apoi decizi: dacă ai datele și utilizatorii sunt afectați, repornești serviciul. Corelezi momentul începerii cu deploy-uri, cereri specifice din loguri sau joburi programate. La final, o analiză scurtă după incident și o alertă pe CPU susținut, ca data viitoare să afli înaintea utilizatorilor.

Ce urmărește intervievatorul: Verifică abordarea senioră: dovezi înainte de restart, limitarea impactului și găsirea cauzei. Răspunsul slab e „îi dau kill și îl repornesc”.

100 Senior

Primești în grijă un server Linux despre care nu există documentație, iar fostul administrator a plecat. Ce faci în primele ore, înainte să schimbi ceva?

Răspuns scurt: Fac un inventar fără modificări: sistemul și versiunea, ce servicii rulează și ce porturi ascultă, ce joburi programate există, cine are acces, unde sunt datele și backup-urile. Documentez totul, verific backup-ul, apoi stabilesc prioritățile cu echipa.

Un răspuns structurat, în ordinea în care aș lucra:

  • Regula de bază: în primele ore doar citesc și notez. Un server nedocumentat poate avea dependențe ascunse, iar o „curățenie” făcută prea devreme poate opri ceva important.
  • Identitatea sistemului:
BASH
cat /etc/os-release; uname -r; uptime
df -hT; lsblk; free -h
  • Ce face serverul:
BASH
systemctl list-units --type=service --state=running
sudo ss -tulpn
ls /etc/nginx/sites-enabled/ /etc/apache2/sites-enabled/ 2>/dev/null
ps auxf --sort=-%mem | head -30
  • Ce rulează automat: crontab -l pentru fiecare utilizator (/var/spool/cron/crontabs/), /etc/cron.*, systemctl list-timers.
  • Cine are acces: utilizatori cu shell de login, membri ai grupului sudo/wheel, fișierele authorized_keys, /etc/sudoers.d/.
  • Date și backup: unde sunt bazele de date și fișierele aplicației, dacă există backup, când a rulat ultima dată și dacă poate fi restaurat. Dacă nu există backup, acesta devine prioritatea 1, înaintea oricărei alte modificări.
  • Starea de sănătate: actualizări de securitate restante, certificate care expiră, erori în journalctl -p err -b, spațiu pe disc.
  • Documentare: un document cu ce am găsit, pe care echipa îl poate completa, plus o copie a configurărilor din /etc într-un depozit Git.

Apoi discut cu echipa și stabilim prioritățile: riscurile majore (lipsa backup-ului, acces nelimitat, software neactualizat), apoi stabilitatea și, abia la final, modernizarea. Modificările le fac pe rând, cu plan de revenire.

Ce urmărește intervievatorul: Verifică maturitatea: prudență, metodă și comunicare. Intervievatorul urmărește dacă primul gând e backup-ul și inventarul, nu reinstalarea sau „curățenia”.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Linux, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Linux scriind cod, nu doar citind

Curs Linux: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.